@agentuity/schema 0.0.69

package/dist/utils/nullable.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"nullable.d.ts","sourceRoot":"","sources":["../../src/utils/nullable.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,MAAM,EAAE,KAAK,EAAE,MAAM,SAAS,CAAC;AAG7C;;;;;;;;;;;;;GAaG;AAEH,qBAAa,cAAc,CAAC,CAAC,SAAS,MAAM,CAAC,GAAG,EAAE,GAAG,CAAC,CACrD,YAAW,MAAM,CAAC,KAAK,CAAC,CAAC,CAAC,GAAG,IAAI,EAAE,KAAK,CAAC,CAAC,CAAC,GAAG,IAAI,CAAC;IAEnD,QAAQ,CAAC,MAAM,EAAE,CAAC,CAAC;IACnB,WAAW,CAAC,EAAE,MAAM,CAAC;IAErB,QAAQ,CAAC,WAAW;;;0BAGD,OAAO;eAMM;YAAE,KAAK,EAAE,KAAK,CAAC,CAAC,CAAC,GAAG,IAAI,CAAC;YAAC,MAAM,EAAE,KAAK,CAAC,CAAC,CAAC,GAAG,IAAI,CAAA;SAAE;MACjF;IAGF,OAAO,CAAC,YAAY,CAAyC;gBAEjD,MAAM,EAAE,CAAC;IAIrB,QAAQ,CAAC,WAAW,EAAE,MAAM,GAAG,IAAI;IAKnC,QAAQ,IAAI,MAAM,CAAC,KAAK,CAAC,CAAC,CAAC,GAAG,IAAI,GAAG,SAAS,EAAE,KAAK,CAAC,CAAC,CAAC,GAAG,IAAI,GAAG,SAAS,CAAC;IAO5E,QAAQ;IAIR,KAAK,0EAA2B;IAChC,SAAS,wGAA+B;CACxC;AAED;;;;;;;;;;;;GAYG;AAEH,wBAAgB,QAAQ,CAAC,CAAC,SAAS,MAAM,CAAC,GAAG,EAAE,GAAG,CAAC,EAAE,MAAM,EAAE,CAAC,GAAG,cAAc,CAAC,CAAC,CAAC,CAEjF"}

package/dist/utils/nullable.js

@@ -0,0 +1,69 @@
+import { success, createParseMethods } from '../base';
+/**
+ * Schema for nullable values (T | null).
+ * Accepts null or the wrapped schema's type.
+ *
+ * @template T - The wrapped schema type
+ *
+ * @example
+ * ```typescript
+ * const schema = s.nullable(s.string());
+ * schema.parse('hello'); // 'hello'
+ * schema.parse(null); // null
+ * schema.parse(123); // throws ValidationError
+ * ```
+ */
+// eslint-disable-next-line @typescript-eslint/no-explicit-any
+export class NullableSchema {
+    schema;
+    description;
+    '~standard' = {
+        version: 1,
+        vendor: 'agentuity',
+        validate: (value) => {
+            if (value === null) {
+                return success(null);
+            }
+            return this.schema['~standard'].validate(value);
+        },
+        types: undefined,
+    };
+    // Type-safe parse methods for this instance
+    parseMethods = createParseMethods();
+    constructor(schema) {
+        this.schema = schema;
+    }
+    describe(description) {
+        this.description = description;
+        return this;
+    }
+    optional() {
+        // Import here to avoid circular dependency
+        // eslint-disable-next-line @typescript-eslint/no-require-imports
+        const { optional } = require('./optional.js');
+        return optional(this);
+    }
+    nullable() {
+        return this; // Already nullable
+    }
+    parse = this.parseMethods.parse;
+    safeParse = this.parseMethods.safeParse;
+}
+/**
+ * Make a schema nullable (T | null).
+ *
+ * @param schema - The schema to make nullable
+ *
+ * @example
+ * ```typescript
+ * const userSchema = s.object({
+ *   name: s.string(),
+ *   bio: s.nullable(s.string())
+ * });
+ * ```
+ */
+// eslint-disable-next-line @typescript-eslint/no-explicit-any
+export function nullable(schema) {
+    return new NullableSchema(schema);
+}
+//# sourceMappingURL=nullable.js.map

