@earendil-works/pi-schema 0.0.0-stage → 0.0.0

package/CHANGELOG.md

@@ -0,0 +1,13 @@
+# Changelog
+
+## [Unreleased]
+
+### Added
+
+- Initial release: `compile(schema, options)` validates JSON Schema drafts 2020-12 and 7 without `eval` or `new Function`, compiling a schema once into plain closures. `Validator.check` is the boolean check (a type guard for schemas built with the builders), `Validator.errors` reports each failure with a JSON Pointer path. Format checks are in the optional `@earendil-works/pi-schema/formats` entry point.
+- Schema builders (`str`, `num`, `int`, `bool`, `nul`, `unknown`, `lit`, `oneOf`, `obj`, `opt`, `arr`, `tuple`, `map`, `union`, `nullable`, `bytes`) that return plain JSON Schema typed with the values it accepts (`Static<typeof schema>`).
+- `compile(schema, { coerce: true })` adds `coerce(value)` and `parse(value)` for loosely typed input such as a model's tool call arguments: optional `null`s dropped, TypeBox 1.3.27's `Value.Convert` rules keyed on JSON Schema keywords (numeric strings, `"true"`, single values to arrays, `const`/`enum` members, union branches), then Ajv-style primitive coercion by `type`. `coerce` copies only the paths it changes and returns the input itself when nothing changes; `parse` coerces, then checks. Validators compiled without the option have neither; the README lists every rule.
+- `Static` also types TypeBox-built schemas, from TypeBox 1.x's type shapes and without importing TypeBox: String, Number, Integer, Boolean, Null, Literal, Array, Object (with `Type.Optional` and `Type.Readonly` properties), Union, Record, Unsafe, Unknown and Any give TypeBox's static type; other TypeBox kinds give `unknown`.
+- `unresolvedRefs: "reject"` compiles a `$ref` that names nothing as `false` (the error is `unresolved reference <ref>`) instead of throwing, for schemas whose references may dangle.
+- `formats` also checks `url` and `json-pointer-uri-fragment`, as TypeBox and ajv-formats do.
+- `npm run bench` compares conformance, speed (with and without eval), setup cost, memory and bundle size with ata-validator (generated code and its interpreter), Ajv, Zod (native schemas, and `z.fromJSONSchema` for the test suite), TypeBox, @cfworker/json-schema and omptype.

package/LICENSES/typebox-LICENSE

@@ -0,0 +1,23 @@
+TypeBox
+
+The MIT License (MIT)
+
+Copyright (c) 2017-2026 Haydn Paterson
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in
+all copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
+THE SOFTWARE.

package/README.md

@@ -1,3 +1,296 @@
-# Temporary Holding Version
+# @earendil-works/pi-schema
 
