@warlock.js/seal 5.30.0 → 5.32.0

package/skills/define-structural-shape/array-methods.md

@@ -4,41 +4,41 @@ The inner validator runs against each element. Failure on any element fails the
 
 ## Length
 
-| Method | Args | JSON Schema | Example |
-|---|---|---|---|
-| `.min(n, msg?)` | n/a — see note below | — | use `.minLength(n)` |
-| `.minLength(n, msg?)` | inclusive lower bound | `minItems: n` | `v.array(v.string()).minLength(1)` |
-| `.maxLength(n, msg?)` | inclusive upper bound | `maxItems: n` | `v.array(v.string()).maxLength(10)` |
-| `.length(n, msg?)` | exact length | `minItems=maxItems=n` | `v.array(v.string()).length(3)` |
-| `.between(a, b, msg?)` | inclusive range | `minItems: a, maxItems: b` | `v.array(v.string()).between(1, 10)` |
-| `.lengthBetween(a, b, msg?)` | alias for `.between()` | `minItems: a, maxItems: b` | — |
+| Method                       | Args                   | JSON Schema                | Example                              |
+| ---------------------------- | ---------------------- | -------------------------- | ------------------------------------ |
+| `.min(n, msg?)`              | n/a — see note below   | —                          | use `.minLength(n)`                  |
+| `.minLength(n, msg?)`        | inclusive lower bound  | `minItems: n`              | `v.array(v.string()).minLength(1)`   |
+| `.maxLength(n, msg?)`        | inclusive upper bound  | `maxItems: n`              | `v.array(v.string()).maxLength(10)`  |
+| `.length(n, msg?)`           | exact length           | `minItems=maxItems=n`      | `v.array(v.string()).length(3)`      |
+| `.between(a, b, msg?)`       | inclusive range        | `minItems: a, maxItems: b` | `v.array(v.string()).between(1, 10)` |
+| `.lengthBetween(a, b, msg?)` | alias for `.between()` | `minItems: a, maxItems: b` | —                                    |
 
 **Note on `.min`/`.max`:** the array validator does not expose `.min`/`.max` directly — use `.minLength`/`.maxLength` (or `.between`/`.length`). This is intentional: `.min`/`.max` would conflict with primitive value-comparison semantics if they ever bled into here.
 
 ## Uniqueness & sort
 
-| Method | Args | Effect |
-|---|---|---|
-| `.unique(msg?)` | — | every element is distinct |
+| Method                      | Args                          | Effect                        |
+| --------------------------- | ----------------------------- | ----------------------------- |
+| `.unique(msg?)`             | —                             | every element is distinct     |
 | `.sorted(direction?, msg?)` | `"asc"` (default) or `"desc"` | array is monotonically sorted |
 
 ## Mutators (pre-validation reshape)
 
-| Method | Args | Effect |
-|---|---|---|
-| `.flip()` | — | reverse the array |
-| `.reverse()` | — | alias for `.flip()` |
-| `.onlyUnique()` | — | dedupe before validation |
-| `.sort(direction?, key?)` | `"asc"` (default) or `"desc"`; optional sort key for object items | sort before validation |
+| Method                    | Args                                                              | Effect                   |
+| ------------------------- | ----------------------------------------------------------------- | ------------------------ |
+| `.flip()`                 | —                                                                 | reverse the array        |
+| `.reverse()`              | —                                                                 | alias for `.flip()`      |
+| `.onlyUnique()`           | —                                                                 | dedupe before validation |
+| `.sort(direction?, key?)` | `"asc"` (default) or `"desc"`; optional sort key for object items | sort before validation   |
 
 `onlyUnique()` and `unique()` differ: the mutator silently dedupes; the rule fails when duplicates are present. Pick by intent — coerce vs reject.
 
 ## Inner validator notes
 
 ```ts
-v.array(v.string().email())              // every element must be a valid email
-v.array(userSchema)                      // every element must satisfy userSchema
-v.array(v.array(v.int()))                // matrix-ish — Infer is recursive
+v.array(v.string().email()); // every element must be a valid email
+v.array(userSchema); // every element must satisfy userSchema
+v.array(v.array(v.int())); // matrix-ish — Infer is recursive
 ```
 
 Element validators run with element-level context. `path` becomes `${parent}.${index}` for error messages. Cross-field rules inside element schemas resolve to that element's fields, not the array.