package/dist/utils/nullable.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"nullable.js","sourceRoot":"","sources":["../../src/utils/nullable.ts"],"names":[],"mappings":"AACA,OAAO,EAAE,OAAO,EAAE,kBAAkB,EAAE,MAAM,SAAS,CAAC;AAEtD;;;;;;;;;;;;;GAaG;AACH,8DAA8D;AAC9D,MAAM,OAAO,cAAc;IAGjB,MAAM,CAAI;IACnB,WAAW,CAAU;IAEZ,WAAW,GAAG;QACtB,OAAO,EAAE,CAAU;QACnB,MAAM,EAAE,WAAW;QACnB,QAAQ,EAAE,CAAC,KAAc,EAAE,EAAE;YAC5B,IAAI,KAAK,KAAK,IAAI,EAAE,CAAC;gBACpB,OAAO,OAAO,CAAC,IAAuB,CAAC,CAAC;YACzC,CAAC;YACD,OAAO,IAAI,CAAC,MAAM,CAAC,WAAW,CAAC,CAAC,QAAQ,CAAC,KAAK,CAAC,CAAC;QACjD,CAAC;QACD,KAAK,EAAE,SAA2E;KAClF,CAAC;IAEF,4CAA4C;IACpC,YAAY,GAAG,kBAAkB,EAAmB,CAAC;IAE7D,YAAY,MAAS;QACpB,IAAI,CAAC,MAAM,GAAG,MAAM,CAAC;IACtB,CAAC;IAED,QAAQ,CAAC,WAAmB;QAC3B,IAAI,CAAC,WAAW,GAAG,WAAW,CAAC;QAC/B,OAAO,IAAI,CAAC;IACb,CAAC;IAED,QAAQ;QACP,2CAA2C;QAC3C,iEAAiE;QACjE,MAAM,EAAE,QAAQ,EAAE,GAAG,OAAO,CAAC,eAAe,CAAC,CAAC;QAC9C,OAAO,QAAQ,CAAC,IAAI,CAAC,CAAC;IACvB,CAAC;IAED,QAAQ;QACP,OAAO,IAAI,CAAC,CAAC,mBAAmB;IACjC,CAAC;IAED,KAAK,GAAG,IAAI,CAAC,YAAY,CAAC,KAAK,CAAC;IAChC,SAAS,GAAG,IAAI,CAAC,YAAY,CAAC,SAAS,CAAC;CACxC;AAED;;;;;;;;;;;;GAYG;AACH,8DAA8D;AAC9D,MAAM,UAAU,QAAQ,CAA6B,MAAS;IAC7D,OAAO,IAAI,cAAc,CAAC,MAAM,CAAC,CAAC;AACnC,CAAC"}

package/dist/utils/optional.d.ts

