@sdxc/validate 2026.9.11 → 2026.9.16

package/README.md

@@ -1,12 +1,6 @@
 # @sdxc/validate
 
-Type-safe form and request validation using Standard Schema with Result types.
-
-## Overview
-
-This package provides a unified validation function that works with FormData, Request objects (both form-encoded and JSON), and plain JavaScript objects. It uses the [Standard Schema](https://standardschema.dev) specification, which means it works with any schema validation library that implements the standard, including `remix/data-schema`, Valibot, ArkType, and more.
-
-The validation result is returned as a `Result<T, ValidationError>` type from `@sdxc/result`, making error handling explicit and type-safe.
+Validate a form submission, a request body, or a plain object against any Standard Schema, and get a `Result` back instead of a thrown error.
 
 ## Installation
 
@@ -14,674 +8,210 @@ The validation result is returned as a `Result<T, ValidationError>` type from `@
 npm add @sdxc/validate
 ```
 
-It works with any Standard Schema-compliant validation library, installed alongside it.
+The schema itself comes from any library implementing [Standard Schema](https://standardschema.dev) — [`remix`](https://www.npmjs.com/package/remix), [Valibot](https://valibot.dev), [ArkType](https://arktype.io) — installed alongside this package. [`@sdxc/result`](https://www.npmjs.com/package/@sdxc/result) installs with it and supplies `isSuccess`, `isFailure` and `unwrap`.
 
 ```bash
-npm add remix  # or valibot, arktype, etc.
+npm add valibot
 ```
 
 ## Usage
 
-### Basic Example with `remix/data-schema`
+### Validate a plain object
 
 ```typescript
-import { badRequest, created } from "@sdxc/response";
 import { isFailure } from "@sdxc/result";
 import { validate } from "@sdxc/validate";
 import * as s from "remix/data-schema";
 import { email, minLength } from "remix/data-schema/checks";
-import { createAction } from "remix/router";
-
-import routes from "~/routes/web";
 
 let schema = s.object({
 	email: s.string().pipe(email()),
 	name: s.string().pipe(minLength(2)),
 });
 
-/** POST /api/users — creates a user from the submitted body. */
-export default createAction(routes.api.users.create, async (ctx) => {
-	let result = await validate(ctx.request, schema);
+let result = await validate({ email: "ada@example.com", name: "Ada" }, schema);
 
-	if (isFailure(result)) {
-		return badRequest({ errors: result.error.issues });
-	}
-
-	// TypeScript knows result.data is { email: string, name: string }
-	let user = await saveUser(result.data);
-	return created({ user });
-});
+if (isFailure(result)) console.error(result.error.issues);
+else console.log(result.data.email); // typed `string` from the schema
 ```
 
-### With FormData
+### Validate a form submission
 
-```typescript
-let formData = new FormData();
-formData.append("email", "user@example.com");
-formData.append("name", "Alice");
-
-let result = await validate(formData, schema);
-
-if (isSuccess(result)) {
-	console.log(result.data.email); // "user@example.com"
-	console.log(result.data.name); // "Alice"
-}
-```
-
-### With Request (Form-Encoded)
+`FormData` and `URLSearchParams` flatten to an object first: a name submitted once becomes a value, and a name submitted several times becomes an array.
 
 ```typescript
-export default createAction(routes.signup.action, async (ctx) => {
-	// Request with Content-Type: application/x-www-form-urlencoded
-	let result = await validate(ctx.request, schema);
+let form = new FormData();
+form.append("email", "ada@example.com");
+form.append("tags", "typescript");
+form.append("tags", "validation");
 
-	if (isFailure(result)) {
-		return badRequest({ errors: result.error.issues });
-	}
-
-	return ok({ data: result.data });
-});
+let result = await validate(form, s.object({ email: s.string(), tags: s.array(s.string()) }));
 ```
 
-With the `formData()` middleware installed, the body is already parsed by the time the
-handler runs, so pass `ctx.formData` and leave `ctx.request` untouched:
-
-```typescript
-export default createAction(routes.signup.action, async (ctx) => {
-	let result = await validate(ctx.formData, schema);
-
-	if (isFailure(result)) {
-		return badRequest({ errors: result.error.issues });
-	}
-
-	return ok({ data: result.data });
-});
-```
+### Validate a request
 
-### With Request (JSON)
+A `Request` is read according to its `Content-Type`, so one call covers every kind of submission a route accepts:
 
 ```typescript
-export default createAction(routes.api.users.create, async (ctx) => {
-	// Request with Content-Type: application/json
-	let result = await validate(ctx.request, schema);
+async function handler(request: Request) {
+	let result = await validate(request, schema);
 
 	if (isFailure(result)) {
-		return badRequest({ errors: result.error.issues });
+		return Response.json({ errors: result.error.issues }, { status: 400 });
 	}
 
-	return ok({ data: result.data });
-});
-```
-
-### With Plain Objects
-
-```typescript
-let data = {
-	email: "user@example.com",
-	name: "Bob",
-};
-
-let result = await validate(data, schema);
-
-if (isSuccess(result)) {
-	console.log(result.data);
+	return Response.json({ user: result.data });
 }
 ```
 
-### With URLSearchParams
+### Read the failure
 
-```typescript
-let params = new URLSearchParams();
-params.append("email", "user@example.com");
-params.append("name", "Charlie");
-
-let result = await validate(params, schema);
+Every issue carries the path it failed at, so a refusal can be reported field by field:
 
-if (isSuccess(result)) {
-	console.log(result.data.email); // "user@example.com"
-	console.log(result.data.name); // "Charlie"
+```typescript
+if (isFailure(result)) {
+	for (let issue of result.error.issues) console.log(issue.path, issue.message);
+	// ["email"] Expected valid email
+	// ["name"] Expected at least 2 characters
 }
 ```
 
 ## API
 
-### `validate<Schema>(input, schema): Promise<Result<T, ValidationError>>`
-
-Validates input data against a Standard Schema-compliant schema.
+### `validate<Schema>(input, schema): Promise<Result<InferOutput<Schema>, ValidationError>>`
 
-**Parameters:**
+Normalizes `input`, runs it through `schema`, and resolves to a `Result` carrying either the schema's own output type or a `ValidationError`. A rejected submission is a value, not an exception.
 
-- `input`: `FormData | URLSearchParams | Request | Record<string, unknown>` - The data to validate
-  - `FormData`: Converts entries to an object and validates
-  - `URLSearchParams`: Converts entries to an object and validates
-  - `Request`: Automatically detects content type
-    - `application/json`: Parses JSON body
-    - `application/x-www-form-urlencoded`: Parses as URLSearchParams
-    - `multipart/form-data`: Parses as FormData
-  - `Record<string, unknown>`: Validates plain object directly
-- `schema`: Any Standard Schema V1 compliant schema (`remix/data-schema`, Valibot, ArkType, etc.)
+`input` is any of:
 
-**Returns:**
+- `FormData` or `URLSearchParams` — entries flatten to an object, a repeated name becoming an array.
+- `Request` — the body is read by content type: `application/json`, `multipart/form-data`, or `application/x-www-form-urlencoded`. Any other type refuses with `Unsupported content-type: …`, and a body that is not valid JSON refuses with `Invalid JSON in request body`.
+- A plain object, or any JSON value — handed to the schema as it stands.
 
-- `Promise<Result<T, ValidationError>>` where:
-  - `Success<T>`: Contains validated and typed data
-  - `Failure<ValidationError>`: Contains validation issues
+Some schemas validate the raw source rather than a flattened object — `remix/data-schema/form-data`'s `object()` is one, and it rejects the flattened object with `Expected FormData or URLSearchParams`. That rejection is retried against the original `FormData` or `URLSearchParams`, so those schemas pass through the same call as any other.
 
-**Example:**
-
-```typescript
-let result = await validate(request, schema);
-
-if (isSuccess(result)) {
-	// result.data is fully typed based on your schema
-	console.log(result.data);
-} else {
-	// result.error is ValidationError with detailed issues
-	console.error(result.error.issues);
-}
-```
+`schema` is any Standard Schema V1 value, and the success type is inferred from it, so nothing restates the shape the schema already describes.
 
 ### `ValidationError`
 
-Error class containing validation issues from the schema.
-
-**Properties:**
+What a refused submission carries. `message` is always `"Validation Error"`, and `issues` is the schema's own `StandardSchemaV1.Issue[]` — each a `message` plus the `path` it failed at, in whatever vocabulary the schema library produced.
 
-- `message`: Always `"Validation Error"`
-- `issues`: `StandardSchemaV1.Issue[]` - Array of validation issues
+## Pattern: One Schema Behind Several Entry Points
 
-**Issue Structure:**
-
-```typescript
-interface Issue {
-	message: string; // Error message
-	path?: ReadonlyArray<PropertyKey | PathSegment> | undefined; // Path to the field
-}
-```
-
-**Example:**
-
-```typescript
-if (isFailure(result)) {
-	console.log(result.error.message); // "Validation Error"
-	console.log(result.error.issues);
-	// [
-	//   { message: "Expected valid email", path: ["email"] },
-	//   { message: "Expected at least 2 characters", path: ["name"] }
-	// ]
-}
-```
-
-## Schema Libraries
-
-This package works with any library that implements the Standard Schema specification.
-
-### `remix/data-schema`
+A schema is a value, so the rule a form enforces in the browser and the rule an API enforces on the wire can be the same object rather than two that drift:
 
 ```typescript
+// schemas.ts
 import * as s from "remix/data-schema";
-import { email, min } from "remix/data-schema/checks";
-
-let schema = s.object({
-	email: s.string().pipe(email()),
-	age: s.number().pipe(min(18)),
-	role: s.enum_(["user", "admin"]),
-});
-
-let result = await validate(formData, schema);
-```
-
-### Valibot
-
-```typescript
-import * as v from "valibot";
-
-let schema = v.object({
-	email: v.pipe(v.string(), v.email()),
-	age: v.pipe(v.number(), v.minValue(18)),
-	role: v.picklist(["user", "admin"]),
-});
-
-let result = await validate(formData, schema);
-```
-
-### ArkType
-
-```typescript
-import { type } from "arktype";
-
-let schema = type({
-	email: "string.email",
-	"age>=": 18,
-	role: "'user'|'admin'",
-});
-
-let result = await validate(formData, schema);
-```
-
-## Type Safety
-
-The `validate` function automatically infers the output type from your schema:
+import { email, min, minLength } from "remix/data-schema/checks";
 
-```typescript
-let schema = s.object({
+export let signup = s.object({
 	email: s.string().pipe(email()),
-	name: s.string(),
-	age: s.number(),
+	name: s.string().pipe(minLength(2)),
+	age: s.optional(s.number().pipe(min(18))),
 });
-
-let result = await validate(request, schema);
-
-if (isSuccess(result)) {
-	// TypeScript knows:
-	// result.data = {
-	//   email: string;
-	//   name: string;
-	//   age: number;
-	// }
-	let email: string = result.data.email; // ✓ Type-safe
-	let name: string = result.data.name; // ✓ Type-safe
-	let age: number = result.data.age; // ✓ Type-safe
-}
 ```
 
-## Integration with `remix/router`
-
-### Basic Action
-
 ```typescript
-import { badRequest, created } from "@sdxc/response";
 import { isFailure } from "@sdxc/result";
 import { validate } from "@sdxc/validate";
-import * as s from "remix/data-schema";
-import { email, minLength } from "remix/data-schema/checks";
-import { createAction } from "remix/router";
-
-import routes from "~/routes/web";
-
-let schema = s.object({
-	email: s.string().pipe(email()),
-	password: s.string().pipe(minLength(8)),
-});
 
-/** POST /signup — registers an account. */
-export default createAction(routes.signup.action, async (ctx) => {
-	let result = await validate(ctx.formData, schema);
+import { signup } from "./schemas.js";
 
-	if (isFailure(result)) {
-		return badRequest({ errors: result.error.issues });
-	}
-
-	let user = await createUser(result.data);
-	return created({ user });
-});
+async function handler(request: Request) {
+	let result = await validate(request, signup);
+	if (isFailure(result)) return Response.json({ errors: result.error.issues }, { status: 400 });
+	return Response.json({ user: await createUser(result.data) });
+}
 ```
 
-### With Early Returns
-
-```typescript
-export default createAction(routes.login.action, async (ctx) => {
-	let validation = await validate(ctx.formData, loginSchema);
-	if (isFailure(validation)) {
-		return badRequest({ errors: validation.error.issues });
-	}
-
-	let userResult = await findUser(validation.data.email);
-	if (isFailure(userResult)) {
-		return notFound({ error: "User not found" });
-	}
-
-	let passwordValid = await verifyPassword(validation.data.password, userResult.data.passwordHash);
-	if (!passwordValid) {
-		return unauthorized({ error: "Invalid credentials" });
-	}
-
-	return ok({ user: userResult.data });
-});
-```
+There is no `.partial()` helper, so a variant where every field is optional wraps each one in `s.optional()`.
 
-### Displaying Errors in Components
+## Pattern: Rendering A Refused Submission
 
-A `Form` takes the issues straight off the failed result and hands each field its own
-messages by `name` through component context, so a refused submission re-renders the same
-page with `issues` set and nothing else threaded down:
+`ValidationError.issues` already matches the issue shape [`@sdxc/ui`](https://www.npmjs.com/package/@sdxc/ui)'s `Form` takes, so a refusal re-renders the same page with the array passed straight through. Each field looks its own messages up by `name`, renders them, marks itself `aria-invalid`, and the first invalid field of the render takes focus — so nothing else is threaded down:
 
 ```tsx
 import type { Handle } from "remix/ui";
 
-import { redirect } from "@sdxc/response";
-import { isFailure } from "@sdxc/result";
 import { Button, Form, TextField } from "@sdxc/ui";
-import { validate } from "@sdxc/validate";
-import { createController } from "remix/router";
-
-import routes from "~/routes/web";
 
-function SignupPage(handle: Handle<{ issues?: ReadonlyArray<Form.Issue> }>) {
+function SignupForm(handle: Handle<{ issues?: ReadonlyArray<Form.Issue> }>) {
 	return () => (
 		<Form method="post" issues={handle.props.issues}>
 			<TextField label="Email" name="email" type="email" required />
 			<TextField label="Password" name="password" type="password" required />
-			<Button type="submit">Sign Up</Button>
+			<Button type="submit">Sign up</Button>
 		</Form>
 	);
 }
-
-export default createController(routes.signup, {
-	actions: {
-		/** GET /signup — the empty form. */
-		index(ctx) {
-			return ctx.render(<SignupPage />);
-		},
-
-		/** POST /signup — registers the account, or re-renders the form with its issues. */
-		async action(ctx) {
-			let result = await validate(ctx.formData, schema);
-
-			if (isFailure(result)) {
-				return ctx.render(<SignupPage issues={result.error.issues} />, { status: 400 });
-			}
-
-			await createUser(result.data);
-			return redirect(routes.dashboard.href(), { status: redirect.Status.SeeOther });
-		},
-	},
-});
-```
-
-`ValidationError.issues` already matches the `Form.Issue` shape, so the array passes through
-as-is. Each field looks its own messages up by `name`, renders them, marks itself
-`aria-invalid`, and the first invalid field of the render takes focus.
-
-## Content Type Detection
-
-The `validate` function automatically detects and handles different content types when given a `Request`:
-
-### Supported Content Types
-
-- **`application/json`** - Parses JSON request body
-- **`multipart/form-data`** - Parses multipart form data
-- **`application/x-www-form-urlencoded`** - Parses URL-encoded form data
-
-### JSON Requests
-
-```typescript
-// Request with Content-Type: application/json
-let request = new Request("https://api.example.com/users", {
-	method: "POST",
-	headers: { "Content-Type": "application/json" },
-	body: JSON.stringify({ email: "user@example.com", name: "Alice" }),
-});
-
-let result = await validate(request, schema);
-// Automatically parses JSON body
-```
-
-### Form Requests (multipart/form-data)
-
-```typescript
-// When you pass FormData to Request, it automatically sets
-// Content-Type: multipart/form-data with boundary
-let formData = new FormData();
-formData.append("email", "user@example.com");
-formData.append("name", "Alice");
-
-let request = new Request("https://example.com/submit", {
-	method: "POST",
-	body: formData,
-});
-
-let result = await validate(request, schema);
-// Automatically parses FormData
-```
-
-### Form Requests (application/x-www-form-urlencoded)
-
-```typescript
-// URL-encoded form data
-let params = new URLSearchParams();
-params.append("email", "user@example.com");
-params.append("name", "Alice");
-
-let request = new Request("https://example.com/submit", {
-	method: "POST",
-	headers: { "Content-Type": "application/x-www-form-urlencoded" },
-	body: params,
-});
-
-let result = await validate(request, schema);
-// Automatically parses URL-encoded data
-```
-
-### Unsupported Content Types
-
-If a Request has an unsupported content-type, validation will fail:
-
-```typescript
-let request = new Request("https://example.com/submit", {
-	method: "POST",
-	headers: { "Content-Type": "text/plain" },
-	body: "plain text",
-});
-
-let result = await validate(request, schema);
-
-if (isFailure(result)) {
-	console.log(result.error.issues[0].message);
-	// "Unsupported content-type: text/plain. Expected application/json, multipart/form-data, or application/x-www-form-urlencoded"
-}
-```
-
-### Invalid JSON Handling
-
-```typescript
-let request = new Request("https://api.example.com/users", {
-	method: "POST",
-	headers: { "Content-Type": "application/json" },
-	body: "{ invalid json",
-});
-
-let result = await validate(request, schema);
-
-if (isFailure(result)) {
-	console.log(result.error.issues[0].message);
-	// "Invalid JSON in request body"
-}
-```
-
-## Pattern: Reusable Schemas
-
-Define schemas once and reuse them across your application:
-
-```typescript
-// schemas.ts
-import * as s from "remix/data-schema";
-import { email, min, minLength } from "remix/data-schema/checks";
-
-export let userSchema = s.object({
-	email: s.string().pipe(email()),
-	name: s.string().pipe(minLength(2)),
-	age: s.optional(s.number().pipe(min(18))),
-});
-
-export let loginSchema = s.object({
-	email: s.string().pipe(email()),
-	password: s.string().pipe(minLength(8)),
-});
-
-// There is no `.partial()` helper, so a schema where every field is optional is
-// spelled out by wrapping each one in `s.optional()`.
-export let updateUserSchema = s.object({
-	email: s.optional(s.string().pipe(email())),
-	name: s.optional(s.string().pipe(minLength(2))),
-	age: s.optional(s.number().pipe(min(18))),
-});
-```
-
-```typescript
-// app/http/controllers/signup.ts
-import { validate } from "@sdxc/validate";
-import { createAction } from "remix/router";
-
-import routes from "~/routes/web";
-import { userSchema } from "~/schemas";
-
-export default createAction(routes.signup.action, async (ctx) => {
-	let result = await validate(ctx.formData, userSchema);
-	// ...
-});
 ```
 
-## Pattern: Custom Error Messages
-
-Checks are plain objects, so a custom message is applied by spreading the check
-and overriding its `message`. There is no regex check, so pattern rules go
-through `.refine()`, which takes the message as its second argument.
-
-```typescript
-import * as s from "remix/data-schema";
-import { email, minLength } from "remix/data-schema/checks";
+```tsx
+let result = await validate(submission, schema);
 
-let schema = s.object({
-	email: s.string().pipe({ ...email(), message: "Please enter a valid email address" }),
-	password: s
-		.string()
-		.pipe({ ...minLength(8), message: "Password must be at least 8 characters" })
-		.refine((value) => /[A-Z]/.test(value), "Password must contain at least one uppercase letter"),
-});
+if (isFailure(result)) return <SignupForm issues={result.error.issues} />;
 ```
 
-## Pattern: Transformations
+## Pattern: Normalizing While Validating
 
-Schema libraries can transform data during validation:
+A schema transforms as it validates, so the handler receives values in the shape it wants rather than the shape the wire delivered. Everything arriving from a form is a string, which is where this earns the most:
 
 ```typescript
-import * as s from "remix/data-schema";
-import { email } from "remix/data-schema/checks";
-
 let schema = s.object({
 	email: s
 		.string()
 		.pipe(email())
-		.transform((value) => value.toLowerCase()), // Transform to lowercase
-	age: s.string().transform(Number), // Convert string to number
-	tags: s.string().transform((str) => str.split(",")), // Split into array
+		.transform((value) => value.toLowerCase()),
+	age: s.string().transform(Number),
+	tags: s.string().transform((value) => value.split(",")),
 });
 
-let formData = new FormData();
-formData.append("email", "USER@EXAMPLE.COM");
-formData.append("age", "25");
-formData.append("tags", "javascript,typescript,react");
+let form = new FormData();
+form.append("email", "ADA@EXAMPLE.COM");
+form.append("age", "25");
+form.append("tags", "typescript,validation");
 
-let result = await validate(formData, schema);
-
-if (isSuccess(result)) {
-	console.log(result.data);
-	// {
-	//   email: "user@example.com",  // Transformed to lowercase
-	//   age: 25,                     // Transformed to number
-	//   tags: ["javascript", "typescript", "react"]  // Transformed to array
-	// }
-}
+let result = await validate(form, schema);
+// { email: "ada@example.com", age: 25, tags: ["typescript", "validation"] }
 ```
 
-## Pattern: Nested Objects
-
-```typescript
-let schema = s.object({
-	user: s.object({
-		name: s.string(),
-		email: s.string().pipe(email()),
-	}),
-	preferences: s.object({
-		newsletter: s.boolean(),
-		theme: s.enum_(["light", "dark"]),
-	}),
-});
-
-let result = await validate(data, schema);
+## Pattern: Custom Messages
 
-if (isFailure(result)) {
-	// Issues include paths like ["user", "email"] or ["preferences", "theme"]
-	result.error.issues.forEach((issue) => {
-		console.log(issue.path, issue.message);
-	});
-}
-```
-
-## Pattern: Array Validation
+Checks are plain objects, so a custom message spreads the check and overrides its `message`. There is no regex check, so a pattern rule goes through `.refine()`, which takes its message as a second argument:
 
 ```typescript
 let schema = s.object({
-	tags: s.array(s.string()),
-	emails: s.array(s.string().pipe(email())),
+	email: s.string().pipe({ ...email(), message: "Please enter a valid email address" }),
+	password: s
+		.string()
+		.pipe({ ...minLength(8), message: "Password must be at least 8 characters" })
+		.refine((value) => /[A-Z]/.test(value), "Password must contain an uppercase letter"),
 });
-
-// With FormData, you can append multiple values with the same name
-let formData = new FormData();
-formData.append("tags", "javascript");
-formData.append("tags", "typescript");
-formData.append("emails", "user1@example.com");
-formData.append("emails", "user2@example.com");
 ```
 
-## Error Handling
+## Versioning
 
-### Checking Individual Fields
+Releases are dated rather than semantic. A version is the UTC date it was published, written `YYYY.M.D`, so `2026.9.4` is the release from 4 September 2026. At most one release goes out per day.
 
-```typescript
-if (isFailure(result)) {
-	let emailIssues = result.error.issues.filter((issue) => issue.path?.[0] === "email");
+Those numbers say when, not what: a later date means a later release and carries no compatibility promise. Any release may change or remove an export.
 
-	let passwordIssues = result.error.issues.filter((issue) => issue.path?.[0] === "password");
+Depend on one exact date, and move it when you are ready to take the change:
 
-	if (emailIssues.length > 0) {
-		console.log("Email errors:", emailIssues);
+```json
+{
+	"dependencies": {
+		"@sdxc/validate": "2026.9.4"
 	}
 }
 ```
 
-### Grouping Errors by Field
-
-```typescript
-if (isFailure(result)) {
-	let errorsByField = result.error.issues.reduce(
-		(acc, issue) => {
-			let field = issue.path?.[0]?.toString() ?? "general";
-			if (!acc[field]) acc[field] = [];
-			acc[field].push(issue.message);
-			return acc;
-		},
-		{} as Record<string, string[]>,
-	);
-
-	console.log(errorsByField);
-	// {
-	//   email: ["Invalid email format"],
-	//   password: ["Password too short", "Password must contain uppercase"]
-	// }
-}
-```
-
-## Why Standard Schema?
-
-The Standard Schema specification allows this package to work with any compliant validation library without needing adapters or library-specific code. Benefits include:
-
-1. **Library agnostic** - Switch between `remix/data-schema`, Valibot, ArkType without changing validation code
-2. **Future-proof** - New libraries implementing the standard work automatically
-3. **Smaller bundles** - Use lightweight libraries like Valibot if bundle size matters
-4. **Ecosystem growth** - More tools and libraries are adopting the standard
+A caret or tilde range reads the date as major, minor and patch, so it accepts every later release in the same year. An exact version keeps the upgrade yours to schedule.
 
-## Related Packages
+## License
 
-- [`@sdxc/result`](https://www.npmjs.com/package/@sdxc/result) - Result type for explicit error handling
-- [`@sdxc/response`](https://www.npmjs.com/package/@sdxc/response) - Semantic helpers that build plain `Response` objects for JSON APIs and redirects
-- [Standard Schema](https://standardschema.dev) - The specification this package implements
+MIT
 
-## Tips
+## Author
 
-1. **Prefer early returns** - Check for validation failures early and return error responses
-2. **Reuse schemas** - Define schemas in a central location and import them
-3. **Custom messages** - Provide user-friendly error messages in your schemas
-4. **Transform data** - Use schema transformations to normalize data (lowercase emails, trim strings, etc.)
-5. **Type inference** - Let TypeScript infer types from your schemas instead of duplicating type definitions
+[Sergio Xalambrí](https://sergiodxa.com)

package/package.json

@@ -1,6 +1,6 @@
 {
 	"name": "@sdxc/validate",
-	"version": "2026.9.11",
+	"version": "2026.9.16",
 	"description": "Standard Schema validation utilities",
 	"license": "MIT",
 	"type": "module",
@@ -8,11 +8,11 @@
 		".": "./dist/index.js"
 	},
 	"dependencies": {
-		"@sdxc/result": "2026.9.11",
-		"@sdxc/types": "2026.9.11",
+		"@sdxc/result": "2026.9.15",
+		"@sdxc/types": "2026.9.15",
 		"@standard-schema/spec": "^1.1.0"
 	},
-	"gitHead": "3aedbf2a8ed2251cecac480501941ee4c4614ec3",
+	"gitHead": "704fb5aba875369a1bdebf8ff23676bd8b3836ce",
 	"publishConfig": {
 		"access": "public"
 	},