@@ -56,23 +56,23 @@ Element validators run with element-level context. `path` becomes `${parent}.${i
 
 ```ts
 // Tags
-v.array(v.string().min(1)).unique().between(1, 10)
+v.array(v.string().min(1)).unique().between(1, 10);
 
 // User list
-v.array(userSchema).minLength(1)
+v.array(userSchema).minLength(1);
 
 // Pre-sorted, deduped
-v.array(v.string()).onlyUnique().sort("asc")
+v.array(v.string()).onlyUnique().sort("asc");
 
 // Reverse-emit
-v.array(v.string()).flip()
+v.array(v.string()).flip();
 
 // Matrix
-v.array(v.array(v.number())).minLength(1)
+v.array(v.array(v.number())).minLength(1);
 
 // Sorted ids
-v.array(v.string().uuid()).sorted("asc").unique()
+v.array(v.string().uuid()).sorted("asc").unique();
 
 // Optional list with default
-v.array(v.string()).default([]).optional()
+v.array(v.string()).default([]).optional();
 ```

package/skills/define-structural-shape/object-methods.md

@@ -9,10 +9,12 @@ These return a new `ObjectValidator` with a transformed schema. The TypeScript i
 ### `.extend(schemaOrValidator)` — add fields, keep config
 
 ```ts