@@ -0,0 +1,50 @@
+import type { Schema, Infer } from '../base';
+/**
+ * Schema for optional values (T | undefined).
+ * Accepts undefined or the wrapped schema's type.
+ *
+ * @template T - The wrapped schema type
+ *
+ * @example
+ * ```typescript
+ * const schema = s.optional(s.string());
+ * schema.parse('hello'); // 'hello'
+ * schema.parse(undefined); // undefined
+ * schema.parse(123); // throws ValidationError
+ * ```
+ */
+export declare class OptionalSchema<T extends Schema<any, any>> implements Schema<Infer<T> | undefined, Infer<T> | undefined> {
+    readonly schema: T;
+    description?: string;
+    readonly '~standard': {
+        version: 1;
+        vendor: string;
+        validate: (value: unknown) => import("@agentuity/core").StandardSchemaV1.Result<any> | Promise<import("@agentuity/core").StandardSchemaV1.Result<any>>;
+        types: {
+            input: Infer<T> | undefined;
+            output: Infer<T> | undefined;
+        };
+    };
+    private parseMethods;
+    constructor(schema: T);
+    describe(description: string): this;
+    optional(): this;
+    nullable(): Schema<Infer<T> | undefined | null, Infer<T> | undefined | null>;
+    parse: (this: Schema<any, Infer<T> | undefined>, value: unknown) => Infer<T> | undefined;
+    safeParse: (this: Schema<any, Infer<T> | undefined>, value: unknown) => import("..").SafeParseResult<Infer<T> | undefined>;
+}
+/**
+ * Make a schema optional (T | undefined).
+ *
+ * @param schema - The schema to make optional
+ *
+ * @example
+ * ```typescript
+ * const userSchema = s.object({
+ *   name: s.string(),
+ *   nickname: s.optional(s.string())
+ * });
+ * ```
+ */
+export declare function optional<T extends Schema<any, any>>(schema: T): OptionalSchema<T>;
+//# sourceMappingURL=optional.d.ts.map

package/dist/utils/optional.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"optional.d.ts","sourceRoot":"","sources":["../../src/utils/optional.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,MAAM,EAAE,KAAK,EAAE,MAAM,SAAS,CAAC;AAG7C;;;;;;;;;;;;;GAaG;AAEH,qBAAa,cAAc,CAAC,CAAC,SAAS,MAAM,CAAC,GAAG,EAAE,GAAG,CAAC,CACrD,YAAW,MAAM,CAAC,KAAK,CAAC,CAAC,CAAC,GAAG,SAAS,EAAE,KAAK,CAAC,CAAC,CAAC,GAAG,SAAS,CAAC;IAE7D,QAAQ,CAAC,MAAM,EAAE,CAAC,CAAC;IACnB,WAAW,CAAC,EAAE,MAAM,CAAC;IAErB,QAAQ,CAAC,WAAW;;;0BAGD,OAAO;eAMM;YAAE,KAAK,EAAE,KAAK,CAAC,CAAC,CAAC,GAAG,SAAS,CAAC;YAAC,MAAM,EAAE,KAAK,CAAC,CAAC,CAAC,GAAG,SAAS,CAAA;SAAE;MAC3F;IAGF,OAAO,CAAC,YAAY,CAA8C;gBAEtD,MAAM,EAAE,CAAC;IAIrB,QAAQ,CAAC,WAAW,EAAE,MAAM,GAAG,IAAI;IAKnC,QAAQ;IAIR,QAAQ,IAAI,MAAM,CAAC,KAAK,CAAC,CAAC,CAAC,GAAG,SAAS,GAAG,IAAI,EAAE,KAAK,CAAC,CAAC,CAAC,GAAG,SAAS,GAAG,IAAI,CAAC;IAO5E,KAAK,oFAA2B;IAChC,SAAS,kHAA+B;CACxC;AAED;;;;;;;;;;;;GAYG;AAEH,wBAAgB,QAAQ,CAAC,CAAC,SAAS,MAAM,CAAC,GAAG,EAAE,GAAG,CAAC,EAAE,MAAM,EAAE,CAAC,GAAG,cAAc,CAAC,CAAC,CAAC,CAEjF"}

package/dist/utils/optional.js

