@warlock.js/seal 5.30.0 → 5.31.0

package/skills/pick-seal-primitive/SKILL.md

@@ -5,25 +5,25 @@ description: 'Pick the right `v` factory primitive — string / int / literal /
 
 # Picking the right primitive
 
-This is the orientation skill — *which* primitive for *which* job. For the chainable methods on each (`.email()`, `.min()`, `.between()`, etc.), load the matching `*-methods.md` reference file in this skill folder.
+This is the orientation skill — _which_ primitive for _which_ job. For the chainable methods on each (`.email()`, `.min()`, `.between()`, etc.), load the matching `*-methods.md` reference file in this skill folder.
 
 ## Strings
 
 ```ts
-v.string()              // type: string — full surface in string-methods.md
-v.email()               // shorthand for v.string().email()
-v.enum(["a", "b"])      // type: "a" | "b" — runs as v.string().oneOf, but the factory overload preserves the literal union
+v.string(); // type: string — full surface in string-methods.md
+v.email(); // shorthand for v.string().email()
+v.enum(["a", "b"]); // type: "a" | "b" — runs as v.string().oneOf, but the factory overload preserves the literal union
 ```
 
 Reach for `v.string()` for any text input. `v.email()` is just sugar — switch back to `v.string().email().min(...)` when you need extra rules.
 
 ## Numbers — pick by what you accept
 
-| Validator | Accepts | When |
-|---|---|---|
-| `v.number()` | any finite number | accepts both integers and floats |
-| `v.int()` | integers only | rejects `1.5` |
-| `v.float()` | finite, non-integer | rejects `1` |
+| Validator     | Accepts                   | When                                                        |
+| ------------- | ------------------------- | ----------------------------------------------------------- |
+| `v.number()`  | any finite number         | accepts both integers and floats                            |
+| `v.int()`     | integers only             | rejects `1.5`                                               |
+| `v.float()`   | finite, non-integer       | rejects `1`                                                 |
 | `v.numeric()` | numeric strings + numbers | form/query inputs that arrive as `"42"` — coerces to number |
 
 All four share the same chain surface (see [`number-methods.md`](./number-methods.md)). Picking is about input acceptance, not chain power.
