@nifrajs/schema 2.1.0 → 2.3.0

package/README.md

@@ -20,12 +20,12 @@ const app = server().post("/users", { body: t.object({ name: t.string(), age: t.
 const openapi = toOpenAPI(app) // OpenAPI 3.1
 ```
 
-- **`t` builder** — `string`/`number`/`integer`/`boolean`/`null`/`literal`/`object`/
+- **`t` builder** - `string`/`number`/`integer`/`boolean`/`null`/`literal`/`object`/
   `array`/`optional`/`union`/`record`, with options (`min`/`max`, `pattern`, `format`,
   …) that become JSON Schema constraints. Validators are compiled (fast).
-- **Validating string formats** — `email`/`uuid`/`date-time`/`date`/`time`/`uri`/`ipv4`
+- **Validating string formats** - `email`/`uuid`/`date-time`/`date`/`time`/`uri`/`ipv4`
   validate *and* annotate; register more with `registerFormat`.
-- **`toOpenAPI`** — richest from a contract (it carries `response` schemas + op names →
+- **`toOpenAPI`** - richest from a contract (it carries `response` schemas + op names →
   `operationId`s); also works on a live app. Routes using a BYO Standard Schema are
   emitted without a detailed schema (Standard Schema exposes no JSON Schema).
 
@@ -52,14 +52,14 @@ It emits `paths`, `parameters` (path + object query), `requestBody`, and `respon
 - **`servers`**, **top-level `tags`**, and an info **`description`** (document options).
 - **`securitySchemes`** → `components.securitySchemes`, a document-wide **`security`**, and per-operation
   `security` (`[]` marks an operation explicitly public).
-- **Non-200 responses** and **non-JSON content** — a contract op's `responses` map declares extra status
+- **Non-200 responses** and **non-JSON content** - a contract op's `responses` map declares extra status
   codes; `requestContentType` / `responseContentType` set media types other than `application/json`.
-- **`$ref` reuse** — a schema with a `$id` (`t.object({…}, { $id: "User" })`) is hoisted into
+- **`$ref` reuse** - a schema with a `$id` (`t.object({…}, { $id: "User" })`) is hoisted into
   `components.schemas` once and referenced by `$ref` everywhere it's used.
-- Per-operation **`summary`**, **`description`**, **`tags`**, **`deprecated`** — declared on the contract op.
+- Per-operation **`summary`**, **`description`**, **`tags`**, **`deprecated`** - declared on the contract op.
 
 A **contract** is richest (its ops carry all of the above); in **app** mode a route's response is a
-generic `200` with no schema — declare a `defineContract` with `response` schemas, or pass
+generic `200` with no schema - declare a `defineContract` with `response` schemas, or pass
 `options.operations` (keyed by `"METHOD /path"`) to enrich app routes. Routes using a BYO Standard Schema
 are still emitted without body/response detail (Standard Schema exposes no JSON Schema).
 
@@ -67,7 +67,7 @@ are still emitted without body/response detail (Standard Schema exposes no JSON
 
 ## For AI agents
 
-Start with [`LLM.md`](./LLM.md) — this package's contract card (the exports you call + its footguns),
+Start with [`LLM.md`](./LLM.md) - this package's contract card (the exports you call + its footguns),
 one cheap read instead of the whole corpus. For the wider framework: the repo's
 [`AGENTS.md`](../../AGENTS.md) is the copy-paste quick reference, and
 [`llms-full.txt`](../../llms-full.txt) is the full machine-readable corpus. Run `nifra check` as the

package/dist/adapter.d.ts

@@ -2,7 +2,7 @@ import type { StandardSchemaV1 } from "@nifrajs/core/schema";
 import type { Static, TSchema } from "@sinclair/typebox";
 /**
  * A `t` schema. It is a Standard Schema (so any nifra route validates it with no
- * special-casing) whose raw TypeBox definition stays reachable as `jsonSchema` —
+ * special-casing) whose raw TypeBox definition stays reachable as `jsonSchema` -
  * and because a TypeBox schema *is* a JSON Schema, that field is exactly what lets
  * `toOpenAPI` emit a real request/response schema for the route. BYO Standard
  * Schemas (zod/valibot/arktype) validate too but expose no JSON Schema, so only
@@ -16,13 +16,13 @@ export type NifraSchema<T extends TSchema = TSchema> = StandardSchemaV1<Static<T
  *
  * **Validation is fast where it can be, and works everywhere.** The first `validate`
  * builds a compiled `TypeCompiler` validator (codegen via `new Function`) and memoizes
- * it — composing schemas (`t.object({ a: t.string() })`) never compiles the inner
+ * it - composing schemas (`t.object({ a: t.string() })`) never compiles the inner
  * pieces; only a schema actually used to validate a request pays the one-time codegen
  * cost. On Bun and Node this is the only path and it is untouched.
  *
  * Edge runtimes (Cloudflare Workers, Vercel Edge, Deno Deploy) **forbid dynamic code
  * generation**, so that first compile throws there. We catch it once per schema and
- * fall back to TypeBox's eval-free `Value` checker — same semantics (and same global
+ * fall back to TypeBox's eval-free `Value` checker - same semantics (and same global
  * `FormatRegistry`, so `t.string({ format })` behaves identically), no `new Function`.
  * The branch is decided once and memoized, so the hot path is a single check either way.
  *
@@ -31,7 +31,7 @@ export type NifraSchema<T extends TSchema = TSchema> = StandardSchemaV1<Static<T
  *
  * `options.coerce` runs TypeBox's `Value.Convert` (string→number/integer/boolean, per the schema)
  * BEFORE validating. Query values always arrive as strings (`?limit=20` → `"20"`), so a query schema
- * with a numeric field can't validate without this — it's how `t.pageQuery` yields a real `number`.
+ * with a numeric field can't validate without this - it's how `t.pageQuery` yields a real `number`.
  * Leave it OFF (the default) for body/JSON schemas: a JSON number is already a number, and coercing
  * would silently accept `"20"` where the contract said `20`.
  */

package/dist/adapter.js

@@ -18,13 +18,13 @@ function toIssue(error) {
  *
  * **Validation is fast where it can be, and works everywhere.** The first `validate`
  * builds a compiled `TypeCompiler` validator (codegen via `new Function`) and memoizes
- * it — composing schemas (`t.object({ a: t.string() })`) never compiles the inner
+ * it - composing schemas (`t.object({ a: t.string() })`) never compiles the inner
  * pieces; only a schema actually used to validate a request pays the one-time codegen
  * cost. On Bun and Node this is the only path and it is untouched.
  *
  * Edge runtimes (Cloudflare Workers, Vercel Edge, Deno Deploy) **forbid dynamic code
  * generation**, so that first compile throws there. We catch it once per schema and
- * fall back to TypeBox's eval-free `Value` checker — same semantics (and same global
+ * fall back to TypeBox's eval-free `Value` checker - same semantics (and same global
  * `FormatRegistry`, so `t.string({ format })` behaves identically), no `new Function`.
  * The branch is decided once and memoized, so the hot path is a single check either way.
  *
@@ -33,7 +33,7 @@ function toIssue(error) {
  *
  * `options.coerce` runs TypeBox's `Value.Convert` (string→number/integer/boolean, per the schema)
  * BEFORE validating. Query values always arrive as strings (`?limit=20` → `"20"`), so a query schema
- * with a numeric field can't validate without this — it's how `t.pageQuery` yields a real `number`.
+ * with a numeric field can't validate without this - it's how `t.pageQuery` yields a real `number`.
  * Leave it OFF (the default) for body/JSON schemas: a JSON number is already a number, and coercing
  * would silently accept `"20"` where the contract said `20`.
  */
@@ -48,7 +48,7 @@ export function fromTypeBox(schema, options) {
             validate: (value) => {
                 // Install the standard string formats before the first Compile/Check. Driven from this
                 // reachable path (not a top-level import side effect) so a production bundle can't
-                // tree-shake the registration away — see ./formats.ts. Idempotent, ~free after first call.
+                // tree-shake the registration away - see ./formats.ts. Idempotent, ~free after first call.
                 ensureDefaultFormats();
                 // Coerce first when asked (query schemas): `Value.Convert` turns "20"→20 per the schema, so the
                 // compiled/eval-free Check below sees the target type. A non-convertible value (e.g. "abc" for an

package/dist/formats.d.ts

@@ -6,7 +6,7 @@ export declare function registerFormat(name: string, validate: (value: string) =
  * This is driven from the validate path (see `./adapter.ts`) rather than run as a bare
  * top-level import side effect *on purpose*: a production bundler (`Bun.build`, esbuild)
  * tree-shakes a module that is only imported for its effect, and Bun.build does **not**
- * honor the `sideEffects` package.json field — so the old top-level registration loop was
+ * honor the `sideEffects` package.json field - so the old top-level registration loop was
  * dropped from prod server bundles, making every `t.string({ format })` reject with
  * "Unknown format" while unbundled `nifra dev` worked. Calling this from code the validator
  * actually reaches keeps the registration in the bundle.

package/dist/formats.js

@@ -32,7 +32,7 @@ let defaultsRegistered = false;
  * This is driven from the validate path (see `./adapter.ts`) rather than run as a bare
  * top-level import side effect *on purpose*: a production bundler (`Bun.build`, esbuild)
  * tree-shakes a module that is only imported for its effect, and Bun.build does **not**
- * honor the `sideEffects` package.json field — so the old top-level registration loop was
+ * honor the `sideEffects` package.json field - so the old top-level registration loop was
  * dropped from prod server bundles, making every `t.string({ format })` reject with
  * "Unknown format" while unbundled `nifra dev` worked. Calling this from code the validator
  * actually reaches keeps the registration in the bundle.

package/dist/index.d.ts

@@ -1,9 +1,9 @@
 /**
- * `@nifrajs/schema` — the optional, batteries-included schema builder for nifra.
+ * `@nifrajs/schema` - the optional, batteries-included schema builder for nifra.
  *
  * `t` is TypeBox-backed: validators are compiled (fast) and every schema is a JSON
  * Schema (free OpenAPI). It implements Standard Schema, so `@nifrajs/core` validates
- * it through the exact same path as any BYO library — `@nifrajs/core` never depends on
+ * it through the exact same path as any BYO library - `@nifrajs/core` never depends on
  * a validator; this package is the opt-in default.
  */
 export { fromTypeBox, type NifraSchema } from "./adapter.js";

package/dist/index.js

@@ -1,18 +1,18 @@
 /**
- * `@nifrajs/schema` — the optional, batteries-included schema builder for nifra.
+ * `@nifrajs/schema` - the optional, batteries-included schema builder for nifra.
  *
  * `t` is TypeBox-backed: validators are compiled (fast) and every schema is a JSON
  * Schema (free OpenAPI). It implements Standard Schema, so `@nifrajs/core` validates
- * it through the exact same path as any BYO library — `@nifrajs/core` never depends on
+ * it through the exact same path as any BYO library - `@nifrajs/core` never depends on
  * a validator; this package is the opt-in default.
  */
 export { fromTypeBox } from "./adapter.js";
 // `registerFormat` adds/overrides a custom string format. The standard formats (email, uuid, …)
-// install themselves lazily from the validate path (see ./adapter.ts) — NOT as an import side
+// install themselves lazily from the validate path (see ./adapter.ts) - NOT as an import side
 // effect of this module, which a production bundler would tree-shake away.
 export { registerFormat } from "./formats.js";
 export { toOpenAPI } from "./openapi.js";
-// Cursor-pagination runtime helpers — pair with `t.paginated` / `t.pageQuery`.
+// Cursor-pagination runtime helpers - pair with `t.paginated` / `t.pageQuery`.
 export { decodeCursor, encodeCursor, paginate } from "./pagination.js";
 export { t } from "./t.js";
 //# sourceMappingURL=index.js.map

package/dist/openapi.d.ts

@@ -2,13 +2,13 @@ import type { ContractShape } from "@nifrajs/core/contract";
 import { type JsonSchema } from "@nifrajs/core/reflection";
 import type { Server } from "@nifrajs/core/server";
 /**
- * OpenAPI 3.1 generation. We model a practical slice of the spec — enough to feed Swagger UI / codegen
+ * OpenAPI 3.1 generation. We model a practical slice of the spec - enough to feed Swagger UI / codegen
  * and to validate structurally: paths, parameters, request bodies, responses (incl. non-200 and
  * non-JSON), tags, security, servers, and `$ref` reuse via `components.schemas`.
  *
  * Schemas carry full detail only for `t`/TypeBox inputs (they expose a JSON Schema); a BYO Standard
  * Schema validates at runtime but exposes no JSON Schema, so its route is emitted without body/response
- * detail. A **contract** is richest — its operations carry `response`, `tags`, `security`, additional
+ * detail. A **contract** is richest - its operations carry `response`, `tags`, `security`, additional
  * `responses`, etc.; an **app** emits request shapes + a generic `200` (an inline handler has no
  * response *schema* to serialize), enrichable via `options.operations`.
  */
@@ -33,7 +33,7 @@ export interface ToOpenAPIOptions {
     readonly description?: string;
     /** Server URLs the API is served from (OpenAPI `servers`). */
     readonly servers?: readonly OpenAPIServer[];
-    /** Tag definitions (OpenAPI top-level `tags`) — names referenced by an operation's `tags`. */
+    /** Tag definitions (OpenAPI top-level `tags`) - names referenced by an operation's `tags`. */
     readonly tags?: readonly OpenAPITag[];
     /** Reusable security schemes → `components.securitySchemes` (e.g. `{ bearer: { type: "http", scheme: "bearer" } }`). */
     readonly securitySchemes?: Readonly<Record<string, Record<string, unknown>>>;
@@ -42,7 +42,7 @@ export interface ToOpenAPIOptions {
     /**
      * Per-operation overrides, shallow-merged over the generated operation. Keyed by `operationId`
      * (contract op name) or `"METHOD /path"` (e.g. `"GET /users/:id"`). The escape hatch for detail that
-     * can't be introspected — richer response bodies, examples, app-route tags/security.
+     * can't be introspected - richer response bodies, examples, app-route tags/security.
      */
     readonly operations?: Readonly<Record<string, Record<string, unknown>>>;
 }

package/dist/openapi.js

@@ -1,6 +1,6 @@
 import { reflectRoutes, reflectSchema, } from "@nifrajs/core/reflection";
 /**
- * Collects schemas that carry a `$id` into `components.schemas`, returning a `$ref` in their place —
+ * Collects schemas that carry a `$id` into `components.schemas`, returning a `$ref` in their place -
  * so a schema used by N operations is emitted once. Schemas without a `$id` stay inline (the existing
  * behavior). The first sighting of an id wins; later ones just `$ref` it.
  */
@@ -209,9 +209,9 @@ export function toOpenAPI(input, options = {}) {
                 body: route.schema?.body,
                 query: route.schema?.query,
                 params: route.schema?.params,
-                // A route may now declare a `response` contract — emit it as the 200 body schema.
+                // A route may now declare a `response` contract - emit it as the 200 body schema.
                 response: route.schema?.response,
-                // …and an `errors` contract — emit each as a non-2xx response.
+                // …and an `errors` contract - emit each as a non-2xx response.
                 responses: reflectedErrorsToResponses(route.schema?.errors),
                 operationId: undefined,
             }, store, options.operations);

package/dist/pagination.d.ts

@@ -1,17 +1,17 @@
 /**
- * Cursor-pagination runtime helpers — an opaque cursor codec + a page builder. Pair with `t.paginated`
+ * Cursor-pagination runtime helpers - an opaque cursor codec + a page builder. Pair with `t.paginated`
  * (the response schema) and `t.pageQuery` (the request schema).
  *
  * Edge-safe: `btoa`/`atob` + `TextEncoder`/`TextDecoder` (no `Buffer`), so it runs on Bun/Node/Deno/
- * Workers. Cursors are opaque but NOT signed — treat a decoded cursor as untrusted client input: validate
+ * Workers. Cursors are opaque but NOT signed - treat a decoded cursor as untrusted client input: validate
  * its shape before keying a DB query off it (it's a position hint, not an authorization token).
  */
 /** Encode any JSON-serializable value (e.g. the last row's sort key) into an opaque cursor string. */
 export declare function encodeCursor(value: unknown): string;
-/** Decode a cursor back to its value. Returns `undefined` for a null/empty/malformed cursor — treat that
+/** Decode a cursor back to its value. Returns `undefined` for a null/empty/malformed cursor - treat that
  * as "start from the beginning" rather than erroring on a client-supplied string. */
 export declare function decodeCursor<T = unknown>(cursor: string | null | undefined): T | undefined;
-/** A cursor-pagination page — matches the shape of `t.paginated(item)`. */
+/** A cursor-pagination page - matches the shape of `t.paginated(item)`. */
 export interface Page<Item> {
     readonly items: Item[];
     readonly nextCursor: string | null;

package/dist/pagination.js

@@ -1,9 +1,9 @@
 /**
- * Cursor-pagination runtime helpers — an opaque cursor codec + a page builder. Pair with `t.paginated`
+ * Cursor-pagination runtime helpers - an opaque cursor codec + a page builder. Pair with `t.paginated`
  * (the response schema) and `t.pageQuery` (the request schema).
  *
  * Edge-safe: `btoa`/`atob` + `TextEncoder`/`TextDecoder` (no `Buffer`), so it runs on Bun/Node/Deno/
- * Workers. Cursors are opaque but NOT signed — treat a decoded cursor as untrusted client input: validate
+ * Workers. Cursors are opaque but NOT signed - treat a decoded cursor as untrusted client input: validate
  * its shape before keying a DB query off it (it's a position hint, not an authorization token).
  */
 /** UTF-8 → URL-safe base64 (no padding). */
@@ -24,7 +24,7 @@ function fromBase64Url(input) {
 export function encodeCursor(value) {
     return toBase64Url(JSON.stringify(value));
 }
-/** Decode a cursor back to its value. Returns `undefined` for a null/empty/malformed cursor — treat that
+/** Decode a cursor back to its value. Returns `undefined` for a null/empty/malformed cursor - treat that
  * as "start from the beginning" rather than erroring on a client-supplied string. */
 export function decodeCursor(cursor) {
     if (cursor === null || cursor === undefined || cursor === "")

package/dist/t.d.ts

@@ -2,7 +2,7 @@ import { type ArrayOptions, type IntegerOptions, type NumberOptions, type Object
 import { type NifraSchema } from "./adapter.js";
 type Props = Record<string, NifraSchema>;
 /**
- * The built-in schema builder. Each constructor returns a `NifraSchema` — a
+ * The built-in schema builder. Each constructor returns a `NifraSchema` - a
  * Standard Schema whose validated output type flows into `c.body`/`c.query`, and
  * whose `jsonSchema` powers `toOpenAPI`. Options (min/max, length, pattern, …)
  * pass straight through to TypeBox and so become JSON Schema constraints.
@@ -21,7 +21,7 @@ export declare const t: {
     readonly null: () => NifraSchema<import("@sinclair/typebox").TNull>;
     readonly literal: <const L extends TLiteralValue>(value: L) => NifraSchema<import("@sinclair/typebox").TLiteral<L>>;
     readonly object: <P extends Props>(props: P, options?: ObjectOptions) => NifraSchema<import("@sinclair/typebox").TObject<{ [K in keyof P]: P[K]["jsonSchema"]; }>>;
-    /** Like `t.object` but ACCEPTS (and passes through) unknown fields — the explicit opt-out of the
+    /** Like `t.object` but ACCEPTS (and passes through) unknown fields - the explicit opt-out of the
      * strict default. Prefer `t.object` unless you genuinely need an open object. */
     readonly looseObject: <P extends Props>(props: P, options?: ObjectOptions) => NifraSchema<import("@sinclair/typebox").TObject<{ [K in keyof P]: P[K]["jsonSchema"]; }>>;
     readonly array: <T extends TSchema>(item: NifraSchema<T>, options?: ArrayOptions) => NifraSchema<import("@sinclair/typebox").TArray<T>>;
@@ -35,7 +35,7 @@ export declare const t: {
         nextCursor: TUnion<[import("@sinclair/typebox").TString, import("@sinclair/typebox").TNull]>;
     }>>;
     /** A request query schema for cursor pagination: `{ cursor?: string; limit?: number }`. `maxLimit`
-     * caps `limit` — a larger value fails validation (a 422), so a client can't request an unbounded page.
+     * caps `limit` - a larger value fails validation (a 422), so a client can't request an unbounded page.
      * `coerce` is on because query values arrive as strings (`?limit=20` → `"20"`); it's what makes `limit`
      * a real `number` in the handler (`c.query.limit`), not a string. */
     readonly pageQuery: (options?: {
@@ -47,7 +47,7 @@ export declare const t: {
     /** A request-query schema with string->scalar COERCION on. Query values always arrive as strings
      * (`?limit=20` -> `"20"`), so a plain `t.object({ limit: t.integer() })` in a `query` slot fails to
      * validate; use `t.query` and `t.integer()`/`t.number()`/`t.boolean()` fields become real numbers/
-     * booleans in `c.query`. **Open by default** (unknown query fields pass through — `additionalProperties:
+     * booleans in `c.query`. **Open by default** (unknown query fields pass through - `additionalProperties:
      * true`): query params are read by name, not spread into a DB write, so unknown params (UTM tracking,
      * `fbclid`, etc.) passing through is safe, and rejecting them is a production-only footgun (ad/social
      * traffic appends params your schema never declares, causing 422s that never appear in dev/CI). Pass

package/dist/t.js

@@ -9,7 +9,7 @@ function unwrap(props) {
     return out;
 }
 /**
- * The built-in schema builder. Each constructor returns a `NifraSchema` — a
+ * The built-in schema builder. Each constructor returns a `NifraSchema` - a
  * Standard Schema whose validated output type flows into `c.body`/`c.query`, and
  * whose `jsonSchema` powers `toOpenAPI`. Options (min/max, length, pattern, …)
  * pass straight through to TypeBox and so become JSON Schema constraints.
@@ -27,12 +27,12 @@ export const t = {
     boolean: () => fromTypeBox(Type.Boolean()),
     null: () => fromTypeBox(Type.Null()),
     literal: (value) => fromTypeBox(Type.Literal(value)),
-    // `t.object` REJECTS unknown fields by default (`additionalProperties: false`) — the trust-boundary
+    // `t.object` REJECTS unknown fields by default (`additionalProperties: false`) - the trust-boundary
     // rule. A body with extra keys fails validation (a 422), so `c.body` never carries attacker-supplied
     // properties (no mass-assignment). Use `t.looseObject` (or pass `{ additionalProperties: true }`) to
     // opt into an open object; an explicit `options.additionalProperties` always wins over the default.
     object: (props, options) => fromTypeBox(Type.Object(unwrap(props), { additionalProperties: false, ...options })),
-    /** Like `t.object` but ACCEPTS (and passes through) unknown fields — the explicit opt-out of the
+    /** Like `t.object` but ACCEPTS (and passes through) unknown fields - the explicit opt-out of the
      * strict default. Prefer `t.object` unless you genuinely need an open object. */
     looseObject: (props, options) => fromTypeBox(Type.Object(unwrap(props), { additionalProperties: true, ...options })),
     array: (item, options) => fromTypeBox(Type.Array(item.jsonSchema, options)),
@@ -40,13 +40,13 @@ export const t = {
     optional: (schema) => fromTypeBox(Type.Optional(schema.jsonSchema)),
     // `const S` captures the argument as a tuple; the explicit return type then maps
     // over that captured tuple (`S[K]["jsonSchema"]`) so the union's `Static` is
-    // `A | B`, not `unknown` — the value-level `.map` can't preserve per-element
+    // `A | B`, not `unknown` - the value-level `.map` can't preserve per-element
     // types, so the output type is derived from `S` and the result cast to match
     // (order/length are preserved by `map`, so the tuple shape is sound).
     union: (schemas) => fromTypeBox(Type.Union(schemas.map((schema) => schema.jsonSchema))),
     record: (value, options) => fromTypeBox(Type.Record(Type.String(), value.jsonSchema, options)),
     // Composed from TypeBox directly (not `t.object`/`t.array`) so the `t` literal doesn't reference
-    // itself during inference. Cursor pagination — not OFFSET — is the production default: stable under
+    // itself during inference. Cursor pagination - not OFFSET - is the production default: stable under
     // concurrent inserts and O(1) per page. Build pages with `paginate()` + `encodeCursor`/`decodeCursor`.
     /** A cursor-pagination response envelope: `{ items: T[]; nextCursor: string | null }` (`null` = last page). */
     paginated: (item, options) => fromTypeBox(Type.Object({
@@ -54,7 +54,7 @@ export const t = {
         nextCursor: Type.Union([Type.String(), Type.Null()]),
     }, { additionalProperties: false, ...options })),
     /** A request query schema for cursor pagination: `{ cursor?: string; limit?: number }`. `maxLimit`
-     * caps `limit` — a larger value fails validation (a 422), so a client can't request an unbounded page.
+     * caps `limit` - a larger value fails validation (a 422), so a client can't request an unbounded page.
      * `coerce` is on because query values arrive as strings (`?limit=20` → `"20"`); it's what makes `limit`
      * a real `number` in the handler (`c.query.limit`), not a string. */
     pageQuery: (options) => fromTypeBox(Type.Object({
@@ -64,7 +64,7 @@ export const t = {
     /** A request-query schema with string->scalar COERCION on. Query values always arrive as strings
      * (`?limit=20` -> `"20"`), so a plain `t.object({ limit: t.integer() })` in a `query` slot fails to
      * validate; use `t.query` and `t.integer()`/`t.number()`/`t.boolean()` fields become real numbers/
-     * booleans in `c.query`. **Open by default** (unknown query fields pass through — `additionalProperties:
+     * booleans in `c.query`. **Open by default** (unknown query fields pass through - `additionalProperties:
      * true`): query params are read by name, not spread into a DB write, so unknown params (UTM tracking,
      * `fbclid`, etc.) passing through is safe, and rejecting them is a production-only footgun (ad/social
      * traffic appends params your schema never declares, causing 422s that never appear in dev/CI). Pass

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "@nifrajs/schema",
-  "version": "2.1.0",
-  "description": "Built-in schema builder `t` — TypeBox-backed (free JSON Schema + compiled validators), implements Standard Schema so nifra routes validate it natively.",
+  "version": "2.3.0",
+  "description": "Built-in schema builder `t` - TypeBox-backed (free JSON Schema + compiled validators), implements Standard Schema so nifra routes validate it natively.",
   "keywords": [
     "bun",
     "typescript",
@@ -35,7 +35,7 @@
     "dist",
     "src"
   ],
-  "comment:sideEffects": "No module here runs work at import time: the standard string formats install lazily from the validate path (src/adapter.ts → src/formats.ts ensureDefaultFormats), not as a top-level import side effect. The previous `sideEffects: [formats]` array did not survive bundling — Bun.build ignores the field — which is why formats were dropped from prod bundles. `false` is accurate now and lets consumers tree-shake freely.",
+  "comment:sideEffects": "No module here runs work at import time: the standard string formats install lazily from the validate path (src/adapter.ts → src/formats.ts ensureDefaultFormats), not as a top-level import side effect. The previous `sideEffects: [formats]` array did not survive bundling - Bun.build ignores the field - which is why formats were dropped from prod bundles. `false` is accurate now and lets consumers tree-shake freely.",
   "sideEffects": false,
   "scripts": {
     "build": "tsc -p tsconfig.build.json && bun run ../../scripts/fix-dts.ts dist"
@@ -48,7 +48,7 @@
     "@sinclair/typebox": "^0.34.49"
   },
   "peerDependencies": {
-    "@nifrajs/core": "^2.1.0"
+    "@nifrajs/core": "^2.3.0"
   },
   "devDependencies": {
     "@nifrajs/core": "workspace:*",

package/src/adapter.ts

@@ -11,7 +11,7 @@ import { ensureDefaultFormats } from "./formats.ts"
 
 /**
  * A `t` schema. It is a Standard Schema (so any nifra route validates it with no
- * special-casing) whose raw TypeBox definition stays reachable as `jsonSchema` —
+ * special-casing) whose raw TypeBox definition stays reachable as `jsonSchema` -
  * and because a TypeBox schema *is* a JSON Schema, that field is exactly what lets
  * `toOpenAPI` emit a real request/response schema for the route. BYO Standard
  * Schemas (zod/valibot/arktype) validate too but expose no JSON Schema, so only
@@ -39,13 +39,13 @@ function toIssue(error: { readonly message: string; readonly path: string }): St
  *
  * **Validation is fast where it can be, and works everywhere.** The first `validate`
  * builds a compiled `TypeCompiler` validator (codegen via `new Function`) and memoizes
- * it — composing schemas (`t.object({ a: t.string() })`) never compiles the inner
+ * it - composing schemas (`t.object({ a: t.string() })`) never compiles the inner
  * pieces; only a schema actually used to validate a request pays the one-time codegen
  * cost. On Bun and Node this is the only path and it is untouched.
  *
  * Edge runtimes (Cloudflare Workers, Vercel Edge, Deno Deploy) **forbid dynamic code
  * generation**, so that first compile throws there. We catch it once per schema and
- * fall back to TypeBox's eval-free `Value` checker — same semantics (and same global
+ * fall back to TypeBox's eval-free `Value` checker - same semantics (and same global
  * `FormatRegistry`, so `t.string({ format })` behaves identically), no `new Function`.
  * The branch is decided once and memoized, so the hot path is a single check either way.
  *
@@ -54,7 +54,7 @@ function toIssue(error: { readonly message: string; readonly path: string }): St
  *
  * `options.coerce` runs TypeBox's `Value.Convert` (string→number/integer/boolean, per the schema)
  * BEFORE validating. Query values always arrive as strings (`?limit=20` → `"20"`), so a query schema
- * with a numeric field can't validate without this — it's how `t.pageQuery` yields a real `number`.
+ * with a numeric field can't validate without this - it's how `t.pageQuery` yields a real `number`.
  * Leave it OFF (the default) for body/JSON schemas: a JSON number is already a number, and coercing
  * would silently accept `"20"` where the contract said `20`.
  */
@@ -72,7 +72,7 @@ export function fromTypeBox<T extends TSchema>(
       validate: (value: unknown): StandardResult<Static<T>> => {
         // Install the standard string formats before the first Compile/Check. Driven from this
         // reachable path (not a top-level import side effect) so a production bundle can't
-        // tree-shake the registration away — see ./formats.ts. Idempotent, ~free after first call.
+        // tree-shake the registration away - see ./formats.ts. Idempotent, ~free after first call.
         ensureDefaultFormats()
         // Coerce first when asked (query schemas): `Value.Convert` turns "20"→20 per the schema, so the
         // compiled/eval-free Check below sees the target type. A non-convertible value (e.g. "abc" for an

package/src/formats.ts

@@ -36,7 +36,7 @@ let defaultsRegistered = false
  * This is driven from the validate path (see `./adapter.ts`) rather than run as a bare
  * top-level import side effect *on purpose*: a production bundler (`Bun.build`, esbuild)
  * tree-shakes a module that is only imported for its effect, and Bun.build does **not**
- * honor the `sideEffects` package.json field — so the old top-level registration loop was
+ * honor the `sideEffects` package.json field - so the old top-level registration loop was
  * dropped from prod server bundles, making every `t.string({ format })` reject with
  * "Unknown format" while unbundled `nifra dev` worked. Calling this from code the validator
  * actually reaches keeps the registration in the bundle.

package/src/index.ts

@@ -1,17 +1,17 @@
 /**
- * `@nifrajs/schema` — the optional, batteries-included schema builder for nifra.
+ * `@nifrajs/schema` - the optional, batteries-included schema builder for nifra.
  *
  * `t` is TypeBox-backed: validators are compiled (fast) and every schema is a JSON
  * Schema (free OpenAPI). It implements Standard Schema, so `@nifrajs/core` validates
- * it through the exact same path as any BYO library — `@nifrajs/core` never depends on
+ * it through the exact same path as any BYO library - `@nifrajs/core` never depends on
  * a validator; this package is the opt-in default.
  */
 export { fromTypeBox, type NifraSchema } from "./adapter.ts"
 // `registerFormat` adds/overrides a custom string format. The standard formats (email, uuid, …)
-// install themselves lazily from the validate path (see ./adapter.ts) — NOT as an import side
+// install themselves lazily from the validate path (see ./adapter.ts) - NOT as an import side
 // effect of this module, which a production bundler would tree-shake away.
 export { registerFormat } from "./formats.ts"
 export { type OpenAPIDocument, type OpenAPIInfo, toOpenAPI } from "./openapi.ts"
-// Cursor-pagination runtime helpers — pair with `t.paginated` / `t.pageQuery`.
+// Cursor-pagination runtime helpers - pair with `t.paginated` / `t.pageQuery`.
 export { decodeCursor, encodeCursor, type Page, paginate } from "./pagination.ts"
 export { t } from "./t.ts"

package/src/openapi.ts

@@ -9,13 +9,13 @@ import {
 import type { Server } from "@nifrajs/core/server"
 
 /**
- * OpenAPI 3.1 generation. We model a practical slice of the spec — enough to feed Swagger UI / codegen
+ * OpenAPI 3.1 generation. We model a practical slice of the spec - enough to feed Swagger UI / codegen
  * and to validate structurally: paths, parameters, request bodies, responses (incl. non-200 and
  * non-JSON), tags, security, servers, and `$ref` reuse via `components.schemas`.
  *
  * Schemas carry full detail only for `t`/TypeBox inputs (they expose a JSON Schema); a BYO Standard
  * Schema validates at runtime but exposes no JSON Schema, so its route is emitted without body/response
- * detail. A **contract** is richest — its operations carry `response`, `tags`, `security`, additional
+ * detail. A **contract** is richest - its operations carry `response`, `tags`, `security`, additional
  * `responses`, etc.; an **app** emits request shapes + a generic `200` (an inline handler has no
  * response *schema* to serialize), enrichable via `options.operations`.
  */
@@ -44,7 +44,7 @@ export interface ToOpenAPIOptions {
   readonly description?: string
   /** Server URLs the API is served from (OpenAPI `servers`). */
   readonly servers?: readonly OpenAPIServer[]
-  /** Tag definitions (OpenAPI top-level `tags`) — names referenced by an operation's `tags`. */
+  /** Tag definitions (OpenAPI top-level `tags`) - names referenced by an operation's `tags`. */
   readonly tags?: readonly OpenAPITag[]
   /** Reusable security schemes → `components.securitySchemes` (e.g. `{ bearer: { type: "http", scheme: "bearer" } }`). */
   readonly securitySchemes?: Readonly<Record<string, Record<string, unknown>>>
@@ -53,7 +53,7 @@ export interface ToOpenAPIOptions {
   /**
    * Per-operation overrides, shallow-merged over the generated operation. Keyed by `operationId`
    * (contract op name) or `"METHOD /path"` (e.g. `"GET /users/:id"`). The escape hatch for detail that
-   * can't be introspected — richer response bodies, examples, app-route tags/security.
+   * can't be introspected - richer response bodies, examples, app-route tags/security.
    */
   readonly operations?: Readonly<Record<string, Record<string, unknown>>>
 }
@@ -107,7 +107,7 @@ export interface OpenAPIDocument {
 }
 
 /**
- * Collects schemas that carry a `$id` into `components.schemas`, returning a `$ref` in their place —
+ * Collects schemas that carry a `$id` into `components.schemas`, returning a `$ref` in their place -
  * so a schema used by N operations is emitted once. Schemas without a `$id` stay inline (the existing
  * behavior). The first sighting of an id wins; later ones just `$ref` it.
  */
@@ -211,11 +211,11 @@ interface OperationInput {
   readonly path: string
   readonly body: SchemaReflection | undefined
   readonly query: SchemaReflection | undefined
-  /** Reflected params schema — per-field constraints merge into path parameters. */
+  /** Reflected params schema - per-field constraints merge into path parameters. */
   readonly params: SchemaReflection | undefined
   readonly response: SchemaReflection | undefined
   readonly operationId: string | undefined
-  // `| undefined` (not just `?`) so a contract op's optional fields — `string | undefined` etc. — are
+  // `| undefined` (not just `?`) so a contract op's optional fields - `string | undefined` etc. - are
   // assignable under `exactOptionalPropertyTypes` when spread into this literal.
   readonly summary?: string | undefined
   readonly description?: string | undefined
@@ -356,9 +356,9 @@ export function toOpenAPI(
           body: route.schema?.body,
           query: route.schema?.query,
           params: route.schema?.params,
-          // A route may now declare a `response` contract — emit it as the 200 body schema.
+          // A route may now declare a `response` contract - emit it as the 200 body schema.
           response: route.schema?.response,
-          // …and an `errors` contract — emit each as a non-2xx response.
+          // …and an `errors` contract - emit each as a non-2xx response.
           responses: reflectedErrorsToResponses(route.schema?.errors),
           operationId: undefined,
         },

package/src/pagination.ts

@@ -1,9 +1,9 @@
 /**
- * Cursor-pagination runtime helpers — an opaque cursor codec + a page builder. Pair with `t.paginated`
+ * Cursor-pagination runtime helpers - an opaque cursor codec + a page builder. Pair with `t.paginated`
  * (the response schema) and `t.pageQuery` (the request schema).
  *
  * Edge-safe: `btoa`/`atob` + `TextEncoder`/`TextDecoder` (no `Buffer`), so it runs on Bun/Node/Deno/
- * Workers. Cursors are opaque but NOT signed — treat a decoded cursor as untrusted client input: validate
+ * Workers. Cursors are opaque but NOT signed - treat a decoded cursor as untrusted client input: validate
  * its shape before keying a DB query off it (it's a position hint, not an authorization token).
  */
 
@@ -27,7 +27,7 @@ export function encodeCursor(value: unknown): string {
   return toBase64Url(JSON.stringify(value))
 }
 
-/** Decode a cursor back to its value. Returns `undefined` for a null/empty/malformed cursor — treat that
+/** Decode a cursor back to its value. Returns `undefined` for a null/empty/malformed cursor - treat that
  * as "start from the beginning" rather than erroring on a client-supplied string. */
 export function decodeCursor<T = unknown>(cursor: string | null | undefined): T | undefined {
   if (cursor === null || cursor === undefined || cursor === "") return undefined
@@ -38,7 +38,7 @@ export function decodeCursor<T = unknown>(cursor: string | null | undefined): T
   }
 }
 
-/** A cursor-pagination page — matches the shape of `t.paginated(item)`. */
+/** A cursor-pagination page - matches the shape of `t.paginated(item)`. */
 export interface Page<Item> {
   readonly items: Item[]
   readonly nextCursor: string | null

package/src/t.ts

@@ -22,7 +22,7 @@ function unwrap<P extends Props>(props: P): { [K in keyof P]: P[K]["jsonSchema"]
 }
 
 /**
- * The built-in schema builder. Each constructor returns a `NifraSchema` — a
+ * The built-in schema builder. Each constructor returns a `NifraSchema` - a
  * Standard Schema whose validated output type flows into `c.body`/`c.query`, and
  * whose `jsonSchema` powers `toOpenAPI`. Options (min/max, length, pattern, …)
  * pass straight through to TypeBox and so become JSON Schema constraints.
@@ -41,13 +41,13 @@ export const t = {
   null: () => fromTypeBox(Type.Null()),
   literal: <const L extends TLiteralValue>(value: L) => fromTypeBox(Type.Literal(value)),
 
-  // `t.object` REJECTS unknown fields by default (`additionalProperties: false`) — the trust-boundary
+  // `t.object` REJECTS unknown fields by default (`additionalProperties: false`) - the trust-boundary
   // rule. A body with extra keys fails validation (a 422), so `c.body` never carries attacker-supplied
   // properties (no mass-assignment). Use `t.looseObject` (or pass `{ additionalProperties: true }`) to
   // opt into an open object; an explicit `options.additionalProperties` always wins over the default.
   object: <P extends Props>(props: P, options?: ObjectOptions) =>
     fromTypeBox(Type.Object(unwrap(props), { additionalProperties: false, ...options })),
-  /** Like `t.object` but ACCEPTS (and passes through) unknown fields — the explicit opt-out of the
+  /** Like `t.object` but ACCEPTS (and passes through) unknown fields - the explicit opt-out of the
    * strict default. Prefer `t.object` unless you genuinely need an open object. */
   looseObject: <P extends Props>(props: P, options?: ObjectOptions) =>
     fromTypeBox(Type.Object(unwrap(props), { additionalProperties: true, ...options })),
@@ -58,7 +58,7 @@ export const t = {
     fromTypeBox(Type.Optional(schema.jsonSchema)),
   // `const S` captures the argument as a tuple; the explicit return type then maps
   // over that captured tuple (`S[K]["jsonSchema"]`) so the union's `Static` is
-  // `A | B`, not `unknown` — the value-level `.map` can't preserve per-element
+  // `A | B`, not `unknown` - the value-level `.map` can't preserve per-element
   // types, so the output type is derived from `S` and the result cast to match
   // (order/length are preserved by `map`, so the tuple shape is sound).
   union: <const S extends readonly NifraSchema[]>(schemas: S) =>
@@ -69,7 +69,7 @@ export const t = {
     fromTypeBox(Type.Record(Type.String(), value.jsonSchema, options)),
 
   // Composed from TypeBox directly (not `t.object`/`t.array`) so the `t` literal doesn't reference
-  // itself during inference. Cursor pagination — not OFFSET — is the production default: stable under
+  // itself during inference. Cursor pagination - not OFFSET - is the production default: stable under
   // concurrent inserts and O(1) per page. Build pages with `paginate()` + `encodeCursor`/`decodeCursor`.
   /** A cursor-pagination response envelope: `{ items: T[]; nextCursor: string | null }` (`null` = last page). */
   paginated: <T extends TSchema>(item: NifraSchema<T>, options?: ObjectOptions) =>
@@ -83,7 +83,7 @@ export const t = {
       ),
     ),
   /** A request query schema for cursor pagination: `{ cursor?: string; limit?: number }`. `maxLimit`
-   * caps `limit` — a larger value fails validation (a 422), so a client can't request an unbounded page.
+   * caps `limit` - a larger value fails validation (a 422), so a client can't request an unbounded page.
    * `coerce` is on because query values arrive as strings (`?limit=20` → `"20"`); it's what makes `limit`
    * a real `number` in the handler (`c.query.limit`), not a string. */
   pageQuery: (options?: { maxLimit?: number }) =>
@@ -100,7 +100,7 @@ export const t = {
   /** A request-query schema with string->scalar COERCION on. Query values always arrive as strings
    * (`?limit=20` -> `"20"`), so a plain `t.object({ limit: t.integer() })` in a `query` slot fails to
    * validate; use `t.query` and `t.integer()`/`t.number()`/`t.boolean()` fields become real numbers/
-   * booleans in `c.query`. **Open by default** (unknown query fields pass through — `additionalProperties:
+   * booleans in `c.query`. **Open by default** (unknown query fields pass through - `additionalProperties:
    * true`): query params are read by name, not spread into a DB write, so unknown params (UTM tracking,
    * `fbclid`, etc.) passing through is safe, and rejecting them is a production-only footgun (ad/social
    * traffic appends params your schema never declares, causing 422s that never appear in dev/CI). Pass