@@ -0,0 +1,69 @@
+import { success, createParseMethods } from '../base';
+/**
+ * Schema for optional values (T | undefined).
+ * Accepts undefined or the wrapped schema's type.
+ *
+ * @template T - The wrapped schema type
+ *
+ * @example
+ * ```typescript
+ * const schema = s.optional(s.string());
+ * schema.parse('hello'); // 'hello'
+ * schema.parse(undefined); // undefined
+ * schema.parse(123); // throws ValidationError
+ * ```
+ */
+// eslint-disable-next-line @typescript-eslint/no-explicit-any
+export class OptionalSchema {
+    schema;
+    description;
+    '~standard' = {
+        version: 1,
+        vendor: 'agentuity',
+        validate: (value) => {
+            if (value === undefined) {
+                return success(undefined);
+            }
+            return this.schema['~standard'].validate(value);
+        },
+        types: undefined,
+    };
+    // Type-safe parse methods for this instance
+    parseMethods = createParseMethods();
+    constructor(schema) {
+        this.schema = schema;
+    }
+    describe(description) {
+        this.description = description;
+        return this;
+    }
+    optional() {
+        return this; // Already optional
+    }
+    nullable() {
+        // Import here to avoid circular dependency
+        // eslint-disable-next-line @typescript-eslint/no-require-imports
+        const { nullable } = require('./nullable.js');
+        return nullable(this);
+    }
+    parse = this.parseMethods.parse;
+    safeParse = this.parseMethods.safeParse;
+}
+/**
+ * Make a schema optional (T | undefined).
+ *
+ * @param schema - The schema to make optional
+ *
+ * @example
+ * ```typescript
+ * const userSchema = s.object({
+ *   name: s.string(),
+ *   nickname: s.optional(s.string())
+ * });
+ * ```
+ */
+// eslint-disable-next-line @typescript-eslint/no-explicit-any
+export function optional(schema) {
+    return new OptionalSchema(schema);
+}
+//# sourceMappingURL=optional.js.map

package/dist/utils/optional.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"optional.js","sourceRoot":"","sources":["../../src/utils/optional.ts"],"names":[],"mappings":"AACA,OAAO,EAAE,OAAO,EAAE,kBAAkB,EAAE,MAAM,SAAS,CAAC;AAEtD;;;;;;;;;;;;;GAaG;AACH,8DAA8D;AAC9D,MAAM,OAAO,cAAc;IAGjB,MAAM,CAAI;IACnB,WAAW,CAAU;IAEZ,WAAW,GAAG;QACtB,OAAO,EAAE,CAAU;QACnB,MAAM,EAAE,WAAW;QACnB,QAAQ,EAAE,CAAC,KAAc,EAAE,EAAE;YAC5B,IAAI,KAAK,KAAK,SAAS,EAAE,CAAC;gBACzB,OAAO,OAAO,CAAC,SAAiC,CAAC,CAAC;YACnD,CAAC;YACD,OAAO,IAAI,CAAC,MAAM,CAAC,WAAW,CAAC,CAAC,QAAQ,CAAC,KAAK,CAAC,CAAC;QACjD,CAAC;QACD,KAAK,EAAE,SAAqF;KAC5F,CAAC;IAEF,4CAA4C;IACpC,YAAY,GAAG,kBAAkB,EAAwB,CAAC;IAElE,YAAY,MAAS;QACpB,IAAI,CAAC,MAAM,GAAG,MAAM,CAAC;IACtB,CAAC;IAED,QAAQ,CAAC,WAAmB;QAC3B,IAAI,CAAC,WAAW,GAAG,WAAW,CAAC;QAC/B,OAAO,IAAI,CAAC;IACb,CAAC;IAED,QAAQ;QACP,OAAO,IAAI,CAAC,CAAC,mBAAmB;IACjC,CAAC;IAED,QAAQ;QACP,2CAA2C;QAC3C,iEAAiE;QACjE,MAAM,EAAE,QAAQ,EAAE,GAAG,OAAO,CAAC,eAAe,CAAC,CAAC;QAC9C,OAAO,QAAQ,CAAC,IAAI,CAAC,CAAC;IACvB,CAAC;IAED,KAAK,GAAG,IAAI,CAAC,YAAY,CAAC,KAAK,CAAC;IAChC,SAAS,GAAG,IAAI,CAAC,YAAY,CAAC,SAAS,CAAC;CACxC;AAED;;;;;;;;;;;;GAYG;AACH,8DAA8D;AAC9D,MAAM,UAAU,QAAQ,CAA6B,MAAS;IAC7D,OAAO,IAAI,cAAc,CAAC,MAAM,CAAC,CAAC;AACnC,CAAC"}