-This version is a temporary placeholder for this package. An operational version to replace this has been submitted for review and is awaiting a staged release.
+JSON Schema builders and validation without `eval`. A schema compiles once into plain closures, so it checks values
+at close to the speed of validators that generate code, also under a strict Content Security Policy, and needs no
+dependencies.
+
+- Drafts 2020-12 and 7. Passes 2,222 of the 2,223 core tests of the official
+  [JSON-Schema-Test-Suite](https://github.com/json-schema-org/JSON-Schema-Test-Suite).
+- Builders return plain JSON Schema typed with the values it accepts; a compiled check narrows to that type.
+- Errors as JSON Pointer paths. A missing or unknown field is reported at the field.
+- Never modifies a schema; frozen schemas work.
+- 8.5 KB minified and gzipped. Format checks are an optional import.
+
+## Installation
+
+```bash
+npm install @earendil-works/pi-schema
+```
+
+## Usage
+
+```typescript
+import { compile, int, obj, oneOf, opt, type Static, str } from "@earendil-works/pi-schema";
+
+const Read = obj({
+	path: str({ description: "Path to the file", minLength: 1 }),
+	offset: opt(int({ minimum: 1 })),
+	mode: oneOf(["text", "binary"]),
+});
+type Read = Static<typeof Read>; // { path: string; mode: "text" | "binary"; offset?: number }
+
+const read = compile(Read);
+if (read.check(value)) value.path; // value: Read
+
+read.errors({ offset: 0, extra: true });
+// [
+//   { path: "/path", keyword: "required", message: "missing" },
+//   { path: "/mode", keyword: "required", message: "missing" },
+//   { path: "/offset", keyword: "minimum", message: "expected >= 1" },
+//   { path: "/extra", keyword: "additionalProperties", message: "unknown field" },
+// ]
+```
+
+`Read` is plain JSON Schema (`{ type: "object", properties: {...}, required: ["path", "mode"], additionalProperties:
+false }`), ready for a tool definition or `JSON.stringify`. `compile` takes any JSON Schema, built with the builders
+or not.
+
+`check(value)` is the fast path: a boolean, no allocations for most schemas, and a plain function you can pass
+around. `errors(value)` explains a failure and returns `[]` for a valid value. It is built on the first failure and
+kept, so a schema whose values always pass never pays for it.
+
+### Builders
+
+| builder | schema | type |
+|---|---|---|
+| `str({ minLength, maxLength, pattern, format })` | `{ type: "string", ... }` | `string` |
+| `num({ minimum, maximum, exclusiveMinimum, exclusiveMaximum, multipleOf })`, `int(...)` | `{ type: "number" }`, `{ type: "integer" }` | `number` |
+| `bool()`, `nul()`, `unknown()` | `{ type: "boolean" }`, `{ type: "null" }`, `{}` | `boolean`, `null`, `unknown` |
+| `lit(value)` | `{ const: value }` | the literal |
+| `oneOf(["a", "b"])` | `{ enum: [...] }` | `"a" \| "b"` |
+| `obj({ a: str(), b: opt(num()) }, { open })` | closed object; `open: true` allows other properties | `{ a: string; b?: number }` |
+| `arr(items, { minItems, maxItems, uniqueItems })` | `{ type: "array", items }` | `T[]` |
+| `tuple([str(), num()])` | `prefixItems`, no more items | `[string, number]` |
+| `map(value)` | `{ type: "object", additionalProperties: value }` | `Record<string, T>` |
+| `union([...])` | `{ anyOf: [...] }` | the union |
+| `nullable(schema)` | `{ anyOf: [schema, { type: "null" }] }` | `T \| null` |
+| `bytes({ minLength, maxLength })` | `{ type: "bytes", ... }` | `Uint8Array` |
+
+Every builder also takes `title`, `description`, `examples`, `deprecated` and `default`. A `default` is an annotation;
+validation never inserts it.
+
+A union of objects tagged by a `lit()` property checks and reports by the tag: only the branch the tag selects runs.
+
+```typescript
+const Block = union([obj({ kind: lit("text"), text: str() }), obj({ kind: lit("image"), width: int({ minimum: 0 }) })]);
+compile(Block).errors({ kind: "video" });
+// [{ path: "/kind", keyword: "anyOf", message: 'expected one of ["text","image"]' }]
+```
+
+`Static` also types schemas built with TypeBox 1.x, read from TypeBox's type shapes (pi-schema does not import
+TypeBox): `String`, `Number`, `Integer`, `Boolean`, `Null`, `Literal`, `Array`, `Object` (with `Type.Optional` and
+`Type.Readonly` properties), `Union`, `Record`, `Unsafe`, `Unknown` and `Any` give TypeBox's own static type, so
+`Static<typeof Type.Object({ path: Type.String() })>` is `{ path: string }`. Other TypeBox kinds (`Enum`, `Tuple`,
+`Intersect`, `Cyclic`, ...) give `unknown` where they stand. Other JSON Schema objects give `unknown`.
+
+### Options
+
+```typescript
+import { formats } from "@earendil-works/pi-schema/formats";
+
+const validator = compile(schema, {
+	draft: "7", // "2020-12" (default) or "7"
+	formats, // check `format`; without it `format` is an annotation, as 2020-12 specifies
+	schemas: { "https://example.com/point.json": point }, // documents for $refs to other documents, by URI
+	unresolvedRefs: "reject", // a $ref that names nothing rejects values at its place; default "throw"
+	coerce: true, // adds coerce() and parse(), see Coercion
+});
+```
+
+`formats` has every format 2020-12 defines (`date-time`, `email`, `uri`, `uuid`, `ipv6`, ...), plus `url` and
+`json-pointer-uri-fragment`, which TypeBox and ajv-formats also check. Pass your own map to check fewer formats, or
+custom ones.
+
+A `$ref` that names nothing (a missing definition, a document not in `schemas`) throws when the schema compiles. With
+`unresolvedRefs: "reject"` it compiles as `false` instead: only values at that place fail, with the error
+`unresolved reference <ref>`, and the rest of the schema works. Use it for schemas from other systems, such as MCP
+servers, whose references may dangle.
+
+### TypeBox schemas
+
+TypeBox 1.x schemas are JSON Schema, so they compile as they are:
+
+```typescript
+import Type from "typebox";
+
+const user = compile(Type.Object({ name: Type.String(), tags: Type.Array(Type.String()) }));
+```
+
+TypeBox's JavaScript-only types (`BigInt`, `Undefined`, `Function`, ...), refinements and codecs are not JSON Schema
+and are not supported.
+
+### Coercion
+
+`compile(schema, { coerce: true })` adds `coerce()` and `parse()`, for loosely typed input such as a model's tool call
+arguments. Without the option the validator has neither, and its `check` pays nothing for them: the coercion rules are
+built on the first `coerce()` or `parse()`.
+
+```typescript
+const read = compile(Read, { coerce: true });
+
+read.coerce({ path: "a.txt", offset: "10", mode: "text" }); // { path: "a.txt", offset: 10, mode: "text" }
+
+const result = read.parse({ path: "a.txt", offset: "ten", mode: "text" });
+if (result.ok) result.value.offset; // number
+else result.errors; // [{ path: "/offset", keyword: "type", message: "expected integer, got string" }]
+```
+
+`coerce(value)` returns the coerced value. It copies only the paths it changes, returns `value` itself when nothing
+changes, and never modifies `value`. A value no rule applies to stays as it is. `parse(value)` coerces, then checks:
+`{ ok: true, value }` with the coerced value, or `{ ok: false, errors }` with the errors of the coerced value.
+
+Three passes run in order:
+
+1. **Optional nulls.** A `null` in an optional property whose schema rejects `null` is dropped, as if omitted.
+2. **Conversions**, ported from TypeBox 1.3.27's `Value.Convert` and keyed on JSON Schema keywords (the first that
+   applies to a schema): `$ref` follows the reference; `const` and `enum` take the member the value converts to;
+   `anyOf`/`oneOf` keep a value one branch accepts, else take the first branch's conversion the whole schema
+   accepts; `allOf` converts with each member in turn; then by `type`:
+   - `string`: numbers and booleans to their text, `null` to `"null"`.
+   - `number`: numeric strings (`""` is 0), `"true"`/`"false"`, booleans to 1/0, `null` to 0.
+   - `integer`: as `number`, then truncated (`"3.5"` and `3.5` become 3).
+   - `boolean`: `"true"`/`"false"` (any case), `"1"`/`"0"`, 1/0, `null` to `false`.
+   - `null`: `"null"`, `"undefined"`, `""`, `"0"`, 0 and `false`.
+   - `array`: a single value becomes a one-item array, then each item converts; a tuple (`prefixItems` or an `items`
+     array) converts its items and never wraps.
+   - `object`: each property converts by `properties`, `patternProperties` or `additionalProperties`.
+3. **Primitive coercion by type**, as Ajv's `coerceTypes`, for what pass 2 leaves (type arrays such as
+   `["integer", "null"]`): numbers from numeric strings and booleans, booleans from `"true"`/`"false"` and 1/0,
+   strings from numbers and booleans, `null` from `""`, 0 and `false`, and `null` to `""`, 0 or `false`. A value that
+   already has one of a type array's types stays.
+
+Where passes 2 and 3 disagree, pass 2 wins: `null` for a required string becomes `"null"`, not `""`. A union's
+branches convert in order and only until one is accepted; a union node that also declares properties converts them into
+each branch's candidate before checking it. A recursive schema (a tree through `$ref`) that meets a value it cannot
+convert leaves the value as it is, so `check` reports it, and results through a `$ref` are reused within one call, so a
+recursive union does not convert (or explain) the same child once per branch.
+
+Pass 1 drops optional nulls inside the values of `properties`, `patternProperties` and `additionalProperties` alike; a
+pattern or additional key itself is never dropped. Items past a draft-7 `items` array (`additionalItems`) are not
+coerced by any pass.
+
+### Values
+
+- A property whose value is `undefined` counts as absent, as in TypeBox.
+- `{ type: "bytes", minLength, maxLength }` matches a `Uint8Array` of that length, an extension for values that never
+  pass through JSON.
+
+## Supported keywords
+
+- Every validation keyword of drafts 2020-12 and 7, including draft 7's `dependencies` and `items` arrays with
+  `additionalItems`.
+- `$id`, `$anchor`, `$ref` (local, by anchor, relative and remote), `$dynamicRef` and `$dynamicAnchor`.
+- `unevaluatedProperties` and `unevaluatedItems`.
+- `pattern` and `patternProperties` are ECMAScript regular expressions with the `u` flag.
+- Not supported: meta-schemas that switch vocabularies on or off (`$vocabulary`), `contentMediaType` and
+  `contentEncoding` assertions (optional in the spec), and draft 2019-09's `$recursiveRef`.
+
+## Benchmarks
+
+Node 24.4.1 on one core of an i9-13900. The other libraries:
+
+- ata-validator 1.61.3: its generated code, and its eval-free interpreter chosen with `engine: "interpreter"`;
+- Ajv 8.20.0, with ajv-formats 3.0.1 for the format tests;
+- Zod 4.6.7: native Zod schemas for speed, setup and memory, and `z.fromJSONSchema` for the test suite;
+- TypeBox 1.3.27;
+- @cfworker/json-schema 4.1.1;
+- @oh-my-pi/omptype 18.13.3, through `fromJsonSchema`.
+
+| test suite (tests passed) | pi-schema | ata | ata interpreter | Ajv | Zod | TypeBox | cfworker | omptype |
+|---|---:|---:|---:|---:|---:|---:|---:|---:|
+| draft 2020-12 core (1,298) | 1,297 | 1,298 | 1,298 | 1,236 | 693 | 1,276 | 1,249 | 863 |
+| draft 7 core (925) | 925 | 925 | 925 | 917 | 632 | 924 | 918 | 659 |
+| draft 2020-12 format (895), with format checks | 895 | 814 | 814 | 750 | 412 | 895 | 740 | 412 |
+
+| check, valid value | pi-schema | ata | ata interpreter | Ajv | Zod | TypeBox | cfworker | omptype |
+|---|---:|---:|---:|---:|---:|---:|---:|---:|
+| nested object with tagged unions | 410 ns | 180 ns | 836 ns | 627 ns | 1.3 µs | 475 ns | 43 µs | 730 ns |
+| union of 5 messages | 86 ns | 37 ns | 212 ns | 70 ns | 297 ns | 95 ns | 11 µs | 96 ns |
+| tool schema (read) | 31 ns | 10 ns | 41 ns | 13 ns | 41 ns | 9 ns | 2.0 µs | 9 ns |
+| MCP tool schema with `$ref` | 161 ns | 64 ns | 314 ns | 136 ns | 927 ns | 87 ns | 15 µs | 1.9 µs |
+| recursive `$ref` schema | 755 ns | 307 ns | 1.9 µs | 378 ns | 2.7 µs | 1.2 µs | 41 µs | 7.5 µs |
+
+| same, without eval (strict CSP) | pi-schema | ata | ata interpreter | Ajv | Zod | TypeBox | cfworker | omptype |
+|---|---:|---:|---:|---:|---:|---:|---:|---:|
+| nested object with tagged unions | 411 ns | 1.6 µs | 844 ns | fails | 3.4 µs | 44 µs | 44 µs | 2.7 µs |
+| union of 5 messages | 87 ns | 396 ns | 209 ns | fails | 652 ns | 10 µs | 11 µs | 501 ns |
+| MCP tool schema with `$ref` | 164 ns | 484 ns | 326 ns | fails | 2.0 µs | 39 µs | 13 µs | 2.2 µs |
+| recursive `$ref` schema | 746 ns | 2.8 µs | 1.9 µs | fails | 7.3 µs | 130 µs | 42 µs | 9.0 µs |
+
+| cost | pi-schema | ata | ata interpreter | Ajv | Zod | TypeBox | cfworker | omptype |
+|---|---:|---:|---:|---:|---:|---:|---:|---:|
+| compile a new schema | 20 µs | 4.9 µs | 1.3 µs | 1.4 ms | 151 µs | 210 µs | 22 µs | 28 µs |
+| its first check | 0.8 µs | 335 µs | 87 µs | 195 µs | 466 µs | 41 µs | 7.1 µs | 109 µs |
+| memory, 3,200 distinct schemas | 7.1 MB | 36.0 MB | 51.3 MB | 59.7 MB | 170.8 MB | 54.7 MB | 7.6 MB | 19.9 MB |
+| bundle, minified + gzip | 8.5 KB | 134.0 KB | 134.0 KB | 39.7 KB | 24.4 KB | 35.2 KB | 5.8 KB | 38.8 KB |
+
+Where code generation is unavailable:
+
+- **ata** answers through its interpreted engine without being told. That automatic fallback measured slower than the
+  engine chosen with `engine: "interpreter"`.
+- **Ajv** cannot compile at all: `compile()` throws `EvalError`.
+- **Zod** notices and parses objects without its generated code.
+- **TypeBox** falls back to its interpreter.
+- **omptype** throws `EvalError` once per schema, then validates through its interpreter.
+
+ata, Zod and omptype compile on a schema's first check, so their compile cost shows there. ata's bundle is for the
+browser without code splitting; with splitting, its first load is about 53 KB plus a 76 KB generator chunk loaded
+later.
+
+Zod is not a JSON Schema validator:
+
+- **Speed, setup and memory:** Zod gets the same schemas written as native Zod schemas (`z.strictObject`,
+  `z.discriminatedUnion`, `z.lazy`), with `.describe()` for the corpus descriptions, and `safeParse` as the check.
+  Its memory includes building the schemas, which the other libraries receive as JSON. Without the descriptions it
+  is 131 MB.
+- **Test suite:** through `z.fromJSONSchema`, which is semi-experimental. It refuses `unevaluatedProperties`,
+  `unevaluatedItems`, `dependentSchemas`, `dependentRequired`, `if`/`then`/`else`, `not`, and every `$ref` that is
+  not local. A refused schema fails all its tests: 405 of the 1,298 draft 2020-12 core tests and 107 of the 925 draft
+  7 core tests.
+- **Bundle:** measured with Zod's documented `import * as z from "zod"`. A named `import { z }` keeps every locale
+  (about 90 KB gzipped), and `z.fromJSONSchema` brings it to 40.0 KB; `zod/mini` is about 6 KB.
+
+Flat objects of simple types check in 13–80 ns, against 7–15 ns for TypeBox. Without code generation, reading a
+property whose name comes from a list costs a few nanoseconds.
+
+### Reproduce
+
+`npm run bench` in `packages/schema` takes about 12 minutes. It runs every library through its fastest boolean path
+(ata's `isValidObject()`) and keeps the object each returns. ata runs with `ATA_NO_NATIVE=1`: its optional native
+addon only serves its buffer APIs. The scripts are in `test/bench/`.
+
+- **Conformance:** every library on the vendored test suite, with the remote documents and meta-schemas the tests
+  reference (Zod through `z.fromJSONSchema`, which takes no remote documents). ata reads the draft only from `$schema`, so draft 7 schemas without one get it declared. ata's defaults
+  (`useDefaults`, `assertFormat`) are turned off to match the other libraries; formats are checked only in the
+  format tests, by each library's own checks.
+- **Speed:** realistic schemas, in ns per check after warm-up. Each result is the median of 15 rounds, with the
+  libraries' order rotated in each round.
+- **Speed without eval:** the same, run with `--disallow-code-generation-from-strings`.
+- **Setup:** compiling 1,000 schemas a library has not seen, and their first checks.
+- **Memory:** 3,200 distinct tool-like schemas, compiled and each checked 3 times, each library in its own process.
+- **Size:** esbuild browser bundles of what a validator needs, minified and gzipped.
+
+### Code generated at build time
+
+Ajv (`ajv/dist/standalone`) and ata (`ata build`, `ata compile`, `toStandaloneModule()`) can also generate their
+validation code when the app is built. The app then imports plain modules and evaluates nothing at run time, so those
+checks run at code-generation speed under a strict CSP. This is not in the benchmark, because it is a different
+deal:
+
+- **A build step per schema.** Every schema must be known when the app is built. Schemas that arrive at run time
+  (MCP servers, extensions, user input) cannot be validated this way.
+- **Code per schema.** In a separate measurement on the same 3,200 schemas:
+  - Ajv: 1.8 ms to build and 8.9 KB of JavaScript per schema;
+  - ata: 1.1 ms and 13 KB per schema, or 0.3–0.8 KB gzipped when only its `isValid` export is bundled;
+  - importing all 3,200 generated validators took 40 MB of heap (Ajv, one module) and 68 MB (ata, one module per
+    schema).
+
+pi-schema compiles at run time in 25 µs per schema, generates no code, and covers schemas known at build time and
+schemas that arrive later.
+
+## Development
+
+`npm test` runs the official test suite (drafts 2020-12 and 7, including the optional and format tests, vendored in
+`test/fixtures/`) and the package's own tests.
+
+The format checks are adapted from TypeBox 1.3.27 (MIT); its license is in `LICENSES/`.

package/dist/annotations.d.ts

@@ -0,0 +1,44 @@
+import type { Check } from "./types.ts";
+/** What a schema evaluated: property names (or all of them), the evaluated item prefix, items matched by `contains`. */
+export interface Annotations {
+    props: Set<string> | null;
+    allProps: boolean;
+    items: number;
+    allItems: boolean;
+    indexes: Set<number> | null;
+}
+/** A check that records what it evaluated into `a` when it passes. */
+export type AnnotatingCheck = (value: unknown, a: Annotations) => boolean;
+/** Empty annotations. */
+export declare function newAnnotations(): Annotations;
+export declare const ANNOTATING_TRUE: AnnotatingCheck;
+export declare const ANNOTATING_FALSE: AnnotatingCheck;
+/** The indirection a recursive reference goes through. */
+export declare function indirectAnnotating(slot: {
+    check: AnnotatingCheck | undefined;
+}): AnnotatingCheck;
+/** A plain check in annotating position: it evaluates nothing that unevaluated* sees. */
+export declare function ignoreAnnotations(check: Check): AnnotatingCheck;
+/** An annotating check run as a plain check, with fresh annotations. */
+export declare function withFreshAnnotations(check: AnnotatingCheck): Check;
+/** `check` with `uri` pushed onto the dynamic scope while it runs. */
+export declare function scopedAnnotating(scope: string[], uri: string, check: AnnotatingCheck): AnnotatingCheck;
+/** unevaluated* sees only the annotations of its own schema, never those of its siblings in the parent. */
+export declare function isolateAnnotations(check: AnnotatingCheck): AnnotatingCheck;
+/** The non-annotating keywords, then each annotating part in order. */
+export declare function annotateAll(plain: Check, parts: readonly AnnotatingCheck[]): AnnotatingCheck;
+/** `properties`, `patternProperties` and `additionalProperties`. */
+export declare function annotateObject(props: readonly (readonly [string, Check])[], patterns: readonly (readonly [RegExp, Check])[], additional: Check | undefined): AnnotatingCheck;
+/** `prefixItems`/`items`/`additionalItems` and `contains` with its bounds. */
+export declare function annotateArray(prefix: readonly Check[], rest: Check | undefined, contains: Check | undefined, minContains: number, maxContains: number): AnnotatingCheck;
+/** `anyOf` (or `oneOf` when `exactlyOne`): every passing branch contributes its annotations. */
+export declare function annotateAny(branches: readonly AnnotatingCheck[], exactlyOne: boolean): AnnotatingCheck;
+/** `if`, `then` and `else`: a passing `if` contributes its annotations even without `then`. */
+export declare function annotateIf(cond: AnnotatingCheck, then: AnnotatingCheck | undefined, otherwise: AnnotatingCheck | undefined): AnnotatingCheck;
+/** One `dependentSchemas` entry. */
+export declare function annotateDependent(key: string, check: AnnotatingCheck): AnnotatingCheck;
+/** `unevaluatedProperties`: every property no other keyword evaluated passes `check`. */
+export declare function unevaluatedProperties(check: Check): AnnotatingCheck;
+/** `unevaluatedItems`: every item no other keyword evaluated passes `check`. */
+export declare function unevaluatedItems(check: Check): AnnotatingCheck;
+//# sourceMappingURL=annotations.d.ts.map

package/dist/annotations.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"annotations.d.ts","sourceRoot":"","sources":["../src/annotations.ts"],"names":[],"mappings":"AAIA,OAAO,KAAK,EAAE,KAAK,EAAE,MAAM,YAAY,CAAC;AAExC,wHAAwH;AACxH,MAAM,WAAW,WAAW;IAC3B,KAAK,EAAE,GAAG,CAAC,MAAM,CAAC,GAAG,IAAI,CAAC;IAC1B,QAAQ,EAAE,OAAO,CAAC;IAClB,KAAK,EAAE,MAAM,CAAC;IACd,QAAQ,EAAE,OAAO,CAAC;IAClB,OAAO,EAAE,GAAG,CAAC,MAAM,CAAC,GAAG,IAAI,CAAC;CAC5B;AAED,sEAAsE;AACtE,MAAM,MAAM,eAAe,GAAG,CAAC,KAAK,EAAE,OAAO,EAAE,CAAC,EAAE,WAAW,KAAK,OAAO,CAAC;AAE1E,yBAAyB;AACzB,wBAAgB,cAAc,IAAI,WAAW,CAE5C;AAoBD,eAAO,MAAM,eAAe,EAAE,eAA4B,CAAC;AAC3D,eAAO,MAAM,gBAAgB,EAAE,eAA6B,CAAC;AAE7D,0DAA0D;AAC1D,wBAAgB,kBAAkB,CAAC,IAAI,EAAE;IAAE,KAAK,EAAE,eAAe,GAAG,SAAS,CAAA;CAAE,GAAG,eAAe,CAEhG;AAED,yFAAyF;AACzF,wBAAgB,iBAAiB,CAAC,KAAK,EAAE,KAAK,GAAG,eAAe,CAE/D;AAED,wEAAwE;AACxE,wBAAgB,oBAAoB,CAAC,KAAK,EAAE,eAAe,GAAG,KAAK,CAElE;AAED,sEAAsE;AACtE,wBAAgB,gBAAgB,CAAC,KAAK,EAAE,MAAM,EAAE,EAAE,GAAG,EAAE,MAAM,EAAE,KAAK,EAAE,eAAe,GAAG,eAAe,CAOtG;AAED,2GAA2G;AAC3G,wBAAgB,kBAAkB,CAAC,KAAK,EAAE,eAAe,GAAG,eAAe,CAO1E;AAED,uEAAuE;AACvE,wBAAgB,WAAW,CAAC,KAAK,EAAE,KAAK,EAAE,KAAK,EAAE,SAAS,eAAe,EAAE,GAAG,eAAe,CAM5F;AAED,oEAAoE;AACpE,wBAAgB,cAAc,CAC7B,KAAK,EAAE,SAAS,CAAC,SAAS,CAAC,MAAM,EAAE,KAAK,CAAC,CAAC,EAAE,EAC5C,QAAQ,EAAE,SAAS,CAAC,SAAS,CAAC,MAAM,EAAE,KAAK,CAAC,CAAC,EAAE,EAC/C,UAAU,EAAE,KAAK,GAAG,SAAS,GAC3B,eAAe,CA2BjB;AAED,8EAA8E;AAC9E,wBAAgB,aAAa,CAC5B,MAAM,EAAE,SAAS,KAAK,EAAE,EACxB,IAAI,EAAE,KAAK,GAAG,SAAS,EACvB,QAAQ,EAAE,KAAK,GAAG,SAAS,EAC3B,WAAW,EAAE,MAAM,EACnB,WAAW,EAAE,MAAM,GACjB,eAAe,CAsBjB;AAED,gGAAgG;AAChG,wBAAgB,WAAW,CAAC,QAAQ,EAAE,SAAS,eAAe,EAAE,EAAE,UAAU,EAAE,OAAO,GAAG,eAAe,CAYtG;AAED,+FAA+F;AAC/F,wBAAgB,UAAU,CACzB,IAAI,EAAE,eAAe,EACrB,IAAI,EAAE,eAAe,GAAG,SAAS,EACjC,SAAS,EAAE,eAAe,GAAG,SAAS,GACpC,eAAe,CASjB;AAED,oCAAoC;AACpC,wBAAgB,iBAAiB,CAAC,GAAG,EAAE,MAAM,EAAE,KAAK,EAAE,eAAe,GAAG,eAAe,CAEtF;AAED,yFAAyF;AACzF,wBAAgB,qBAAqB,CAAC,KAAK,EAAE,KAAK,GAAG,eAAe,CAOnE;AAED,gFAAgF;AAChF,wBAAgB,gBAAgB,CAAC,KAAK,EAAE,KAAK,GAAG,eAAe,CAO9D"}

