@atproto/lex-schema 0.0.11 → 0.0.13

package/dist/schema/literal.js

@@ -3,8 +3,24 @@ Object.defineProperty(exports, "__esModule", { value: true });
 exports.LiteralSchema = void 0;
 exports.literal = literal;
 const core_js_1 = require("../core.js");
+/**
+ * Schema that only accepts a specific literal value.
+ *
+ * Validates that the input is exactly equal to the specified value using
+ * strict equality (===).
+ *
+ * @template TValue - The literal type (null, string, number, or boolean)
+ *
+ * @example
+ * ```ts
+ * const schema = new LiteralSchema('admin')
+ * schema.validate('admin') // success
+ * schema.validate('user')  // fails
+ * ```
+ */
 class LiteralSchema extends core_js_1.Schema {
     value;
+    type = 'literal';
     constructor(value) {
         super();
         this.value = value;
@@ -17,6 +33,35 @@ class LiteralSchema extends core_js_1.Schema {
     }
 }
 exports.LiteralSchema = LiteralSchema;
+/**
+ * Creates a literal schema that only accepts the exact specified value.
+ *
+ * Useful for discriminator fields in unions, constant values, or type narrowing.
+ *
+ * @param value - The exact value that must be matched
+ * @returns A new {@link LiteralSchema} instance
+ *
+ * @example
+ * ```ts
+ * // String literal
+ * const roleSchema = l.literal('admin')
+ *
+ * // Number literal
+ * const versionSchema = l.literal(1)
+ *
+ * // Boolean literal
+ * const enabledSchema = l.literal(true)
+ *
+ * // Null literal
+ * const nullSchema = l.literal(null)
+ *
+ * // In discriminated unions
+ * const actionSchema = l.discriminatedUnion('type', [
+ *   l.object({ type: l.literal('create'), data: l.unknown() }),
+ *   l.object({ type: l.literal('delete'), id: l.string() }),
+ * ])
+ * ```
+ */
 /*@__NO_SIDE_EFFECTS__*/
 function literal(value) {
     return new LiteralSchema(value);

package/dist/schema/literal.js.map

@@ -1 +1 @@
-{"version":3,"file":"literal.js","sourceRoot":"","sources":["../../src/schema/literal.ts"],"names":[],"mappings":";;;AAmBA,0BAIC;AAvBD,wCAAsD;AAEtD,MAAa,aAEX,SAAQ,gBAAc;IACD;IAArB,YAAqB,KAAa;QAChC,KAAK,EAAE,CAAA;QADY,UAAK,GAAL,KAAK,CAAQ;IAElC,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;AAdD,sCAcC;AAED,wBAAwB;AACxB,SAAgB,OAAO,CACrB,KAAQ;IAER,OAAO,IAAI,aAAa,CAAI,KAAK,CAAC,CAAA;AACpC,CAAC","sourcesContent":["import { Schema, ValidationContext } from '../core.js'\n\nexport class LiteralSchema<\n  const TValue extends null | string | number | boolean,\n> extends Schema<TValue> {\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/*@__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":";;;AAiEA,0BAIC;AArED,wCAAsD;AAEtD;;;;;;;;;;;;;;GAcG;AACH,MAAa,aAEX,SAAQ,gBAAc;IAGD;IAFZ,IAAI,GAAG,SAAkB,CAAA;IAElC,YAAqB,KAAa;QAChC,KAAK,EAAE,CAAA;QADY,UAAK,GAAL,KAAK,CAAQ;IAElC,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;AAhBD,sCAgBC;AAED;;;;;;;;;;;;;;;;;;;;;;;;;;;;GA4BG;AACH,wBAAwB;AACxB,SAAgB,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.d.ts

@@ -1,6 +1,49 @@
 import { Schema, ValidationContext } from '../core.js';
+/**
+ * Schema that always fails validation.
+ *
+ * Represents an impossible type - no value can satisfy this schema.
+ * Useful for exhaustiveness checking or marking impossible branches.
+ *
+ * @example
+ * ```ts
+ * const schema = new NeverSchema()
+ * schema.validate(anything) // always fails
+ * ```
+ */
 export declare class NeverSchema extends Schema<never> {
+    readonly type: "never";
     validateInContext(input: unknown, ctx: ValidationContext): import("../core.js").ValidationFailure;
 }
+/**
+ * Creates a never schema that always fails validation.
+ *
+ * Useful for exhaustiveness checking in TypeScript or marking impossible
+ * code paths.
+ *
+ * @returns A new {@link NeverSchema} instance
+ *
+ * @example
+ * ```ts
+ * // Exhaustiveness checking
+ * type Status = 'active' | 'inactive'
+ *
+ * function handleStatus(status: Status) {
+ *   switch (status) {
+ *     case 'active': return 'Active'
+ *     case 'inactive': return 'Inactive'
+ *     default:
+ *       // TypeScript will error if we miss a case
+ *       l.never().parse(status)
+ *   }
+ * }
+ *
+ * // In impossible union branches
+ * const schema = l.object({
+ *   type: l.literal('fixed'),
+ *   dynamic: l.never(), // This property can never exist
+ * })
+ * ```
+ */
 export declare const never: () => NeverSchema;
 //# sourceMappingURL=never.d.ts.map

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

@@ -1 +1 @@
-{"version":3,"file":"never.d.ts","sourceRoot":"","sources":["../../src/schema/never.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,MAAM,EAAE,iBAAiB,EAAE,MAAM,YAAY,CAAA;AAGtD,qBAAa,WAAY,SAAQ,MAAM,CAAC,KAAK,CAAC;IAC5C,iBAAiB,CAAC,KAAK,EAAE,OAAO,EAAE,GAAG,EAAE,iBAAiB;CAGzD;AAED,eAAO,MAAM,KAAK,mBAEhB,CAAA"}
+{"version":3,"file":"never.d.ts","sourceRoot":"","sources":["../../src/schema/never.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,MAAM,EAAE,iBAAiB,EAAE,MAAM,YAAY,CAAA;AAGtD;;;;;;;;;;;GAWG;AACH,qBAAa,WAAY,SAAQ,MAAM,CAAC,KAAK,CAAC;IAC5C,QAAQ,CAAC,IAAI,EAAG,OAAO,CAAS;IAEhC,iBAAiB,CAAC,KAAK,EAAE,OAAO,EAAE,GAAG,EAAE,iBAAiB;CAGzD;AAED;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GA6BG;AACH,eAAO,MAAM,KAAK,mBAEhB,CAAA"}

package/dist/schema/never.js

@@ -3,12 +3,55 @@ Object.defineProperty(exports, "__esModule", { value: true });
 exports.never = exports.NeverSchema = void 0;
 const core_js_1 = require("../core.js");
 const memoize_js_1 = require("../util/memoize.js");
+/**
+ * Schema that always fails validation.
+ *
+ * Represents an impossible type - no value can satisfy this schema.
+ * Useful for exhaustiveness checking or marking impossible branches.
+ *
+ * @example
+ * ```ts
+ * const schema = new NeverSchema()
+ * schema.validate(anything) // always fails
+ * ```
+ */
 class NeverSchema extends core_js_1.Schema {
+    type = 'never';
     validateInContext(input, ctx) {
-        return ctx.issueInvalidType(input, 'never');
+        return ctx.issueUnexpectedType(input, 'never');
     }
 }
 exports.NeverSchema = NeverSchema;
+/**
+ * Creates a never schema that always fails validation.
+ *
+ * Useful for exhaustiveness checking in TypeScript or marking impossible
+ * code paths.
+ *
+ * @returns A new {@link NeverSchema} instance
+ *
+ * @example
+ * ```ts
+ * // Exhaustiveness checking
+ * type Status = 'active' | 'inactive'
+ *
+ * function handleStatus(status: Status) {
+ *   switch (status) {
+ *     case 'active': return 'Active'
+ *     case 'inactive': return 'Inactive'
+ *     default:
+ *       // TypeScript will error if we miss a case
+ *       l.never().parse(status)
+ *   }
+ * }
+ *
+ * // In impossible union branches
+ * const schema = l.object({
+ *   type: l.literal('fixed'),
+ *   dynamic: l.never(), // This property can never exist
+ * })
+ * ```
+ */
 exports.never = (0, memoize_js_1.memoizedOptions)(function () {
     return new NeverSchema();
 });

package/dist/schema/never.js.map

@@ -1 +1 @@
-{"version":3,"file":"never.js","sourceRoot":"","sources":["../../src/schema/never.ts"],"names":[],"mappings":";;;AAAA,wCAAsD;AACtD,mDAAoD;AAEpD,MAAa,WAAY,SAAQ,gBAAa;IAC5C,iBAAiB,CAAC,KAAc,EAAE,GAAsB;QACtD,OAAO,GAAG,CAAC,gBAAgB,CAAC,KAAK,EAAE,OAAO,CAAC,CAAA;IAC7C,CAAC;CACF;AAJD,kCAIC;AAEY,QAAA,KAAK,GAAiB,IAAA,4BAAe,EAAC;IACjD,OAAO,IAAI,WAAW,EAAE,CAAA;AAC1B,CAAC,CAAC,CAAA","sourcesContent":["import { Schema, ValidationContext } from '../core.js'\nimport { memoizedOptions } from '../util/memoize.js'\n\nexport class NeverSchema extends Schema<never> {\n  validateInContext(input: unknown, ctx: ValidationContext) {\n    return ctx.issueInvalidType(input, 'never')\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,wCAAsD;AACtD,mDAAoD;AAEpD;;;;;;;;;;;GAWG;AACH,MAAa,WAAY,SAAQ,gBAAa;IACnC,IAAI,GAAG,OAAgB,CAAA;IAEhC,iBAAiB,CAAC,KAAc,EAAE,GAAsB;QACtD,OAAO,GAAG,CAAC,mBAAmB,CAAC,KAAK,EAAE,OAAO,CAAC,CAAA;IAChD,CAAC;CACF;AAND,kCAMC;AAED;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GA6BG;AACU,QAAA,KAAK,GAAiB,IAAA,4BAAe,EAAC;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.d.ts

@@ -1,7 +1,37 @@
 import { Schema, ValidationContext } from '../core.js';
+/**
+ * Schema for validating null values.
+ *
+ * Only accepts the JavaScript `null` value. Rejects `undefined` and all
+ * other values.
+ *
+ * @example
+ * ```ts
+ * const schema = new NullSchema()
+ * schema.validate(null)      // success
+ * schema.validate(undefined) // fails
+ * ```
+ */
 export declare class NullSchema extends Schema<null> {
+    readonly type: "null";
     validateInContext(input: unknown, ctx: ValidationContext): import("../core.js").ValidationResult<null>;
 }
+/**
+ * Creates a null schema that only accepts the null value.
+ *
+ * Useful for explicitly representing null in union types or optional fields.
+ *
+ * @returns A new {@link NullSchema} instance
+ *
+ * @example
+ * ```ts
+ * // Explicit null
+ * const nullOnlySchema = l.null()
+ *
+ * // Nullable string (string or null)
+ * const nullableStringSchema = l.union([l.string(), l.null()])
+ * ```
+ */
 export declare const nullSchema: () => NullSchema;
 export { nullSchema as null };
 //# sourceMappingURL=null.d.ts.map

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

@@ -1 +1 @@
-{"version":3,"file":"null.d.ts","sourceRoot":"","sources":["../../src/schema/null.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,MAAM,EAAE,iBAAiB,EAAE,MAAM,YAAY,CAAA;AAGtD,qBAAa,UAAW,SAAQ,MAAM,CAAC,IAAI,CAAC;IAC1C,iBAAiB,CAAC,KAAK,EAAE,OAAO,EAAE,GAAG,EAAE,iBAAiB;CAOzD;AAED,eAAO,MAAM,UAAU,kBAErB,CAAA;AAEF,OAAO,EAAE,UAAU,IAAI,IAAI,EAAE,CAAA"}
+{"version":3,"file":"null.d.ts","sourceRoot":"","sources":["../../src/schema/null.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,MAAM,EAAE,iBAAiB,EAAE,MAAM,YAAY,CAAA;AAGtD;;;;;;;;;;;;GAYG;AACH,qBAAa,UAAW,SAAQ,MAAM,CAAC,IAAI,CAAC;IAC1C,QAAQ,CAAC,IAAI,EAAG,MAAM,CAAS;IAE/B,iBAAiB,CAAC,KAAK,EAAE,OAAO,EAAE,GAAG,EAAE,iBAAiB;CAOzD;AAED;;;;;;;;;;;;;;;GAeG;AACH,eAAO,MAAM,UAAU,kBAErB,CAAA;AAEF,OAAO,EAAE,UAAU,IAAI,IAAI,EAAE,CAAA"}

package/dist/schema/null.js

@@ -3,15 +3,45 @@ Object.defineProperty(exports, "__esModule", { value: true });
 exports.null = exports.nullSchema = exports.NullSchema = void 0;
 const core_js_1 = require("../core.js");
 const memoize_js_1 = require("../util/memoize.js");
+/**
+ * Schema for validating null values.
+ *
+ * Only accepts the JavaScript `null` value. Rejects `undefined` and all
+ * other values.
+ *
+ * @example
+ * ```ts
+ * const schema = new NullSchema()
+ * schema.validate(null)      // success
+ * schema.validate(undefined) // fails
+ * ```
+ */
 class NullSchema extends core_js_1.Schema {
+    type = 'null';
     validateInContext(input, ctx) {
         if (input !== null) {
-            return ctx.issueInvalidType(input, 'null');
+            return ctx.issueUnexpectedType(input, 'null');
         }
         return ctx.success(null);
     }
 }
 exports.NullSchema = NullSchema;
+/**
+ * Creates a null schema that only accepts the null value.
+ *
+ * Useful for explicitly representing null in union types or optional fields.
+ *
+ * @returns A new {@link NullSchema} instance
+ *
+ * @example
+ * ```ts
+ * // Explicit null
+ * const nullOnlySchema = l.null()
+ *
+ * // Nullable string (string or null)
+ * const nullableStringSchema = l.union([l.string(), l.null()])
+ * ```
+ */
 exports.nullSchema = (0, memoize_js_1.memoizedOptions)(function () {
     return new NullSchema();
 });

package/dist/schema/null.js.map

@@ -1 +1 @@
-{"version":3,"file":"null.js","sourceRoot":"","sources":["../../src/schema/null.ts"],"names":[],"mappings":";;;AAAA,wCAAsD;AACtD,mDAAoD;AAEpD,MAAa,UAAW,SAAQ,gBAAY;IAC1C,iBAAiB,CAAC,KAAc,EAAE,GAAsB;QACtD,IAAI,KAAK,KAAK,IAAI,EAAE,CAAC;YACnB,OAAO,GAAG,CAAC,gBAAgB,CAAC,KAAK,EAAE,MAAM,CAAC,CAAA;QAC5C,CAAC;QAED,OAAO,GAAG,CAAC,OAAO,CAAC,IAAI,CAAC,CAAA;IAC1B,CAAC;CACF;AARD,gCAQC;AAEY,QAAA,UAAU,GAAiB,IAAA,4BAAe,EAAC;IACtD,OAAO,IAAI,UAAU,EAAE,CAAA;AACzB,CAAC,CAAC,CAAA;AAEqB,eAJV,kBAAU,CAII","sourcesContent":["import { Schema, ValidationContext } from '../core.js'\nimport { memoizedOptions } from '../util/memoize.js'\n\nexport class NullSchema extends Schema<null> {\n  validateInContext(input: unknown, ctx: ValidationContext) {\n    if (input !== null) {\n      return ctx.issueInvalidType(input, 'null')\n    }\n\n    return ctx.success(null)\n  }\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,wCAAsD;AACtD,mDAAoD;AAEpD;;;;;;;;;;;;GAYG;AACH,MAAa,UAAW,SAAQ,gBAAY;IACjC,IAAI,GAAG,MAAe,CAAA;IAE/B,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;AAVD,gCAUC;AAED;;;;;;;;;;;;;;;GAeG;AACU,QAAA,UAAU,GAAiB,IAAA,4BAAe,EAAC;IACtD,OAAO,IAAI,UAAU,EAAE,CAAA;AACzB,CAAC,CAAC,CAAA;AAEqB,eAJV,kBAAU,CAII","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,8 +1,50 @@
 import { InferInput, InferOutput, Schema, ValidationContext, Validator } from '../core.js';
+/**
+ * Schema wrapper that allows null values in addition to the wrapped schema.
+ *
+ * When the input is `null`, validation succeeds immediately. Otherwise,
+ * the input is validated against the wrapped schema.
+ *
+ * @template TValidator - The wrapped validator type
+ *
+ * @example
+ * ```ts
+ * const schema = new NullableSchema(l.string())
+ * schema.validate(null)    // success
+ * schema.validate('hello') // success
+ * ```
+ */
 export declare class NullableSchema<const TValidator extends Validator> extends Schema<InferInput<TValidator> | null, InferOutput<TValidator> | null> {
     readonly validator: TValidator;
+    readonly type: "nullable";
     constructor(validator: TValidator);
     validateInContext(input: unknown, ctx: ValidationContext): import("../core.js").ValidationFailure | import("../core.js").ValidationSuccess<null> | import("../core.js").ValidationSuccess<InferInput<TValidator>>;
 }
+/**
+ * Creates a nullable schema that accepts null in addition to the wrapped type.
+ *
+ * Wraps another schema to allow null values. Different from `optional()` which
+ * allows undefined.
+ *
+ * @param validator - The validator to make nullable
+ * @returns A new {@link NullableSchema} instance
+ *
+ * @example
+ * ```ts
+ * // Nullable string
+ * const nullableString = l.nullable(l.string())
+ * nullableString.parse(null)    // null
+ * nullableString.parse('hello') // 'hello'
+ *
+ * // In an object
+ * const userSchema = l.object({
+ *   name: l.string(),
+ *   deletedAt: l.nullable(l.string({ format: 'datetime' })),
+ * })
+ *
+ * // Combine with optional for null or undefined
+ * const maybeString = l.optional(l.nullable(l.string()))
+ * ```
+ */
 export declare const nullable: <const TValidator extends Validator>(validator: TValidator) => NullableSchema<TValidator>;
 //# sourceMappingURL=nullable.d.ts.map

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,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;IACa,QAAQ,CAAC,SAAS,EAAE,UAAU;gBAArB,SAAS,EAAE,UAAU;IAI1C,iBAAiB,CAAC,KAAK,EAAE,OAAO,EAAE,GAAG,EAAE,iBAAiB;CAOzD;AAED,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,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;gBAEd,SAAS,EAAE,UAAU;IAI1C,iBAAiB,CAAC,KAAK,EAAE,OAAO,EAAE,GAAG,EAAE,iBAAiB;CAOzD;AAED;;;;;;;;;;;;;;;;;;;;;;;;;GAyBG;AACH,eAAO,MAAM,QAAQ,SACb,UAAU,SAAS,SAAS,aACvB,UAAU,+BAErB,CAAA"}

package/dist/schema/nullable.js

@@ -3,8 +3,24 @@ Object.defineProperty(exports, "__esModule", { value: true });
 exports.nullable = exports.NullableSchema = void 0;
 const core_js_1 = require("../core.js");
 const memoize_js_1 = require("../util/memoize.js");
+/**
+ * Schema wrapper that allows null values in addition to the wrapped schema.
+ *
+ * When the input is `null`, validation succeeds immediately. Otherwise,
+ * the input is validated against the wrapped schema.
+ *
+ * @template TValidator - The wrapped validator type
+ *
+ * @example
+ * ```ts
+ * const schema = new NullableSchema(l.string())
+ * schema.validate(null)    // success
+ * schema.validate('hello') // success
+ * ```
+ */
 class NullableSchema extends core_js_1.Schema {
     validator;
+    type = 'nullable';
     constructor(validator) {
         super();
         this.validator = validator;
@@ -17,6 +33,32 @@ class NullableSchema extends core_js_1.Schema {
     }
 }
 exports.NullableSchema = NullableSchema;
+/**
+ * Creates a nullable schema that accepts null in addition to the wrapped type.
+ *
+ * Wraps another schema to allow null values. Different from `optional()` which
+ * allows undefined.
+ *
+ * @param validator - The validator to make nullable
+ * @returns A new {@link NullableSchema} instance
+ *
+ * @example
+ * ```ts
+ * // Nullable string
+ * const nullableString = l.nullable(l.string())
+ * nullableString.parse(null)    // null
+ * nullableString.parse('hello') // 'hello'
+ *
+ * // In an object
+ * const userSchema = l.object({
+ *   name: l.string(),
+ *   deletedAt: l.nullable(l.string({ format: 'datetime' })),
+ * })
+ *
+ * // Combine with optional for null or undefined
+ * const maybeString = l.optional(l.nullable(l.string()))
+ * ```
+ */
 exports.nullable = (0, memoize_js_1.memoizedTransformer)(function (validator) {
     return new NullableSchema(validator);
 });

package/dist/schema/nullable.js.map

@@ -1 +1 @@
-{"version":3,"file":"nullable.js","sourceRoot":"","sources":["../../src/schema/nullable.ts"],"names":[],"mappings":";;;AAAA,wCAMmB;AACnB,mDAAwD;AAExD,MAAa,cAAmD,SAAQ,gBAGvE;IACsB;IAArB,YAAqB,SAAqB;QACxC,KAAK,EAAE,CAAA;QADY,cAAS,GAAT,SAAS,CAAY;IAE1C,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;AAfD,wCAeC;AAEY,QAAA,QAAQ,GAAiB,IAAA,gCAAmB,EAAC,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\nexport class NullableSchema<const TValidator extends Validator> extends Schema<\n  InferInput<TValidator> | null,\n  InferOutput<TValidator> | null\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\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,wCAMmB;AACnB,mDAAwD;AAExD;;;;;;;;;;;;;;GAcG;AACH,MAAa,cAAmD,SAAQ,gBAGvE;IAGsB;IAFZ,IAAI,GAAG,UAAmB,CAAA;IAEnC,YAAqB,SAAqB;QACxC,KAAK,EAAE,CAAA;QADY,cAAS,GAAT,SAAS,CAAY;IAE1C,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;AAjBD,wCAiBC;AAED;;;;;;;;;;;;;;;;;;;;;;;;;GAyBG;AACU,QAAA,QAAQ,GAAiB,IAAA,gCAAmB,EAAC,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"]}

package/dist/schema/object.d.ts

@@ -1,14 +1,71 @@
 import { InferInput, InferOutput, Schema, ValidationContext, Validator, WithOptionalProperties } from '../core.js';
+/**
+ * Type representing the shape of an object schema.
+ *
+ * Maps property names to their corresponding validators.
+ */
 export type ObjectSchemaShape = Record<string, Validator>;
+/**
+ * Schema for validating objects with a defined shape.
+ *
+ * Each property in the shape is validated against its corresponding schema.
+ * Properties wrapped in `optional()` are not required.
+ *
+ * @template TShape - The object shape type mapping property names to validators
+ *
+ * @example
+ * ```ts
+ * const schema = new ObjectSchema({
+ *   name: l.string(),
+ *   age: l.optional(l.integer()),
+ * })
+ * const result = schema.validate({ name: 'Alice' })
+ * ```
+ */
 export declare class ObjectSchema<const TShape extends ObjectSchemaShape = any> extends Schema<WithOptionalProperties<{
     [K in keyof TShape]: InferInput<TShape[K]>;
 }>, WithOptionalProperties<{
     [K in keyof TShape]: InferOutput<TShape[K]>;
 }>> {
     readonly shape: TShape;
+    readonly type: "object";
     constructor(shape: TShape);
     get validatorsMap(): Map<string, Validator>;
     validateInContext(input: unknown, ctx: ValidationContext): import("../core.js").ValidationResult<Record<string, unknown>>;
 }
+/**
+ * Creates an object schema with the specified property validators.
+ *
+ * Validates that the input is a plain object and each property matches
+ * its corresponding schema. Properties wrapped in `optional()` are not required.
+ *
+ * @param properties - Object mapping property names to their validators
+ * @returns A new {@link ObjectSchema} instance
+ *
+ * @example
+ * ```ts
+ * // Basic object
+ * const userSchema = l.object({
+ *   name: l.string(),
+ *   email: l.string({ format: 'uri' }),
+ * })
+ *
+ * // With optional properties
+ * const profileSchema = l.object({
+ *   displayName: l.string(),
+ *   bio: l.optional(l.string({ maxLength: 256 })),
+ *   avatar: l.optional(l.blob({ accept: ['image/*'] })),
+ * })
+ *
+ * // Nested objects
+ * const postSchema = l.object({
+ *   text: l.string(),
+ *   author: l.object({
+ *     did: l.string({ format: 'did' }),
+ *     handle: l.string({ format: 'handle' }),
+ *   }),
+ * })
+ * ```
+ */
 export declare function object<const TShape extends ObjectSchemaShape>(properties: TShape): ObjectSchema<TShape>;
 //# sourceMappingURL=object.d.ts.map

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,MAAM,MAAM,iBAAiB,GAAG,MAAM,CAAC,MAAM,EAAE,SAAS,CAAC,CAAA;AAEzD,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;IACa,QAAQ,CAAC,KAAK,EAAE,MAAM;gBAAb,KAAK,EAAE,MAAM;IAIlC,IAAI,aAAa,IAAI,GAAG,CAAC,MAAM,EAAE,SAAS,CAAC,CAI1C;IAED,iBAAiB,CAAC,KAAK,EAAE,OAAO,EAAE,GAAG,EAAE,iBAAiB;CAqCzD;AAGD,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,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;gBAEZ,KAAK,EAAE,MAAM;IAIlC,IAAI,aAAa,IAAI,GAAG,CAAC,MAAM,EAAE,SAAS,CAAC,CAI1C;IAED,iBAAiB,CAAC,KAAK,EAAE,OAAO,EAAE,GAAG,EAAE,iBAAiB;CAqCzD;AAED;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAiCG;AAEH,wBAAgB,MAAM,CAAC,KAAK,CAAC,MAAM,SAAS,iBAAiB,EAC3D,UAAU,EAAE,MAAM,wBAGnB"}

package/dist/schema/object.js

@@ -5,8 +5,26 @@ exports.object = object;
 const lex_data_1 = require("@atproto/lex-data");
 const core_js_1 = require("../core.js");
 const lazy_property_js_1 = require("../util/lazy-property.js");
+/**
+ * Schema for validating objects with a defined shape.
+ *
+ * Each property in the shape is validated against its corresponding schema.
+ * Properties wrapped in `optional()` are not required.
+ *
+ * @template TShape - The object shape type mapping property names to validators
+ *
+ * @example
+ * ```ts
+ * const schema = new ObjectSchema({
+ *   name: l.string(),
+ *   age: l.optional(l.integer()),
+ * })
+ * const result = schema.validate({ name: 'Alice' })
+ * ```
+ */
 class ObjectSchema extends core_js_1.Schema {
     shape;
+    type = 'object';
     constructor(shape) {
         super();
         this.shape = shape;
@@ -17,7 +35,7 @@ class ObjectSchema extends core_js_1.Schema {
     }
     validateInContext(input, ctx) {
         if (!(0, lex_data_1.isPlainObject)(input)) {
-            return ctx.issueInvalidType(input, 'object');
+            return ctx.issueUnexpectedType(input, 'object');
         }
         // Lazily copy value
         let copy;
@@ -47,6 +65,40 @@ class ObjectSchema extends core_js_1.Schema {
     }
 }
 exports.ObjectSchema = ObjectSchema;
+/**
+ * Creates an object schema with the specified property validators.
+ *
+ * Validates that the input is a plain object and each property matches
+ * its corresponding schema. Properties wrapped in `optional()` are not required.
+ *
+ * @param properties - Object mapping property names to their validators
+ * @returns A new {@link ObjectSchema} instance
+ *
+ * @example
+ * ```ts
+ * // Basic object
+ * const userSchema = l.object({
+ *   name: l.string(),
+ *   email: l.string({ format: 'uri' }),
+ * })
+ *
+ * // With optional properties
+ * const profileSchema = l.object({
+ *   displayName: l.string(),
+ *   bio: l.optional(l.string({ maxLength: 256 })),
+ *   avatar: l.optional(l.blob({ accept: ['image/*'] })),
+ * })
+ *
+ * // Nested objects
+ * const postSchema = l.object({
+ *   text: l.string(),
+ *   author: l.object({
+ *     did: l.string({ format: 'did' }),
+ *     handle: l.string({ format: 'handle' }),
+ *   }),
+ * })
+ * ```
+ */
 /*@__NO_SIDE_EFFECTS__*/
 function object(properties) {
     return new ObjectSchema(properties);

package/dist/schema/object.js.map

@@ -1 +1 @@
-{"version":3,"file":"object.js","sourceRoot":"","sources":["../../src/schema/object.ts"],"names":[],"mappings":";;;AAyEA,wBAIC;AA7ED,gDAAiD;AACjD,wCAOmB;AACnB,+DAAuD;AAIvD,MAAa,YAEX,SAAQ,gBAOT;IACsB;IAArB,YAAqB,KAAa;QAChC,KAAK,EAAE,CAAA;QADY,UAAK,GAAL,KAAK,CAAQ;IAElC,CAAC;IAED,IAAI,aAAa;QACf,MAAM,GAAG,GAAG,IAAI,GAAG,CAAC,MAAM,CAAC,OAAO,CAAC,IAAI,CAAC,KAAK,CAAC,CAAC,CAAA;QAE/C,OAAO,IAAA,+BAAY,EAAC,IAAI,EAAE,eAAe,EAAE,GAAG,CAAC,CAAA;IACjD,CAAC;IAED,iBAAiB,CAAC,KAAc,EAAE,GAAsB;QACtD,IAAI,CAAC,IAAA,wBAAa,EAAC,KAAK,CAAC,EAAE,CAAC;YAC1B,OAAO,GAAG,CAAC,gBAAgB,CAAC,KAAK,EAAE,QAAQ,CAAC,CAAA;QAC9C,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;AAzDD,oCAyDC;AAED,wBAAwB;AACxB,SAAgB,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\nexport type ObjectSchemaShape = Record<string, Validator>\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  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.issueInvalidType(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/*@__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":";;;AAmIA,wBAIC;AAvID,gDAAiD;AACjD,wCAOmB;AACnB,+DAAuD;AASvD;;;;;;;;;;;;;;;;GAgBG;AACH,MAAa,YAEX,SAAQ,gBAOT;IAGsB;IAFZ,IAAI,GAAG,QAAiB,CAAA;IAEjC,YAAqB,KAAa;QAChC,KAAK,EAAE,CAAA;QADY,UAAK,GAAL,KAAK,CAAQ;IAElC,CAAC;IAED,IAAI,aAAa;QACf,MAAM,GAAG,GAAG,IAAI,GAAG,CAAC,MAAM,CAAC,OAAO,CAAC,IAAI,CAAC,KAAK,CAAC,CAAC,CAAA;QAE/C,OAAO,IAAA,+BAAY,EAAC,IAAI,EAAE,eAAe,EAAE,GAAG,CAAC,CAAA;IACjD,CAAC;IAED,iBAAiB,CAAC,KAAc,EAAE,GAAsB;QACtD,IAAI,CAAC,IAAA,wBAAa,EAAC,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;AA3DD,oCA2DC;AAED;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAiCG;AACH,wBAAwB;AACxB,SAAgB,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"]}

package/dist/schema/optional.d.ts

@@ -1,9 +1,52 @@
 import { InferInput, InferOutput, Schema, UnwrapValidator, ValidationContext, Validator } from '../core.js';
 import { WithDefaultSchema } from './with-default.js';
+/**
+ * Schema wrapper that makes a value optional (allows undefined).
+ *
+ * When the input is `undefined`, validation succeeds without running the
+ * inner validator. If the inner validator has a default value (via `withDefault`),
+ * that default will be applied in parse mode.
+ *
+ * @template TValidator - The wrapped validator type
+ *
+ * @example
+ * ```ts
+ * const schema = new OptionalSchema(l.string())
+ * schema.validate(undefined) // success
+ * schema.validate('hello')   // success
+ * ```
+ */
 export declare class OptionalSchema<TValidator extends Validator> extends Schema<InferInput<TValidator> | undefined, UnwrapValidator<TValidator> extends WithDefaultSchema<infer TValidator> ? InferOutput<TValidator> : InferOutput<TValidator> | undefined> {
     readonly validator: TValidator;
+    readonly type: "optional";
     constructor(validator: TValidator);
     validateInContext(input: unknown, ctx: ValidationContext): import("../core.js").ValidationResult<undefined> | import("../core.js").ValidationSuccess<InferInput<TValidator>>;
 }
+/**
+ * Creates an optional schema that allows undefined values.
+ *
+ * Wraps another schema to make it optional. When used in an object schema,
+ * properties with optional schemas are not required.
+ *
+ * @param validator - The validator to make optional
+ * @returns A new {@link OptionalSchema} instance
+ *
+ * @example
+ * ```ts
+ * // Optional string
+ * const optionalBio = l.optional(l.string())
+ *
+ * // In an object - property is not required
+ * const userSchema = l.object({
+ *   name: l.string(),
+ *   bio: l.optional(l.string()),
+ * })
+ * userSchema.parse({ name: 'Alice' }) // Valid, bio is undefined
+ *
+ * // With default value
+ * const countSchema = l.optional(l.withDefault(l.integer(), 0))
+ * countSchema.parse(undefined) // Returns 0
+ * ```
+ */
 export declare const optional: <const TValidator extends Validator>(validator: TValidator) => OptionalSchema<TValidator>;
 //# sourceMappingURL=optional.d.ts.map