package/dist/utils/union.d.ts

@@ -0,0 +1,60 @@
+import type { Schema, Infer } from '../base';
+type InferUnion<T extends Schema<any, any>[]> = Infer<T[number]>;
+/**
+ * Schema for union types (one of multiple possible schemas).
+ * Validates against each schema until one succeeds.
+ *
+ * @template T - Array of schema types
+ *
+ * @example
+ * ```typescript
+ * const idSchema = s.union(s.string(), s.number());
+ * idSchema.parse('abc123'); // 'abc123'
+ * idSchema.parse(123); // 123
+ *
+ * const roleSchema = s.union(
+ *   s.literal('admin'),
+ *   s.literal('user'),
+ *   s.literal('guest')
+ * );
+ * ```
+ */
+export declare class UnionSchema<T extends Schema<any, any>[]> implements Schema<InferUnion<T>, InferUnion<T>> {
+    private schemas;
+    description?: string;
+    private parseMethods;
+    constructor(schemas: T);
+    readonly '~standard': {
+        version: 1;
+        vendor: string;
+        validate: (value: unknown) => any;
+        types: {
+            input: InferUnion<T>;
+            output: InferUnion<T>;
+        };
+    };
+    describe(description: string): this;
+    optional(): import("..").OptionalSchema<this>;
+    nullable(): import("..").NullableSchema<this>;
+    parse: (this: Schema<any, InferUnion<T>>, value: unknown) => InferUnion<T>;
+    safeParse: (this: Schema<any, InferUnion<T>>, value: unknown) => import("..").SafeParseResult<InferUnion<T>>;
+}
+/**
+ * Create a union schema (one of multiple possible types).
+ *
+ * @param schemas - Variable number of schemas to union
+ *
+ * @example
+ * ```typescript
+ * const idSchema = s.union(s.string(), s.number());
+ *
+ * const roleSchema = s.union(
+ *   s.literal('admin'),
+ *   s.literal('user'),
+ *   s.literal('guest')
+ * );
+ * ```
+ */
+export declare function union<T extends Schema<any, any>[]>(...schemas: T): UnionSchema<T>;
+export {};
+//# sourceMappingURL=union.d.ts.map

package/dist/utils/union.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"union.d.ts","sourceRoot":"","sources":["../../src/utils/union.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,MAAM,EAAE,KAAK,EAAE,MAAM,SAAS,CAAC;AAM7C,KAAK,UAAU,CAAC,CAAC,SAAS,MAAM,CAAC,GAAG,EAAE,GAAG,CAAC,EAAE,IAAI,KAAK,CAAC,CAAC,CAAC,MAAM,CAAC,CAAC,CAAC;AAEjE;;;;;;;;;;;;;;;;;;GAkBG;AAEH,qBAAa,WAAW,CAAC,CAAC,SAAS,MAAM,CAAC,GAAG,EAAE,GAAG,CAAC,EAAE,CACpD,YAAW,MAAM,CAAC,UAAU,CAAC,CAAC,CAAC,EAAE,UAAU,CAAC,CAAC,CAAC,CAAC;IAKnC,OAAO,CAAC,OAAO;IAH3B,WAAW,CAAC,EAAE,MAAM,CAAC;IACrB,OAAO,CAAC,YAAY,CAAuC;gBAEvC,OAAO,EAAE,CAAC;IAE9B,QAAQ,CAAC,WAAW;;;0BAGD,OAAO;eAwBM;YAAE,KAAK,EAAE,UAAU,CAAC,CAAC,CAAC,CAAC;YAAC,MAAM,EAAE,UAAU,CAAC,CAAC,CAAC,CAAA;SAAE;MAC7E;IAEF,QAAQ,CAAC,WAAW,EAAE,MAAM,GAAG,IAAI;IAKnC,QAAQ;IAIR,QAAQ;IAIR,KAAK,sEAA2B;IAChC,SAAS,oGAA+B;CACxC;AAED;;;;;;;;;;;;;;;GAeG;AAEH,wBAAgB,KAAK,CAAC,CAAC,SAAS,MAAM,CAAC,GAAG,EAAE,GAAG,CAAC,EAAE,EAAE,GAAG,OAAO,EAAE,CAAC,GAAG,WAAW,CAAC,CAAC,CAAC,CAEjF"}