package/dist/annotations.js

@@ -0,0 +1,193 @@
+// Annotation tracking for `unevaluatedProperties` and `unevaluatedItems`: annotating checks record which
+// properties and items a schema evaluated. Only schemas that use those keywords compile into these closures.
+import { isObject } from "./checks.js";
+/** Empty annotations. */
+export function newAnnotations() {
+    return { props: null, allProps: false, items: 0, allItems: false, indexes: null };
+}
+function merge(a, b) {
+    if (b.props !== null)
+        for (const k of b.props)
+            addProp(a, k);
+    a.allProps ||= b.allProps;
+    if (b.items > a.items)
+        a.items = b.items;
+    a.allItems ||= b.allItems;
+    if (b.indexes !== null)
+        for (const i of b.indexes)
+            addIndex(a, i);
+}
+function addProp(a, key) {
+    if (a.props === null)
+        a.props = new Set();
+    a.props.add(key);
+}
+function addIndex(a, index) {
+    if (a.indexes === null)
+        a.indexes = new Set();
+    a.indexes.add(index);
+}
+export const ANNOTATING_TRUE = () => true;
+export const ANNOTATING_FALSE = () => false;
+/** The indirection a recursive reference goes through. */
+export function indirectAnnotating(slot) {
+    return (v, a) => slot.check(v, a);
+}
+/** A plain check in annotating position: it evaluates nothing that unevaluated* sees. */
+export function ignoreAnnotations(check) {
+    return (v) => check(v);
+}
+/** An annotating check run as a plain check, with fresh annotations. */
+export function withFreshAnnotations(check) {
+    return (v) => check(v, newAnnotations());
+}
+/** `check` with `uri` pushed onto the dynamic scope while it runs. */
+export function scopedAnnotating(scope, uri, check) {
+    return (v, a) => {
+        scope.push(uri);
+        const ok = check(v, a);
+        scope.pop();
+        return ok;
+    };
+}
+/** unevaluated* sees only the annotations of its own schema, never those of its siblings in the parent. */
+export function isolateAnnotations(check) {
+    return (v, a) => {
+        const b = newAnnotations();
+        if (!check(v, b))
+            return false;
+        merge(a, b);
+        return true;
+    };
+}
+/** The non-annotating keywords, then each annotating part in order. */
+export function annotateAll(plain, parts) {
+    return (v, a) => {
+        if (!plain(v))
+            return false;
+        for (let i = 0; i < parts.length; i++)
+            if (!parts[i](v, a))
+                return false;
+        return true;
+    };
+}
+/** `properties`, `patternProperties` and `additionalProperties`. */
+export function annotateObject(props, patterns, additional) {
+    const declared = new Set(props.map(([k]) => k));
+    return (v, a) => {
+        if (!isObject(v))
+            return true;
+        const seen = [];
+        for (const [k, check] of props) {
+            if (!Object.hasOwn(v, k))
+                continue;
+            if (!check(v[k]))
+                return false;
+            seen.push(k);
+        }
+        for (const k of Object.keys(v)) {
+            let matched = declared.has(k);
+            for (const [re, check] of patterns) {
+                if (re.test(k)) {
+                    if (!check(v[k]))
+                        return false;
+                    matched = true;
+                    seen.push(k);
+                }
+            }
+            if (!matched && additional !== undefined) {
+                if (!additional(v[k]))
+                    return false;
+                seen.push(k);
+            }
+        }
+        for (const k of seen)
+            addProp(a, k);
+        return true;
+    };
+}
+/** `prefixItems`/`items`/`additionalItems` and `contains` with its bounds. */
+export function annotateArray(prefix, rest, contains, minContains, maxContains) {
+    return (v, a) => {
+        if (!Array.isArray(v))
+            return true;
+        const m = Math.min(v.length, prefix.length);
+        for (let i = 0; i < m; i++)
+            if (!prefix[i](v[i]))
+                return false;
+        if (rest !== undefined) {
+            for (let i = prefix.length; i < v.length; i++)
+                if (!rest(v[i]))
+                    return false;
+            a.allItems = true;
+        }
+        if (m > a.items)
+            a.items = m;
+        if (contains !== undefined) {
+            let n = 0;
+            for (let i = 0; i < v.length; i++) {
+                if (contains(v[i])) {
+                    n++;
+                    addIndex(a, i);
+                }
+            }
+            if (n < minContains || n > maxContains)
+                return false;
+        }
+        return true;
+    };
+}
+/** `anyOf` (or `oneOf` when `exactlyOne`): every passing branch contributes its annotations. */
+export function annotateAny(branches, exactlyOne) {
+    return (v, a) => {
+        let n = 0;
+        for (const branch of branches) {
+            const b = newAnnotations();
+            if (branch(v, b)) {
+                n++;
+                merge(a, b);
+            }
+        }
+        return exactlyOne ? n === 1 : n > 0;
+    };
+}
+/** `if`, `then` and `else`: a passing `if` contributes its annotations even without `then`. */
+export function annotateIf(cond, then, otherwise) {
+    return (v, a) => {
+        const b = newAnnotations();
+        if (cond(v, b)) {
+            merge(a, b);
+            return then === undefined || then(v, a);
+        }
+        return otherwise === undefined || otherwise(v, a);
+    };
+}
+/** One `dependentSchemas` entry. */
+export function annotateDependent(key, check) {
+    return (v, a) => !isObject(v) || !Object.hasOwn(v, key) || check(v, a);
+}
+/** `unevaluatedProperties`: every property no other keyword evaluated passes `check`. */
+export function unevaluatedProperties(check) {
+    return (v, a) => {
+        if (!isObject(v) || a.allProps)
+            return true;
+        for (const k of Object.keys(v))
+            if (!(a.props?.has(k) ?? false) && !check(v[k]))
+                return false;
+        a.allProps = true;
+        return true;
+    };
+}
+/** `unevaluatedItems`: every item no other keyword evaluated passes `check`. */
+export function unevaluatedItems(check) {
+    return (v, a) => {
+        if (!Array.isArray(v) || a.allItems)
+            return true;
+        for (let i = a.items; i < v.length; i++)
+            if (!(a.indexes?.has(i) ?? false) && !check(v[i]))
+                return false;
+        a.allItems = true;
+        return true;
+    };
+}
+//# sourceMappingURL=annotations.js.map

