@atproto/lex-schema 0.0.11 → 0.0.13

package/dist/schema/subscription.d.ts

@@ -1,8 +1,41 @@
+import { LexValue } from '@atproto/lex-data';
 import { Infer, NsidString, Schema } from '../core.js';
 import { ParamsSchema } from './params.js';
+/**
+ * Infers the parameters type from a Subscription definition.
+ *
+ * @template S - The Subscription type
+ */
 export type InferSubscriptionParameters<S extends Subscription> = Infer<S['parameters']>;
+/**
+ * Infers the message type from a Subscription definition.
+ *
+ * @template S - The Subscription type
+ */
 export type InferSubscriptionMessage<S extends Subscription> = Infer<S['message']>;
-export declare class Subscription<const TNsid extends NsidString = NsidString, const TParameters extends ParamsSchema = ParamsSchema, const TMessage extends Schema = Schema, const TErrors extends undefined | readonly string[] = undefined | readonly string[]> {
+/**
+ * Represents a Lexicon subscription (WebSocket) endpoint definition.
+ *
+ * Subscriptions are real-time event streams delivered over WebSocket.
+ * They have parameters for initializing the connection and a message
+ * schema for validating incoming events.
+ *
+ * @template TNsid - The NSID identifying this subscription
+ * @template TParameters - The connection parameters schema type
+ * @template TMessage - The message schema type
+ * @template TErrors - Array of error type strings, or undefined
+ *
+ * @example
+ * ```ts
+ * const firehose = new Subscription(
+ *   'com.atproto.sync.subscribeRepos',
+ *   l.params({ cursor: l.optional(l.integer()) }),
+ *   repoEventSchema,
+ *   ['FutureCursor']
+ * )
+ * ```
+ */
+export declare class Subscription<const TNsid extends NsidString = NsidString, const TParameters extends ParamsSchema = ParamsSchema, const TMessage extends Schema<LexValue> = Schema<LexValue>, const TErrors extends undefined | readonly string[] = undefined | readonly string[]> {
     readonly nsid: TNsid;
     readonly parameters: TParameters;
     readonly message: TMessage;
@@ -10,5 +43,42 @@ export declare class Subscription<const TNsid extends NsidString = NsidString, c
     readonly type: "subscription";
     constructor(nsid: TNsid, parameters: TParameters, message: TMessage, errors: TErrors);
 }
-export declare function subscription<const N extends NsidString, const P extends ParamsSchema, const M extends Schema, const E extends undefined | readonly string[] = undefined>(nsid: N, parameters: P, message: M, errors?: E): Subscription<N, P, M, E>;
+/**
+ * Creates a subscription definition for a Lexicon WebSocket endpoint.
+ *
+ * Subscriptions enable real-time event streaming. The connection is
+ * initialized with parameters, and the server sends messages matching
+ * the message schema.
+ *
+ * @param nsid - The NSID identifying this subscription endpoint
+ * @param parameters - Schema for connection parameters
+ * @param message - Schema for validating incoming messages
+ * @param errors - Optional array of error type strings
+ * @returns A new {@link Subscription} instance
+ *
+ * @example
+ * ```ts
+ * // Repository event stream
+ * const subscribeRepos = l.subscription(
+ *   'com.atproto.sync.subscribeRepos',
+ *   l.params({
+ *     cursor: l.optional(l.integer()),
+ *   }),
+ *   l.typedUnion([
+ *     l.typedRef(() => commitEventSchema),
+ *     l.typedRef(() => handleEventSchema),
+ *     l.typedRef(() => identityEventSchema),
+ *   ], false),
+ *   ['FutureCursor', 'ConsumerTooSlow'],
+ * )
+ *
+ * // Label stream
+ * const subscribeLabels = l.subscription(
+ *   'com.atproto.label.subscribeLabels',
+ *   l.params({ cursor: l.optional(l.integer()) }),
+ *   labelEventSchema,
+ * )
+ * ```
+ */
+export declare function subscription<const N extends NsidString, const P extends ParamsSchema, const M extends Schema<LexValue>, const E extends undefined | readonly string[] = undefined>(nsid: N, parameters: P, message: M, errors?: E): Subscription<N, P, M, E>;
 //# sourceMappingURL=subscription.d.ts.map

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

@@ -1 +1 @@
-{"version":3,"file":"subscription.d.ts","sourceRoot":"","sources":["../../src/schema/subscription.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,KAAK,EAAE,UAAU,EAAE,MAAM,EAAE,MAAM,YAAY,CAAA;AACtD,OAAO,EAAE,YAAY,EAAE,MAAM,aAAa,CAAA;AAE1C,MAAM,MAAM,2BAA2B,CAAC,CAAC,SAAS,YAAY,IAAI,KAAK,CACrE,CAAC,CAAC,YAAY,CAAC,CAChB,CAAA;AAED,MAAM,MAAM,wBAAwB,CAAC,CAAC,SAAS,YAAY,IAAI,KAAK,CAClE,CAAC,CAAC,SAAS,CAAC,CACb,CAAA;AAED,qBAAa,YAAY,CACvB,KAAK,CAAC,KAAK,SAAS,UAAU,GAAG,UAAU,EAC3C,KAAK,CAAC,WAAW,SAAS,YAAY,GAAG,YAAY,EACrD,KAAK,CAAC,QAAQ,SAAS,MAAM,GAAG,MAAM,EACtC,KAAK,CAAC,OAAO,SAAS,SAAS,GAAG,SAAS,MAAM,EAAE,GAC/C,SAAS,GACT,SAAS,MAAM,EAAE;IAKnB,QAAQ,CAAC,IAAI,EAAE,KAAK;IACpB,QAAQ,CAAC,UAAU,EAAE,WAAW;IAChC,QAAQ,CAAC,OAAO,EAAE,QAAQ;IAC1B,QAAQ,CAAC,MAAM,EAAE,OAAO;IAN1B,QAAQ,CAAC,IAAI,EAAG,cAAc,CAAS;gBAG5B,IAAI,EAAE,KAAK,EACX,UAAU,EAAE,WAAW,EACvB,OAAO,EAAE,QAAQ,EACjB,MAAM,EAAE,OAAO;CAE3B;AAGD,wBAAgB,YAAY,CAC1B,KAAK,CAAC,CAAC,SAAS,UAAU,EAC1B,KAAK,CAAC,CAAC,SAAS,YAAY,EAC5B,KAAK,CAAC,CAAC,SAAS,MAAM,EACtB,KAAK,CAAC,CAAC,SAAS,SAAS,GAAG,SAAS,MAAM,EAAE,GAAG,SAAS,EACzD,IAAI,EAAE,CAAC,EAAE,UAAU,EAAE,CAAC,EAAE,OAAO,EAAE,CAAC,EAAE,MAAM,GAAE,CAAkB,4BAE/D"}
+{"version":3,"file":"subscription.d.ts","sourceRoot":"","sources":["../../src/schema/subscription.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,QAAQ,EAAE,MAAM,mBAAmB,CAAA;AAC5C,OAAO,EAAE,KAAK,EAAE,UAAU,EAAE,MAAM,EAAE,MAAM,YAAY,CAAA;AACtD,OAAO,EAAE,YAAY,EAAE,MAAM,aAAa,CAAA;AAE1C;;;;GAIG;AACH,MAAM,MAAM,2BAA2B,CAAC,CAAC,SAAS,YAAY,IAAI,KAAK,CACrE,CAAC,CAAC,YAAY,CAAC,CAChB,CAAA;AAED;;;;GAIG;AACH,MAAM,MAAM,wBAAwB,CAAC,CAAC,SAAS,YAAY,IAAI,KAAK,CAClE,CAAC,CAAC,SAAS,CAAC,CACb,CAAA;AAED;;;;;;;;;;;;;;;;;;;;;GAqBG;AACH,qBAAa,YAAY,CACvB,KAAK,CAAC,KAAK,SAAS,UAAU,GAAG,UAAU,EAC3C,KAAK,CAAC,WAAW,SAAS,YAAY,GAAG,YAAY,EACrD,KAAK,CAAC,QAAQ,SAAS,MAAM,CAAC,QAAQ,CAAC,GAAG,MAAM,CAAC,QAAQ,CAAC,EAC1D,KAAK,CAAC,OAAO,SAAS,SAAS,GAAG,SAAS,MAAM,EAAE,GAC/C,SAAS,GACT,SAAS,MAAM,EAAE;IAKnB,QAAQ,CAAC,IAAI,EAAE,KAAK;IACpB,QAAQ,CAAC,UAAU,EAAE,WAAW;IAChC,QAAQ,CAAC,OAAO,EAAE,QAAQ;IAC1B,QAAQ,CAAC,MAAM,EAAE,OAAO;IAN1B,QAAQ,CAAC,IAAI,EAAG,cAAc,CAAS;gBAG5B,IAAI,EAAE,KAAK,EACX,UAAU,EAAE,WAAW,EACvB,OAAO,EAAE,QAAQ,EACjB,MAAM,EAAE,OAAO;CAE3B;AAED;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAoCG;AAEH,wBAAgB,YAAY,CAC1B,KAAK,CAAC,CAAC,SAAS,UAAU,EAC1B,KAAK,CAAC,CAAC,SAAS,YAAY,EAC5B,KAAK,CAAC,CAAC,SAAS,MAAM,CAAC,QAAQ,CAAC,EAChC,KAAK,CAAC,CAAC,SAAS,SAAS,GAAG,SAAS,MAAM,EAAE,GAAG,SAAS,EACzD,IAAI,EAAE,CAAC,EAAE,UAAU,EAAE,CAAC,EAAE,OAAO,EAAE,CAAC,EAAE,MAAM,GAAE,CAAkB,4BAE/D"}

package/dist/schema/subscription.js

@@ -2,6 +2,28 @@
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.Subscription = void 0;
 exports.subscription = subscription;
+/**
+ * Represents a Lexicon subscription (WebSocket) endpoint definition.
+ *
+ * Subscriptions are real-time event streams delivered over WebSocket.
+ * They have parameters for initializing the connection and a message
+ * schema for validating incoming events.
+ *
+ * @template TNsid - The NSID identifying this subscription
+ * @template TParameters - The connection parameters schema type
+ * @template TMessage - The message schema type
+ * @template TErrors - Array of error type strings, or undefined
+ *
+ * @example
+ * ```ts
+ * const firehose = new Subscription(
+ *   'com.atproto.sync.subscribeRepos',
+ *   l.params({ cursor: l.optional(l.integer()) }),
+ *   repoEventSchema,
+ *   ['FutureCursor']
+ * )
+ * ```
+ */
 class Subscription {
     nsid;
     parameters;
@@ -16,6 +38,43 @@ class Subscription {
     }
 }
 exports.Subscription = Subscription;
+/**
+ * Creates a subscription definition for a Lexicon WebSocket endpoint.
+ *
+ * Subscriptions enable real-time event streaming. The connection is
+ * initialized with parameters, and the server sends messages matching
+ * the message schema.
+ *
+ * @param nsid - The NSID identifying this subscription endpoint
+ * @param parameters - Schema for connection parameters
+ * @param message - Schema for validating incoming messages
+ * @param errors - Optional array of error type strings
+ * @returns A new {@link Subscription} instance
+ *
+ * @example
+ * ```ts
+ * // Repository event stream
+ * const subscribeRepos = l.subscription(
+ *   'com.atproto.sync.subscribeRepos',
+ *   l.params({
+ *     cursor: l.optional(l.integer()),
+ *   }),
+ *   l.typedUnion([
+ *     l.typedRef(() => commitEventSchema),
+ *     l.typedRef(() => handleEventSchema),
+ *     l.typedRef(() => identityEventSchema),
+ *   ], false),
+ *   ['FutureCursor', 'ConsumerTooSlow'],
+ * )
+ *
+ * // Label stream
+ * const subscribeLabels = l.subscription(
+ *   'com.atproto.label.subscribeLabels',
+ *   l.params({ cursor: l.optional(l.integer()) }),
+ *   labelEventSchema,
+ * )
+ * ```
+ */
 /*@__NO_SIDE_EFFECTS__*/
 function subscription(nsid, parameters, message, errors = undefined) {
     return new Subscription(nsid, parameters, message, errors);

package/dist/schema/subscription.js.map

@@ -1 +1 @@
-{"version":3,"file":"subscription.js","sourceRoot":"","sources":["../../src/schema/subscription.ts"],"names":[],"mappings":";;;AA8BA,oCAOC;AA1BD,MAAa,YAAY;IAWZ;IACA;IACA;IACA;IANF,IAAI,GAAG,cAAuB,CAAA;IAEvC,YACW,IAAW,EACX,UAAuB,EACvB,OAAiB,EACjB,MAAe;QAHf,SAAI,GAAJ,IAAI,CAAO;QACX,eAAU,GAAV,UAAU,CAAa;QACvB,YAAO,GAAP,OAAO,CAAU;QACjB,WAAM,GAAN,MAAM,CAAS;IACvB,CAAC;CACL;AAhBD,oCAgBC;AAED,wBAAwB;AACxB,SAAgB,YAAY,CAK1B,IAAO,EAAE,UAAa,EAAE,OAAU,EAAE,SAAY,SAAc;IAC9D,OAAO,IAAI,YAAY,CAAa,IAAI,EAAE,UAAU,EAAE,OAAO,EAAE,MAAM,CAAC,CAAA;AACxE,CAAC","sourcesContent":["import { Infer, NsidString, Schema } from '../core.js'\nimport { ParamsSchema } from './params.js'\n\nexport type InferSubscriptionParameters<S extends Subscription> = Infer<\n  S['parameters']\n>\n\nexport type InferSubscriptionMessage<S extends Subscription> = Infer<\n  S['message']\n>\n\nexport class Subscription<\n  const TNsid extends NsidString = NsidString,\n  const TParameters extends ParamsSchema = ParamsSchema,\n  const TMessage extends Schema = Schema,\n  const TErrors extends undefined | readonly string[] =\n    | undefined\n    | readonly string[],\n> {\n  readonly type = 'subscription' as const\n\n  constructor(\n    readonly nsid: TNsid,\n    readonly parameters: TParameters,\n    readonly message: TMessage,\n    readonly errors: TErrors,\n  ) {}\n}\n\n/*@__NO_SIDE_EFFECTS__*/\nexport function subscription<\n  const N extends NsidString,\n  const P extends ParamsSchema,\n  const M extends Schema,\n  const E extends undefined | readonly string[] = undefined,\n>(nsid: N, parameters: P, message: M, errors: E = undefined as E) {\n  return new Subscription<N, P, M, E>(nsid, parameters, message, errors)\n}\n"]}
+{"version":3,"file":"subscription.js","sourceRoot":"","sources":["../../src/schema/subscription.ts"],"names":[],"mappings":";;;AAoGA,oCAOC;AArFD;;;;;;;;;;;;;;;;;;;;;GAqBG;AACH,MAAa,YAAY;IAWZ;IACA;IACA;IACA;IANF,IAAI,GAAG,cAAuB,CAAA;IAEvC,YACW,IAAW,EACX,UAAuB,EACvB,OAAiB,EACjB,MAAe;QAHf,SAAI,GAAJ,IAAI,CAAO;QACX,eAAU,GAAV,UAAU,CAAa;QACvB,YAAO,GAAP,OAAO,CAAU;QACjB,WAAM,GAAN,MAAM,CAAS;IACvB,CAAC;CACL;AAhBD,oCAgBC;AAED;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAoCG;AACH,wBAAwB;AACxB,SAAgB,YAAY,CAK1B,IAAO,EAAE,UAAa,EAAE,OAAU,EAAE,SAAY,SAAc;IAC9D,OAAO,IAAI,YAAY,CAAa,IAAI,EAAE,UAAU,EAAE,OAAO,EAAE,MAAM,CAAC,CAAA;AACxE,CAAC","sourcesContent":["import { LexValue } from '@atproto/lex-data'\nimport { Infer, NsidString, Schema } from '../core.js'\nimport { ParamsSchema } from './params.js'\n\n/**\n * Infers the parameters type from a Subscription definition.\n *\n * @template S - The Subscription type\n */\nexport type InferSubscriptionParameters<S extends Subscription> = Infer<\n  S['parameters']\n>\n\n/**\n * Infers the message type from a Subscription definition.\n *\n * @template S - The Subscription type\n */\nexport type InferSubscriptionMessage<S extends Subscription> = Infer<\n  S['message']\n>\n\n/**\n * Represents a Lexicon subscription (WebSocket) endpoint definition.\n *\n * Subscriptions are real-time event streams delivered over WebSocket.\n * They have parameters for initializing the connection and a message\n * schema for validating incoming events.\n *\n * @template TNsid - The NSID identifying this subscription\n * @template TParameters - The connection parameters schema type\n * @template TMessage - The message schema type\n * @template TErrors - Array of error type strings, or undefined\n *\n * @example\n * ```ts\n * const firehose = new Subscription(\n *   'com.atproto.sync.subscribeRepos',\n *   l.params({ cursor: l.optional(l.integer()) }),\n *   repoEventSchema,\n *   ['FutureCursor']\n * )\n * ```\n */\nexport class Subscription<\n  const TNsid extends NsidString = NsidString,\n  const TParameters extends ParamsSchema = ParamsSchema,\n  const TMessage extends Schema<LexValue> = Schema<LexValue>,\n  const TErrors extends undefined | readonly string[] =\n    | undefined\n    | readonly string[],\n> {\n  readonly type = 'subscription' as const\n\n  constructor(\n    readonly nsid: TNsid,\n    readonly parameters: TParameters,\n    readonly message: TMessage,\n    readonly errors: TErrors,\n  ) {}\n}\n\n/**\n * Creates a subscription definition for a Lexicon WebSocket endpoint.\n *\n * Subscriptions enable real-time event streaming. The connection is\n * initialized with parameters, and the server sends messages matching\n * the message schema.\n *\n * @param nsid - The NSID identifying this subscription endpoint\n * @param parameters - Schema for connection parameters\n * @param message - Schema for validating incoming messages\n * @param errors - Optional array of error type strings\n * @returns A new {@link Subscription} instance\n *\n * @example\n * ```ts\n * // Repository event stream\n * const subscribeRepos = l.subscription(\n *   'com.atproto.sync.subscribeRepos',\n *   l.params({\n *     cursor: l.optional(l.integer()),\n *   }),\n *   l.typedUnion([\n *     l.typedRef(() => commitEventSchema),\n *     l.typedRef(() => handleEventSchema),\n *     l.typedRef(() => identityEventSchema),\n *   ], false),\n *   ['FutureCursor', 'ConsumerTooSlow'],\n * )\n *\n * // Label stream\n * const subscribeLabels = l.subscription(\n *   'com.atproto.label.subscribeLabels',\n *   l.params({ cursor: l.optional(l.integer()) }),\n *   labelEventSchema,\n * )\n * ```\n */\n/*@__NO_SIDE_EFFECTS__*/\nexport function subscription<\n  const N extends NsidString,\n  const P extends ParamsSchema,\n  const M extends Schema<LexValue>,\n  const E extends undefined | readonly string[] = undefined,\n>(nsid: N, parameters: P, message: M, errors: E = undefined as E) {\n  return new Subscription<N, P, M, E>(nsid, parameters, message, errors)\n}\n"]}

package/dist/schema/token.d.ts

@@ -1,10 +1,58 @@
 import { NsidString, Schema, ValidationContext } from '../core.js';
+/**
+ * Schema for Lexicon token values.
+ *
+ * Tokens are named constants in Lexicon, identified by their NSID and hash.
+ * They validate to their string value (e.g., 'app.bsky.feed.defs#requestLess').
+ * TokenSchema instances can also be used as values themselves.
+ *
+ * @template TValue - The token string literal type
+ *
+ * @example
+ * ```ts
+ * const schema = new TokenSchema('app.bsky.feed.defs#requestLess')
+ * schema.validate('app.bsky.feed.defs#requestLess') // success
+ * ```
+ */
 export declare class TokenSchema<const TValue extends string = string> extends Schema<TValue> {
     readonly value: TValue;
+    readonly type: "token";
     constructor(value: TValue);
     validateInContext(input: unknown, ctx: ValidationContext): import("../core.js").ValidationResult<TValue>;
     toJSON(): string;
     toString(): string;
 }
+/**
+ * Creates a token schema for Lexicon named constants.
+ *
+ * Tokens are used in Lexicon as named constants or enum-like values.
+ * The token instance can be used both as a schema validator and as
+ * the token value itself (it serializes to its string value).
+ *
+ * @param nsid - The NSID part of the token
+ * @param hash - The hash part of the token (defaults to 'main')
+ * @returns A new {@link TokenSchema} instance
+ *
+ * @example
+ * ```ts
+ * // Define tokens
+ * const requestLess = l.token('app.bsky.feed.defs', 'requestLess')
+ * const requestMore = l.token('app.bsky.feed.defs', 'requestMore')
+ *
+ * // Use as a value
+ * console.log(requestLess.toString()) // 'app.bsky.feed.defs#requestLess'
+ *
+ * // Use in union for validation
+ * const feedbackSchema = l.union([requestLess, requestMore])
+ *
+ * // Validate
+ * feedbackSchema.parse('app.bsky.feed.defs#requestLess') // success
+ *
+ * // Token instances can be used as values in other schemas
+ * const feedbackRequest = l.object({
+ *   feedback: requestLess, // Accepts the token value
+ * })
+ * ```
+ */
 export declare function token<const N extends NsidString, const H extends string = 'main'>(nsid: N, hash?: H): TokenSchema<import("../core.js").$Type<N, H>>;
 //# sourceMappingURL=token.d.ts.map

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

@@ -1 +1 @@
-{"version":3,"file":"token.d.ts","sourceRoot":"","sources":["../../src/schema/token.ts"],"names":[],"mappings":"AAAA,OAAO,EAAS,UAAU,EAAE,MAAM,EAAE,iBAAiB,EAAE,MAAM,YAAY,CAAA;AAEzE,qBAAa,WAAW,CACtB,KAAK,CAAC,MAAM,SAAS,MAAM,GAAG,MAAM,CACpC,SAAQ,MAAM,CAAC,MAAM,CAAC;IACV,QAAQ,CAAC,KAAK,EAAE,MAAM;gBAAb,KAAK,EAAE,MAAM;IAIlC,iBAAiB,CAAC,KAAK,EAAE,OAAO,EAAE,GAAG,EAAE,iBAAiB;IAqBxD,MAAM,IAAI,MAAM;IAIhB,QAAQ,IAAI,MAAM;CAGnB;AAGD,wBAAgB,KAAK,CACnB,KAAK,CAAC,CAAC,SAAS,UAAU,EAC1B,KAAK,CAAC,CAAC,SAAS,MAAM,GAAG,MAAM,EAC/B,IAAI,EAAE,CAAC,EAAE,IAAI,GAAE,CAAe,iDAE/B"}
+{"version":3,"file":"token.d.ts","sourceRoot":"","sources":["../../src/schema/token.ts"],"names":[],"mappings":"AAAA,OAAO,EAAS,UAAU,EAAE,MAAM,EAAE,iBAAiB,EAAE,MAAM,YAAY,CAAA;AAEzE;;;;;;;;;;;;;;GAcG;AACH,qBAAa,WAAW,CACtB,KAAK,CAAC,MAAM,SAAS,MAAM,GAAG,MAAM,CACpC,SAAQ,MAAM,CAAC,MAAM,CAAC;IAGV,QAAQ,CAAC,KAAK,EAAE,MAAM;IAFlC,QAAQ,CAAC,IAAI,EAAG,OAAO,CAAS;gBAEX,KAAK,EAAE,MAAM;IAIlC,iBAAiB,CAAC,KAAK,EAAE,OAAO,EAAE,GAAG,EAAE,iBAAiB;IAqBxD,MAAM,IAAI,MAAM;IAIhB,QAAQ,IAAI,MAAM;CAGnB;AAED;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GA+BG;AAEH,wBAAgB,KAAK,CACnB,KAAK,CAAC,CAAC,SAAS,UAAU,EAC1B,KAAK,CAAC,CAAC,SAAS,MAAM,GAAG,MAAM,EAC/B,IAAI,EAAE,CAAC,EAAE,IAAI,GAAE,CAAe,iDAE/B"}

package/dist/schema/token.js

@@ -3,8 +3,24 @@ Object.defineProperty(exports, "__esModule", { value: true });
 exports.TokenSchema = void 0;
 exports.token = token;
 const core_js_1 = require("../core.js");
+/**
+ * Schema for Lexicon token values.
+ *
+ * Tokens are named constants in Lexicon, identified by their NSID and hash.
+ * They validate to their string value (e.g., 'app.bsky.feed.defs#requestLess').
+ * TokenSchema instances can also be used as values themselves.
+ *
+ * @template TValue - The token string literal type
+ *
+ * @example
+ * ```ts
+ * const schema = new TokenSchema('app.bsky.feed.defs#requestLess')
+ * schema.validate('app.bsky.feed.defs#requestLess') // success
+ * ```
+ */
 class TokenSchema extends core_js_1.Schema {
     value;
+    type = 'token';
     constructor(value) {
         super();
         this.value = value;
@@ -19,7 +35,7 @@ class TokenSchema extends core_js_1.Schema {
             return ctx.success(this.value);
         }
         if (typeof input !== 'string') {
-            return ctx.issueInvalidType(input, 'token');
+            return ctx.issueUnexpectedType(input, 'token');
         }
         return ctx.issueInvalidValue(input, [this.value]);
     }
@@ -33,6 +49,38 @@ class TokenSchema extends core_js_1.Schema {
     }
 }
 exports.TokenSchema = TokenSchema;
+/**
+ * Creates a token schema for Lexicon named constants.
+ *
+ * Tokens are used in Lexicon as named constants or enum-like values.
+ * The token instance can be used both as a schema validator and as
+ * the token value itself (it serializes to its string value).
+ *
+ * @param nsid - The NSID part of the token
+ * @param hash - The hash part of the token (defaults to 'main')
+ * @returns A new {@link TokenSchema} instance
+ *
+ * @example
+ * ```ts
+ * // Define tokens
+ * const requestLess = l.token('app.bsky.feed.defs', 'requestLess')
+ * const requestMore = l.token('app.bsky.feed.defs', 'requestMore')
+ *
+ * // Use as a value
+ * console.log(requestLess.toString()) // 'app.bsky.feed.defs#requestLess'
+ *
+ * // Use in union for validation
+ * const feedbackSchema = l.union([requestLess, requestMore])
+ *
+ * // Validate
+ * feedbackSchema.parse('app.bsky.feed.defs#requestLess') // success
+ *
+ * // Token instances can be used as values in other schemas
+ * const feedbackRequest = l.object({
+ *   feedback: requestLess, // Accepts the token value
+ * })
+ * ```
+ */
 /*@__NO_SIDE_EFFECTS__*/
 function token(nsid, hash = 'main') {
     return new TokenSchema((0, core_js_1.$type)(nsid, hash));

package/dist/schema/token.js.map

@@ -1 +1 @@
-{"version":3,"file":"token.js","sourceRoot":"","sources":["../../src/schema/token.ts"],"names":[],"mappings":";;;AAwCA,sBAKC;AA7CD,wCAAyE;AAEzE,MAAa,WAEX,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,OAAO,CAAC,IAAI,CAAC,KAAK,CAAC,CAAA;QAChC,CAAC;QAED,0EAA0E;QAC1E,eAAe;QACf,IAAI,KAAK,YAAY,WAAW,IAAI,KAAK,CAAC,KAAK,KAAK,IAAI,CAAC,KAAK,EAAE,CAAC;YAC/D,OAAO,GAAG,CAAC,OAAO,CAAC,IAAI,CAAC,KAAK,CAAC,CAAA;QAChC,CAAC;QAED,IAAI,OAAO,KAAK,KAAK,QAAQ,EAAE,CAAC;YAC9B,OAAO,GAAG,CAAC,gBAAgB,CAAC,KAAK,EAAE,OAAO,CAAC,CAAA;QAC7C,CAAC;QAED,OAAO,GAAG,CAAC,iBAAiB,CAAC,KAAK,EAAE,CAAC,IAAI,CAAC,KAAK,CAAC,CAAC,CAAA;IACnD,CAAC;IAED,yEAAyE;IACzE,cAAc;IAEd,MAAM;QACJ,OAAO,IAAI,CAAC,KAAK,CAAA;IACnB,CAAC;IAED,QAAQ;QACN,OAAO,IAAI,CAAC,KAAK,CAAA;IACnB,CAAC;CACF;AAnCD,kCAmCC;AAED,wBAAwB;AACxB,SAAgB,KAAK,CAGnB,IAAO,EAAE,OAAU,MAAW;IAC9B,OAAO,IAAI,WAAW,CAAC,IAAA,eAAK,EAAC,IAAI,EAAE,IAAI,CAAC,CAAC,CAAA;AAC3C,CAAC","sourcesContent":["import { $type, NsidString, Schema, ValidationContext } from '../core.js'\n\nexport class TokenSchema<\n  const TValue extends string = string,\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.success(this.value)\n    }\n\n    // @NOTE: allow using the token instance itself (but convert to the actual\n    // token value)\n    if (input instanceof TokenSchema && input.value === this.value) {\n      return ctx.success(this.value)\n    }\n\n    if (typeof input !== 'string') {\n      return ctx.issueInvalidType(input, 'token')\n    }\n\n    return ctx.issueInvalidValue(input, [this.value])\n  }\n\n  // When using the TokenSchema instance as data, let's serialize it to the\n  // token value\n\n  toJSON(): string {\n    return this.value\n  }\n\n  toString(): string {\n    return this.value\n  }\n}\n\n/*@__NO_SIDE_EFFECTS__*/\nexport function token<\n  const N extends NsidString,\n  const H extends string = 'main',\n>(nsid: N, hash: H = 'main' as H) {\n  return new TokenSchema($type(nsid, hash))\n}\n"]}
+{"version":3,"file":"token.js","sourceRoot":"","sources":["../../src/schema/token.ts"],"names":[],"mappings":";;;AAyFA,sBAKC;AA9FD,wCAAyE;AAEzE;;;;;;;;;;;;;;GAcG;AACH,MAAa,WAEX,SAAQ,gBAAc;IAGD;IAFZ,IAAI,GAAG,OAAgB,CAAA;IAEhC,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,OAAO,CAAC,IAAI,CAAC,KAAK,CAAC,CAAA;QAChC,CAAC;QAED,0EAA0E;QAC1E,eAAe;QACf,IAAI,KAAK,YAAY,WAAW,IAAI,KAAK,CAAC,KAAK,KAAK,IAAI,CAAC,KAAK,EAAE,CAAC;YAC/D,OAAO,GAAG,CAAC,OAAO,CAAC,IAAI,CAAC,KAAK,CAAC,CAAA;QAChC,CAAC;QAED,IAAI,OAAO,KAAK,KAAK,QAAQ,EAAE,CAAC;YAC9B,OAAO,GAAG,CAAC,mBAAmB,CAAC,KAAK,EAAE,OAAO,CAAC,CAAA;QAChD,CAAC;QAED,OAAO,GAAG,CAAC,iBAAiB,CAAC,KAAK,EAAE,CAAC,IAAI,CAAC,KAAK,CAAC,CAAC,CAAA;IACnD,CAAC;IAED,yEAAyE;IACzE,cAAc;IAEd,MAAM;QACJ,OAAO,IAAI,CAAC,KAAK,CAAA;IACnB,CAAC;IAED,QAAQ;QACN,OAAO,IAAI,CAAC,KAAK,CAAA;IACnB,CAAC;CACF;AArCD,kCAqCC;AAED;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GA+BG;AACH,wBAAwB;AACxB,SAAgB,KAAK,CAGnB,IAAO,EAAE,OAAU,MAAW;IAC9B,OAAO,IAAI,WAAW,CAAC,IAAA,eAAK,EAAC,IAAI,EAAE,IAAI,CAAC,CAAC,CAAA;AAC3C,CAAC","sourcesContent":["import { $type, NsidString, Schema, ValidationContext } from '../core.js'\n\n/**\n * Schema for Lexicon token values.\n *\n * Tokens are named constants in Lexicon, identified by their NSID and hash.\n * They validate to their string value (e.g., 'app.bsky.feed.defs#requestLess').\n * TokenSchema instances can also be used as values themselves.\n *\n * @template TValue - The token string literal type\n *\n * @example\n * ```ts\n * const schema = new TokenSchema('app.bsky.feed.defs#requestLess')\n * schema.validate('app.bsky.feed.defs#requestLess') // success\n * ```\n */\nexport class TokenSchema<\n  const TValue extends string = string,\n> extends Schema<TValue> {\n  readonly type = 'token' 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.success(this.value)\n    }\n\n    // @NOTE: allow using the token instance itself (but convert to the actual\n    // token value)\n    if (input instanceof TokenSchema && input.value === this.value) {\n      return ctx.success(this.value)\n    }\n\n    if (typeof input !== 'string') {\n      return ctx.issueUnexpectedType(input, 'token')\n    }\n\n    return ctx.issueInvalidValue(input, [this.value])\n  }\n\n  // When using the TokenSchema instance as data, let's serialize it to the\n  // token value\n\n  toJSON(): string {\n    return this.value\n  }\n\n  toString(): string {\n    return this.value\n  }\n}\n\n/**\n * Creates a token schema for Lexicon named constants.\n *\n * Tokens are used in Lexicon as named constants or enum-like values.\n * The token instance can be used both as a schema validator and as\n * the token value itself (it serializes to its string value).\n *\n * @param nsid - The NSID part of the token\n * @param hash - The hash part of the token (defaults to 'main')\n * @returns A new {@link TokenSchema} instance\n *\n * @example\n * ```ts\n * // Define tokens\n * const requestLess = l.token('app.bsky.feed.defs', 'requestLess')\n * const requestMore = l.token('app.bsky.feed.defs', 'requestMore')\n *\n * // Use as a value\n * console.log(requestLess.toString()) // 'app.bsky.feed.defs#requestLess'\n *\n * // Use in union for validation\n * const feedbackSchema = l.union([requestLess, requestMore])\n *\n * // Validate\n * feedbackSchema.parse('app.bsky.feed.defs#requestLess') // success\n *\n * // Token instances can be used as values in other schemas\n * const feedbackRequest = l.object({\n *   feedback: requestLess, // Accepts the token value\n * })\n * ```\n */\n/*@__NO_SIDE_EFFECTS__*/\nexport function token<\n  const N extends NsidString,\n  const H extends string = 'main',\n>(nsid: N, hash: H = 'main' as H) {\n  return new TokenSchema($type(nsid, hash))\n}\n"]}

package/dist/schema/typed-object.d.ts

@@ -1,38 +1,88 @@
 import { $Type, $TypeOf, $Typed, $TypedMaybe, InferInput, InferOutput, NsidString, Schema, Unknown$TypedObject, ValidationContext, Validator } from '../core.js';
+export type MaybeTypedObject<TType extends $Type, TValue extends {
+    $type?: unknown;
+} = {
+    $type?: unknown;
+}> = TValue extends {
+    $type?: TType;
+} ? TValue : $TypedMaybe<Exclude<TValue, Unknown$TypedObject>, TType>;
+/**
+ * Schema for typed objects in Lexicon unions.
+ *
+ * Typed objects have a `$type` field that identifies which variant they are
+ * in a union. The `$type` can be omitted in input (it's implicit), but if
+ * present, it must match the expected value.
+ *
+ * @template TType - The $type string literal type
+ * @template TShape - The validator type for the object's shape
+ *
+ * @example
+ * ```ts
+ * const schema = new TypedObjectSchema(
+ *   'app.bsky.embed.images#view',
+ *   l.object({ images: l.array(imageSchema) })
+ * )
+ * ```
+ */
 export declare class TypedObjectSchema<const TType extends $Type = $Type, const TShape extends Validator<{
     [k: string]: unknown;
 }> = any> extends Schema<$TypedMaybe<InferInput<TShape>, TType>, $TypedMaybe<InferOutput<TShape>, TType>> {
     readonly $type: TType;
     readonly schema: TShape;
+    readonly type: "typedObject";
     constructor($type: TType, schema: TShape);
-    isTypeOf<X extends Record<string, unknown>>(value: X): value is X extends {
-        $type?: TType;
-    } ? X : $TypedMaybe<Exclude<X, Unknown$TypedObject>, TType>;
+    isTypeOf<TValue extends Record<string, unknown>>(value: TValue): value is MaybeTypedObject<TType, TValue>;
     build(input: Omit<InferInput<this>, '$type'>): $Typed<InferOutput<this>, TType>;
-    $isTypeOf<X extends Record<string, unknown>>(value: X): value is X extends {
-        $type?: TType;
-    } ? X : Exclude<X, Unknown$TypedObject> & {
-        $type?: TType | undefined;
-    } extends infer T ? { [K in keyof T]: (Exclude<X, Unknown$TypedObject> & {
-        $type?: TType | undefined;
-    })[K]; } : never;
-    $build(input: Omit<InferInput<this>, '$type'>): InferOutput<this> & {
-        $type: TType;
-    } extends infer T ? { [K in keyof T]: (InferOutput<this> & {
-        $type: TType;
-    })[K]; } : never;
+    $isTypeOf<TValue extends Record<string, unknown>>(value: TValue): value is MaybeTypedObject<TType, TValue>;
+    $build(input: Omit<InferInput<this>, '$type'>): $Typed<InferOutput<this>, TType>;
     validateInContext(input: unknown, ctx: ValidationContext): import("../core.js").ValidationResult<InferInput<TShape>>;
 }
 /**
+ * Creates a typed object schema for use in Lexicon unions.
+ *
+ * Typed objects are identified by their `$type` field, which combines an NSID
+ * and a hash (e.g., 'app.bsky.embed.images#view'). Used for union variants.
+ *
  * This function offers two overloads:
- * - One that allows creating a {@link TypedObjectSchema}, and infer the output
- *   type from the provided arguments, without requiring to specify any of the
- *   generics. This is useful when you want to define a record without
- *   explicitly defining its interface. This version does not support circular
- *   references, as TypeScript cannot infer types in such cases.
- * - One allows creating a {@link TypedObjectSchema} with an explicitly defined
- *   interface. This will typically be used by codegen (`lex build`) to generate
- *   schemas that work even if they contain circular references.
+ * - One that infers the type from arguments (no circular reference support)
+ * - One with explicit interface for codegen with circular references
+ *
+ * @param nsid - The NSID part of the type (e.g., 'app.bsky.embed.images')
+ * @param hash - The hash part of the type (e.g., 'view'), defaults to 'main'
+ * @param validator - Schema for validating the object properties
+ * @returns A new {@link TypedObjectSchema} instance
+ *
+ * @example
+ * ```ts
+ * // Image embed view
+ * const imageViewSchema = l.typedObject(
+ *   'app.bsky.embed.images',
+ *   'view',
+ *   l.object({
+ *     images: l.array(l.object({
+ *       thumb: l.string(),
+ *       fullsize: l.string(),
+ *       alt: l.string(),
+ *     })),
+ *   })
+ * )
+ *
+ * // Main type (hash defaults to 'main')
+ * const postViewSchema = l.typedObject(
+ *   'app.bsky.feed.defs',
+ *   'postView',
+ *   l.object({ uri: l.string(), cid: l.string(), author: authorSchema })
+ * )
+ *
+ * // Use $isTypeOf to narrow union types
+ * if (imageViewSchema.$isTypeOf(embed)) {
+ *   // embed is narrowed to image view type
+ * }
+ *
+ * // Use $build to construct typed objects
+ * const view = imageViewSchema.$build({ images: [...] })
+ * // view.$type === 'app.bsky.embed.images#view'
+ * ```
  */
 export declare function typedObject<const N extends NsidString, const H extends string, const S extends Validator<{
     [k: string]: unknown;

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

@@ -1 +1 @@
-{"version":3,"file":"typed-object.d.ts","sourceRoot":"","sources":["../../src/schema/typed-object.ts"],"names":[],"mappings":"AACA,OAAO,EACL,KAAK,EACL,OAAO,EACP,MAAM,EACN,WAAW,EAGX,UAAU,EACV,WAAW,EACX,UAAU,EACV,MAAM,EACN,mBAAmB,EACnB,iBAAiB,EACjB,SAAS,EACV,MAAM,YAAY,CAAA;AAEnB,qBAAa,iBAAiB,CAC5B,KAAK,CAAC,KAAK,SAAS,KAAK,GAAG,KAAK,EACjC,KAAK,CAAC,MAAM,SAAS,SAAS,CAAC;IAAE,CAAC,CAAC,EAAE,MAAM,GAAG,OAAO,CAAA;CAAE,CAAC,GAAG,GAAG,CAC9D,SAAQ,MAAM,CACd,WAAW,CAAC,UAAU,CAAC,MAAM,CAAC,EAAE,KAAK,CAAC,EACtC,WAAW,CAAC,WAAW,CAAC,MAAM,CAAC,EAAE,KAAK,CAAC,CACxC;IAEG,QAAQ,CAAC,KAAK,EAAE,KAAK;IACrB,QAAQ,CAAC,MAAM,EAAE,MAAM;gBADd,KAAK,EAAE,KAAK,EACZ,MAAM,EAAE,MAAM;IAKzB,QAAQ,CAAC,CAAC,SAAS,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,EACxC,KAAK,EAAE,CAAC,GACP,KAAK,IAAI,CAAC,SAAS;QAAE,KAAK,CAAC,EAAE,KAAK,CAAA;KAAE,GACnC,CAAC,GACD,WAAW,CAAC,OAAO,CAAC,CAAC,EAAE,mBAAmB,CAAC,EAAE,KAAK,CAAC;IAIvD,KAAK,CACH,KAAK,EAAE,IAAI,CAAC,UAAU,CAAC,IAAI,CAAC,EAAE,OAAO,CAAC,GACrC,MAAM,CAAC,WAAW,CAAC,IAAI,CAAC,EAAE,KAAK,CAAC;IAOnC,SAAS,CAAC,CAAC,SAAS,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,EAAE,KAAK,EAAE,CAAC;gBAfrB,KAAK;;;;;;IAmBrC,MAAM,CAAC,KAAK,EAAE,IAAI,CAAC,UAAU,CAAC,IAAI,CAAC,EAAE,OAAO,CAAC;;;;;IAI7C,iBAAiB,CAAC,KAAK,EAAE,OAAO,EAAE,GAAG,EAAE,iBAAiB;CAezD;AAED;;;;;;;;;;GAUG;AACH,wBAAgB,WAAW,CACzB,KAAK,CAAC,CAAC,SAAS,UAAU,EAC1B,KAAK,CAAC,CAAC,SAAS,MAAM,EACtB,KAAK,CAAC,CAAC,SAAS,SAAS,CAAC;IAAE,CAAC,CAAC,EAAE,MAAM,GAAG,OAAO,CAAA;CAAE,CAAC,EACnD,IAAI,EAAE,CAAC,EAAE,IAAI,EAAE,CAAC,EAAE,SAAS,EAAE,CAAC,GAAG,iBAAiB,CAAC,KAAK,CAAC,CAAC,EAAE,CAAC,CAAC,EAAE,CAAC,CAAC,CAAA;AACpE,wBAAgB,WAAW,CAAC,CAAC,SAAS;IAAE,KAAK,CAAC,EAAE,KAAK,CAAA;CAAE,EACrD,IAAI,EAAE,CAAC,SAAS;IAAE,KAAK,CAAC,EAAE,MAAM,CAAC,SAAS,MAAM,CAAA;CAAE,GAC9C,CAAC,SAAS,GAAG,MAAM,CAAC,IAAI,MAAM,EAAE,GAC9B,CAAC,GACD,CAAC,GACH,KAAK,EACT,IAAI,EAAE,CAAC,SAAS;IAAE,KAAK,CAAC,EAAE,MAAM,CAAC,SAAS,MAAM,CAAA;CAAE,GAC9C,CAAC,SAAS,GAAG,MAAM,IAAI,MAAM,CAAC,EAAE,GAC9B,CAAC,GACD,MAAM,GACR,KAAK,EACT,SAAS,EAAE,SAAS,CAAC,IAAI,CAAC,CAAC,EAAE,OAAO,CAAC,CAAC,GACrC,iBAAiB,CAAC,OAAO,CAAC,CAAC,CAAC,EAAE,SAAS,CAAC,CAAC,CAAC,CAAC,CAAA"}
+{"version":3,"file":"typed-object.d.ts","sourceRoot":"","sources":["../../src/schema/typed-object.ts"],"names":[],"mappings":"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"}

package/dist/schema/typed-object.js

@@ -4,9 +4,28 @@ exports.TypedObjectSchema = void 0;
 exports.typedObject = typedObject;
 const lex_data_1 = require("@atproto/lex-data");
 const core_js_1 = require("../core.js");
+/**
+ * Schema for typed objects in Lexicon unions.
+ *
+ * Typed objects have a `$type` field that identifies which variant they are
+ * in a union. The `$type` can be omitted in input (it's implicit), but if
+ * present, it must match the expected value.
+ *
+ * @template TType - The $type string literal type
+ * @template TShape - The validator type for the object's shape
+ *
+ * @example
+ * ```ts
+ * const schema = new TypedObjectSchema(
+ *   'app.bsky.embed.images#view',
+ *   l.object({ images: l.array(imageSchema) })
+ * )
+ * ```
+ */
 class TypedObjectSchema extends core_js_1.Schema {
     $type;
     schema;
+    type = 'typedObject';
     constructor($type, schema) {
         super();
         this.$type = $type;
@@ -26,7 +45,7 @@ class TypedObjectSchema 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');
         }
         if ('$type' in input &&
             input.$type !== undefined &&

package/dist/schema/typed-object.js.map

@@ -1 +1 @@
-{"version":3,"file":"typed-object.js","sourceRoot":"","sources":["../../src/schema/typed-object.ts"],"names":[],"mappings":";;;AAuGA,kCAMC;AA7GD,gDAAiD;AACjD,wCAcmB;AAEnB,MAAa,iBAGX,SAAQ,gBAGT;IAEY;IACA;IAFX,YACW,KAAY,EACZ,MAAc;QAEvB,KAAK,EAAE,CAAA;QAHE,UAAK,GAAL,KAAK,CAAO;QACZ,WAAM,GAAN,MAAM,CAAQ;IAGzB,CAAC;IAED,QAAQ,CACN,KAAQ;QAIR,OAAO,KAAK,CAAC,KAAK,KAAK,SAAS,IAAI,KAAK,CAAC,KAAK,KAAK,IAAI,CAAC,KAAK,CAAA;IAChE,CAAC;IAED,KAAK,CACH,KAAsC;QAEtC,OAAO,IAAI,CAAC,KAAK,CAAC,IAAA,gBAAM,EAAC,KAAK,EAAE,IAAI,CAAC,KAAK,CAAC,CAG1C,CAAA;IACH,CAAC;IAED,SAAS,CAAoC,KAAQ;QACnD,OAAO,IAAI,CAAC,QAAQ,CAAC,KAAK,CAAC,CAAA;IAC7B,CAAC;IAED,MAAM,CAAC,KAAsC;QAC3C,OAAO,IAAI,CAAC,KAAK,CAAC,KAAK,CAAC,CAAA;IAC1B,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,IACE,OAAO,IAAI,KAAK;YAChB,KAAK,CAAC,KAAK,KAAK,SAAS;YACzB,KAAK,CAAC,KAAK,KAAK,IAAI,CAAC,KAAK,EAC1B,CAAC;YACD,OAAO,GAAG,CAAC,yBAAyB,CAAC,KAAK,EAAE,OAAO,EAAE,CAAC,IAAI,CAAC,KAAK,CAAC,CAAC,CAAA;QACpE,CAAC;QAED,OAAO,GAAG,CAAC,QAAQ,CAAC,KAAK,EAAE,IAAI,CAAC,MAAM,CAAC,CAAA;IACzC,CAAC;CACF;AAtDD,8CAsDC;AA+BD,wBAAwB;AACxB,SAAgB,WAAW,CAIzB,IAAO,EAAE,IAAO,EAAE,SAAY;IAC9B,OAAO,IAAI,iBAAiB,CAAiB,IAAA,eAAK,EAAC,IAAI,EAAE,IAAI,CAAC,EAAE,SAAS,CAAC,CAAA;AAC5E,CAAC","sourcesContent":["import { isPlainObject } from '@atproto/lex-data'\nimport {\n  $Type,\n  $TypeOf,\n  $Typed,\n  $TypedMaybe,\n  $type,\n  $typed,\n  InferInput,\n  InferOutput,\n  NsidString,\n  Schema,\n  Unknown$TypedObject,\n  ValidationContext,\n  Validator,\n} from '../core.js'\n\nexport class TypedObjectSchema<\n  const TType extends $Type = $Type,\n  const TShape extends Validator<{ [k: string]: unknown }> = any,\n> extends Schema<\n  $TypedMaybe<InferInput<TShape>, TType>,\n  $TypedMaybe<InferOutput<TShape>, TType>\n> {\n  constructor(\n    readonly $type: TType,\n    readonly schema: TShape,\n  ) {\n    super()\n  }\n\n  isTypeOf<X extends Record<string, unknown>>(\n    value: X,\n  ): value is X extends { $type?: TType }\n    ? X\n    : $TypedMaybe<Exclude<X, Unknown$TypedObject>, TType> {\n    return value.$type === undefined || value.$type === this.$type\n  }\n\n  build(\n    input: Omit<InferInput<this>, '$type'>,\n  ): $Typed<InferOutput<this>, TType> {\n    return this.parse($typed(input, this.$type)) as $Typed<\n      InferOutput<this>,\n      TType\n    >\n  }\n\n  $isTypeOf<X extends Record<string, unknown>>(value: X) {\n    return this.isTypeOf(value)\n  }\n\n  $build(input: Omit<InferInput<this>, '$type'>) {\n    return this.build(input)\n  }\n\n  validateInContext(input: unknown, ctx: ValidationContext) {\n    if (!isPlainObject(input)) {\n      return ctx.issueInvalidType(input, 'object')\n    }\n\n    if (\n      '$type' in input &&\n      input.$type !== undefined &&\n      input.$type !== this.$type\n    ) {\n      return ctx.issueInvalidPropertyValue(input, '$type', [this.$type])\n    }\n\n    return ctx.validate(input, this.schema)\n  }\n}\n\n/**\n * This function offers two overloads:\n * - One that allows creating a {@link TypedObjectSchema}, and infer the output\n *   type from the provided arguments, without requiring to specify any of the\n *   generics. This is useful when you want to define a record without\n *   explicitly defining its interface. This version does not support circular\n *   references, as TypeScript cannot infer types in such cases.\n * - One allows creating a {@link TypedObjectSchema} with an explicitly defined\n *   interface. This will typically be used by codegen (`lex build`) to generate\n *   schemas that work even if they contain circular references.\n */\nexport function typedObject<\n  const N extends NsidString,\n  const H extends string,\n  const S extends Validator<{ [k: string]: unknown }>,\n>(nsid: N, hash: H, validator: S): TypedObjectSchema<$Type<N, H>, S>\nexport function typedObject<V extends { $type?: $Type }>(\n  nsid: V extends { $type?: infer T extends string }\n    ? T extends `${infer N}#${string}`\n      ? N\n      : T // (T is a \"main\" type, so already an NSID)\n    : never,\n  hash: V extends { $type?: infer T extends string }\n    ? T extends `${string}#${infer H}`\n      ? H\n      : 'main'\n    : never,\n  validator: Validator<Omit<V, '$type'>>,\n): TypedObjectSchema<$TypeOf<V>, Validator<V>>\n/*@__NO_SIDE_EFFECTS__*/\nexport function typedObject<\n  const N extends NsidString,\n  const H extends string,\n  const S extends Validator<{ [k: string]: unknown }>,\n>(nsid: N, hash: H, validator: S) {\n  return new TypedObjectSchema<$Type<N, H>, S>($type(nsid, hash), validator)\n}\n"]}
+{"version":3,"file":"typed-object.js","sourceRoot":"","sources":["../../src/schema/typed-object.ts"],"names":[],"mappings":";;;AAwKA,kCAMC;AA9KD,gDAAiD;AACjD,wCAcmB;AASnB;;;;;;;;;;;;;;;;;GAiBG;AACH,MAAa,iBAGX,SAAQ,gBAGT;IAIY;IACA;IAJF,IAAI,GAAG,aAAsB,CAAA;IAEtC,YACW,KAAY,EACZ,MAAc;QAEvB,KAAK,EAAE,CAAA;QAHE,UAAK,GAAL,KAAK,CAAO;QACZ,WAAM,GAAN,MAAM,CAAQ;IAGzB,CAAC;IAED,QAAQ,CACN,KAAa;QAEb,OAAO,KAAK,CAAC,KAAK,KAAK,SAAS,IAAI,KAAK,CAAC,KAAK,KAAK,IAAI,CAAC,KAAK,CAAA;IAChE,CAAC;IAED,KAAK,CACH,KAAsC;QAEtC,OAAO,IAAI,CAAC,KAAK,CAAC,IAAA,gBAAM,EAAC,KAAK,EAAE,IAAI,CAAC,KAAK,CAAC,CAG1C,CAAA;IACH,CAAC;IAED,SAAS,CACP,KAAa;QAEb,OAAO,IAAI,CAAC,QAAQ,CAAC,KAAK,CAAC,CAAA;IAC7B,CAAC;IAED,MAAM,CACJ,KAAsC;QAEtC,OAAO,IAAI,CAAC,KAAK,CAAC,KAAK,CAAC,CAAA;IAC1B,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,IACE,OAAO,IAAI,KAAK;YAChB,KAAK,CAAC,KAAK,KAAK,SAAS;YACzB,KAAK,CAAC,KAAK,KAAK,IAAI,CAAC,KAAK,EAC1B,CAAC;YACD,OAAO,GAAG,CAAC,yBAAyB,CAAC,KAAK,EAAE,OAAO,EAAE,CAAC,IAAI,CAAC,KAAK,CAAC,CAAC,CAAA;QACpE,CAAC;QAED,OAAO,GAAG,CAAC,QAAQ,CAAC,KAAK,EAAE,IAAI,CAAC,MAAM,CAAC,CAAA;IACzC,CAAC;CACF;AA1DD,8CA0DC;AAmED,wBAAwB;AACxB,SAAgB,WAAW,CAIzB,IAAO,EAAE,IAAO,EAAE,SAAY;IAC9B,OAAO,IAAI,iBAAiB,CAAiB,IAAA,eAAK,EAAC,IAAI,EAAE,IAAI,CAAC,EAAE,SAAS,CAAC,CAAA;AAC5E,CAAC","sourcesContent":["import { isPlainObject } from '@atproto/lex-data'\nimport {\n  $Type,\n  $TypeOf,\n  $Typed,\n  $TypedMaybe,\n  $type,\n  $typed,\n  InferInput,\n  InferOutput,\n  NsidString,\n  Schema,\n  Unknown$TypedObject,\n  ValidationContext,\n  Validator,\n} from '../core.js'\n\nexport type MaybeTypedObject<\n  TType extends $Type,\n  TValue extends { $type?: unknown } = { $type?: unknown },\n> = TValue extends { $type?: TType }\n  ? TValue\n  : $TypedMaybe<Exclude<TValue, Unknown$TypedObject>, TType>\n\n/**\n * Schema for typed objects in Lexicon unions.\n *\n * Typed objects have a `$type` field that identifies which variant they are\n * in a union. The `$type` can be omitted in input (it's implicit), but if\n * present, it must match the expected value.\n *\n * @template TType - The $type string literal type\n * @template TShape - The validator type for the object's shape\n *\n * @example\n * ```ts\n * const schema = new TypedObjectSchema(\n *   'app.bsky.embed.images#view',\n *   l.object({ images: l.array(imageSchema) })\n * )\n * ```\n */\nexport class TypedObjectSchema<\n  const TType extends $Type = $Type,\n  const TShape extends Validator<{ [k: string]: unknown }> = any,\n> extends Schema<\n  $TypedMaybe<InferInput<TShape>, TType>,\n  $TypedMaybe<InferOutput<TShape>, TType>\n> {\n  readonly type = 'typedObject' as const\n\n  constructor(\n    readonly $type: TType,\n    readonly schema: TShape,\n  ) {\n    super()\n  }\n\n  isTypeOf<TValue extends Record<string, unknown>>(\n    value: TValue,\n  ): value is MaybeTypedObject<TType, TValue> {\n    return value.$type === undefined || value.$type === this.$type\n  }\n\n  build(\n    input: Omit<InferInput<this>, '$type'>,\n  ): $Typed<InferOutput<this>, TType> {\n    return this.parse($typed(input, this.$type)) as $Typed<\n      InferOutput<this>,\n      TType\n    >\n  }\n\n  $isTypeOf<TValue extends Record<string, unknown>>(\n    value: TValue,\n  ): value is MaybeTypedObject<TType, TValue> {\n    return this.isTypeOf(value)\n  }\n\n  $build(\n    input: Omit<InferInput<this>, '$type'>,\n  ): $Typed<InferOutput<this>, TType> {\n    return this.build(input)\n  }\n\n  validateInContext(input: unknown, ctx: ValidationContext) {\n    if (!isPlainObject(input)) {\n      return ctx.issueUnexpectedType(input, 'object')\n    }\n\n    if (\n      '$type' in input &&\n      input.$type !== undefined &&\n      input.$type !== this.$type\n    ) {\n      return ctx.issueInvalidPropertyValue(input, '$type', [this.$type])\n    }\n\n    return ctx.validate(input, this.schema)\n  }\n}\n\n/**\n * Creates a typed object schema for use in Lexicon unions.\n *\n * Typed objects are identified by their `$type` field, which combines an NSID\n * and a hash (e.g., 'app.bsky.embed.images#view'). Used for union variants.\n *\n * This function offers two overloads:\n * - One that infers the type from arguments (no circular reference support)\n * - One with explicit interface for codegen with circular references\n *\n * @param nsid - The NSID part of the type (e.g., 'app.bsky.embed.images')\n * @param hash - The hash part of the type (e.g., 'view'), defaults to 'main'\n * @param validator - Schema for validating the object properties\n * @returns A new {@link TypedObjectSchema} instance\n *\n * @example\n * ```ts\n * // Image embed view\n * const imageViewSchema = l.typedObject(\n *   'app.bsky.embed.images',\n *   'view',\n *   l.object({\n *     images: l.array(l.object({\n *       thumb: l.string(),\n *       fullsize: l.string(),\n *       alt: l.string(),\n *     })),\n *   })\n * )\n *\n * // Main type (hash defaults to 'main')\n * const postViewSchema = l.typedObject(\n *   'app.bsky.feed.defs',\n *   'postView',\n *   l.object({ uri: l.string(), cid: l.string(), author: authorSchema })\n * )\n *\n * // Use $isTypeOf to narrow union types\n * if (imageViewSchema.$isTypeOf(embed)) {\n *   // embed is narrowed to image view type\n * }\n *\n * // Use $build to construct typed objects\n * const view = imageViewSchema.$build({ images: [...] })\n * // view.$type === 'app.bsky.embed.images#view'\n * ```\n */\nexport function typedObject<\n  const N extends NsidString,\n  const H extends string,\n  const S extends Validator<{ [k: string]: unknown }>,\n>(nsid: N, hash: H, validator: S): TypedObjectSchema<$Type<N, H>, S>\nexport function typedObject<V extends { $type?: $Type }>(\n  nsid: V extends { $type?: infer T extends string }\n    ? T extends `${infer N}#${string}`\n      ? N\n      : T // (T is a \"main\" type, so already an NSID)\n    : never,\n  hash: V extends { $type?: infer T extends string }\n    ? T extends `${string}#${infer H}`\n      ? H\n      : 'main'\n    : never,\n  validator: Validator<Omit<V, '$type'>>,\n): TypedObjectSchema<$TypeOf<V>, Validator<V>>\n/*@__NO_SIDE_EFFECTS__*/\nexport function typedObject<\n  const N extends NsidString,\n  const H extends string,\n  const S extends Validator<{ [k: string]: unknown }>,\n>(nsid: N, hash: H, validator: S) {\n  return new TypedObjectSchema<$Type<N, H>, S>($type(nsid, hash), validator)\n}\n"]}

package/dist/schema/typed-ref.d.ts

@@ -1,4 +1,12 @@
 import { $Typed, InferInput, InferOutput, Schema, ValidationContext, Validator } from '../core.js';
+/**
+ * Interface for validators that have a $type property.
+ *
+ * Used by typed objects and records to identify their type in unions.
+ *
+ * @template TInput - The input type (with optional $type)
+ * @template TOutput - The output type (with non-optional $type)
+ */
 export interface TypedObjectValidator<TInput extends {
     $type?: string;
 } = {
@@ -6,14 +14,60 @@ export interface TypedObjectValidator<TInput extends {
 }, TOutput extends TInput = TInput> extends Validator<TInput, TOutput> {
     $type: NonNullable<TOutput['$type']>;
 }
+/**
+ * Function type that returns a typed object validator, used for lazy resolution.
+ *
+ * @template TValidator - The typed object validator type
+ */
 export type TypedRefGetter<out TValidator extends TypedObjectValidator> = () => TValidator;
+/**
+ * Schema for referencing typed objects with lazy resolution.
+ *
+ * Used in typed unions to reference typed object schemas. Requires the
+ * `$type` field to be present and match the referenced schema's type.
+ * The referenced schema is resolved lazily to support circular references.
+ *
+ * @template TValidator - The referenced typed object validator type
+ *
+ * @example
+ * ```ts
+ * const ref = new TypedRefSchema(() => imageViewSchema)
+ * // ref.$type === 'app.bsky.embed.images#view'
+ * ```
+ */
 export declare class TypedRefSchema<const TValidator extends TypedObjectValidator = TypedObjectValidator> extends Schema<$Typed<InferInput<TValidator>>, $Typed<InferOutput<TValidator>>> {
     #private;
+    readonly type: "typedRef";
     constructor(getter: TypedRefGetter<TValidator>);
     get validator(): TValidator;
     get $type(): TValidator['$type'];
     validateInContext(input: unknown, ctx: ValidationContext): import("../core.js").ValidationFailure | import("../core.js").ValidationSuccess<InferInput<TValidator>>;
 }
+/**
+ * Creates a reference to a typed object schema for use in typed unions.
+ *
+ * Unlike regular `ref()`, this requires the referenced schema to have a
+ * `$type` property, and validates that the input's `$type` matches.
+ *
+ * @param get - Function that returns the typed object validator
+ * @returns A new {@link TypedRefSchema} instance
+ *
+ * @example
+ * ```ts
+ * // Reference to image embed view
+ * const imageRef = l.typedRef(() => imageViewSchema)
+ *
+ * // Use in a typed union
+ * const embedUnion = l.typedUnion([
+ *   l.typedRef(() => imageViewSchema),
+ *   l.typedRef(() => videoViewSchema),
+ *   l.typedRef(() => externalViewSchema),
+ * ], true) // closed union
+ *
+ * // The $type is accessible on the ref
+ * console.log(imageRef.$type) // 'app.bsky.embed.images#view'
+ * ```
+ */
 export declare function typedRef<const TValidator extends TypedObjectValidator>(get: TypedRefGetter<TValidator>): TypedRefSchema<TValidator>;
 export declare function typedRef<TInput extends {
     $type?: string;

package/dist/schema/typed-ref.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"typed-ref.d.ts","sourceRoot":"","sources":["../../src/schema/typed-ref.ts"],"names":[],"mappings":"AAAA,OAAO,EACL,MAAM,EACN,UAAU,EACV,WAAW,EACX,MAAM,EACN,iBAAiB,EACjB,SAAS,EACV,MAAM,YAAY,CAAA;AAEnB,MAAM,WAAW,oBAAoB,CACnC,MAAM,SAAS;IAAE,KAAK,CAAC,EAAE,MAAM,CAAA;CAAE,GAAG;IAAE,KAAK,CAAC,EAAE,MAAM,CAAA;CAAE,EACtD,OAAO,SAAS,MAAM,GAAG,MAAM,CAC/B,SAAQ,SAAS,CAAC,MAAM,EAAE,OAAO,CAAC;IAClC,KAAK,EAAE,WAAW,CAAC,OAAO,CAAC,OAAO,CAAC,CAAC,CAAA;CACrC;AAED,MAAM,MAAM,cAAc,CAAC,GAAG,CAAC,UAAU,SAAS,oBAAoB,IACpE,MAAM,UAAU,CAAA;AAElB,qBAAa,cAAc,CACzB,KAAK,CAAC,UAAU,SAAS,oBAAoB,GAAG,oBAAoB,CACpE,SAAQ,MAAM,CACd,MAAM,CAAC,UAAU,CAAC,UAAU,CAAC,CAAC,EAC9B,MAAM,CAAC,WAAW,CAAC,UAAU,CAAC,CAAC,CAChC;;gBAGa,MAAM,EAAE,cAAc,CAAC,UAAU,CAAC;IAS9C,IAAI,SAAS,IAAI,UAAU,CAE1B;IAED,IAAI,KAAK,IAAI,UAAU,CAAC,OAAO,CAAC,CAE/B;IAED,iBAAiB,CAAC,KAAK,EAAE,OAAO,EAAE,GAAG,EAAE,iBAAiB;CAUzD;AAGD,wBAAgB,QAAQ,CAAC,KAAK,CAAC,UAAU,SAAS,oBAAoB,EACpE,GAAG,EAAE,cAAc,CAAC,UAAU,CAAC,GAC9B,cAAc,CAAC,UAAU,CAAC,CAAA;AAC7B,wBAAgB,QAAQ,CACtB,MAAM,SAAS;IAAE,KAAK,CAAC,EAAE,MAAM,CAAA;CAAE,EACjC,OAAO,SAAS,MAAM,GAAG,MAAM,EAE/B,GAAG,EAAE,cAAc,CAAC,oBAAoB,CAAC,MAAM,EAAE,OAAO,CAAC,CAAC,GACzD,cAAc,CAAC,oBAAoB,CAAC,MAAM,EAAE,OAAO,CAAC,CAAC,CAAA"}
+{"version":3,"file":"typed-ref.d.ts","sourceRoot":"","sources":["../../src/schema/typed-ref.ts"],"names":[],"mappings":"AAAA,OAAO,EACL,MAAM,EACN,UAAU,EACV,WAAW,EACX,MAAM,EACN,iBAAiB,EACjB,SAAS,EACV,MAAM,YAAY,CAAA;AAEnB;;;;;;;GAOG;AACH,MAAM,WAAW,oBAAoB,CACnC,MAAM,SAAS;IAAE,KAAK,CAAC,EAAE,MAAM,CAAA;CAAE,GAAG;IAAE,KAAK,CAAC,EAAE,MAAM,CAAA;CAAE,EACtD,OAAO,SAAS,MAAM,GAAG,MAAM,CAC/B,SAAQ,SAAS,CAAC,MAAM,EAAE,OAAO,CAAC;IAClC,KAAK,EAAE,WAAW,CAAC,OAAO,CAAC,OAAO,CAAC,CAAC,CAAA;CACrC;AAED;;;;GAIG;AACH,MAAM,MAAM,cAAc,CAAC,GAAG,CAAC,UAAU,SAAS,oBAAoB,IACpE,MAAM,UAAU,CAAA;AAElB;;;;;;;;;;;;;;GAcG;AACH,qBAAa,cAAc,CACzB,KAAK,CAAC,UAAU,SAAS,oBAAoB,GAAG,oBAAoB,CACpE,SAAQ,MAAM,CACd,MAAM,CAAC,UAAU,CAAC,UAAU,CAAC,CAAC,EAC9B,MAAM,CAAC,WAAW,CAAC,UAAU,CAAC,CAAC,CAChC;;IACC,QAAQ,CAAC,IAAI,EAAG,UAAU,CAAS;gBAIvB,MAAM,EAAE,cAAc,CAAC,UAAU,CAAC;IAS9C,IAAI,SAAS,IAAI,UAAU,CAE1B;IAED,IAAI,KAAK,IAAI,UAAU,CAAC,OAAO,CAAC,CAE/B;IAED,iBAAiB,CAAC,KAAK,EAAE,OAAO,EAAE,GAAG,EAAE,iBAAiB;CAUzD;AAED;;;;;;;;;;;;;;;;;;;;;;;;GAwBG;AAEH,wBAAgB,QAAQ,CAAC,KAAK,CAAC,UAAU,SAAS,oBAAoB,EACpE,GAAG,EAAE,cAAc,CAAC,UAAU,CAAC,GAC9B,cAAc,CAAC,UAAU,CAAC,CAAA;AAC7B,wBAAgB,QAAQ,CACtB,MAAM,SAAS;IAAE,KAAK,CAAC,EAAE,MAAM,CAAA;CAAE,EACjC,OAAO,SAAS,MAAM,GAAG,MAAM,EAE/B,GAAG,EAAE,cAAc,CAAC,oBAAoB,CAAC,MAAM,EAAE,OAAO,CAAC,CAAC,GACzD,cAAc,CAAC,oBAAoB,CAAC,MAAM,EAAE,OAAO,CAAC,CAAC,CAAA"}

package/dist/schema/typed-ref.js

@@ -3,7 +3,23 @@ Object.defineProperty(exports, "__esModule", { value: true });
 exports.TypedRefSchema = void 0;
 exports.typedRef = typedRef;
 const core_js_1 = require("../core.js");
+/**
+ * Schema for referencing typed objects with lazy resolution.
+ *
+ * Used in typed unions to reference typed object schemas. Requires the
+ * `$type` field to be present and match the referenced schema's type.
+ * The referenced schema is resolved lazily to support circular references.
+ *
+ * @template TValidator - The referenced typed object validator type
+ *
+ * @example
+ * ```ts
+ * const ref = new TypedRefSchema(() => imageViewSchema)
+ * // ref.$type === 'app.bsky.embed.images#view'
+ * ```
+ */
 class TypedRefSchema extends core_js_1.Schema {
+    type = 'typedRef';
     #getter;
     constructor(getter) {
         // @NOTE In order to avoid circular dependency issues, we don't resolve