package/dist/utils/union.js

@@ -0,0 +1,87 @@
+import { createIssue, failure, createParseMethods } from '../base';
+import { optional } from '../utils/optional';
+import { nullable } from '../utils/nullable';
+/**
+ * Schema for union types (one of multiple possible schemas).
+ * Validates against each schema until one succeeds.
+ *
+ * @template T - Array of schema types
+ *
+ * @example
+ * ```typescript
+ * const idSchema = s.union(s.string(), s.number());
+ * idSchema.parse('abc123'); // 'abc123'
+ * idSchema.parse(123); // 123
+ *
+ * const roleSchema = s.union(
+ *   s.literal('admin'),
+ *   s.literal('user'),
+ *   s.literal('guest')
+ * );
+ * ```
+ */
+// eslint-disable-next-line @typescript-eslint/no-explicit-any
+export class UnionSchema {
+    schemas;
+    description;
+    parseMethods = createParseMethods();
+    constructor(schemas) {
+        this.schemas = schemas;
+    }
+    '~standard' = {
+        version: 1,
+        vendor: 'agentuity',
+        validate: (value) => {
+            const allIssues = [];
+            for (const schema of this.schemas) {
+                const result = schema['~standard'].validate(value);
+                // Only support synchronous validation for now
+                if (result instanceof Promise) {
+                    throw new Error('Async validation not supported');
+                }
+                if (!result.issues) {
+                    // eslint-disable-next-line @typescript-eslint/no-explicit-any
+                    return result;
+                }
+                allIssues.push(...result.issues);
+            }
+            return failure([
+                createIssue(`Value did not match any of the union types (${allIssues.length} validation errors)`),
+            ]);
+        },
+        types: undefined,
+    };
+    describe(description) {
+        this.description = description;
+        return this;
+    }
+    optional() {
+        return optional(this);
+    }
+    nullable() {
+        return nullable(this);
+    }
+    parse = this.parseMethods.parse;
+    safeParse = this.parseMethods.safeParse;
+}
+/**
+ * Create a union schema (one of multiple possible types).
+ *
+ * @param schemas - Variable number of schemas to union
+ *
+ * @example
+ * ```typescript
+ * const idSchema = s.union(s.string(), s.number());
+ *
+ * const roleSchema = s.union(
+ *   s.literal('admin'),
+ *   s.literal('user'),
+ *   s.literal('guest')
+ * );
+ * ```
+ */
+// eslint-disable-next-line @typescript-eslint/no-explicit-any
+export function union(...schemas) {
+    return new UnionSchema(schemas);
+}
+//# sourceMappingURL=union.js.map

