@agentuity/schema 0.0.69 → 0.0.71

package/dist/primitives/string.d.ts

@@ -13,6 +13,8 @@ export declare class StringSchema implements Schema<string, string> {
     description?: string;
     private _min?;
     private _max?;
+    private _email?;
+    private _url?;
     readonly '~standard': {
         version: 1;
         vendor: string;
@@ -45,6 +47,28 @@ export declare class StringSchema implements Schema<string, string> {
      * ```
      */
     max(length: number): StringSchema;
+    /**
+     * Validate email format.
+     *
+     * @example
+     * ```typescript
+     * const schema = s.string().email();
+     * schema.parse('user@example.com'); // "user@example.com"
+     * schema.parse('invalid'); // throws ValidationError
+     * ```
+     */
+    email(): StringSchema;
+    /**
+     * Validate URL format.
+     *
+     * @example
+     * ```typescript
+     * const schema = s.string().url();
+     * schema.parse('https://example.com'); // "https://example.com"
+     * schema.parse('invalid'); // throws ValidationError
+     * ```
+     */
+    url(): StringSchema;
     optional(): import("..").OptionalSchema<this>;
     nullable(): import("..").NullableSchema<this>;
     private _clone;

package/dist/primitives/string.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"string.d.ts","sourceRoot":"","sources":["../../src/primitives/string.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,MAAM,EAAE,MAAM,SAAS,CAAC;AAOtC;;;;;;;;;GASG;AACH,qBAAa,YAAa,YAAW,MAAM,CAAC,MAAM,EAAE,MAAM,CAAC;IAC1D,WAAW,CAAC,EAAE,MAAM,CAAC;IACrB,OAAO,CAAC,IAAI,CAAC,CAAS;IACtB,OAAO,CAAC,IAAI,CAAC,CAAS;IAEtB,QAAQ,CAAC,WAAW;;;0BAGD,OAAO;eAgBM;YAAE,KAAK,EAAE,MAAM,CAAC;YAAC,MAAM,EAAE,MAAM,CAAA;SAAE;MAC/D;IAEF,QAAQ,CAAC,WAAW,EAAE,MAAM,GAAG,IAAI;IAKnC;;;;;;;;;OASG;IACH,GAAG,CAAC,MAAM,EAAE,MAAM,GAAG,YAAY;IAMjC;;;;;;;;;OASG;IACH,GAAG,CAAC,MAAM,EAAE,MAAM,GAAG,YAAY;IAMjC,QAAQ;IAIR,QAAQ;IAIR,OAAO,CAAC,MAAM;IAQd,KAAK,wDAAsB;IAC3B,SAAS,sFAA0B;CACnC;AAED;;;;;;;;GAQG;AACH,wBAAgB,MAAM,IAAI,YAAY,CAErC"}
+{"version":3,"file":"string.d.ts","sourceRoot":"","sources":["../../src/primitives/string.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,MAAM,EAAE,MAAM,SAAS,CAAC;AAOtC;;;;;;;;;GASG;AACH,qBAAa,YAAa,YAAW,MAAM,CAAC,MAAM,EAAE,MAAM,CAAC;IAC1D,WAAW,CAAC,EAAE,MAAM,CAAC;IACrB,OAAO,CAAC,IAAI,CAAC,CAAS;IACtB,OAAO,CAAC,IAAI,CAAC,CAAS;IACtB,OAAO,CAAC,MAAM,CAAC,CAAU;IACzB,OAAO,CAAC,IAAI,CAAC,CAAU;IAEvB,QAAQ,CAAC,WAAW;;;0BAGD,OAAO;eA8BM;YAAE,KAAK,EAAE,MAAM,CAAC;YAAC,MAAM,EAAE,MAAM,CAAA;SAAE;MAC/D;IAEF,QAAQ,CAAC,WAAW,EAAE,MAAM,GAAG,IAAI;IAKnC;;;;;;;;;OASG;IACH,GAAG,CAAC,MAAM,EAAE,MAAM,GAAG,YAAY;IAMjC;;;;;;;;;OASG;IACH,GAAG,CAAC,MAAM,EAAE,MAAM,GAAG,YAAY;IAMjC;;;;;;;;;OASG;IACH,KAAK,IAAI,YAAY;IAMrB;;;;;;;;;OASG;IACH,GAAG,IAAI,YAAY;IAMnB,QAAQ;IAIR,QAAQ;IAIR,OAAO,CAAC,MAAM;IAUd,KAAK,wDAAsB;IAC3B,SAAS,sFAA0B;CACnC;AAED;;;;;;;;GAQG;AACH,wBAAgB,MAAM,IAAI,YAAY,CAErC"}

package/dist/primitives/string.js

@@ -16,6 +16,8 @@ export class StringSchema {
     description;
     _min;
     _max;
+    _email;
+    _url;
     '~standard' = {
         version: 1,
         vendor: 'agentuity',
@@ -33,6 +35,21 @@ export class StringSchema {
                     createIssue(`String must be at most ${this._max} characters, got ${value.length}`),
                 ]);
             }
+            if (this._email) {
+                // Basic email regex - matches most valid emails
+                const emailRegex = /^[^\s@]+@[^\s@]+\.[^\s@]+$/;
+                if (!emailRegex.test(value)) {
+                    return failure([createIssue(`Invalid email format`)]);
+                }
+            }
+            if (this._url) {
+                try {
+                    new URL(value);
+                }
+                catch {
+                    return failure([createIssue(`Invalid URL format`)]);
+                }
+            }
             return success(value);
         },
         types: undefined,
@@ -71,6 +88,36 @@ export class StringSchema {
         clone._max = length;
         return clone;
     }
+    /**
+     * Validate email format.
+     *
+     * @example
+     * ```typescript
+     * const schema = s.string().email();
+     * schema.parse('user@example.com'); // "user@example.com"
+     * schema.parse('invalid'); // throws ValidationError
+     * ```
+     */
+    email() {
+        const clone = this._clone();
+        clone._email = true;
+        return clone;
+    }
+    /**
+     * Validate URL format.
+     *
+     * @example
+     * ```typescript
+     * const schema = s.string().url();
+     * schema.parse('https://example.com'); // "https://example.com"
+     * schema.parse('invalid'); // throws ValidationError
+     * ```
+     */
+    url() {
+        const clone = this._clone();
+        clone._url = true;
+        return clone;
+    }
     optional() {
         return optional(this);
     }
@@ -82,6 +129,8 @@ export class StringSchema {
         clone.description = this.description;
         clone._min = this._min;
         clone._max = this._max;
+        clone._email = this._email;
+        clone._url = this._url;
         return clone;
     }
     parse = parseMethods.parse;

package/dist/primitives/string.js.map

@@ -1 +1 @@
-{"version":3,"file":"string.js","sourceRoot":"","sources":["../../src/primitives/string.ts"],"names":[],"mappings":"AACA,OAAO,EAAE,WAAW,EAAE,OAAO,EAAE,OAAO,EAAE,kBAAkB,EAAE,MAAM,SAAS,CAAC;AAC5E,OAAO,EAAE,QAAQ,EAAE,MAAM,mBAAmB,CAAC;AAC7C,OAAO,EAAE,QAAQ,EAAE,MAAM,mBAAmB,CAAC;AAE7C,MAAM,YAAY,GAAG,kBAAkB,EAAU,CAAC;AAElD;;;;;;;;;GASG;AACH,MAAM,OAAO,YAAY;IACxB,WAAW,CAAU;IACb,IAAI,CAAU;IACd,IAAI,CAAU;IAEb,WAAW,GAAG;QACtB,OAAO,EAAE,CAAU;QACnB,MAAM,EAAE,WAAW;QACnB,QAAQ,EAAE,CAAC,KAAc,EAAE,EAAE;YAC5B,IAAI,OAAO,KAAK,KAAK,QAAQ,EAAE,CAAC;gBAC/B,OAAO,OAAO,CAAC,CAAC,WAAW,CAAC,wBAAwB,OAAO,KAAK,EAAE,CAAC,CAAC,CAAC,CAAC;YACvE,CAAC;YACD,IAAI,IAAI,CAAC,IAAI,KAAK,SAAS,IAAI,KAAK,CAAC,MAAM,GAAG,IAAI,CAAC,IAAI,EAAE,CAAC;gBACzD,OAAO,OAAO,CAAC;oBACd,WAAW,CAAC,2BAA2B,IAAI,CAAC,IAAI,oBAAoB,KAAK,CAAC,MAAM,EAAE,CAAC;iBACnF,CAAC,CAAC;YACJ,CAAC;YACD,IAAI,IAAI,CAAC,IAAI,KAAK,SAAS,IAAI,KAAK,CAAC,MAAM,GAAG,IAAI,CAAC,IAAI,EAAE,CAAC;gBACzD,OAAO,OAAO,CAAC;oBACd,WAAW,CAAC,0BAA0B,IAAI,CAAC,IAAI,oBAAoB,KAAK,CAAC,MAAM,EAAE,CAAC;iBAClF,CAAC,CAAC;YACJ,CAAC;YACD,OAAO,OAAO,CAAC,KAAK,CAAC,CAAC;QACvB,CAAC;QACD,KAAK,EAAE,SAAyD;KAChE,CAAC;IAEF,QAAQ,CAAC,WAAmB;QAC3B,IAAI,CAAC,WAAW,GAAG,WAAW,CAAC;QAC/B,OAAO,IAAI,CAAC;IACb,CAAC;IAED;;;;;;;;;OASG;IACH,GAAG,CAAC,MAAc;QACjB,MAAM,KAAK,GAAG,IAAI,CAAC,MAAM,EAAE,CAAC;QAC5B,KAAK,CAAC,IAAI,GAAG,MAAM,CAAC;QACpB,OAAO,KAAK,CAAC;IACd,CAAC;IAED;;;;;;;;;OASG;IACH,GAAG,CAAC,MAAc;QACjB,MAAM,KAAK,GAAG,IAAI,CAAC,MAAM,EAAE,CAAC;QAC5B,KAAK,CAAC,IAAI,GAAG,MAAM,CAAC;QACpB,OAAO,KAAK,CAAC;IACd,CAAC;IAED,QAAQ;QACP,OAAO,QAAQ,CAAC,IAAI,CAAC,CAAC;IACvB,CAAC;IAED,QAAQ;QACP,OAAO,QAAQ,CAAC,IAAI,CAAC,CAAC;IACvB,CAAC;IAEO,MAAM;QACb,MAAM,KAAK,GAAG,IAAI,YAAY,EAAE,CAAC;QACjC,KAAK,CAAC,WAAW,GAAG,IAAI,CAAC,WAAW,CAAC;QACrC,KAAK,CAAC,IAAI,GAAG,IAAI,CAAC,IAAI,CAAC;QACvB,KAAK,CAAC,IAAI,GAAG,IAAI,CAAC,IAAI,CAAC;QACvB,OAAO,KAAK,CAAC;IACd,CAAC;IAED,KAAK,GAAG,YAAY,CAAC,KAAK,CAAC;IAC3B,SAAS,GAAG,YAAY,CAAC,SAAS,CAAC;CACnC;AAED;;;;;;;;GAQG;AACH,MAAM,UAAU,MAAM;IACrB,OAAO,IAAI,YAAY,EAAE,CAAC;AAC3B,CAAC"}
+{"version":3,"file":"string.js","sourceRoot":"","sources":["../../src/primitives/string.ts"],"names":[],"mappings":"AACA,OAAO,EAAE,WAAW,EAAE,OAAO,EAAE,OAAO,EAAE,kBAAkB,EAAE,MAAM,SAAS,CAAC;AAC5E,OAAO,EAAE,QAAQ,EAAE,MAAM,mBAAmB,CAAC;AAC7C,OAAO,EAAE,QAAQ,EAAE,MAAM,mBAAmB,CAAC;AAE7C,MAAM,YAAY,GAAG,kBAAkB,EAAU,CAAC;AAElD;;;;;;;;;GASG;AACH,MAAM,OAAO,YAAY;IACxB,WAAW,CAAU;IACb,IAAI,CAAU;IACd,IAAI,CAAU;IACd,MAAM,CAAW;IACjB,IAAI,CAAW;IAEd,WAAW,GAAG;QACtB,OAAO,EAAE,CAAU;QACnB,MAAM,EAAE,WAAW;QACnB,QAAQ,EAAE,CAAC,KAAc,EAAE,EAAE;YAC5B,IAAI,OAAO,KAAK,KAAK,QAAQ,EAAE,CAAC;gBAC/B,OAAO,OAAO,CAAC,CAAC,WAAW,CAAC,wBAAwB,OAAO,KAAK,EAAE,CAAC,CAAC,CAAC,CAAC;YACvE,CAAC;YACD,IAAI,IAAI,CAAC,IAAI,KAAK,SAAS,IAAI,KAAK,CAAC,MAAM,GAAG,IAAI,CAAC,IAAI,EAAE,CAAC;gBACzD,OAAO,OAAO,CAAC;oBACd,WAAW,CAAC,2BAA2B,IAAI,CAAC,IAAI,oBAAoB,KAAK,CAAC,MAAM,EAAE,CAAC;iBACnF,CAAC,CAAC;YACJ,CAAC;YACD,IAAI,IAAI,CAAC,IAAI,KAAK,SAAS,IAAI,KAAK,CAAC,MAAM,GAAG,IAAI,CAAC,IAAI,EAAE,CAAC;gBACzD,OAAO,OAAO,CAAC;oBACd,WAAW,CAAC,0BAA0B,IAAI,CAAC,IAAI,oBAAoB,KAAK,CAAC,MAAM,EAAE,CAAC;iBAClF,CAAC,CAAC;YACJ,CAAC;YACD,IAAI,IAAI,CAAC,MAAM,EAAE,CAAC;gBACjB,gDAAgD;gBAChD,MAAM,UAAU,GAAG,4BAA4B,CAAC;gBAChD,IAAI,CAAC,UAAU,CAAC,IAAI,CAAC,KAAK,CAAC,EAAE,CAAC;oBAC7B,OAAO,OAAO,CAAC,CAAC,WAAW,CAAC,sBAAsB,CAAC,CAAC,CAAC,CAAC;gBACvD,CAAC;YACF,CAAC;YACD,IAAI,IAAI,CAAC,IAAI,EAAE,CAAC;gBACf,IAAI,CAAC;oBACJ,IAAI,GAAG,CAAC,KAAK,CAAC,CAAC;gBAChB,CAAC;gBAAC,MAAM,CAAC;oBACR,OAAO,OAAO,CAAC,CAAC,WAAW,CAAC,oBAAoB,CAAC,CAAC,CAAC,CAAC;gBACrD,CAAC;YACF,CAAC;YACD,OAAO,OAAO,CAAC,KAAK,CAAC,CAAC;QACvB,CAAC;QACD,KAAK,EAAE,SAAyD;KAChE,CAAC;IAEF,QAAQ,CAAC,WAAmB;QAC3B,IAAI,CAAC,WAAW,GAAG,WAAW,CAAC;QAC/B,OAAO,IAAI,CAAC;IACb,CAAC;IAED;;;;;;;;;OASG;IACH,GAAG,CAAC,MAAc;QACjB,MAAM,KAAK,GAAG,IAAI,CAAC,MAAM,EAAE,CAAC;QAC5B,KAAK,CAAC,IAAI,GAAG,MAAM,CAAC;QACpB,OAAO,KAAK,CAAC;IACd,CAAC;IAED;;;;;;;;;OASG;IACH,GAAG,CAAC,MAAc;QACjB,MAAM,KAAK,GAAG,IAAI,CAAC,MAAM,EAAE,CAAC;QAC5B,KAAK,CAAC,IAAI,GAAG,MAAM,CAAC;QACpB,OAAO,KAAK,CAAC;IACd,CAAC;IAED;;;;;;;;;OASG;IACH,KAAK;QACJ,MAAM,KAAK,GAAG,IAAI,CAAC,MAAM,EAAE,CAAC;QAC5B,KAAK,CAAC,MAAM,GAAG,IAAI,CAAC;QACpB,OAAO,KAAK,CAAC;IACd,CAAC;IAED;;;;;;;;;OASG;IACH,GAAG;QACF,MAAM,KAAK,GAAG,IAAI,CAAC,MAAM,EAAE,CAAC;QAC5B,KAAK,CAAC,IAAI,GAAG,IAAI,CAAC;QAClB,OAAO,KAAK,CAAC;IACd,CAAC;IAED,QAAQ;QACP,OAAO,QAAQ,CAAC,IAAI,CAAC,CAAC;IACvB,CAAC;IAED,QAAQ;QACP,OAAO,QAAQ,CAAC,IAAI,CAAC,CAAC;IACvB,CAAC;IAEO,MAAM;QACb,MAAM,KAAK,GAAG,IAAI,YAAY,EAAE,CAAC;QACjC,KAAK,CAAC,WAAW,GAAG,IAAI,CAAC,WAAW,CAAC;QACrC,KAAK,CAAC,IAAI,GAAG,IAAI,CAAC,IAAI,CAAC;QACvB,KAAK,CAAC,IAAI,GAAG,IAAI,CAAC,IAAI,CAAC;QACvB,KAAK,CAAC,MAAM,GAAG,IAAI,CAAC,MAAM,CAAC;QAC3B,KAAK,CAAC,IAAI,GAAG,IAAI,CAAC,IAAI,CAAC;QACvB,OAAO,KAAK,CAAC;IACd,CAAC;IAED,KAAK,GAAG,YAAY,CAAC,KAAK,CAAC;IAC3B,SAAS,GAAG,YAAY,CAAC,SAAS,CAAC;CACnC;AAED;;;;;;;;GAQG;AACH,MAAM,UAAU,MAAM;IACrB,OAAO,IAAI,YAAY,EAAE,CAAC;AAC3B,CAAC"}

package/package.json

@@ -1,6 +1,6 @@
 {
 	"name": "@agentuity/schema",
-	"version": "0.0.69",
+	"version": "0.0.71",
 	"license": "Apache-2.0",
 	"author": "Agentuity employees and contributors",
 	"type": "module",
@@ -26,7 +26,7 @@
 		"prepublishOnly": "bun run clean && bun run build"
 	},
 	"dependencies": {
-		"@agentuity/core": "0.0.69"
+		"@agentuity/core": "0.0.71"
 	},
 	"devDependencies": {
 		"@types/bun": "latest",

package/src/primitives/string.ts

@@ -19,6 +19,8 @@ export class StringSchema implements Schema<string, string> {
 	description?: string;
 	private _min?: number;
 	private _max?: number;
+	private _email?: boolean;
+	private _url?: boolean;
 
 	readonly '~standard' = {
 		version: 1 as const,
@@ -37,6 +39,20 @@ export class StringSchema implements Schema<string, string> {
 					createIssue(`String must be at most ${this._max} characters, got ${value.length}`),
 				]);
 			}
+			if (this._email) {
+				// Basic email regex - matches most valid emails
+				const emailRegex = /^[^\s@]+@[^\s@]+\.[^\s@]+$/;
+				if (!emailRegex.test(value)) {
+					return failure([createIssue(`Invalid email format`)]);
+				}
+			}
+			if (this._url) {
+				try {
+					new URL(value);
+				} catch {
+					return failure([createIssue(`Invalid URL format`)]);
+				}
+			}
 			return success(value);
 		},
 		types: undefined as unknown as { input: string; output: string },
@@ -79,6 +95,38 @@ export class StringSchema implements Schema<string, string> {
 		return clone;
 	}
 
+	/**
+	 * Validate email format.
+	 *
+	 * @example
+	 * ```typescript
+	 * const schema = s.string().email();
+	 * schema.parse('user@example.com'); // "user@example.com"
+	 * schema.parse('invalid'); // throws ValidationError
+	 * ```
+	 */
+	email(): StringSchema {
+		const clone = this._clone();
+		clone._email = true;
+		return clone;
+	}
+
+	/**
+	 * Validate URL format.
+	 *
+	 * @example
+	 * ```typescript
+	 * const schema = s.string().url();
+	 * schema.parse('https://example.com'); // "https://example.com"
+	 * schema.parse('invalid'); // throws ValidationError
+	 * ```
+	 */
+	url(): StringSchema {
+		const clone = this._clone();
+		clone._url = true;
+		return clone;
+	}
+
 	optional() {
 		return optional(this);
 	}
@@ -92,6 +140,8 @@ export class StringSchema implements Schema<string, string> {
 		clone.description = this.description;
 		clone._min = this._min;
 		clone._max = this._max;
+		clone._email = this._email;
+		clone._url = this._url;
 		return clone;
 	}
 

package/src/__tests__/coerce.test.ts

@@ -1,88 +0,0 @@
-import { describe, test, expect } from 'bun:test';
-import { s, ValidationError } from '../index.js';
-
-describe('Coercion Schemas', () => {
-	describe('coerce.string', () => {
-		const schema = s.coerce.string();
-
-		test('should coerce numbers to strings', () => {
-			expect(schema.parse(123)).toBe('123');
-		});
-
-		test('should coerce booleans to strings', () => {
-			expect(schema.parse(true)).toBe('true');
-			expect(schema.parse(false)).toBe('false');
-		});
-
-		test('should keep strings as-is', () => {
-			expect(schema.parse('hello')).toBe('hello');
-		});
-	});
-
-	describe('coerce.number', () => {
-		const schema = s.coerce.number();
-
-		test('should coerce string numbers', () => {
-			expect(schema.parse('123')).toBe(123);
-			expect(schema.parse('45.67')).toBe(45.67);
-		});
-
-		test('should coerce booleans', () => {
-			expect(schema.parse(true)).toBe(1);
-			expect(schema.parse(false)).toBe(0);
-		});
-
-		test('should keep numbers as-is', () => {
-			expect(schema.parse(42)).toBe(42);
-		});
-
-		test('should reject invalid coercions', () => {
-			expect(() => schema.parse('not-a-number')).toThrow(ValidationError);
-			expect(() => schema.parse(NaN)).toThrow(ValidationError);
-		});
-	});
-
-	describe('coerce.boolean', () => {
-		const schema = s.coerce.boolean();
-
-		test('should coerce truthy values', () => {
-			expect(schema.parse(1)).toBe(true);
-			expect(schema.parse('hello')).toBe(true);
-			expect(schema.parse([])).toBe(true);
-		});
-
-		test('should coerce falsy values', () => {
-			expect(schema.parse(0)).toBe(false);
-			expect(schema.parse('')).toBe(false);
-			expect(schema.parse(null)).toBe(false);
-			expect(schema.parse(undefined)).toBe(false);
-		});
-	});
-
-	describe('coerce.date', () => {
-		const schema = s.coerce.date();
-
-		test('should coerce ISO strings', () => {
-			const result = schema.parse('2025-01-01');
-			expect(result).toBeInstanceOf(Date);
-			expect(result.getFullYear()).toBe(2025);
-		});
-
-		test('should coerce timestamps', () => {
-			const timestamp = Date.now();
-			const result = schema.parse(timestamp);
-			expect(result).toBeInstanceOf(Date);
-			expect(result.getTime()).toBe(timestamp);
-		});
-
-		test('should keep dates as-is', () => {
-			const date = new Date('2025-01-01');
-			const result = schema.parse(date);
-			expect(result).toBe(date);
-		});
-
-		test('should reject invalid dates', () => {
-			expect(() => schema.parse('invalid-date')).toThrow(ValidationError);
-		});
-	});
-});

package/src/__tests__/complex.test.ts

@@ -1,124 +0,0 @@
-import { describe, test, expect } from 'bun:test';
-import { s, ValidationError } from '../index.js';
-
-describe('Complex Schemas', () => {
-	describe('object', () => {
-		const schema = s.object({
-			name: s.string(),
-			age: s.number(),
-			active: s.boolean(),
-		});
-
-		test('should validate objects', () => {
-			const result = schema.parse({
-				name: 'John',
-				age: 30,
-				active: true,
-			});
-			expect(result.name).toBe('John');
-			expect(result.age).toBe(30);
-			expect(result.active).toBe(true);
-		});
-
-		test('should reject invalid objects', () => {
-			expect(() =>
-				schema.parse({
-					name: 'John',
-					age: 'thirty',
-					active: true,
-				})
-			).toThrow(ValidationError);
-		});
-
-		test('should report field path in errors', () => {
-			try {
-				schema.parse({
-					name: 'John',
-					age: 'invalid',
-					active: true,
-				});
-				throw new Error('Expected parse to throw');
-			} catch (error) {
-				expect(error).toBeInstanceOf(ValidationError);
-				if (error instanceof ValidationError) {
-					expect(error.issues[0].path).toEqual(['age']);
-				} else {
-					throw error;
-				}
-			}
-		});
-
-		test('should work with nested objects', () => {
-			const nested = s.object({
-				user: s.object({
-					name: s.string(),
-					email: s.string(),
-				}),
-			});
-
-			const result = nested.parse({
-				user: {
-					name: 'Alice',
-					email: 'alice@example.com',
-				},
-			});
-			expect(result.user.name).toBe('Alice');
-		});
-	});
-
-	describe('array', () => {
-		const schema = s.array(s.string());
-
-		test('should validate arrays', () => {
-			const result = schema.parse(['a', 'b', 'c']);
-			expect(result).toEqual(['a', 'b', 'c']);
-		});
-
-		test('should reject non-arrays', () => {
-			expect(() => schema.parse('not-an-array')).toThrow(ValidationError);
-		});
-
-		test('should validate array items', () => {
-			expect(() => schema.parse(['a', 123, 'c'])).toThrow(ValidationError);
-		});
-
-		test('should report array index in errors', () => {
-			try {
-				schema.parse(['a', 123, 'c']);
-				throw new Error('Expected parse to throw');
-			} catch (error) {
-				expect(error).toBeInstanceOf(ValidationError);
-				if (error instanceof ValidationError) {
-					expect(error.issues[0].path).toContain(1);
-				} else {
-					throw error;
-				}
-			}
-		});
-
-		test('should work with array of objects', () => {
-			const objArray = s.array(
-				s.object({
-					id: s.number(),
-					name: s.string(),
-				})
-			);
-
-			const result = objArray.parse([
-				{ id: 1, name: 'First' },
-				{ id: 2, name: 'Second' },
-			]);
-			expect(result.length).toBe(2);
-			expect(result[0].id).toBe(1);
-		});
-	});
-});
-describe('record', () => {
-	const schema = s.record(s.string(), s.number());
-	test('should validate records', () => {
-		expect(schema.parse({ a: 1, b: 2 })).toEqual({ a: 1, b: 2 });
-	});
-	test('should reject non-objects', () => {
-		expect(() => schema.parse([])).toThrow(ValidationError);
-	});
-});

package/src/__tests__/errors.test.ts

@@ -1,129 +0,0 @@
-import { describe, test, expect } from 'bun:test';
-import { s, ValidationError } from '../index.js';
-
-describe('Error Handling', () => {
-	describe('ValidationError', () => {
-		test('should contain issues array', () => {
-			const schema = s.string();
-
-			try {
-				schema.parse(123);
-				throw new Error('Expected parse to throw');
-			} catch (error) {
-				expect(error).toBeInstanceOf(ValidationError);
-				if (error instanceof ValidationError) {
-					expect(Array.isArray(error.issues)).toBe(true);
-					expect(error.issues.length).toBeGreaterThan(0);
-				} else {
-					throw error;
-				}
-			}
-		});
-
-		test('should include field paths', () => {
-			const schema = s.object({
-				user: s.object({
-					name: s.string(),
-				}),
-			});
-
-			try {
-				schema.parse({
-					user: {
-						name: 123,
-					},
-				});
-				throw new Error('Expected parse to throw');
-			} catch (error) {
-				expect(error).toBeInstanceOf(ValidationError);
-				if (error instanceof ValidationError) {
-					expect(error.issues[0].path).toEqual(['user', 'name']);
-				} else {
-					throw error;
-				}
-			}
-		});
-
-		test('should have readable error message', () => {
-			const schema = s.object({
-				age: s.number(),
-			});
-
-			try {
-				schema.parse({ age: 'invalid' });
-				throw new Error('Expected parse to throw');
-			} catch (error) {
-				expect(error).toBeInstanceOf(ValidationError);
-				if (error instanceof ValidationError) {
-					expect(error.message).toContain('age');
-					expect(error.message).toContain('number');
-				} else {
-					throw error;
-				}
-			}
-		});
-	});
-
-	describe('safeParse', () => {
-		test('should not throw on invalid data', () => {
-			const schema = s.string();
-			const result = schema.safeParse(123);
-
-			expect(result.success).toBe(false);
-			if (!result.success) {
-				expect(result.error).toBeInstanceOf(ValidationError);
-			}
-		});
-
-		test('should return data on valid input', () => {
-			const schema = s.string();
-			const result = schema.safeParse('hello');
-
-			expect(result.success).toBe(true);
-			if (result.success) {
-				expect(result.data).toBe('hello');
-			}
-		});
-	});
-
-	describe('parse', () => {
-		test('should throw ValidationError on invalid data', () => {
-			const schema = s.number();
-
-			expect(() => schema.parse('not-a-number')).toThrow(ValidationError);
-		});
-
-		test('should return typed data on valid input', () => {
-			const schema = s.number();
-			const result = schema.parse(42);
-
-			expect(result).toBe(42);
-		});
-	});
-
-	describe('multiple errors', () => {
-		test('should collect all validation errors', () => {
-			const schema = s.object({
-				name: s.string(),
-				age: s.number(),
-				email: s.string(),
-			});
-
-			try {
-				schema.parse({
-					name: 123,
-					age: 'invalid',
-					email: false,
-				});
-				throw new Error('Expected parse to throw');
-			} catch (error) {
-				expect(error).toBeInstanceOf(ValidationError);
-				if (error instanceof ValidationError) {
-					expect(error.issues.length).toBe(3);
-				} else {
-					throw error;
-				}
-			}
-		});
-	});
-});

package/src/__tests__/json-schema.test.ts

@@ -1,138 +0,0 @@
-import { describe, test, expect } from 'bun:test';
-import { s } from '../index.js';
-
-describe('JSON Schema Conversion', () => {
-	describe('toJSONSchema', () => {
-		test('should convert primitive types', () => {
-			const stringSchema = s.toJSONSchema(s.string());
-			expect(stringSchema.type).toBe('string');
-
-			const numberSchema = s.toJSONSchema(s.number());
-			expect(numberSchema.type).toBe('number');
-
-			const booleanSchema = s.toJSONSchema(s.boolean());
-			expect(booleanSchema.type).toBe('boolean');
-		});
-
-		test('should convert object schemas', () => {
-			const schema = s.object({
-				name: s.string(),
-				age: s.number(),
-			});
-
-			const jsonSchema = s.toJSONSchema(schema);
-			expect(jsonSchema.type).toBe('object');
-			expect(jsonSchema.properties).toHaveProperty('name');
-			expect(jsonSchema.properties).toHaveProperty('age');
-			expect(jsonSchema.required).toContain('name');
-			expect(jsonSchema.required).toContain('age');
-		});
-
-		test('should convert array schemas', () => {
-			const schema = s.array(s.string());
-			const jsonSchema = s.toJSONSchema(schema);
-
-			expect(jsonSchema.type).toBe('array');
-			expect(jsonSchema.items).toHaveProperty('type', 'string');
-		});
-
-		test('should preserve descriptions', () => {
-			const schema = s.string().describe('A test string');
-			const jsonSchema = s.toJSONSchema(schema);
-
-			expect(jsonSchema.description).toBe('A test string');
-		});
-
-		test('should handle optional fields', () => {
-			const schema = s.object({
-				required: s.string(),
-				optional: s.optional(s.string()),
-			});
-
-			const jsonSchema = s.toJSONSchema(schema);
-			expect(jsonSchema.required).toContain('required');
-			expect(jsonSchema.required).not.toContain('optional');
-		});
-
-		test('should handle nullable fields', () => {
-			const schema = s.nullable(s.string());
-			const jsonSchema = s.toJSONSchema(schema);
-
-			expect(jsonSchema.anyOf).toHaveLength(2);
-		});
-	});
-
-	describe('fromJSONSchema', () => {
-		test('should convert primitive types', () => {
-			const stringSchema = s.fromJSONSchema({ type: 'string' });
-			expect(stringSchema.parse('hello')).toBe('hello');
-
-			const numberSchema = s.fromJSONSchema({ type: 'number' });
-			expect(numberSchema.parse(123)).toBe(123);
-		});
-
-		test('should convert object schemas', () => {
-			const jsonSchema = {
-				type: 'object' as const,
-				properties: {
-					name: { type: 'string' as const },
-					age: { type: 'number' as const },
-				},
-				required: ['name', 'age'],
-			};
-
-			const schema = s.fromJSONSchema(jsonSchema);
-			const result = schema.parse({
-				name: 'John',
-				age: 30,
-			});
-
-			expect(result).toEqual({ name: 'John', age: 30 });
-		});
-
-		test('should convert array schemas', () => {
-			const jsonSchema = {
-				type: 'array' as const,
-				items: { type: 'string' as const },
-			};
-
-			const schema = s.fromJSONSchema(jsonSchema);
-			const result = schema.parse(['a', 'b', 'c']);
-
-			expect(result).toEqual(['a', 'b', 'c']);
-		});
-
-		test('should handle enum values', () => {
-			const jsonSchema = {
-				enum: ['red', 'green', 'blue'],
-			};
-
-			const schema = s.fromJSONSchema(jsonSchema);
-			expect(schema.parse('red')).toBe('red');
-		});
-	});
-
-	describe('round-trip conversion', () => {
-		test('should preserve schema through round-trip', () => {
-			const original = s.object({
-				name: s.string(),
-				age: s.number(),
-				tags: s.array(s.string()),
-			});
-
-			const jsonSchema = s.toJSONSchema(original);
-			const reconstructed = s.fromJSONSchema(jsonSchema);
-
-			const testData = {
-				name: 'Test',
-				age: 25,
-				tags: ['tag1', 'tag2'],
-			};
-
-			const originalResult = original.parse(testData);
-			const reconstructedResult = reconstructed.parse(testData);
-
-			expect(reconstructedResult).toEqual(originalResult);
-		});
-	});
-});

package/src/__tests__/primitives.test.ts

@@ -1,184 +0,0 @@
-import { describe, test, expect } from 'bun:test';
-import { s, ValidationError } from '../index.js';
-
-describe('Primitive Schemas', () => {
-	describe('string', () => {
-		const schema = s.string();
-
-		test('should validate strings', () => {
-			expect(schema.parse('hello')).toBe('hello');
-			expect(schema.parse('')).toBe('');
-		});
-
-		test('should reject non-strings', () => {
-			expect(() => schema.parse(123)).toThrow(ValidationError);
-			expect(() => schema.parse(true)).toThrow(ValidationError);
-			expect(() => schema.parse(null)).toThrow(ValidationError);
-		});
-
-		test('should work with safeParse', () => {
-			const result = schema.safeParse('test');
-			expect(result.success).toBe(true);
-			if (result.success) {
-				expect(result.data).toBe('test');
-			}
-
-			const badResult = schema.safeParse(123);
-			expect(badResult.success).toBe(false);
-		});
-
-		test('min() should enforce minimum length', () => {
-			const minSchema = s.string().min(3);
-			expect(minSchema.parse('hello')).toBe('hello');
-			expect(minSchema.parse('abc')).toBe('abc');
-			expect(() => minSchema.parse('ab')).toThrow(ValidationError);
-		});
-
-		test('max() should enforce maximum length', () => {
-			const maxSchema = s.string().max(5);
-			expect(maxSchema.parse('hello')).toBe('hello');
-			expect(maxSchema.parse('hi')).toBe('hi');
-			expect(() => maxSchema.parse('toolong')).toThrow(ValidationError);
-		});
-
-		test('should chain min and max', () => {
-			const rangeSchema = s.string().min(3).max(10);
-			expect(rangeSchema.parse('hello')).toBe('hello');
-			expect(() => rangeSchema.parse('ab')).toThrow(ValidationError);
-			expect(() => rangeSchema.parse('this is too long')).toThrow(ValidationError);
-		});
-	});
-
-	describe('number', () => {
-		const schema = s.number();
-
-		test('should validate numbers', () => {
-			expect(schema.parse(123)).toBe(123);
-			expect(schema.parse(0)).toBe(0);
-			expect(schema.parse(-45.67)).toBe(-45.67);
-			expect(schema.parse(Infinity)).toBe(Infinity);
-			expect(schema.parse(-Infinity)).toBe(-Infinity);
-		});
-
-		test('should reject non-numbers', () => {
-			expect(() => schema.parse('123')).toThrow(ValidationError);
-			expect(() => schema.parse(true)).toThrow(ValidationError);
-			expect(() => schema.parse(NaN)).toThrow(ValidationError);
-		});
-
-		test('finite() should reject Infinity', () => {
-			const finiteSchema = s.number().finite();
-			expect(finiteSchema.parse(123)).toBe(123);
-			expect(finiteSchema.parse(0)).toBe(0);
-			expect(finiteSchema.parse(-45.67)).toBe(-45.67);
-			expect(() => finiteSchema.parse(Infinity)).toThrow(ValidationError);
-			expect(() => finiteSchema.parse(-Infinity)).toThrow(ValidationError);
-		});
-
-		test('min() should enforce minimum', () => {
-			const minSchema = s.number().min(0);
-			expect(minSchema.parse(0)).toBe(0);
-			expect(minSchema.parse(10)).toBe(10);
-			expect(() => minSchema.parse(-1)).toThrow(ValidationError);
-		});
-
-		test('max() should enforce maximum', () => {
-			const maxSchema = s.number().max(100);
-			expect(maxSchema.parse(100)).toBe(100);
-			expect(maxSchema.parse(50)).toBe(50);
-			expect(() => maxSchema.parse(101)).toThrow(ValidationError);
-		});
-
-		test('should chain min and max', () => {
-			const rangeSchema = s.number().min(0).max(100);
-			expect(rangeSchema.parse(50)).toBe(50);
-			expect(() => rangeSchema.parse(-1)).toThrow(ValidationError);
-			expect(() => rangeSchema.parse(101)).toThrow(ValidationError);
-		});
-	});
-
-	describe('boolean', () => {
-		const schema = s.boolean();
-
-		test('should validate booleans', () => {
-			expect(schema.parse(true)).toBe(true);
-			expect(schema.parse(false)).toBe(false);
-		});
-
-		test('should reject non-booleans', () => {
-			expect(() => schema.parse('true')).toThrow(ValidationError);
-			expect(() => schema.parse(1)).toThrow(ValidationError);
-			expect(() => schema.parse(0)).toThrow(ValidationError);
-		});
-	});
-
-	describe('null', () => {
-		const schema = s.null();
-
-		test('should validate null', () => {
-			expect(schema.parse(null)).toBe(null);
-		});
-
-		test('should reject non-null', () => {
-			expect(() => schema.parse(undefined)).toThrow(ValidationError);
-			expect(() => schema.parse(0)).toThrow(ValidationError);
-		});
-	});
-
-	describe('undefined', () => {
-		const schema = s.undefined();
-
-		test('should validate undefined', () => {
-			expect(schema.parse(undefined)).toBe(undefined);
-		});
-
-		test('should reject non-undefined', () => {
-			expect(() => schema.parse(null)).toThrow(ValidationError);
-			expect(() => schema.parse(0)).toThrow(ValidationError);
-		});
-	});
-
-	describe('unknown', () => {
-		const schema = s.unknown();
-
-		test('should accept any value', () => {
-			expect(schema.parse(123)).toBe(123);
-			expect(schema.parse('hello')).toBe('hello');
-			expect(schema.parse(true)).toBe(true);
-			expect(schema.parse(null)).toBe(null);
-			expect(schema.parse(undefined)).toBe(undefined);
-			expect(schema.parse({ foo: 'bar' })).toEqual({ foo: 'bar' });
-			expect(schema.parse([1, 2, 3])).toEqual([1, 2, 3]);
-		});
-
-		test('should work with safeParse', () => {
-			const result = schema.safeParse('anything');
-			expect(result.success).toBe(true);
-			if (result.success) {
-				expect(result.data).toBe('anything');
-			}
-		});
-	});
-
-	describe('any', () => {
-		const schema = s.any();
-
-		test('should accept any value', () => {
-			expect(schema.parse(123)).toBe(123);
-			expect(schema.parse('hello')).toBe('hello');
-			expect(schema.parse(true)).toBe(true);
-			expect(schema.parse(null)).toBe(null);
-			expect(schema.parse(undefined)).toBe(undefined);
-			expect(schema.parse({ foo: 'bar' })).toEqual({ foo: 'bar' });
-			expect(schema.parse([1, 2, 3])).toEqual([1, 2, 3]);
-		});
-
-		test('should work with safeParse', () => {
-			const result = schema.safeParse('anything');
-			expect(result.success).toBe(true);
-			if (result.success) {
-				expect(result.data).toBe('anything');
-			}
-		});
-	});
-});

package/src/__tests__/type-inference.test.ts

@@ -1,68 +0,0 @@
-import { describe, test, expect } from 'bun:test';
-import { s } from '../index.js';
-
-describe('Type Inference', () => {
-	test('should infer object types', () => {
-		const schema = s.object({
-			name: s.string(),
-			age: s.number(),
-		});
-
-		type User = s.infer<typeof schema>;
-
-		const user: User = schema.parse({
-			name: 'John',
-			age: 30,
-		});
-
-		expect(user.name).toBe('John');
-		expect(user.age).toBe(30);
-	});
-
-	test('should infer array types', () => {
-		const schema = s.array(s.string());
-		type StringArray = s.infer<typeof schema>;
-
-		const arr: StringArray = schema.parse(['a', 'b', 'c']);
-		expect(arr).toEqual(['a', 'b', 'c']);
-	});
-
-	test('should infer union types', () => {
-		const schema = s.union(s.literal('admin'), s.literal('user'));
-
-		type Role = s.infer<typeof schema>;
-
-		const role: Role = schema.parse('admin');
-		expect(role).toBe('admin');
-	});
-
-	test('should infer optional types', () => {
-		const schema = s.object({
-			required: s.string(),
-			optional: s.optional(s.number()),
-		});
-
-		type Data = s.infer<typeof schema>;
-
-		const data: Data = schema.parse({
-			required: 'test',
-		});
-
-		expect(data.required).toBe('test');
-		expect(data.optional).toBe(undefined);
-	});
-
-	test('should infer nullable types', () => {
-		const schema = s.object({
-			value: s.nullable(s.string()),
-		});
-
-		type Data = s.infer<typeof schema>;
-
-		const data: Data = schema.parse({
-			value: null,
-		});
-
-		expect(data.value).toBe(null);
-	});
-});

package/src/__tests__/utils.test.ts

@@ -1,100 +0,0 @@
-import { describe, test, expect } from 'bun:test';
-import { s, ValidationError } from '../index.js';
-
-describe('Utility Schemas', () => {
-	describe('literal', () => {
-		test('should validate exact string values', () => {
-			const schema = s.literal('admin');
-			expect(schema.parse('admin')).toBe('admin');
-			expect(() => schema.parse('user')).toThrow(ValidationError);
-		});
-
-		test('should validate exact number values', () => {
-			const schema = s.literal(42);
-			expect(schema.parse(42)).toBe(42);
-			expect(() => schema.parse(41)).toThrow(ValidationError);
-		});
-
-		test('should validate exact boolean values', () => {
-			const schema = s.literal(true);
-			expect(schema.parse(true)).toBe(true);
-			expect(() => schema.parse(false)).toThrow(ValidationError);
-		});
-	});
-
-	describe('enum', () => {
-		test('should validate enum values', () => {
-			const schema = s.enum(['red', 'green', 'blue']);
-			expect(schema.parse('red')).toBe('red');
-			expect(schema.parse('green')).toBe('green');
-			expect(() => schema.parse('yellow')).toThrow(ValidationError);
-		});
-
-		test('should work with numbers', () => {
-			const schema = s.enum([1, 2, 3]);
-			expect(schema.parse(2)).toBe(2);
-			expect(() => schema.parse(4)).toThrow(ValidationError);
-		});
-
-		test('should work with mixed types', () => {
-			const schema = s.enum(['active', 'inactive', 1, 2]);
-			expect(schema.parse('active')).toBe('active');
-			expect(schema.parse(1)).toBe(1);
-			expect(() => schema.parse('pending')).toThrow(ValidationError);
-		});
-	});
-
-	describe('optional', () => {
-		const schema = s.optional(s.string());
-
-		test('should validate undefined', () => {
-			expect(schema.parse(undefined)).toBe(undefined);
-		});
-
-		test('should validate the wrapped type', () => {
-			expect(schema.parse('hello')).toBe('hello');
-		});
-
-		test('should reject invalid values', () => {
-			expect(() => schema.parse(123)).toThrow(ValidationError);
-		});
-	});
-
-	describe('nullable', () => {
-		const schema = s.nullable(s.string());
-
-		test('should validate null', () => {
-			expect(schema.parse(null)).toBe(null);
-		});
-
-		test('should validate the wrapped type', () => {
-			expect(schema.parse('hello')).toBe('hello');
-		});
-
-		test('should reject invalid values', () => {
-			expect(() => schema.parse(123)).toThrow(ValidationError);
-		});
-	});
-
-	describe('union', () => {
-		const schema = s.union(s.string(), s.number(), s.boolean());
-
-		test('should validate any union member', () => {
-			expect(schema.parse('hello')).toBe('hello');
-			expect(schema.parse(123)).toBe(123);
-			expect(schema.parse(true)).toBe(true);
-		});
-
-		test('should reject non-members', () => {
-			expect(() => schema.parse(null)).toThrow(ValidationError);
-			expect(() => schema.parse(undefined)).toThrow(ValidationError);
-		});
-
-		test('should work with literal union (enum-like)', () => {
-			const roleSchema = s.union(s.literal('admin'), s.literal('user'), s.literal('guest'));
-
-			expect(roleSchema.parse('admin')).toBe('admin');
-			expect(() => roleSchema.parse('superuser')).toThrow(ValidationError);
-		});
-	});
-});