Add support for object-level descriptions in lx.object()

packages/prototypey/core/lib.ts

···
 	}
 >;
 
+/**
+ * Object-level options (not property-level).
+ * @see https://atproto.com/specs/lexicon#object
+ */
+type ObjectOptions = {
+	/** Human-readable description of the object */
+	description?: string;
+};
+
 type RequiredKeys<T> = {
 	[K in keyof T]: T[K] extends { required: true } ? K : never;
 }[keyof T];
···
  * Resulting object schema with required and nullable fields extracted.
  * @see https://atproto.com/specs/lexicon#object
  */
-type ObjectResult<T extends ObjectProperties> = {
+type ObjectResult<T extends ObjectProperties, O extends ObjectOptions = {}> = {
 	type: "object";
 	/** Property definitions */
 	properties: {
···
 	: { required: UnionToTuple<RequiredKeys<T>> }) &
 	([NullableKeys<T>] extends [never]
 		? {}
-		: { nullable: UnionToTuple<NullableKeys<T>> });
+		: { nullable: UnionToTuple<NullableKeys<T>> }) &
+	O;
 
 /**
  * Map of parameter names to their lexicon item definitions.
···
 	 * Creates an object type with defined properties.
 	 * @see https://atproto.com/specs/lexicon#object
 	 */
-	object<T extends ObjectProperties>(options: T): ObjectResult<T> {
-		const required = Object.keys(options).filter(
-			(key) => "required" in options[key] && options[key].required,
+	object<T extends ObjectProperties, O extends ObjectOptions>(
+		properties: T,
+		options?: O,
+	): ObjectResult<T, O> {
+		const required = Object.keys(properties).filter(
+			(key) => "required" in properties[key] && properties[key].required,
 		);
-		const nullable = Object.keys(options).filter(
-			(key) => "nullable" in options[key] && options[key].nullable,
+		const nullable = Object.keys(properties).filter(
+			(key) => "nullable" in properties[key] && properties[key].nullable,
 		);
 		const result: Record<string, unknown> = {
 			type: "object",
-			properties: options,
+			properties,
+			...options,
 		};
 		if (required.length > 0) {
 			result.required = required;
···
 		if (nullable.length > 0) {
 			result.nullable = nullable;
 		}
-		return result as ObjectResult<T>;
+		return result as ObjectResult<T, O>;
 	},
 	/**
 	 * Creates a params type for query string parameters.

packages/prototypey/core/tests/from-json-infer.test.ts

···
 
 	attest(lexicon["~infer"]).type.toString.snap(`{
   $type: "app.bsky.actor.profile"
-  displayName?: string | undefined
   description?: string | undefined
+  displayName?: string | undefined
 }`);
 });

packages/prototypey/core/tests/primitives.test.ts

···
 	});
 });
 
+test("lx.object() basic", () => {
+	const result = lx.object({
+		name: lx.string(),
+	});
+	expect(result).toEqual({
+		type: "object",
+		properties: {
+			name: { type: "string" },
+		},
+	});
+});
+
+test("lx.object() with description", () => {
+	const result = lx.object(
+		{
+			enabled: lx.boolean({
+				default: true,
+				description: "Whether this feature is enabled.",
+			}),
+		},
+		{
+			description: "Configuration options for the feature.",
+		},
+	);
+	expect(result).toEqual({
+		type: "object",
+		description: "Configuration options for the feature.",
+		properties: {
+			enabled: {
+				type: "boolean",
+				default: true,
+				description: "Whether this feature is enabled.",
+			},
+		},
+	});
+});
+
+test("lx.object() with required and description", () => {
+	const result = lx.object(
+		{
+			id: lx.string({ required: true }),
+			name: lx.string(),
+		},
+		{ description: "User profile object" },
+	);
+	expect(result).toEqual({
+		type: "object",
+		description: "User profile object",
+		properties: {
+			id: { type: "string", required: true },
+			name: { type: "string" },
+		},
+		required: ["id"],
+	});
+});
+
+test("lx.object() with nullable and description", () => {
+	const result = lx.object(
+		{
+			bio: lx.string({ nullable: true }),
+		},
+		{ description: "Optional profile fields" },
+	);
+	expect(result).toEqual({
+		type: "object",
+		description: "Optional profile fields",
+		properties: {
+			bio: { type: "string", nullable: true },
+		},
+		nullable: ["bio"],
+	});
+});
+
 test("lx.token() with interaction event", () => {
 	const result = lx.token(
 		"Request that less content like the given feed item be shown in the feed",