package/dist/utils/union.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"union.js","sourceRoot":"","sources":["../../src/utils/union.ts"],"names":[],"mappings":"AACA,OAAO,EAAE,WAAW,EAAE,OAAO,EAAE,kBAAkB,EAAE,MAAM,SAAS,CAAC;AACnE,OAAO,EAAE,QAAQ,EAAE,MAAM,mBAAmB,CAAC;AAC7C,OAAO,EAAE,QAAQ,EAAE,MAAM,mBAAmB,CAAC;AAK7C;;;;;;;;;;;;;;;;;;GAkBG;AACH,8DAA8D;AAC9D,MAAM,OAAO,WAAW;IAMH;IAHpB,WAAW,CAAU;IACb,YAAY,GAAG,kBAAkB,EAAiB,CAAC;IAE3D,YAAoB,OAAU;QAAV,YAAO,GAAP,OAAO,CAAG;IAAG,CAAC;IAEzB,WAAW,GAAG;QACtB,OAAO,EAAE,CAAU;QACnB,MAAM,EAAE,WAAW;QACnB,QAAQ,EAAE,CAAC,KAAc,EAAE,EAAE;YAC5B,MAAM,SAAS,GAAqC,EAAE,CAAC;YAEvD,KAAK,MAAM,MAAM,IAAI,IAAI,CAAC,OAAO,EAAE,CAAC;gBACnC,MAAM,MAAM,GAAG,MAAM,CAAC,WAAW,CAAC,CAAC,QAAQ,CAAC,KAAK,CAAC,CAAC;gBAEnD,8CAA8C;gBAC9C,IAAI,MAAM,YAAY,OAAO,EAAE,CAAC;oBAC/B,MAAM,IAAI,KAAK,CAAC,gCAAgC,CAAC,CAAC;gBACnD,CAAC;gBAED,IAAI,CAAC,MAAM,CAAC,MAAM,EAAE,CAAC;oBACpB,8DAA8D;oBAC9D,OAAO,MAAa,CAAC;gBACtB,CAAC;gBACD,SAAS,CAAC,IAAI,CAAC,GAAG,MAAM,CAAC,MAAM,CAAC,CAAC;YAClC,CAAC;YAED,OAAO,OAAO,CAAC;gBACd,WAAW,CACV,+CAA+C,SAAS,CAAC,MAAM,qBAAqB,CACpF;aACD,CAAC,CAAC;QACJ,CAAC;QACD,KAAK,EAAE,SAAuE;KAC9E,CAAC;IAEF,QAAQ,CAAC,WAAmB;QAC3B,IAAI,CAAC,WAAW,GAAG,WAAW,CAAC;QAC/B,OAAO,IAAI,CAAC;IACb,CAAC;IAED,QAAQ;QACP,OAAO,QAAQ,CAAC,IAAI,CAAC,CAAC;IACvB,CAAC;IAED,QAAQ;QACP,OAAO,QAAQ,CAAC,IAAI,CAAC,CAAC;IACvB,CAAC;IAED,KAAK,GAAG,IAAI,CAAC,YAAY,CAAC,KAAK,CAAC;IAChC,SAAS,GAAG,IAAI,CAAC,YAAY,CAAC,SAAS,CAAC;CACxC;AAED;;;;;;;;;;;;;;;GAeG;AACH,8DAA8D;AAC9D,MAAM,UAAU,KAAK,CAA+B,GAAG,OAAU;IAChE,OAAO,IAAI,WAAW,CAAC,OAAO,CAAC,CAAC;AACjC,CAAC"}

package/package.json

@@ -0,0 +1,39 @@
+{
+	"name": "@agentuity/schema",
+	"version": "0.0.69",
+	"license": "Apache-2.0",
+	"author": "Agentuity employees and contributors",
+	"type": "module",
+	"main": "./dist/index.js",
+	"types": "./dist/index.d.ts",
+	"files": [
+		"AGENTS.md",
+		"README.md",
+		"src",
+		"dist"
+	],
+	"exports": {
+		".": {
+			"types": "./dist/index.d.ts",
+			"import": "./dist/index.js"
+		}
+	},
+	"scripts": {
+		"clean": "rm -rf dist",
+		"build": "bunx tsc --build --force",
+		"typecheck": "bunx tsc --noEmit",
+		"test": "bun test",
+		"prepublishOnly": "bun run clean && bun run build"
+	},
+	"dependencies": {
+		"@agentuity/core": "0.0.69"
+	},
+	"devDependencies": {
+		"@types/bun": "latest",
+		"bun-types": "latest",
+		"typescript": "^5.9.0"
+	},
+	"publishConfig": {
+		"access": "public"
+	}
+}

package/src/__tests__/coerce.test.ts

@@ -0,0 +1,88 @@
+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

@@ -0,0 +1,124 @@
+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);
+	});
+});