@@ -31,8 +31,8 @@ All four share the same chain surface (see [`number-methods.md`](./number-method
 ## Booleans & scalars
 
 ```ts
-v.boolean()  // type: boolean — adds .accepted() / .declined() for form-style inputs
-v.scalar()   // type: string | number | boolean — usually a smell pointing at a missing discriminator
+v.boolean(); // type: boolean — adds .accepted() / .declined() for form-style inputs
+v.scalar(); // type: string | number | boolean — usually a smell pointing at a missing discriminator
 ```
 
 Use `v.scalar()` only when the field truly accepts any of the three primitives. If it's "one of N specific values across types", `v.literal(...)` is cleaner.
@@ -40,8 +40,8 @@ Use `v.scalar()` only when the field truly accepts any of the three primitives.
 ## Dates
 
 ```ts
-v.date()                  // type: Date — normalizes strings/timestamps to Date, rich rule surface
-v.instanceof(Date)        // type: Date — raw instanceof, no normalization, no rules
+v.date(); // type: Date — normalizes strings/timestamps to Date, rich rule surface
+v.instanceof(Date); // type: Date — raw instanceof, no normalization, no rules
 ```
 
 `v.date()` is the right tool 99% of the time — it ships `.min/.max/.before/.after/.weekDay/.minAge/...` and a built-in mutator that parses strings. `v.instanceof(Date)` is the escape hatch when you specifically need strict instance identity with zero coercion.
@@ -49,14 +49,14 @@ v.instanceof(Date)        // type: Date — raw instanceof, no normalization, no
 ## Literals & instances
 
 ```ts
-v.literal("items")                          // type: "items"
-v.literal("draft", "published", "archived") // type: "draft" | "published" | "archived"
-v.literal(1, 2, 3)                          // type: 1 | 2 | 3
-v.literal(true)                             // type: true
-
-v.instanceof(File)                          // type: File
-v.instanceof(Buffer)                        // type: Buffer
-v.instanceof(MyClass)                       // type: MyClass
+v.literal("items"); // type: "items"
+v.literal("draft", "published", "archived"); // type: "draft" | "published" | "archived"
+v.literal(1, 2, 3); // type: 1 | 2 | 3
+v.literal(true); // type: true
+
+v.instanceof(File); // type: File
+v.instanceof(Buffer); // type: Buffer
+v.instanceof(MyClass); // type: MyClass
 ```
 
 **`v.literal` vs `v.string().oneOf([...])` vs `v.enum([...])`:**
@@ -65,20 +65,20 @@ v.instanceof(MyClass)                       // type: MyClass
 - `v.string().oneOf(["a", "b"])` infers as `string` (loses literal types). Use when broad type is fine.
 - `v.enum(["a", "b"])` runs the same `oneOf` rule at runtime (it builds a `StringValidator().oneOf(...)`), but the `v.enum` factory overload **preserves the literal union** — it infers `"a" | "b"`, not `string`. Pass a TS enum object (`v.enum(Direction)`) and it uses `Object.values`, inferring `Direction[keyof Direction]`.
 
-`**`v.literal("")` — the empty string is a value, not an absence.** `""` is accepted when it is one of the configured literals, and the field is still required to be *present*:
+`**`v.literal("")`— the empty string is a value, not an absence.**`""` is accepted when it is one of the configured literals, and the field is still required to be _present_:
 
 ```ts
 const decorative = v.object({ decorative: v.literal(true), alt: v.literal("") });
 
-await v.validate(decorative, { decorative: true, alt: "" });      // valid
-await v.validate(decorative, { decorative: true, alt: "text" });  // invalid — not the literal
-await v.validate(decorative, { decorative: true });               // invalid — key missing
+await v.validate(decorative, { decorative: true, alt: "" }); // valid
+await v.validate(decorative, { decorative: true, alt: "text" }); // invalid — not the literal
+await v.validate(decorative, { decorative: true }); // invalid — key missing
 ```
 
 That distinction matters wherever "empty" and "absent" mean different things — `alt=""` marks an image as decorative to a screen reader, while a missing `alt` is an authoring mistake. Add `.optional()` only when a missing key really is acceptable; a present value must still match the literal.
 
 :::note[Fixed in 4.9.2]
-Before 4.9.2 `v.literal("")` always failed with *"is required"*, and `.optional()` looked like a workaround while actually disabling the literal check — accepting `""`, `null`, and a missing key alike. `v.literal(0)` and `v.literal(false)` were never affected.
+Before 4.9.2 `v.literal("")` always failed with _"is required"_, and `.optional()` looked like a workaround while actually disabling the literal check — accepting `""`, `null`, and a missing key alike. `v.literal(0)` and `v.literal(false)` were never affected.
 :::
 
 :::note[Fixed again in 5.30]
@@ -90,7 +90,7 @@ Before 4.9.2 `v.literal("")` always failed with *"is required"*, and `.optional(
 ## `v.any` — escape hatch
 
 ```ts
-v.any()  // type: any — skips validation entirely
+v.any(); // type: any — skips validation entirely
 ```
 
 Reach for it when you genuinely don't care about the shape. Usually a smell — search PRs for it and ask whether a real schema would catch a class of bugs.
@@ -112,26 +112,26 @@ v.object({
 - **`v.computed`** runs after sibling validation; callback signature is `(data, context)` — `data` is the validated sibling object. Use for derived values (full name, hash of fields, computed totals). An optional second arg validates the result: `v.computed<string>(cb, v.string().min(3))`.
 - **`v.managed`** runs from `SchemaContext` only — callback signature is `(context)`. Caller-supplied extras passed to `validate(schema, data, { context })` land on `context.context`. Use for framework-injected values — timestamps, current user, request id. The callback is optional (`v.managed()`) for values the framework injects without a generator.
 
-Both are **skipped** when their parent `v.object` generates JSON Schema — they never appear in `properties`, since they're runtime-only and not part of the JSON contract an LLM or external API consumer reads. Calling `.toJsonSchema()` *directly* on a `v.computed` / `v.managed` validator **throws** (it's a programming error — let the parent object skip them).
+Both are **skipped** when their parent `v.object` generates JSON Schema — they never appear in `properties`, since they're runtime-only and not part of the JSON contract an LLM or external API consumer reads. Calling `.toJsonSchema()` _directly_ on a `v.computed` / `v.managed` validator **throws** (it's a programming error — let the parent object skip them).
 
 ## Quick map — "I need to validate…"
 
-| Need | Reach for |
-|---|---|
-| Email | `v.string().email()` or `v.email()` |
-| URL | `v.string().url()` |
-| UUID | `v.string().uuid()` (see [`string-methods.md`](./string-methods.md)) |
-| Number 0–100 | `v.number().between(0, 100)` |
-| Positive integer | `v.int().positive()` |
-| One of N constants | `v.literal(...values)` |
-| One of TS enum values | `v.enum(MyEnum)` |
-| Date in the past | `v.date().past()` |
-| File upload | `v.instanceof(File)` |
-| Class instance (not Date) | `v.instanceof(Ctor)` |
-| Discriminated union | see the `define-structural-shape` topic |
-| Derived value (computed from siblings) | `v.computed<T>(callback)` |
-| Framework-injected value | `v.managed<T>(callback)` |
-| Free-form / pass-through | `v.any()` (only when you've thought about it) |
+| Need                                   | Reach for                                                            |
+| -------------------------------------- | -------------------------------------------------------------------- |
+| Email                                  | `v.string().email()` or `v.email()`                                  |
+| URL                                    | `v.string().url()`                                                   |
+| UUID                                   | `v.string().uuid()` (see [`string-methods.md`](./string-methods.md)) |
+| Number 0–100                           | `v.number().between(0, 100)`                                         |
+| Positive integer                       | `v.int().positive()`                                                 |
+| One of N constants                     | `v.literal(...values)`                                               |
+| One of TS enum values                  | `v.enum(MyEnum)`                                                     |
+| Date in the past                       | `v.date().past()`                                                    |
+| File upload                            | `v.instanceof(File)`                                                 |
+| Class instance (not Date)              | `v.instanceof(Ctor)`                                                 |
+| Discriminated union                    | see the `define-structural-shape` topic                              |
+| Derived value (computed from siblings) | `v.computed<T>(callback)`                                            |
+| Framework-injected value               | `v.managed<T>(callback)`                                             |
+| Free-form / pass-through               | `v.any()` (only when you've thought about it)                        |
 
 ## Method-surface reference
 
@@ -150,4 +150,4 @@ For cross-cutting modifiers (`.optional`/`.nullable`/`.default`/`.catch`/`.in`/`
 - Don't pick `v.scalar` because "it's flexible". Flexibility at this layer usually means a missing discriminator — try `v.literal` or `v.union` first.
 - Don't reach for `v.instanceof(Date)` when `v.date()` works. The latter is purpose-built.
 - Don't use `v.string().oneOf(["a", "b"])` for discriminator fields where you need the literal type — use `v.literal("a", "b")`.
-- Don't expect `v.computed` / `v.managed` to validate input — they ignore input shape entirely. Reach for them only when *producing* a value.
+- Don't expect `v.computed` / `v.managed` to validate input — they ignore input shape entirely. Reach for them only when _producing_ a value.

package/skills/pick-seal-primitive/date-methods.md

@@ -4,139 +4,139 @@
 
 ## Range — global value comparison
 
-| Method | Args | Example |
-|---|---|---|
-| `.min(dateOrField, msg?)` | inclusive `>=` | `v.date().min("2024-01-01")` or `v.date().min(new Date())` |
-| `.max(dateOrField, msg?)` | inclusive `<=` | `v.date().max(new Date())` |
-| `.before(dateOrField, msg?)` | strict `<` | `v.date().before(new Date())` |
-| `.after(dateOrField, msg?)` | strict `>` | `v.date().after(new Date())` |
-| `.between(start, end, msg?)` | inclusive range | `v.date().between(start, end)` |
+| Method                       | Args            | Example                                                    |
+| ---------------------------- | --------------- | ---------------------------------------------------------- |
+| `.min(dateOrField, msg?)`    | inclusive `>=`  | `v.date().min("2024-01-01")` or `v.date().min(new Date())` |
+| `.max(dateOrField, msg?)`    | inclusive `<=`  | `v.date().max(new Date())`                                 |
+| `.before(dateOrField, msg?)` | strict `<`      | `v.date().before(new Date())`                              |
+| `.after(dateOrField, msg?)`  | strict `>`      | `v.date().after(new Date())`                               |
+| `.between(start, end, msg?)` | inclusive range | `v.date().between(start, end)`                             |
 
 Smart detection: a string with `-` or `/` is a date string; a plain string is a sibling field name.
 
 ## Range — explicit sibling scope
 
-| Method | Effect |
-|---|---|
-| `.minSibling(field, msg?)` | `>=` sibling field |
-| `.maxSibling(field, msg?)` | `<=` sibling field |
-| `.beforeSibling(field, msg?)` | `<` sibling field |
-| `.afterSibling(field, msg?)` | `>` sibling field |
-| `.sameAsField(field, msg?)` | `===` sibling field |
+| Method                             | Effect                               |
+| ---------------------------------- | ------------------------------------ |
+| `.minSibling(field, msg?)`         | `>=` sibling field                   |
+| `.maxSibling(field, msg?)`         | `<=` sibling field                   |
+| `.beforeSibling(field, msg?)`      | `<` sibling field                    |
+| `.afterSibling(field, msg?)`       | `>` sibling field                    |
+| `.sameAsField(field, msg?)`        | `===` sibling field                  |
 | `.sameAsFieldSibling(field, msg?)` | `===` sibling field (explicit scope) |
 
 Only run inside `v.object`. Not representable in JSON Schema.
 
 ## Today / past / future
 
-| Method | Effect |
-|---|---|
-| `.today(msg?)` | exactly today |
-| `.fromToday(msg?)` | today or future |
+| Method               | Effect                |
+| -------------------- | --------------------- |
+| `.today(msg?)`       | exactly today         |
+| `.fromToday(msg?)`   | today or future       |
 | `.beforeToday(msg?)` | strictly before today |
-| `.afterToday(msg?)` | strictly after today |
-| `.past(msg?)` | any past date |
-| `.future(msg?)` | any future date |
+| `.afterToday(msg?)`  | strictly after today  |
+| `.past(msg?)`        | any past date         |
+| `.future(msg?)`      | any future date       |
 
 ## Relative window
 
-| Method | Args | Effect |
-|---|---|---|
-| `.withinDays(n, msg?)` | within N days past or future | — |
-| `.withinPastDays(n, msg?)` | within N days in the past | — |
-| `.withinFutureDays(n, msg?)` | within N days in the future | — |
+| Method                       | Args                         | Effect |
+| ---------------------------- | ---------------------------- | ------ |
+| `.withinDays(n, msg?)`       | within N days past or future | —      |
+| `.withinPastDays(n, msg?)`   | within N days in the past    | —      |
+| `.withinFutureDays(n, msg?)` | within N days in the future  | —      |
 
 ## Age
 
-| Method | Args | Effect |
-|---|---|---|
-| `.age(years, msg?)` | exactly N years old |
-| `.minAge(years, msg?)` | at least N years old |
-| `.maxAge(years, msg?)` | at most N years old |
-| `.betweenAge(min, max, msg?)` | between min/max years |
+| Method                              | Args                              | Effect |
+| ----------------------------------- | --------------------------------- | ------ |
+| `.age(years, msg?)`                 | exactly N years old               |
+| `.minAge(years, msg?)`              | at least N years old              |
+| `.maxAge(years, msg?)`              | at most N years old               |
+| `.betweenAge(min, max, msg?)`       | between min/max years             |
 | `.birthday(minAge?, maxAge?, msg?)` | not in future, optional age range |
 
 ## Weekday / weekend / business day
 
-| Method | Args | Effect |
-|---|---|---|
-| `.weekDay(day, msg?)` | day = `"monday"` … `"sunday"` |
-| `.weekdays(days, msg?)` | array of weekdays |
-| `.weekend(msg?)` | Saturday or Sunday |
-| `.businessDay(msg?)` | Monday – Friday |
+| Method                  | Args                          | Effect |
+| ----------------------- | ----------------------------- | ------ |
+| `.weekDay(day, msg?)`   | day = `"monday"` … `"sunday"` |
+| `.weekdays(days, msg?)` | array of weekdays             |
+| `.weekend(msg?)`        | Saturday or Sunday            |
+| `.businessDay(msg?)`    | Monday – Friday               |
 
 ## Period — month / year / quarter
 
-| Method | Args | Effect |
-|---|---|---|
-| `.month(m, msg?)` | `m` = 1–12 (or `Month` enum) |
-| `.year(y, msg?)` | exact year |
-| `.quarter(q, msg?)` | `q` = 1–4 |
-| `.leapYear(msg?)` | year is a leap year |
-| `.minYear(yearOrField, msg?)` | year `>=` |
-| `.maxYear(yearOrField, msg?)` | year `<=` |
-| `.minMonth(mOrField, msg?)` | month `>=` |
-| `.maxMonth(mOrField, msg?)` | month `<=` |
-| `.minDay(dOrField, msg?)` | day-of-month `>=` |
-| `.maxDay(dOrField, msg?)` | day-of-month `<=` |
-| `.betweenYears(start, end, msg?)` | inclusive year range |
-| `.betweenMonths(start, end, msg?)` | inclusive month range |
-| `.betweenDays(start, end, msg?)` | inclusive day-of-month range |
+| Method                             | Args                         | Effect |
+| ---------------------------------- | ---------------------------- | ------ |
+| `.month(m, msg?)`                  | `m` = 1–12 (or `Month` enum) |
+| `.year(y, msg?)`                   | exact year                   |
+| `.quarter(q, msg?)`                | `q` = 1–4                    |
+| `.leapYear(msg?)`                  | year is a leap year          |
+| `.minYear(yearOrField, msg?)`      | year `>=`                    |
+| `.maxYear(yearOrField, msg?)`      | year `<=`                    |
+| `.minMonth(mOrField, msg?)`        | month `>=`                   |
+| `.maxMonth(mOrField, msg?)`        | month `<=`                   |
+| `.minDay(dOrField, msg?)`          | day-of-month `>=`            |
+| `.maxDay(dOrField, msg?)`          | day-of-month `<=`            |
+| `.betweenYears(start, end, msg?)`  | inclusive year range         |
+| `.betweenMonths(start, end, msg?)` | inclusive month range        |
+| `.betweenDays(start, end, msg?)`   | inclusive day-of-month range |
 
 Each `min*` / `max*` / `between*` accepts a sibling field name. Sibling-explicit variants exist: `.minYearSibling`, `.maxYearSibling`, `.minMonthSibling`, `.maxMonthSibling`, `.minDaySibling`, `.maxDaySibling`, `.betweenYearsSibling`, `.betweenMonthsSibling`, `.betweenDaysSibling`.
 
 ## Time — hour / minute
 
-| Method | Args | Effect |
-|---|---|---|
-| `.fromHour(h, msg?)` | h = 0–23, time `>= h:00` |
-| `.beforeHour(h, msg?)` | time `< h:00` |
-| `.betweenHours(start, end, msg?)` | inclusive hour range |
-| `.fromMinute(m, msg?)` | m = 0–59 |
-| `.beforeMinute(m, msg?)` | — |
-| `.betweenMinutes(start, end, msg?)` | inclusive minute range |
-| `.betweenTimes(start, end, msg?)` | "HH:MM" strings |
+| Method                              | Args                     | Effect |
+| ----------------------------------- | ------------------------ | ------ |
+| `.fromHour(h, msg?)`                | h = 0–23, time `>= h:00` |
+| `.beforeHour(h, msg?)`              | time `< h:00`            |
+| `.betweenHours(start, end, msg?)`   | inclusive hour range     |
+| `.fromMinute(m, msg?)`              | m = 0–59                 |
+| `.beforeMinute(m, msg?)`            | —                        |
+| `.betweenMinutes(start, end, msg?)` | inclusive minute range   |
+| `.betweenTimes(start, end, msg?)`   | "HH:MM" strings          |
 
 ## Format
 
-| Method | Args | Effect |
-|---|---|---|
+| Method               | Args                | Effect                      |
+| -------------------- | ------------------- | --------------------------- |
 | `.format(fmt, msg?)` | dayjs format string | input must match the format |
 
 ## Mutators (pre-validation reshape)
 
-| Method | Effect |
-|---|---|
-| `.toStartOfDay()` | 00:00:00.000 |
-| `.toEndOfDay()` | 23:59:59.999 |
-| `.toStartOfMonth()` | first day of month |
-| `.toEndOfMonth()` | last day of month |
-| `.toStartOfYear()` | January 1st |
-| `.toEndOfYear()` | December 31st |
-| `.addDays(n)` | shift by N days (negative = back) |
-| `.addMonths(n)` | shift by N months |
-| `.addYears(n)` | shift by N years |
-| `.addHours(n)` | shift by N hours |
-| `.toUTC()` | normalize to UTC |
-
-Mutators run *before* rules. `v.date().addDays(7).future()` checks whether the shifted date is in the future.
+| Method              | Effect                            |
+| ------------------- | --------------------------------- |
+| `.toStartOfDay()`   | 00:00:00.000                      |
+| `.toEndOfDay()`     | 23:59:59.999                      |
+| `.toStartOfMonth()` | first day of month                |
+| `.toEndOfMonth()`   | last day of month                 |
+| `.toStartOfYear()`  | January 1st                       |
+| `.toEndOfYear()`    | December 31st                     |
+| `.addDays(n)`       | shift by N days (negative = back) |
+| `.addMonths(n)`     | shift by N months                 |
+| `.addYears(n)`      | shift by N years                  |
+| `.addHours(n)`      | shift by N hours                  |
+| `.toUTC()`          | normalize to UTC                  |
+
+Mutators run _before_ rules. `v.date().addDays(7).future()` checks whether the shifted date is in the future.
 
 ## Transformers (post-validation, reshape `data`)
 
-| Method | Args | Effect |
-|---|---|---|
-| `.toISOString()` | — | `Date` → `"2026-01-15T00:00:00.000Z"` |
-| `.toTimestamp()` | — | `Date` → number (ms since epoch) |
-| `.toFormat(fmt)` | dayjs format string | `Date` → formatted string |
-| `.toDateOnly()` | — | `"YYYY-MM-DD"` |
-| `.toTimeOnly()` | — | `"HH:mm:ss"` |
+| Method           | Args                | Effect                                |
+| ---------------- | ------------------- | ------------------------------------- |
+| `.toISOString()` | —                   | `Date` → `"2026-01-15T00:00:00.000Z"` |
+| `.toTimestamp()` | —                   | `Date` → number (ms since epoch)      |
+| `.toFormat(fmt)` | dayjs format string | `Date` → formatted string             |
+| `.toDateOnly()`  | —                   | `"YYYY-MM-DD"`                        |
+| `.toTimeOnly()`  | —                   | `"HH:mm:ss"`                          |
 
-Transformers shape the *output*. `Infer<>` still resolves to `Date` even if a transformer changes the runtime shape — `Infer` reads the validator type, not the transformer pipeline.
+Transformers shape the _output_. `Infer<>` still resolves to `Date` even if a transformer changes the runtime shape — `Infer` reads the validator type, not the transformer pipeline.
 
 ## Defaults
 
-| Method | Effect |
-|---|---|
+| Method          | Effect                                     |
+| --------------- | ------------------------------------------ |
 | `.defaultNow()` | shorthand for `.default(() => new Date())` |
 
 ## JSON Schema mapping
@@ -150,26 +150,26 @@ Transformers shape the *output*. `Infer<>` still resolves to `Date` even if a tr
 
 ```ts
 // Birthday — must be 13+ and in the past
-v.date().past().minAge(13)
+v.date().past().minAge(13);
 
 // Reservation — future, business day, between hours
-v.date().future().businessDay().betweenHours(9, 17)
+v.date().future().businessDay().betweenHours(9, 17);
 
 // Effective date range (cross-field)
 v.object({
   startsAt: v.date(),
   endsAt: v.date().afterSibling("startsAt"),
-})
+});
 
 // API response — emit ISO string
-v.date().toISOString()
+v.date().toISOString();
 
 // Event window — within 30 future days, normalized to UTC
-v.date().toUTC().withinFutureDays(30)
+v.date().toUTC().withinFutureDays(30);
 
 // Quarterly report
-v.date().quarter(1).year(2026)
+v.date().quarter(1).year(2026);
 
 // Date-only, end-of-day for inclusive comparisons
-v.date().toEndOfDay().toDateOnly()
+v.date().toEndOfDay().toDateOnly();
 ```

package/skills/pick-seal-primitive/number-methods.md

@@ -4,23 +4,23 @@ All four share this surface. The picking guide (which factory to call) is in the
 
 ## Range — global value comparison
 
-| Method | Args | JSON Schema | Example |
-|---|---|---|---|
-| `.min(n, msg?)` | inclusive lower bound | `minimum: n` | `v.int().min(0)` |
-| `.max(n, msg?)` | inclusive upper bound | `maximum: n` | `v.int().max(100)` |
-| `.between(a, b, msg?)` | inclusive range | `minimum: a, maximum: b` | `v.number().between(0, 1)` |
-| `.greaterThan(n, msg?)` | strict `>` | `exclusiveMinimum: n` | `v.int().greaterThan(0)` |
-| `.gt(n, msg?)` | alias for `.greaterThan` | `exclusiveMinimum: n` | — |
-| `.lessThan(n, msg?)` | strict `<` | `exclusiveMaximum: n` | `v.int().lessThan(100)` |
-| `.lt(n, msg?)` | alias for `.lessThan` | `exclusiveMaximum: n` | — |
+| Method                  | Args                     | JSON Schema              | Example                    |
+| ----------------------- | ------------------------ | ------------------------ | -------------------------- |
+| `.min(n, msg?)`         | inclusive lower bound    | `minimum: n`             | `v.int().min(0)`           |
+| `.max(n, msg?)`         | inclusive upper bound    | `maximum: n`             | `v.int().max(100)`         |
+| `.between(a, b, msg?)`  | inclusive range          | `minimum: a, maximum: b` | `v.number().between(0, 1)` |
+| `.greaterThan(n, msg?)` | strict `>`               | `exclusiveMinimum: n`    | `v.int().greaterThan(0)`   |
+| `.gt(n, msg?)`          | alias for `.greaterThan` | `exclusiveMinimum: n`    | —                          |
+| `.lessThan(n, msg?)`    | strict `<`               | `exclusiveMaximum: n`    | `v.int().lessThan(100)`    |
+| `.lt(n, msg?)`          | alias for `.lessThan`    | `exclusiveMaximum: n`    | —                          |
 
 `.min` / `.max` / `.between` / `.greaterThan` / `.lessThan` accept a **string** as the value — interpreted as a sibling field name (smart detection):
 
 ```ts
 v.object({
   minPrice: v.int(),
-  maxPrice: v.int().min("minPrice"),  // maxPrice >= minPrice
-})
+  maxPrice: v.int().min("minPrice"), // maxPrice >= minPrice
+});
 ```
 
 Sibling references are **not representable in JSON Schema** — silently omitted from generated output.
@@ -29,68 +29,68 @@ Sibling references are **not representable in JSON Schema** — silently omitted
 
 For when smart detection is ambiguous (e.g. a numeric string that happens to match a field name):
 
-| Method | Effect |
-|---|---|
-| `.minSibling(field, msg?)` | value `>=` sibling field |
-| `.maxSibling(field, msg?)` | value `<=` sibling field |
-| `.greaterThanSibling(field, msg?)` | value `>` sibling field |
-| `.gtSibling(field, msg?)` | alias |
-| `.lessThanSibling(field, msg?)` | value `<` sibling field |
-| `.ltSibling(field, msg?)` | alias |
+| Method                                      | Effect                     |
+| ------------------------------------------- | -------------------------- |
+| `.minSibling(field, msg?)`                  | value `>=` sibling field   |
+| `.maxSibling(field, msg?)`                  | value `<=` sibling field   |
+| `.greaterThanSibling(field, msg?)`          | value `>` sibling field    |
+| `.gtSibling(field, msg?)`                   | alias                      |
+| `.lessThanSibling(field, msg?)`             | value `<` sibling field    |
+| `.ltSibling(field, msg?)`                   | alias                      |
 | `.betweenSibling(minField, maxField, msg?)` | between two sibling fields |
 
 These **only run inside `v.object`** — sibling resolution silently passes otherwise.
 
 ## Sign & parity
 
-| Method | Effect | Example |
-|---|---|---|
-| `.positive(msg?)` | value `> 0` | `v.int().positive()` |
-| `.negative(msg?)` | value `< 0` | `v.int().negative()` |
-| `.odd(msg?)` | value is odd | `v.int().odd()` |
-| `.even(msg?)` | value is even | `v.int().even()` |
+| Method            | Effect        | Example              |
+| ----------------- | ------------- | -------------------- |
+| `.positive(msg?)` | value `> 0`   | `v.int().positive()` |
+| `.negative(msg?)` | value `< 0`   | `v.int().negative()` |
+| `.odd(msg?)`      | value is odd  | `v.int().odd()`      |
+| `.even(msg?)`     | value is even | `v.int().even()`     |
 
 ## Divisibility / modulo
 
-| Method | Effect | JSON Schema |
-|---|---|---|
-| `.modulo(n, msg?)` | value `% n === 0` | `multipleOf: n` |
-| `.divisibleBy(n, msg?)` | alias | `multipleOf: n` |
-| `.multipleOf(n, msg?)` | alias | `multipleOf: n` |
-| `.modulusOf(n, msg?)` | alias | `multipleOf: n` |
+| Method                  | Effect            | JSON Schema     |
+| ----------------------- | ----------------- | --------------- |
+| `.modulo(n, msg?)`      | value `% n === 0` | `multipleOf: n` |
+| `.divisibleBy(n, msg?)` | alias             | `multipleOf: n` |
+| `.multipleOf(n, msg?)`  | alias             | `multipleOf: n` |
+| `.modulusOf(n, msg?)`   | alias             | `multipleOf: n` |
 
 ## String-form length (rare)
 
 When the numeric value is a fixed-format code (PINs, IDs):
 
-| Method | Effect |
-|---|---|
-| `.length(n, msg?)` | string-rep length must be exactly `n` |
-| `.minLength(n, msg?)` | string-rep length `>= n` |
-| `.maxLength(n, msg?)` | string-rep length `<= n` |
+| Method                | Effect                                |
+| --------------------- | ------------------------------------- |
+| `.length(n, msg?)`    | string-rep length must be exactly `n` |
+| `.minLength(n, msg?)` | string-rep length `>= n`              |
+| `.maxLength(n, msg?)` | string-rep length `<= n`              |
 
 For most numeric-shaped IDs you'd use `v.string().length(n).numeric()` instead — let the value be a string.
 
 ## Mutators (pre-validation reshape)
 
-| Method | Args | Effect |
-|---|---|---|
-| `.abs()` | — | `Math.abs(value)` |
-| `.ceil()` | — | round up to integer |
-| `.floor()` | — | round down to integer |
-| `.round(decimals?)` | default 0 | round to N decimals |
-| `.toFixed(decimals?)` | default 2 | round to N decimals — returns a **number** |
-| `.coerce()` | — | a **numeric-shaped string** → `Number`; any other value passes through unchanged |
+| Method                | Args      | Effect                                                                           |
+| --------------------- | --------- | -------------------------------------------------------------------------------- |
+| `.abs()`              | —         | `Math.abs(value)`                                                                |
+| `.ceil()`             | —         | round up to integer                                                              |
+| `.floor()`            | —         | round down to integer                                                            |
+| `.round(decimals?)`   | default 0 | round to N decimals                                                              |
+| `.toFixed(decimals?)` | default 2 | round to N decimals — returns a **number**                                       |
+| `.coerce()`           | —         | a **numeric-shaped string** → `Number`; any other value passes through unchanged |
 
-These run *before* validation rules. If you mutate `1.6` with `.ceil()`, `v.int()` sees `2` and passes. Use mutators when the input arrives in a slightly wrong form and you want to coerce, not reject.
+These run _before_ validation rules. If you mutate `1.6` with `.ceil()`, `v.int()` sees `2` and passes. Use mutators when the input arrives in a slightly wrong form and you want to coerce, not reject.
 
 `.coerce()` (5.9+) is the opt-in for the most common case: **query-string params arrive as strings.** `v.int()` is strict by default — `?limit=2` is the string `"2"` and is rejected — so add `.coerce()` when a schema validates `request.query`:
 
 ```ts
-v.object({ limit: v.int().coerce().min(1).max(100) })   // "2" → 2, passes
+v.object({ limit: v.int().coerce().min(1).max(100) }); // "2" → 2, passes
 ```
 
-It only fixes the string *representation* — the type rule still runs, so `v.int().coerce()` on `"5.5"` coerces to `5.5` and correctly **fails** (still not an integer), and `"abc"` passes through and fails. Strictness is unchanged unless you chain `.coerce()`; the output type is unaffected (`v.int().coerce()` still infers `number`). Prefer this over hand-rolling `.addMutator(...)` in app schemas.
+It only fixes the string _representation_ — the type rule still runs, so `v.int().coerce()` on `"5.5"` coerces to `5.5` and correctly **fails** (still not an integer), and `"abc"` passes through and fails. Strictness is unchanged unless you chain `.coerce()`; the output type is unaffected (`v.int().coerce()` still infers `number`). Prefer this over hand-rolling `.addMutator(...)` in app schemas.
 
 That ordering is exactly why `.toFixed()` yields a number rather than a fixed-point string: the mutated value is what the validator's own type rule sees, and a `number` schema that emitted `"3.14"` would reject its own output. Format to a string at the presentation edge instead.
 
@@ -110,29 +110,29 @@ Before 4.9.2 `.toFixed()` returned a string, so `v.number().toFixed(2)` **always
 
 ```ts
 // Age
-v.int().min(0).max(150)
+v.int().min(0).max(150);
 
 // Price (cents)
-v.int().min(0)
+v.int().min(0);
 
 // Probability
-v.number().between(0, 1)
+v.number().between(0, 1);
 
 // Even page index
-v.int().min(0).even()
+v.int().min(0).even();
 
 // Quantity divisible by box size
-v.int().min(1).multipleOf(12)
+v.int().min(1).multipleOf(12);
 
 // Coerced from form input
-v.numeric().min(0).max(100)
+v.numeric().min(0).max(100);
 
 // Cross-field range
 v.object({
   startYear: v.int(),
   endYear: v.int().minSibling("startYear"),
-})
+});
 
 // Optional with default
-v.int().min(0).default(0).optional()
+v.int().min(0).default(0).optional();
 ```