package/dist/annotations.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"annotations.js","sourceRoot":"","sources":["../src/annotations.ts"],"names":[],"mappings":"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","sourcesContent":["// Annotation tracking for `unevaluatedProperties` and `unevaluatedItems`: annotating checks record which\n// properties and items a schema evaluated. Only schemas that use those keywords compile into these closures.\n\nimport { isObject } from \"./checks.ts\";\nimport type { Check } from \"./types.ts\";\n\n/** What a schema evaluated: property names (or all of them), the evaluated item prefix, items matched by `contains`. */\nexport interface Annotations {\n\tprops: Set<string> | null;\n\tallProps: boolean;\n\titems: number;\n\tallItems: boolean;\n\tindexes: Set<number> | null;\n}\n\n/** A check that records what it evaluated into `a` when it passes. */\nexport type AnnotatingCheck = (value: unknown, a: Annotations) => boolean;\n\n/** Empty annotations. */\nexport function newAnnotations(): Annotations {\n\treturn { props: null, allProps: false, items: 0, allItems: false, indexes: null };\n}\n\nfunction merge(a: Annotations, b: Annotations): void {\n\tif (b.props !== null) for (const k of b.props) addProp(a, k);\n\ta.allProps ||= b.allProps;\n\tif (b.items > a.items) a.items = b.items;\n\ta.allItems ||= b.allItems;\n\tif (b.indexes !== null) for (const i of b.indexes) addIndex(a, i);\n}\n\nfunction addProp(a: Annotations, key: string): void {\n\tif (a.props === null) a.props = new Set();\n\ta.props.add(key);\n}\n\nfunction addIndex(a: Annotations, index: number): void {\n\tif (a.indexes === null) a.indexes = new Set();\n\ta.indexes.add(index);\n}\n\nexport const ANNOTATING_TRUE: AnnotatingCheck = () => true;\nexport const ANNOTATING_FALSE: AnnotatingCheck = () => false;\n\n/** The indirection a recursive reference goes through. */\nexport function indirectAnnotating(slot: { check: AnnotatingCheck | undefined }): AnnotatingCheck {\n\treturn (v, a) => (slot.check as AnnotatingCheck)(v, a);\n}\n\n/** A plain check in annotating position: it evaluates nothing that unevaluated* sees. */\nexport function ignoreAnnotations(check: Check): AnnotatingCheck {\n\treturn (v) => check(v);\n}\n\n/** An annotating check run as a plain check, with fresh annotations. */\nexport function withFreshAnnotations(check: AnnotatingCheck): Check {\n\treturn (v) => check(v, newAnnotations());\n}\n\n/** `check` with `uri` pushed onto the dynamic scope while it runs. */\nexport function scopedAnnotating(scope: string[], uri: string, check: AnnotatingCheck): AnnotatingCheck {\n\treturn (v, a) => {\n\t\tscope.push(uri);\n\t\tconst ok = check(v, a);\n\t\tscope.pop();\n\t\treturn ok;\n\t};\n}\n\n/** unevaluated* sees only the annotations of its own schema, never those of its siblings in the parent. */\nexport function isolateAnnotations(check: AnnotatingCheck): AnnotatingCheck {\n\treturn (v, a) => {\n\t\tconst b = newAnnotations();\n\t\tif (!check(v, b)) return false;\n\t\tmerge(a, b);\n\t\treturn true;\n\t};\n}\n\n/** The non-annotating keywords, then each annotating part in order. */\nexport function annotateAll(plain: Check, parts: readonly AnnotatingCheck[]): AnnotatingCheck {\n\treturn (v, a) => {\n\t\tif (!plain(v)) return false;\n\t\tfor (let i = 0; i < parts.length; i++) if (!parts[i](v, a)) return false;\n\t\treturn true;\n\t};\n}\n\n/** `properties`, `patternProperties` and `additionalProperties`. */\nexport function annotateObject(\n\tprops: readonly (readonly [string, Check])[],\n\tpatterns: readonly (readonly [RegExp, Check])[],\n\tadditional: Check | undefined,\n): AnnotatingCheck {\n\tconst declared = new Set(props.map(([k]) => k));\n\treturn (v, a) => {\n\t\tif (!isObject(v)) return true;\n\t\tconst seen: string[] = [];\n\t\tfor (const [k, check] of props) {\n\t\t\tif (!Object.hasOwn(v, k)) continue;\n\t\t\tif (!check(v[k])) return false;\n\t\t\tseen.push(k);\n\t\t}\n\t\tfor (const k of Object.keys(v)) {\n\t\t\tlet matched = declared.has(k);\n\t\t\tfor (const [re, check] of patterns) {\n\t\t\t\tif (re.test(k)) {\n\t\t\t\t\tif (!check(v[k])) return false;\n\t\t\t\t\tmatched = true;\n\t\t\t\t\tseen.push(k);\n\t\t\t\t}\n\t\t\t}\n\t\t\tif (!matched && additional !== undefined) {\n\t\t\t\tif (!additional(v[k])) return false;\n\t\t\t\tseen.push(k);\n\t\t\t}\n\t\t}\n\t\tfor (const k of seen) addProp(a, k);\n\t\treturn true;\n\t};\n}\n\n/** `prefixItems`/`items`/`additionalItems` and `contains` with its bounds. */\nexport function annotateArray(\n\tprefix: readonly Check[],\n\trest: Check | undefined,\n\tcontains: Check | undefined,\n\tminContains: number,\n\tmaxContains: number,\n): AnnotatingCheck {\n\treturn (v, a) => {\n\t\tif (!Array.isArray(v)) return true;\n\t\tconst m = Math.min(v.length, prefix.length);\n\t\tfor (let i = 0; i < m; i++) if (!prefix[i](v[i])) return false;\n\t\tif (rest !== undefined) {\n\t\t\tfor (let i = prefix.length; i < v.length; i++) if (!rest(v[i])) return false;\n\t\t\ta.allItems = true;\n\t\t}\n\t\tif (m > a.items) a.items = m;\n\t\tif (contains !== undefined) {\n\t\t\tlet n = 0;\n\t\t\tfor (let i = 0; i < v.length; i++) {\n\t\t\t\tif (contains(v[i])) {\n\t\t\t\t\tn++;\n\t\t\t\t\taddIndex(a, i);\n\t\t\t\t}\n\t\t\t}\n\t\t\tif (n < minContains || n > maxContains) return false;\n\t\t}\n\t\treturn true;\n\t};\n}\n\n/** `anyOf` (or `oneOf` when `exactlyOne`): every passing branch contributes its annotations. */\nexport function annotateAny(branches: readonly AnnotatingCheck[], exactlyOne: boolean): AnnotatingCheck {\n\treturn (v, a) => {\n\t\tlet n = 0;\n\t\tfor (const branch of branches) {\n\t\t\tconst b = newAnnotations();\n\t\t\tif (branch(v, b)) {\n\t\t\t\tn++;\n\t\t\t\tmerge(a, b);\n\t\t\t}\n\t\t}\n\t\treturn exactlyOne ? n === 1 : n > 0;\n\t};\n}\n\n/** `if`, `then` and `else`: a passing `if` contributes its annotations even without `then`. */\nexport function annotateIf(\n\tcond: AnnotatingCheck,\n\tthen: AnnotatingCheck | undefined,\n\totherwise: AnnotatingCheck | undefined,\n): AnnotatingCheck {\n\treturn (v, a) => {\n\t\tconst b = newAnnotations();\n\t\tif (cond(v, b)) {\n\t\t\tmerge(a, b);\n\t\t\treturn then === undefined || then(v, a);\n\t\t}\n\t\treturn otherwise === undefined || otherwise(v, a);\n\t};\n}\n\n/** One `dependentSchemas` entry. */\nexport function annotateDependent(key: string, check: AnnotatingCheck): AnnotatingCheck {\n\treturn (v, a) => !isObject(v) || !Object.hasOwn(v, key) || check(v, a);\n}\n\n/** `unevaluatedProperties`: every property no other keyword evaluated passes `check`. */\nexport function unevaluatedProperties(check: Check): AnnotatingCheck {\n\treturn (v, a) => {\n\t\tif (!isObject(v) || a.allProps) return true;\n\t\tfor (const k of Object.keys(v)) if (!(a.props?.has(k) ?? false) && !check(v[k])) return false;\n\t\ta.allProps = true;\n\t\treturn true;\n\t};\n}\n\n/** `unevaluatedItems`: every item no other keyword evaluated passes `check`. */\nexport function unevaluatedItems(check: Check): AnnotatingCheck {\n\treturn (v, a) => {\n\t\tif (!Array.isArray(v) || a.allItems) return true;\n\t\tfor (let i = a.items; i < v.length; i++) if (!(a.indexes?.has(i) ?? false) && !check(v[i])) return false;\n\t\ta.allItems = true;\n\t\treturn true;\n\t};\n}\n"]}