-const baseUser = v.object({
-  name: v.string(),
-  email: v.string().email(),
-}).allowUnknown();
+const baseUser = v
+  .object({
+    name: v.string(),
+    email: v.string().email(),
+  })
+  .allowUnknown();
 
 const adminUser = baseUser.extend({
   role: v.string().oneOf(["admin", "superadmin"]),
@@ -26,10 +28,12 @@ Accepts a plain schema object **or** another `ObjectValidator` (only its schema
 
 ```ts
 const base = v.object({ name: v.string() }).allowUnknown();
-const audit = v.object({
-  createdAt: v.date(),
-  updatedAt: v.date(),
-}).stripUnknown();
+const audit = v
+  .object({
+    createdAt: v.date(),
+    updatedAt: v.date(),
+  })
+  .stripUnknown();
 
 const merged = base.merge(audit);
 // type: { name; createdAt; updatedAt }
@@ -66,8 +70,8 @@ Returns `ObjectValidator<Omit<TSchema, K>>`. Inverse of `.pick`. Keeps original
 ### `.partial(...keys?)` — mark fields optional
 
 ```ts
-fullUser.partial()                // every field becomes optional
-fullUser.partial("password")      // only `password` becomes optional
+fullUser.partial(); // every field becomes optional
+fullUser.partial("password"); // only `password` becomes optional
 ```
 
 Walks the schema and applies `.optional()` to each named field (or all if no keys given). `Infer<>` makes those keys optional.
@@ -75,7 +79,7 @@ Walks the schema and applies `.optional()` to each named field (or all if no key
 ### `.requiredFields(...keys?)` — mark fields required
 
 ```ts
-const partialUser = fullUser.partial();    // all optional
+const partialUser = fullUser.partial(); // all optional
 const updateUser = partialUser.requiredFields("id", "email");
 // id and email are required again, others stay optional
 ```
@@ -86,29 +90,31 @@ Inverse of `.partial`.
 
 By default, extra keys in input are silently dropped from `data` (no error, no forward).
 
-| Method | Effect |
-|---|---|
-| `.allowUnknown(allow = true)` | extra **direct-child** keys forward as-is |
-| `.stripUnknown()` | explicit drop (mutator-based — affects `data` shape) |
-| `.allow(...keys)` | whitelist specific extras to forward without validation |
+| Method                        | Effect                                                  |
+| ----------------------------- | ------------------------------------------------------- |
+| `.allowUnknown(allow = true)` | extra **direct-child** keys forward as-is               |
+| `.stripUnknown()`             | explicit drop (mutator-based — affects `data` shape)    |
+| `.allow(...keys)`             | whitelist specific extras to forward without validation |
 
 `.allowUnknown()` only affects direct children — nested objects keep their own policies. For a fully permissive object including nested children, set `.allowUnknown()` on each level.
 
 ### Output DTOs — stripping extras instead of rejecting them
 
-The default is to **reject** unknown keys, which is what you want for inbound payloads. For an *outbound* DTO — where the record legitimately carries internal fields you simply don't want to expose — use `.stripUnknown()`, which drops them and returns the clean object:
+The default is to **reject** unknown keys, which is what you want for inbound payloads. For an _outbound_ DTO — where the record legitimately carries internal fields you simply don't want to expose — use `.stripUnknown()`, which drops them and returns the clean object:
 
 ```ts
-const publicArticle = v.object({
-  id: v.string(),
-  title: v.string(),
-}).stripUnknown();
+const publicArticle = v
+  .object({
+    id: v.string(),
+    title: v.string(),
+  })
+  .stripUnknown();
 
 const { isValid, data } = await v.validate(publicArticle, record);
 // record had version / authorId / status; data has only id + title
 ```
 
-Without `.stripUnknown()` the same record fails with *"The schema contains unknown keys: …"* rather than being cleaned.
+Without `.stripUnknown()` the same record fails with _"The schema contains unknown keys: …"_ rather than being cleaned.
 
 :::note[`data` is `undefined` on failure — since 4.9.2]
 A failed validation returns `data: undefined`, never the input it rejected. Before 4.9.2 an `object` returned the raw input on failure (while `discriminatedUnion` returned `undefined`), so a caller who read `data` without branching on `isValid` forwarded the exact fields the schema existed to exclude. Always branch on `isValid`.
@@ -116,8 +122,8 @@ A failed validation returns `data: undefined`, never the input it rejected. Befo
 
 ## Object-level mutators
 
-| Method | Args | Effect |
-|---|---|---|
+| Method              | Args           | Effect                                           |
+| ------------------- | -------------- | ------------------------------------------------ |
 | `.trim(recursive?)` | default `true` | recursively trim string values across the object |
 
 For per-field mutators, attach on the field validator instead.
@@ -130,7 +136,7 @@ The cross-field methods (`.sameAs`, `.requiredIf`, `.requiredWith`, etc.) are **
 v.object({
   password: v.string(),
   passwordConfirm: v.string().sameAs("password"),
-})
+});
 ```
 
 If you call cross-field rules outside a `v.object`, sibling resolution silently passes — there's nobody to compare against.
@@ -138,7 +144,7 @@ If you call cross-field rules outside a `v.object`, sibling resolution silently
 ## `Infer<>` semantics
 
 ```ts
-Infer<typeof userSchema>
+Infer<typeof userSchema>;
 // { reqField: T; optField?: T }
 ```
 
@@ -171,10 +177,12 @@ const timestamps = v.object({
 const userWithAudit = baseUser.extend(timestamps);
 
 // Permissive container that forwards extras
-const eventEnvelope = v.object({
-  type: v.literal("user.created", "user.updated"),
-  payload: v.object({}).allowUnknown(),
-}).allowUnknown();
+const eventEnvelope = v
+  .object({
+    type: v.literal("user.created", "user.updated"),
+    payload: v.object({}).allowUnknown(),
+  })
+  .allowUnknown();
 
 // Confirmation pattern with omit
 const signupSchema = v.object({

package/skills/extend-seal-with-plugins/SKILL.md

@@ -21,7 +21,7 @@ Seal exposes a plugin system so you can add validator methods without forking th
 import type { SealPlugin } from "@warlock.js/seal";
 
 type SealPlugin = {
-  name: string;          // unique identifier — duplicates warn and skip install
+  name: string; // unique identifier — duplicates warn and skip install
   version?: string;
   description?: string;
   install: (context: { name: string; version?: string }) => void | Promise<void>;
@@ -59,8 +59,8 @@ import { registerPlugin, unregisterPlugin, hasPlugin, getInstalledPlugins } from
 await registerPlugin(slugPlugin);
 // console.warn if "slug" is already installed; otherwise install() runs and the plugin is tracked.
 
-hasPlugin("slug");           // → true
-getInstalledPlugins();       // → [slugPlugin]
+hasPlugin("slug"); // → true
+getInstalledPlugins(); // → [slugPlugin]
 
 await unregisterPlugin("slug");
 // runs slugPlugin.uninstall?.(); removes from registry.
@@ -163,8 +163,8 @@ For a method that creates a **new validator** (not chained from an existing one)
 ## Introspection — checking what's loaded
 
 ```ts
-hasPlugin("slug");                 // boolean
-getInstalledPlugins();             // SealPlugin[]
+hasPlugin("slug"); // boolean
+getInstalledPlugins(); // SealPlugin[]
 ```
 
 Use these in startup diagnostics or in tests that need to assert a plugin is registered before exercising a method that depends on it.
@@ -176,3 +176,37 @@ Use these in startup diagnostics or in tests that need to assert a plugin is reg
 - Don't make the plugin's `install` function depend on shared state mutable from elsewhere. Plugins should be idempotent — installing twice (or registering across hot-reloads) should not break anything.
 - Don't ship a plugin that overrides a built-in method without a clear reason. If you must, `uninstall` should restore the original — but the better path is a different method name.
 - Don't author one plugin per method. Group related methods (e.g. "country-specific validators") into one plugin so the install/uninstall lifecycle is coherent.
+
+## Returning validated rule output
+
+A custom rule's success result can contain `data` to replace the current value:
+`{ isValid: true, data: replacement }`. Later rules, transformers and refinements
+receive that replacement. Omitting `data` preserves the current value; a present
+`data: undefined` explicitly clears it. This is also how a union preserves the
+selected branch's validated defaults, catches and child transformations.
+
+## Reporting several errors from one rule
+
+A failed rule result can carry `errors: [{ error, path }, ...]` to report more than
+one error, each at its own path; every entry gets the rule's `name` as its `type`.
+`v.union` uses this to relay the closest branch's errors. Return as many as fit the
+caller's `context.configurations?.firstErrorOnly` (default `true`: one).
+
+```ts
+import { invalidRule, type SchemaRule } from "@warlock.js/seal";
+
+const bothDates: SchemaRule = {
+  name: "bothDates",
+  async validate(value: { from?: unknown; to?: unknown }, context) {
+    const missing = (["from", "to"] as const).filter((key) => !value?.[key]);
+    if (missing.length === 0) return { isValid: true };
+
+    const failed = invalidRule(this, context);
+    const errors = missing.map((key) => ({
+      error: `The ${key} date is required`,
+      path: context.path ? `${context.path}.${key}` : key,
+    }));
+    return { ...failed, errors };
+  },
+};
+```

package/skills/generate-json-schema/SKILL.md

@@ -29,19 +29,19 @@ userSchema.toJsonSchema("draft-2020-12");
 
 ```ts
 type JsonSchemaTarget =
-  | "draft-2020-12"  // default — modern JSON Schema
-  | "draft-07"       // older tooling, Swagger 2.0
-  | "openapi-3.0"    // uses { nullable: true } instead of type unions
-  | "openai-strict"  // OpenAI Structured Outputs strict mode
+  | "draft-2020-12" // default — modern JSON Schema
+  | "draft-07" // older tooling, Swagger 2.0
+  | "openapi-3.0" // uses { nullable: true } instead of type unions
+  | "openai-strict"; // OpenAI Structured Outputs strict mode
 ```
 
 Pick by consumer:
 
-| Consumer | Target |
-| --- | --- |
-| Modern tooling, no specific reason otherwise | `"draft-2020-12"` |
-| Swagger 2.0 / older OpenAPI / older form builders | `"draft-07"` |
-| OpenAPI 3.0 spec (uses `nullable: true`) | `"openapi-3.0"` |
+| Consumer                                                        | Target            |
+| --------------------------------------------------------------- | ----------------- |
+| Modern tooling, no specific reason otherwise                    | `"draft-2020-12"` |
+| Swagger 2.0 / older OpenAPI / older form builders               | `"draft-07"`      |
+| OpenAPI 3.0 spec (uses `nullable: true`)                        | `"openapi-3.0"`   |
 | OpenAI `response_format: { type: "json_schema", strict: true }` | `"openai-strict"` |
 
 ## OpenAI structured outputs (`openai-strict`)
@@ -122,8 +122,8 @@ Cleanly mapped:
 
 Some seal constructs have no JSON Schema representation:
 
-- **Cross-field rules** (`sameAs`, `requiredIf`, `requiredWith`, etc.) — runtime-only. The generated schema describes the *shape*, not the inter-field invariants.
-- **Transformers and mutators** — output reshaping doesn't appear in the schema; the schema reflects *post-mutator, pre-transformer* shape (since that's what rules see and what the LLM is asked to produce for `openai-strict`).
+- **Cross-field rules** (`sameAs`, `requiredIf`, `requiredWith`, etc.) — runtime-only. The generated schema describes the _shape_, not the inter-field invariants.
+- **Transformers and mutators** — output reshaping doesn't appear in the schema; the schema reflects _post-mutator, pre-transformer_ shape (since that's what rules see and what the LLM is asked to produce for `openai-strict`).
 - **`v.computed` / `v.managed`** — **skipped** entirely by the parent `v.object`; they never appear in `properties`. They aren't part of the data contract. (Calling `.toJsonSchema()` directly on one throws — the parent object is responsible for skipping them.)
 - **`v.instanceof(Ctor)`** — produces `{}`. Class identity isn't expressible. For `File`, attach `{ type: "string", format: "binary" }` manually after generation if needed for OpenAPI.
 - **`v.any()`** — produces `{}` deliberately (any value is valid).
@@ -132,10 +132,10 @@ Boolean rules `accepted` / `declined` and similar coercion-style rules are also
 
 ## When the generated schema rejects valid data
 
-If the schema validator itself accepts data but the *generated* JSON Schema rejects the same data downstream, the cause is usually one of:
+If the schema validator itself accepts data but the _generated_ JSON Schema rejects the same data downstream, the cause is usually one of:
 
 - **Cross-field rule.** The generated schema doesn't enforce it, but a separate consumer might. (Or the runtime check fired at a different stage.)
-- **Transformer running on the wrong side.** The schema describes the input shape (or strict-mode normalized form). If your transformer reshapes `Date` to ISO string for `data`, the *input* still needs to be a Date-parseable thing.
+- **Transformer running on the wrong side.** The schema describes the input shape (or strict-mode normalized form). If your transformer reshapes `Date` to ISO string for `data`, the _input_ still needs to be a Date-parseable thing.
 - **`openai-strict` quirk.** Optional fields show as `["T", "null"]` rather than omitted — if the model omits them entirely (without sending `null`), strict mode fails. The fix is on the prompt side: tell the model to send `null` for unused fields.
 
 ## Cost note

package/skills/handle-seal-errors/SKILL.md

@@ -9,13 +9,13 @@ description: 'Read `ValidationResult` — `isValid`, `errors[]`, `data`. Branch
 
 ```ts
 type TypedValidationResult<TData> =
-  | { isValid: true; data: TData; errors: ValidationError[] }   // TData = Infer.Output<typeof schema>
+  | { isValid: true; data: TData; errors: ValidationError[] } // TData = Infer.Output<typeof schema>
   | { isValid: false; data: undefined; errors: ValidationError[] };
 
 type ValidationError = {
-  type: string;          // rule type that failed — "required", "email", "min", "string", ...
-  error: string;         // resolved message (translated, with attribute substitution)
-  input: string;         // input field name — "email" or "address.city"
+  type: string; // rule type that failed — "required", "email", "min", "string", ...
+  error: string; // resolved message (translated, with attribute substitution)
+  input: string; // input field name — "email" or "address.city"
 };
 ```
 
@@ -34,7 +34,7 @@ const schema = v.object({
 const result = await validate(schema, input);
 
 if (result.isValid) {
-  return result.data;  // typed as the inferred shape (post-transformer)
+  return result.data; // typed as the inferred shape (post-transformer)
 }
 
 return {
@@ -49,15 +49,13 @@ return {
 const result = await validate(schema, input);
 
 if (!result.isValid) {
-  const emailMissing = result.errors.find(
-    e => e.input === "email" && e.type === "required",
-  );
+  const emailMissing = result.errors.find((e) => e.input === "email" && e.type === "required");
   if (emailMissing) {
     return { redirect: "/signup", reason: "no email" };
   }
 
   const ageInvalid = result.errors.find(
-    e => e.input === "age" && (e.type === "int" || e.type === "min"),
+    (e) => e.input === "age" && (e.type === "int" || e.type === "min"),
   );
   if (ageInvalid) {
     return { error: "Age must be 13 or older" };
@@ -73,18 +71,20 @@ These are the strings you'll see in `error.type`:
 
 The `type` is the rule's own `name` field — not the method you called. Several methods map to one shared rule name (e.g. `.min()` / `.minLength()` on a string both surface as `minLength`; `.sameAs()` surfaces as `equalsField`). The table below lists the actual `type` strings:
 
-| Type | Produced by |
-| --- | --- |
-| `required`, `present` | `.required()`, `.present()` (note: `.optional()` has no error type — it clears the required rule) |
-| `requiredIf`, `requiredWith`, `requiredWithout`, `requiredUnless` | conditional required methods |
-| `string`, `number`, `int`, `float`, `boolean`, `scalar`, `object`, `array`, `date` | type guards from `matchesType` |
-| `minLength`, `maxLength`, `betweenLength`, `length` | string / array length rules (`.min`/`.max` on a string alias to `minLength`/`maxLength`) |
-| `min`, `max`, `betweenNumbers` | number range rules (`.min`/`.max`/`.between` on a number) |
-| `email`, `url`, `uuid`, `pattern`, `matches` | string format rules (`.pattern()` → `pattern`) |
-| `literal`, `enum`, `in`, `allowedValues`, `notAllowedValues` | value-membership rules (`.oneOf` aliases `in`; `.notIn`/`.forbids` → `notAllowedValues`; `.allowsOnly` → `allowedValues`) |
-| `instanceof` | `v.instanceof(Ctor)` |
-| `equalsField`, `notEqualsField` | cross-field equality (`.sameAs` → `equalsField`; `.differentFrom` → `notEqualsField`) |
-| `minDate`, `maxDate`, `beforeField`, `afterField`, `today`, `past`, `future`, `weekDay`, `weekend`, `businessDay`, `birthday` | date rules (`.min`/`.max` → `minDate`/`maxDate`; `.before`/`.after` → `beforeField`/`afterField`) |
+| Type                                                                                                                          | Produced by                                                                                                               |
+| ----------------------------------------------------------------------------------------------------------------------------- | ------------------------------------------------------------------------------------------------------------------------- |
+| `required`, `present`                                                                                                         | `.required()`, `.present()` (note: `.optional()` has no error type — it clears the required rule)                         |
+| `requiredIf`, `requiredWith`, `requiredWithout`, `requiredUnless`                                                             | conditional required methods                                                                                              |
+| `string`, `number`, `int`, `float`, `boolean`, `scalar`, `object`, `array`, `date`                                            | type guards from `matchesType`                                                                                            |
+| `minLength`, `maxLength`, `betweenLength`, `length`                                                                           | string / array length rules (`.min`/`.max` on a string alias to `minLength`/`maxLength`)                                  |
+| `min`, `max`, `betweenNumbers`                                                                                                | number range rules (`.min`/`.max`/`.between` on a number)                                                                 |
+| `email`, `url`, `uuid`, `pattern`, `matches`                                                                                  | string format rules (`.pattern()` → `pattern`)                                                                            |
+| `literal`, `enum`, `in`, `allowedValues`, `notAllowedValues`                                                                  | value-membership rules (`.oneOf` aliases `in`; `.notIn`/`.forbids` → `notAllowedValues`; `.allowsOnly` → `allowedValues`) |
+| `instanceof`                                                                                                                  | `v.instanceof(Ctor)`                                                                                                      |
+| `equalsField`, `notEqualsField`                                                                                               | cross-field equality (`.sameAs` → `equalsField`; `.differentFrom` → `notEqualsField`)                                     |
+| `minDate`, `maxDate`, `beforeField`, `afterField`, `today`, `past`, `future`, `weekDay`, `weekend`, `businessDay`, `birthday` | date rules (`.min`/`.max` → `minDate`/`maxDate`; `.before`/`.after` → `beforeField`/`afterField`)                         |
+
+`v.union(...)` reports `union`: when no branch passes, it relays the closest branch's errors (fewest mismatched literals, then fewest errors, then deepest path) at their own paths, all typed `union`. A custom rule can do the same by returning `errors: [{ error, path }, ...]` with its failed result.
 
 If you write custom rules, the `type` name you set on the rule object is what shows up here. Pick stable, kebab-or-camel-case names — they become a public API.
 
@@ -116,7 +116,7 @@ For attribute display names ("email" → "Email Address"), use `.attributes({ em
 
 ## When to throw
 
-Don't wrap `validate()` in try/catch for *validation* failures — those land in `result.errors`. The only thing that *throws* is a programming bug:
+Don't wrap `validate()` in try/catch for _validation_ failures — those land in `result.errors`. The only thing that _throws_ is a programming bug:
 
 - A rule's callback threw (e.g. you wrote `async validate() { throw new Error(...) }`).
 - A transformer threw on output.
@@ -132,7 +132,7 @@ If you're surfacing seal errors through HTTP / RPC, the typical shape is:
 if (!result.isValid) {
   return reply.code(422).send({
     error: "validation_failed",
-    fields: result.errors.map(e => ({
+    fields: result.errors.map((e) => ({
       field: e.input,
       type: e.type,
       message: e.error,

package/skills/index.md

@@ -1,11 +1,13 @@
 ---
-description: "Type-safe, framework-agnostic validation for Warlock.js: schemas, coercion, modifiers, JSON Schema, Standard Schema. Exports `v`, `validate`, `ObjectValidator`, `StringValidator`, `Infer`, reached as `v.object`, `v.string`, `v.array`, `v.enum`, `v.union`. Use for: \"validate this request body\", \"require an email and a min-length password\", \"infer the TypeScript type from a schema\", \"make a field optional or give it a default\", \"generate JSON Schema\", \"write a custom rule\". Not this package: database rules and file validators live in @warlock.js/core; model schemas and persistence are @warlock.js/cascade."
+description: 'Type-safe, framework-agnostic validation for Warlock.js: schemas, coercion, modifiers, JSON Schema, Standard Schema. Exports `v`, `validate`, `ObjectValidator`, `StringValidator`, `Infer`, reached as `v.object`, `v.string`, `v.array`, `v.enum`, `v.union`. Use for: "validate this request body", "require an email and a min-length password", "infer the TypeScript type from a schema", "make a field optional or give it a default", "generate JSON Schema", "write a custom rule". Not this package: database rules and file validators live in @warlock.js/core; model schemas and persistence are @warlock.js/cascade.'
 ---
+
 # @warlock.js/seal
 
 Compose validators from the `v` factory (`v.object({ email: v.string().email() })`), run them with `validate(schema, data)`, and infer static types with `Infer`. Validators chain rules, mutators (transforms) and modifiers; the same schema works as a Standard Schema.
 
 ## The 80% path
+
 1. Orient: `overview.md`, `seal-basics.md`.
 2. Choose the right primitive: `pick-seal-primitive.md`.
 3. Shape nested data: `define-structural-shape.md`.
@@ -14,6 +16,7 @@ Compose validators from the `v` factory (`v.object({ email: v.string().email() }
 6. Interop: `bridge-standard-schema.md`, `generate-json-schema.md`; extend via `extend-seal-with-plugins.md`.
 
 ## Conventions and pitfalls
+
 - Validation is async; always `await validate(...)`.
 - The package root is framework-agnostic; database-backed rules (unique, exists) and `FileValidator` come from `@warlock.js/core`, not here.
 - Derive types with `Infer` instead of hand-writing parallel interfaces.

package/skills/overview/SKILL.md

@@ -5,7 +5,7 @@ description: "@warlock.js/seal overview for orientation and choosing the focused
 
 # `@warlock.js/seal` — overview
 
-A type-safe, framework-agnostic validation library. You build a schema with the `v` factory, run it with `validate(schema, data)`, and pull the static type out with `Infer<typeof schema>`. One schema is the runtime check *and* the TypeScript type *and* (optionally) a JSON Schema.
+A type-safe, framework-agnostic validation library. You build a schema with the `v` factory, run it with `validate(schema, data)`, and pull the static type out with `Infer<typeof schema>`. One schema is the runtime check _and_ the TypeScript type _and_ (optionally) a JSON Schema.
 
 Standalone — no framework required. Ships built-in with `@warlock.js/core`, which adds framework-specific validators (file uploads, database existence/uniqueness rules) on top.
 
@@ -28,31 +28,39 @@ Eight task skills. Most schemas only need `seal-basics` + `pick-seal-primitive`
 ### Foundations
 
 #### `seal-basics`
+
 Start here. The `v` factory, `validate(schema, data)`, and `Infer<typeof schema>`.
 
 ### Building schemas
 
 #### `pick-seal-primitive`
+
 Choose the right primitive — `string` / `int` / `literal` / `date` / `enum` / `computed` / `managed` / `instanceof` / `any`. Covers the close calls (`string` vs `scalar`, `int` vs `number`, `literal` vs `enum`).
 
 #### `define-structural-shape`
+
 Compose `v.object` / `v.array` / `v.record` / `v.tuple` / `v.union` / `v.discriminatedUnion` / `v.lazy` — object schemas, dynamic-keyed records, tagged unions, recursive shapes.
 
 #### `compose-seal-modifiers`
+
 Cross-cutting modifiers — `.optional` / `.nullable` / `.default` / `.catch` / `.omit` / membership rules — plus the mutator-vs-transformer pipeline and `Infer.Input` vs `Infer.Output`.
 
 ### Output + interop
 
 #### `handle-seal-errors`
+
 Read a `ValidationResult` — `isValid`, `errors[]`, `data`. Branch on `error.type`, customize messages, hook translation.
 
 #### `generate-json-schema`
+
 `schema.toJsonSchema(target)` — draft-2020-12 / draft-07 / openapi-3.0 / openai-strict. For OpenAI structured outputs, OpenAPI specs, any JSON-Schema consumer.
 
 #### `bridge-standard-schema`
-Standard Schema interop — why a `StandardSchemaV1<T>` slot might reject a schema, the phantom-intersection at the `v` factory return, Cascade `Model<TSchema>` variance. For migrating off `as unknown as` casts.
+
+Standard Schema interop — why a `StandardSchemaV1<T>` slot might reject a schema, object input/output class parameters and primitive factory intersections, Cascade `Model<TSchema>` variance. For migrating off `as unknown as` casts.
 
 #### `extend-seal-with-plugins`
+
 Author a plugin to add validator methods (`.slug`, `.postalCode`, …) — the `SealPlugin` shape, `registerPlugin` lifecycle, TS prototype augmentation.
 
 ## Configuration