bantamkit-mcp 0.35.6 → 0.35.8

package/dist/pyjsonschema.js

@@ -1,5 +1,5 @@
 /**
- * The `jsonschema` seam: `Draft202012Validator.iter_errors` + `exceptions.best_match`.
+ * The `jsonschema` seam: `validator_for(schema)(schema).iter_errors` + `exceptions.best_match`.
  *
  * WHY THIS IS NOT AJV — measured, not assumed. Over the 288-case corpus in
  * `tools/conformance/suites/validate.mjs`, ajv 8.20.0 and jsonschema 4.26.0 agree on
@@ -14,14 +14,41 @@
  * costs a runtime dependency; the whole keyword vocabulary is 286 lines of Python
  * (`jsonschema/_keywords.py`), which is smaller than the translation layer would be.
  *
- * WHAT IS IMPLEMENTED. Draft 2020-12, which is the checkpoint schema's dialect and also
- * jsonschema's default for a schema with no `$schema` — the shape `validate_json` receives.
- * 30 of the 36 keywords in `Draft202012Validator.VALIDATORS`. The other six RAISE rather
- * than answer plausibly: `$ref` and `$dynamicRef` need a reference resolver,
- * `unevaluatedItems`/`unevaluatedProperties` need annotation collection, and neither appears
- * anywhere in the asset pack (measured: `assets/**\/*.json`). `format` is implemented as the
- * no-op it is — `jsonschema.validate` passes no `format_checker`, so the keyword can never
- * produce an error on this path.
+ * WHAT IS IMPLEMENTED (job65, #125/#126; before it this file was 2020-12 only and RAISED on
+ * `$ref`, `$dynamicRef`, `$recursiveRef`, `unevaluatedItems` and `unevaluatedProperties`).
+ *
+ * THE DIALECT IS READ FROM `$schema`, as `jsonschema.validators.validator_for` reads it:
+ * the URI is normalised the way `_META_SCHEMAS` normalises its keys —
+ * `urlsplit(uri).geturl()`, which lowercases the scheme and drops an EMPTY fragment or
+ * query, so `…/draft-07/schema#` and `…/draft-07/schema` are one key and `https://…/draft-07`
+ * or a trailing slash are not — and an unknown URI, or no `$schema`, is draft 2020-12 (the
+ * reference warns and uses the latest draft). Drafts 4, 6, 7, 2019-09 and 2020-12 each get
+ * their own keyword table and type checker (`1.0` is an `integer` from draft 6 on, not in 4),
+ * and from draft 7 back `$ref` silences its siblings (`_legacy_keywords.ignore_ref_siblings`).
+ * Every subschema re-dispatches on its OWN `$schema` with the enclosing dialect as the
+ * default, because `Validator.evolve` does. Draft 3 is the one dialect the two runtimes
+ * REFUSE, with one shared sentence (`contract.py`'s pre-scan says the same words).
+ *
+ * `$ref` RESOLVES INSIDE THE ONE RESOURCE A CALLER SCHEMA IS. `#`, a JSON pointer `#/…`
+ * (percent-decoded as a whole, then `~1`/`~0` per segment, `int()` for a list index — the
+ * order `referencing`'s `Resource.pointer` uses) and a plain-name `#anchor` (`$anchor`,
+ * plus `$dynamicAnchor` under 2020-12) all resolve against the root document. `$dynamicRef`
+ * is the same lookup because `_keywords.dynamicRef` IS `_validate_reference(ref)` in 4.26,
+ * and `$recursiveRef` is the root because `lookup_recursive_ref` can only land on the root
+ * when there is one resource. What is NOT here is a second resource: a reference with a
+ * scheme, host, path or query, or a schema that embeds a `$id` (`id` under draft 4) below
+ * its root, is refused BEFORE validation with one sentence both runtimes print — a
+ * `PyJsonSchemaRefusal`, which `contract.schemaError` turns into the `{valid: false,
+ * feedback}` answer rather than an exception, because a model handed that sentence can act
+ * on it and a model handed `isError` cannot. A pointer to nowhere or an unknown anchor is
+ * the same refusal, found lazily where Python's `PointerToNowhere`/`NoSuchAnchor` find it.
+ *
+ * `unevaluatedItems`/`unevaluatedProperties` carry BOTH walkers: `_utils.find_evaluated_*`
+ * for 2020-12 and `_legacy_keywords.find_evaluated_*` for 2019-09, which differ in more than
+ * `prefixItems` — the 2019 property walker reads the KEYS of an `additionalProperties`
+ * subschema as property names, and this port reproduces that because the sentence does.
+ * `format` is implemented as the no-op it is — `jsonschema.validate` passes no
+ * `format_checker`, so the keyword can never produce an error on this path.
  *
  * THE CALLER SCHEMA IS CHECKED FIRST, as it is in the reference. `jsonschema.validate` calls
  * `cls.check_schema(schema)` before it looks at the instance, so an invalid schema raises
@@ -34,13 +61,17 @@
  * `{"additionalProperties": [1]}` all answered `{"valid": true}`, and `{"type": 3}` answered
  * `{"valid": false}` with a sentence about a schema that is not a schema.
  *
- * `checkSchema` below is the fix and it is NOT the metaschema — running that would need
- * `$ref` and `$dynamicRef`, which is the vocabulary this file refuses to implement. It is
- * the keyword SHAPE table, applied recursively. Measured over 50 malformed schemas: 50 of 50
- * now refuse on both sides, and only the WORDS differ. Each is a ruled case in
- * `tools/conformance/suites/validate.mjs`. Registered and NOT fixed here: `validate_json`
- * letting an exception out on caller input is a `runtime-py` defect (invariant 8).
+ * `checkSchema` below is the fix and it is NOT the metaschema — the metaschemas are several
+ * documents wired together with `$ref`/`$dynamicRef` across resources, which is the second
+ * resource this file does not implement. It is the keyword SHAPE table, applied recursively
+ * and gated per dialect, because a keyword the dialect does not know is DATA to its
+ * metaschema: `{"if": 3}` is a `SchemaError` under draft 7 and a valid schema under draft 4.
+ * Measured over 50 malformed shapes under 2020-12 and 121 shapes under each of the five
+ * dialects: the refusal bit matches the reference on every row the suite carries, and only
+ * the WORDS differ. Registered and NOT fixed here: `validate_json` letting an exception out
+ * on caller input is a `runtime-py` defect (invariant 8).
  */
+import vm from 'node:vm';
 import { cmpCodepoint } from './memory/pyfs.js';
 import { reprValue } from './pyjson.js';
 export class PyJsonSchemaUnsupported extends Error {
@@ -49,6 +80,97 @@ export class PyJsonSchemaUnsupported extends Error {
         this.name = 'PyJsonSchemaUnsupported';
     }
 }
+/**
+ * A schema the validator will not resolve, answered — not raised. `contract.schemaError`
+ * returns the message as the feedback sentence, so `validate_json` says `{"valid": false,
+ * "feedback": …}` where it used to say `isError` (#125). The Python side prints the same
+ * sentence from `contract._unsupported_schema` and from the `referencing` exceptions.
+ */
+export class PyJsonSchemaRefusal extends Error {
+    constructor(message) {
+        super(message);
+        this.name = 'PyJsonSchemaRefusal';
+    }
+}
+const DRAFT_BY_URI = new Map([
+    ['http://json-schema.org/draft-03/schema', 3],
+    ['http://json-schema.org/draft-04/schema', 4],
+    ['http://json-schema.org/draft-06/schema', 6],
+    ['http://json-schema.org/draft-07/schema', 7],
+    ['https://json-schema.org/draft/2019-09/schema', 2019],
+    ['https://json-schema.org/draft/2020-12/schema', 2020],
+]);
+/** `urllib.parse.uses_netloc`, which decides whether `urlunsplit` re-inserts `//`. */
+const USES_NETLOC = new Set([
+    '', 'ftp', 'http', 'gopher', 'nntp', 'telnet', 'imap', 'wais', 'file', 'mms', 'https', 'shttp',
+    'snews', 'prospero', 'rtsp', 'rtsps', 'rtspu', 'rsync', 'svn', 'svn+ssh', 'sftp', 'nfs', 'git',
+    'git+ssh', 'ws', 'wss', 'itms-services',
+]);
+/**
+ * `urllib.parse.urlsplit(uri).geturl()` — `_utils.URIDict.normalize`, the function every
+ * `$schema` goes through before `_META_SCHEMAS` is consulted. 3.12 strips leading C0/space,
+ * removes every tab/CR/LF, lowercases the scheme, and `urlunsplit` drops an empty query and
+ * an empty fragment. Measured in `tools/conformance/suites/validate.mjs` (`dialect/…`).
+ */
+export function pyUrlNormalize(uri) {
+    let url = uri.replace(/^[\u0000- ]+/, '').replace(/[\t\r\n]/g, '');
+    let scheme = '';
+    const colon = url.indexOf(':');
+    if (colon > 0 && /^[A-Za-z][A-Za-z0-9+.-]*$/.test(url.slice(0, colon))) {
+        scheme = url.slice(0, colon).toLowerCase();
+        url = url.slice(colon + 1);
+    }
+    let netloc = '';
+    if (url.startsWith('//')) {
+        const rel = url.slice(2).search(/[/?#]/);
+        const stop = rel === -1 ? url.length : 2 + rel;
+        netloc = url.slice(2, stop);
+        url = url.slice(stop);
+    }
+    let fragment = '';
+    const hash = url.indexOf('#');
+    if (hash !== -1) {
+        fragment = url.slice(hash + 1);
+        url = url.slice(0, hash);
+    }
+    let query = '';
+    const q = url.indexOf('?');
+    if (q !== -1) {
+        query = url.slice(q + 1);
+        url = url.slice(0, q);
+    }
+    if (netloc || (scheme && USES_NETLOC.has(scheme) && !url.startsWith('//'))) {
+        if (url && !url.startsWith('/'))
+            url = `/${url}`;
+        url = `//${netloc}${url}`;
+    }
+    if (scheme)
+        url = `${scheme}:${url}`;
+    if (query)
+        url += `?${query}`;
+    if (fragment)
+        url += `#${fragment}`;
+    return url;
+}
+const draft3Sentence = (uri) => `the schema's $schema ${JSON.stringify(uri)} names draft 3, which this validator does not ` +
+    'support (draft-04, draft-06, draft-07, 2019-09 and 2020-12 are)';
+/**
+ * `validator_for(schema, default=fallback)`: the dialect a (sub)schema is validated under.
+ * The root falls back to 2020-12 (`_LATEST_VERSION`); a subschema falls back to the
+ * enclosing dialect, which is what `Validator.evolve` passes as `default`.
+ */
+function dialectOf(schema, fallback) {
+    const v = get(schema, '$schema');
+    if (v === undefined)
+        return fallback;
+    // `schema["$schema"] not in _META_SCHEMAS` → `urlsplit(3)` → AttributeError. Both raise.
+    if (v.t !== 'str')
+        throw new PyJsonSchemaUnsupported(`$schema must be a string, got ${v.t}`);
+    const found = DRAFT_BY_URI.get(pyUrlNormalize(v.v));
+    if (found === 3)
+        throw new PyJsonSchemaRefusal(draft3Sentence(v.v));
+    return found ?? fallback;
+}
 export function absolutePath(error) {
     return error.parent === null ? error.path : [...absolutePath(error.parent), ...error.path];
 }
@@ -87,20 +209,23 @@ export function pyEqual(a, b) {
     return false;
 }
 /**
- * `draft202012_type_checker`.
+ * The draft type checkers.
  *
  * Two Python-isms carry: `bool` is not an `int`, so `true` is neither `integer` nor
  * `number`; and draft 6 onward redefines `integer` to accept a float with no fractional
- * part, so `1.0` IS an integer.
+ * part, so `1.0` IS an integer — under draft 6+ only. `draft4_type_checker` is
+ * `is_integer` alone, and `{"type": "integer"}` refuses `1.0` there.
  */
-function isType(instance, type) {
+function isType(instance, type, draft = 2020) {
     switch (type) {
         case 'array':
             return instance.t === 'list';
         case 'boolean':
             return instance.t === 'bool';
         case 'integer':
-            return instance.t === 'int' || (instance.t === 'float' && Number.isInteger(instance.v));
+            if (instance.t === 'int')
+                return true;
+            return draft !== 4 && instance.t === 'float' && Number.isInteger(instance.v);
         case 'null':
             return instance.t === 'null';
         case 'number':
@@ -115,39 +240,53 @@ function isType(instance, type) {
             throw new PyJsonSchemaUnsupported(`undefined type check ${JSON.stringify(type)}`);
     }
 }
-function iterErrors(instance, schema) {
+const falseSchemaError = (instance, draft) => ({
+    message: `False schema does not allow ${reprValue(instance)}`,
+    validator: null,
+    instance,
+    schema: false,
+    path: [],
+    context: [],
+    parent: null,
+    draft,
+});
+/**
+ * `applicable_validators`: for 2019-09 and 2020-12 it is `methodcaller("items")` — plain
+ * dict order, which for a JSON-parsed schema is DOCUMENT order; from draft 7 back it is
+ * `_legacy_keywords.ignore_ref_siblings`, which returns `$ref` ALONE when the schema has
+ * one. That order decides which error comes first, and `best_match` breaks ties by taking
+ * the first maximum, so it is load-bearing.
+ */
+function applicable(schema, draft) {
+    if (draft === 4 || draft === 6 || draft === 7) {
+        const ref = schema.get('$ref');
+        // `schema.get("$ref") is not None` — a JSON null counts as absent.
+        if (ref !== undefined && ref.t !== 'null')
+            return [['$ref', ref]];
+    }
+    return schema;
+}
+function iterErrors(instance, schema, ctx) {
+    const c = ctx ?? rootCtx(schema);
     if (schema === true)
         return [];
-    if (schema === false) {
-        return [
-            {
-                message: `False schema does not allow ${reprValue(instance)}`,
-                validator: null,
-                instance,
-                schema,
-                path: [],
-                context: [],
-                parent: null,
-            },
-        ];
-    }
+    if (schema === false)
+        return [falseSchemaError(instance, c.draft)];
     if (schema.t === 'bool')
-        return iterErrors(instance, schema.v);
+        return iterErrors(instance, schema.v, c);
     if (schema.t !== 'dict') {
         throw new PyJsonSchemaUnsupported(`a schema must be an object or a boolean, got ${schema.t}`);
     }
+    // `Validator.evolve` re-dispatches on the subschema's own `$schema`, defaulting to the
+    // enclosing class.
+    const draft = dialectOf(schema, c.draft);
+    const here = draft === c.draft ? c : { ...c, draft };
+    const table = KEYWORDS_BY_DRAFT[draft];
     const out = [];
-    // `applicable_validators` for draft 2020-12 is `methodcaller("items")` — plain dict order,
-    // which for a JSON-parsed schema is DOCUMENT order. That order decides which error comes
-    // first, and `best_match` breaks ties by taking the first maximum, so it is load-bearing.
-    for (const [keyword, value] of schema.v) {
-        const fn = KEYWORDS[keyword];
-        if (fn === undefined) {
-            if (UNSUPPORTED.has(keyword)) {
-                throw new PyJsonSchemaUnsupported(`${keyword} is not implemented by this port`);
-            }
-            continue; // an annotation (`title`, `$comment`, `description`, …) — jsonschema skips it too
-        }
+    for (const [keyword, value] of applicable(schema.v, draft)) {
+        const fn = table[keyword];
+        if (fn === undefined)
+            continue; // an annotation, or a keyword of another dialect — jsonschema skips it too
         const emit = (message, extra = {}) => ({
             message,
             validator: extra.validator ?? keyword,
@@ -156,6 +295,7 @@ function iterErrors(instance, schema) {
             path: [],
             context: extra.context ?? [],
             parent: null,
+            draft,
         });
         const descend = (childInstance, childSchema, path) => {
             if (childSchema === undefined)
@@ -165,28 +305,30 @@ function iterErrors(instance, schema) {
             // Measured against Python; a port that prepended here would name a field Python does
             // not name.
             if (childSchema.t === 'bool')
-                return iterErrors(childInstance, childSchema.v);
-            const errors = iterErrors(childInstance, childSchema);
+                return iterErrors(childInstance, childSchema.v, here);
+            const errors = iterErrors(childInstance, childSchema, here);
             if (path !== undefined)
                 for (const e of errors)
                     e.path.unshift(path);
             return errors;
         };
-        out.push(...fn(value, instance, schema, emit, descend));
+        out.push(...fn(value, instance, schema, emit, descend, here));
     }
     return out;
 }
-const isValid = (instance, schema) => iterErrors(instance, schema).length === 0;
-const UNSUPPORTED = new Set([
-    '$ref',
-    '$dynamicRef',
-    '$recursiveRef',
-    'unevaluatedItems',
-    'unevaluatedProperties',
-]);
+const isValid = (instance, schema, ctx) => iterErrors(instance, schema, ctx).length === 0;
+/** The context a bare `iterErrors(instance, schema)` call runs under: the schema is the root. */
+function rootCtx(schema) {
+    const draft = dialectOf(schema, 2020);
+    const root = typeof schema === 'boolean' ? { t: 'bool', v: schema } : schema;
+    return { root, draft, rootDraft: draft };
+}
 /** `extras_msg`: `"'a', 'b'", "were"`. */
 function extrasMsg(extras) {
-    return [extras.map((e) => reprValue({ t: 'str', v: e })).join(', '), extras.length === 1 ? 'was' : 'were'];
+    return extrasMsgValues(extras.map((e) => ({ t: 'str', v: e })));
+}
+function extrasMsgValues(extras) {
+    return [extras.map(reprValue).join(', '), extras.length === 1 ? 'was' : 'were'];
 }
 /** `find_additional_properties`, in instance order. */
 function findAdditionalProperties(instance, schema) {
@@ -204,30 +346,748 @@ function findAdditionalProperties(instance, schema) {
     }
     return out;
 }
+// ------------------------------------------------------------- Python `re`, translated
 /**
- * `re.search(pattern, string)`.
+ * `re.search(pattern, string)` — the reference's dialect, translated, bounded (#131, #132).
+ *
+ * THE DIALECT IS PYTHON'S. Until job65 this was `new RegExp(pattern, 'u')` with a silent
+ * fallback to a non-`u` RegExp, so the two runtimes disagreed on 5 of 5 of #131's probes:
+ * `\d`/`\w` are Unicode-wide in `re` and ASCII in JS, `$` matches before a final newline in
+ * `re`, `(?P<x>…)` refused here, and the fallback read `\Z` as a literal `Z`. JSON Schema
+ * recommends ECMA-262, but the product's contract is the reference's verdict, so the pattern
+ * is parsed the way `re._parser` parses it and re-emitted as a `v`-mode RegExp whose every
+ * construct means what it means in `re`:
+ *
+ *   - `\d` → `\p{Nd}`; `\w` → `[\p{L}\p{N}_]` (`str.isalnum() or "_"`); `\s` → the 29
+ *     codepoints `str.isspace()` names (JS's `\s` adds U+FEFF and drops U+001C-1F, U+0085);
+ *     `\b`/`\B` are look-arounds over that `\w`, and `\B` never matches the empty string
+ *     (`SRE_AT_UNI_NON_BOUNDARY`, CPython 3.11-3.13). Measured over every codepoint: the
+ *     three classes are equal except for the codepoints Unicode 16 assigned after the
+ *     reference's Unicode 15 (5,004 for `\w`, 80 for `\d`, 0 for `\s`).
+ *   - `.` → `[^\n]` (JS also stops at `\r`, U+2028, U+2029); `$` → `(?=\n?$)`; `\A` → `^`;
+ *     `\Z` → `$`; `(?P<n>…)` → a group; `{,n}` → `{0,n}`; a `{` that is not a repeat is a
+ *     literal; every literal is emitted as `\u{…}`, so no JS syntax rule can reach it.
  *
- * RULING. Python's `re` and JS's `RegExp` are different languages past the common core:
- * `\d` is Unicode-wide in Python and ASCII-only in JS, `$` matches before a trailing newline
- * in Python and not in JS, and `(?P<x>…)`/`\Z`/`\A` are Python-only syntax. The asset pack
- * holds exactly one `pattern` (`assets/tools/memory_save.json`), which is inside the common
- * core; a caller-supplied schema is not guaranteed to be. Carried as a ruled case rather
- * than fixed, because fixing it means porting `sre_compile`.
+ * A pattern `re` itself refuses is a `PyReError` (what `re.error` is on the reference: the
+ * schema check raises it). Constructs with no faithful translation — inline flags,
+ * look-behind (fixed-width in `re`, any width in JS), backreferences (a JS backreference to
+ * a group that did not take part matches the empty string; `re`'s fails), atomic groups,
+ * possessive quantifiers, conditional groups and `\N{…}` (no Unicode name table here) — are
+ * parsed, so that a broken pattern is still an error, and then REFUSED on both runtimes with
+ * one sentence (`unsupportedPatternSentence`; `contract._pattern_unsupported` on the
+ * reference), never answered differently.
  */
-function reSearch(pattern, text) {
-    let re;
+export class PyReError extends Error {
+    constructor(message) {
+        super(message);
+        this.name = 'PyReError';
+    }
+}
+const RE_SPECIAL = new Set([...'.\\[{()*+?^$|']);
+const RE_DIGITS = new Set([...'0123456789']);
+const RE_OCT = new Set([...'01234567']);
+const RE_HEX = new Set([...'0123456789abcdefABCDEF']);
+const RE_WHITESPACE = new Set([...' \t\n\r\v\f']);
+const RE_FLAGS = new Map([
+    ['i', 2], ['L', 4], ['m', 8], ['s', 16], ['x', 64], ['a', 256], ['t', 1], ['u', 32],
+]);
+const FLAG_UNICODE = 32;
+const FLAG_ASCII = 256;
+const FLAG_VERBOSE = 64;
+const TYPE_FLAGS = 4 | 32 | 256;
+const GLOBAL_FLAGS = 1 | 128;
+const MAXREPEAT = 4294967295n;
+const MAXGROUPS = 1073741823n;
+const u = (cp) => `\\u{${cp.toString(16)}}`;
+const RE_WORD = '[\\p{L}\\p{N}_]';
+const RE_NOT_WORD = '[^\\p{L}\\p{N}_]';
+const RE_SPACE_ITEMS = `${u(9)}-${u(13)}${u(0x1c)}-${u(0x20)}${u(0x85)}${u(0xa0)}${u(0x1680)}${u(0x2000)}-${u(0x200a)}` +
+    `${u(0x2028)}${u(0x2029)}${u(0x202f)}${u(0x205f)}${u(0x3000)}`;
+/** `\d \D \s \S \w \W` as a class member (a nested class where JS needs one). */
+const RE_CATEGORY_IN_CLASS = {
+    '\\d': '\\p{Nd}',
+    '\\D': '\\P{Nd}',
+    '\\w': RE_WORD,
+    '\\W': RE_NOT_WORD,
+    '\\s': `[${RE_SPACE_ITEMS}]`,
+    '\\S': `[^${RE_SPACE_ITEMS}]`,
+};
+const RE_AT = {
+    '\\A': '^',
+    '\\Z': '$',
+    '\\b': `(?:(?<=${RE_WORD})(?!${RE_WORD})|(?<!${RE_WORD})(?=${RE_WORD}))`,
+    '\\B': `(?:(?<=${RE_WORD})(?=${RE_WORD})|(?<!${RE_WORD})(?!${RE_WORD})(?!(?<![\\s\\S])(?![\\s\\S])))`,
+};
+const RE_ESCAPES = {
+    '\\a': 7, '\\b': 8, '\\f': 12, '\\n': 10, '\\r': 13, '\\t': 9, '\\v': 11, '\\\\': 92,
+};
+const XID_START = /^[\p{XID_Start}_]$/u;
+const XID_CONTINUE = /^\p{XID_Continue}$/u;
+/** `re._parser.Tokenizer` over codepoints: an escape is one two-character token. */
+class ReSource {
+    chars;
+    index = 0;
+    next = null;
+    constructor(pattern) {
+        this.chars = [...pattern];
+        this.advance();
+    }
+    advance() {
+        let index = this.index;
+        if (index >= this.chars.length) {
+            this.next = null;
+            return;
+        }
+        let char = this.chars[index];
+        if (char === '\\') {
+            index += 1;
+            if (index >= this.chars.length)
+                throw new PyReError('bad escape (end of pattern)');
+            char += this.chars[index];
+        }
+        this.index = index + 1;
+        this.next = char;
+    }
+    match(char) {
+        if (char === this.next) {
+            this.advance();
+            return true;
+        }
+        return false;
+    }
+    get() {
+        const self = this.next;
+        this.advance();
+        return self;
+    }
+    getwhile(n, charset) {
+        let result = '';
+        for (let i = 0; i < n; i += 1) {
+            const c = this.next;
+            if (c === null || !charset.has(c))
+                break;
+            result += c;
+            this.advance();
+        }
+        return result;
+    }
+    getuntil(terminator, name) {
+        let result = '';
+        for (;;) {
+            const c = this.next;
+            this.advance();
+            if (c === null) {
+                if (!result)
+                    throw new PyReError(`missing ${name}`);
+                throw new PyReError(`missing ${terminator}, unterminated name`);
+            }
+            if (c === terminator) {
+                if (!result)
+                    throw new PyReError(`missing ${name}`);
+                break;
+            }
+            result += c;
+        }
+        return result;
+    }
+    tell() {
+        return this.index - (this.next === null ? 0 : [...this.next].length);
+    }
+    seek(index) {
+        this.index = index;
+        this.advance();
+    }
+}
+function checkGroupName(name) {
+    const cps = [...name];
+    if (!(XID_START.test(cps[0]) && cps.slice(1).every((c) => XID_CONTINUE.test(c)))) {
+        throw new PyReError(`bad character in group name ${JSON.stringify(name)}`);
+    }
+}
+function checkGroup(state, gid) {
+    return gid < state.groups && state.closed.has(gid);
+}
+function checkLookbehindGroup(state, gid) {
+    if (state.lookbehindgroups !== null) {
+        if (!checkGroup(state, gid))
+            throw new PyReError('cannot refer to an open group');
+        if (gid >= state.lookbehindgroups) {
+            throw new PyReError('cannot refer to group defined in the same lookbehind subpattern');
+        }
+    }
+}
+/** `_class_escape`: a literal codepoint, or a category's class-member source. */
+function classEscape(source, escape) {
+    const known = RE_ESCAPES[escape];
+    if (known !== undefined)
+        return { lit: known };
+    const cat = RE_CATEGORY_IN_CLASS[escape];
+    if (cat !== undefined)
+        return { cat };
+    return { lit: escapeLiteral(source, escape, true, null) };
+}
+/** The literal arms `_escape` and `_class_escape` share: `\x \u \U \N`, octal, an identity escape. */
+function escapeLiteral(source, escape, inClass, state) {
+    const c = escape.slice(1);
+    if (c === 'x' || c === 'u' || c === 'U') {
+        const width = c === 'x' ? 2 : c === 'u' ? 4 : 8;
+        const digits = source.getwhile(width, RE_HEX);
+        if (digits.length !== width)
+            throw new PyReError(`incomplete escape ${escape}${digits}`);
+        const cp = parseInt(digits, 16);
+        if (cp > 0x10ffff)
+            throw new PyReError(`bad escape ${escape}${digits}`);
+        return cp;
+    }
+    if (c === 'N') {
+        if (!source.match('{'))
+            throw new PyReError('missing {');
+        source.getuntil('}', 'character name');
+        // No Unicode name table here: parsed so a broken one is still an error, then refused.
+        if (state !== null)
+            state.unsupported = true;
+        else
+            NAMED_IN_CLASS.hit = true;
+        return 0x3f;
+    }
+    if (inClass ? RE_OCT.has(c) : c === '0') {
+        const digits = c + source.getwhile(2, RE_OCT);
+        const cp = parseInt(digits, 8);
+        if (cp > 0o377)
+            throw new PyReError(`octal escape value \\${digits} outside of range 0-0o377`);
+        return cp;
+    }
+    if (RE_DIGITS.has(c))
+        throw new PyReError(`bad escape ${escape}`);
+    if (/^[A-Za-z]$/.test(c))
+        throw new PyReError(`bad escape ${escape}`);
+    return c.codePointAt(0);
+}
+/** `\N{…}` inside a class has no state to mark; the class parser reads this flag back. */
+const NAMED_IN_CLASS = { hit: false };
+function parseClass(source, state) {
+    const items = [];
+    let count = 0;
+    const negate = source.match('^');
+    NAMED_IN_CLASS.hit = false;
+    for (;;) {
+        const self = source.get();
+        if (self === null)
+            throw new PyReError('unterminated character set');
+        if (self === ']' && count > 0)
+            break;
+        const code1 = self.startsWith('\\') ? classEscape(source, self) : { lit: self.codePointAt(0) };
+        if (source.match('-')) {
+            const that = source.get();
+            if (that === null)
+                throw new PyReError('unterminated character set');
+            if (that === ']') {
+                items.push('lit' in code1 ? u(code1.lit) : code1.cat, u(0x2d));
+                count += 2;
+                break;
+            }
+            const code2 = that.startsWith('\\') ? classEscape(source, that) : { lit: that.codePointAt(0) };
+            if (!('lit' in code1) || !('lit' in code2) || code2.lit < code1.lit) {
+                throw new PyReError(`bad character range ${self}-${that}`);
+            }
+            items.push(`${u(code1.lit)}-${u(code2.lit)}`);
+        }
+        else {
+            items.push('lit' in code1 ? u(code1.lit) : code1.cat);
+        }
+        count += 1;
+    }
+    if (NAMED_IN_CLASS.hit)
+        state.unsupported = true;
+    return `[${negate ? '^' : ''}${items.join('')}]`;
+}
+/** `_parse_flags`. Returns `null` for global flags (`(?…)`), else the scoped pair. */
+function parseFlags(source, state, first) {
+    let char = first;
+    let add = 0;
+    let del = 0;
+    if (char !== '-') {
+        for (;;) {
+            const flag = RE_FLAGS.get(char);
+            if (char === 'L')
+                throw new PyReError("bad inline flag: cannot use 'L' flag with a str pattern");
+            add |= flag;
+            if (flag & TYPE_FLAGS && (add & TYPE_FLAGS) !== flag) {
+                throw new PyReError("bad inline flag: flags 'a', 'u' and 'L' are incompatible");
+            }
+            char = source.get();
+            if (char === null)
+                throw new PyReError('missing -, : or )');
+            if (char === ')' || char === '-' || char === ':')
+                break;
+            if (!RE_FLAGS.has(char))
+                throw new PyReError(/\p{L}/u.test(char) ? 'unknown flag' : 'missing -, : or )');
+        }
+    }
+    if (char === ')') {
+        state.flags |= add;
+        return null;
+    }
+    if (add & GLOBAL_FLAGS)
+        throw new PyReError('bad inline flag: cannot turn on global flag');
+    if (char === '-') {
+        char = source.get();
+        if (char === null)
+            throw new PyReError('missing flag');
+        if (!RE_FLAGS.has(char))
+            throw new PyReError(/\p{L}/u.test(char) ? 'unknown flag' : 'missing flag');
+        for (;;) {
+            const flag = RE_FLAGS.get(char);
+            if (flag & TYPE_FLAGS)
+                throw new PyReError("bad inline flag: cannot turn off flags 'a', 'u' and 'L'");
+            del |= flag;
+            char = source.get();
+            if (char === null)
+                throw new PyReError('missing :');
+            if (char === ':')
+                break;
+            if (!RE_FLAGS.has(char))
+                throw new PyReError(/\p{L}/u.test(char) ? 'unknown flag' : 'missing :');
+        }
+    }
+    if (del & GLOBAL_FLAGS)
+        throw new PyReError('bad inline flag: cannot turn off global flag');
+    if (add & del)
+        throw new PyReError('bad inline flag: flag turned on and off');
+    return [add, del];
+}
+/** `_parse_sub`: alternatives joined by `|`. */
+function parseSub(source, state, verbose, nested) {
+    const branches = [];
+    for (;;) {
+        branches.push(parseSeq(source, state, verbose, nested, nested === 0 && branches.length === 0));
+        if (!source.match('|'))
+            break;
+        if (nested === 0)
+            verbose = (state.flags & FLAG_VERBOSE) !== 0;
+    }
+    return branches.length === 1 ? branches[0] : branches.join('|');
+}
+/** `_parse`: one branch. */
+function parseSeq(source, state, verbose, nested, first) {
+    const items = [];
+    for (;;) {
+        const self = source.next;
+        if (self === null || self === '|' || self === ')')
+            break;
+        source.get();
+        if (verbose) {
+            if (RE_WHITESPACE.has(self))
+                continue;
+            if (self === '#') {
+                for (;;) {
+                    const c = source.get();
+                    if (c === null || c === '\n')
+                        break;
+                }
+                continue;
+            }
+        }
+        if (self.startsWith('\\')) {
+            items.push(parseEscape(source, self, state));
+        }
+        else if (!RE_SPECIAL.has(self)) {
+            items.push({ kind: 'atom', src: u(self.codePointAt(0)) });
+        }
+        else if (self === '[') {
+            items.push({ kind: 'atom', src: parseClass(source, state) });
+        }
+        else if (self === '*' || self === '+' || self === '?' || self === '{') {
+            const here = source.tell();
+            let quant;
+            if (self === '{') {
+                if (source.next === '}') {
+                    items.push({ kind: 'atom', src: u(0x7b) });
+                    continue;
+                }
+                let lo = '';
+                let hi = '';
+                while (source.next !== null && RE_DIGITS.has(source.next))
+                    lo += source.get();
+                if (source.match(',')) {
+                    while (source.next !== null && RE_DIGITS.has(source.next))
+                        hi += source.get();
+                }
+                else {
+                    hi = lo;
+                }
+                if (!source.match('}')) {
+                    items.push({ kind: 'atom', src: u(0x7b) });
+                    source.seek(here);
+                    continue;
+                }
+                const min = lo ? BigInt(lo) : 0n;
+                const max = hi ? BigInt(hi) : MAXREPEAT;
+                if (lo && min >= MAXREPEAT)
+                    throw new PyJsonSchemaUnsupported('OverflowError: the repetition number is too large');
+                if (hi && max >= MAXREPEAT)
+                    throw new PyJsonSchemaUnsupported('OverflowError: the repetition number is too large');
+                if (hi && max < min)
+                    throw new PyReError('min repeat greater than max repeat');
+                quant = max === MAXREPEAT ? `{${min},}` : min === max ? `{${min}}` : `{${min},${max}}`;
+            }
+            else {
+                quant = self;
+            }
+            const item = items[items.length - 1];
+            if (item === undefined || item.kind === 'at')
+                throw new PyReError('nothing to repeat');
+            if (item.kind === 'repeat')
+                throw new PyReError('multiple repeat');
+            if (source.match('?')) {
+                quant += '?';
+            }
+            else if (source.match('+')) {
+                state.unsupported = true; // possessive
+            }
+            items[items.length - 1] = { kind: 'repeat', src: `(?:${item.src})${quant}` };
+        }
+        else if (self === '.') {
+            items.push({ kind: 'atom', src: `[^${u(10)}]` });
+        }
+        else if (self === '(') {
+            const item = parseGroup(source, state, verbose, nested, first && items.length === 0);
+            if (item === 'global-flags') {
+                verbose = (state.flags & FLAG_VERBOSE) !== 0;
+                continue;
+            }
+            if (item !== null)
+                items.push(item);
+        }
+        else if (self === '^') {
+            items.push({ kind: 'at', src: '^' });
+        }
+        else if (self === '$') {
+            items.push({ kind: 'at', src: `(?=${u(10)}?$)` });
+        }
+        else {
+            throw new PyReError(`unexpected ${self}`);
+        }
+    }
+    return items.map((i) => i.src).join('');
+}
+/** `_escape`, outside a class. */
+function parseEscape(source, escape, state) {
+    const at = RE_AT[escape];
+    if (at !== undefined)
+        return { kind: 'at', src: at };
+    const cat = RE_CATEGORY_IN_CLASS[escape];
+    if (cat !== undefined)
+        return { kind: 'atom', src: escape === '\\d' ? '\\p{Nd}' : escape === '\\D' ? '\\P{Nd}' : cat };
+    const known = RE_ESCAPES[escape];
+    if (known !== undefined)
+        return { kind: 'atom', src: u(known) };
+    const c = escape.slice(1);
+    if (c !== '0' && RE_DIGITS.has(c)) {
+        // An octal escape or a decimal group reference.
+        let digits = c;
+        if (source.next !== null && RE_DIGITS.has(source.next)) {
+            digits += source.get();
+            if (RE_OCT.has(digits[0]) && RE_OCT.has(digits[1]) && source.next !== null && RE_OCT.has(source.next)) {
+                digits += source.get();
+                const cp = parseInt(digits, 8);
+                if (cp > 0o377)
+                    throw new PyReError(`octal escape value \\${digits} outside of range 0-0o377`);
+                return { kind: 'atom', src: u(cp) };
+            }
+        }
+        const group = Number(digits);
+        if (group < state.groups) {
+            if (!checkGroup(state, group))
+                throw new PyReError('cannot refer to an open group');
+            checkLookbehindGroup(state, group);
+            state.unsupported = true; // a backreference
+            return { kind: 'atom', src: '(?:)' };
+        }
+        throw new PyReError(`invalid group reference ${group}`);
+    }
+    return { kind: 'atom', src: u(escapeLiteral(source, escape, false, state)) };
+}
+/** `(` … — a group, an assertion, a comment, flags, or a Python extension. */
+function parseGroup(source, state, verbose, nested, first) {
+    let capture = true;
+    let name = null;
+    let subVerbose = verbose;
+    let wrap = (body) => `(?:${body})`;
+    if (source.match('?')) {
+        const char = source.get();
+        if (char === null)
+            throw new PyReError('unexpected end of pattern');
+        if (char === 'P') {
+            if (source.match('<')) {
+                name = source.getuntil('>', 'group name');
+                checkGroupName(name);
+            }
+            else if (source.match('=')) {
+                const ref = source.getuntil(')', 'group name');
+                checkGroupName(ref);
+                const gid = state.groupdict.get(ref);
+                if (gid === undefined)
+                    throw new PyReError(`unknown group name ${JSON.stringify(ref)}`);
+                if (!checkGroup(state, gid))
+                    throw new PyReError('cannot refer to an open group');
+                checkLookbehindGroup(state, gid);
+                state.unsupported = true; // a named backreference
+                return { kind: 'atom', src: '(?:)' };
+            }
+            else {
+                const next = source.get();
+                if (next === null)
+                    throw new PyReError('unexpected end of pattern');
+                throw new PyReError(`unknown extension ?P${next}`);
+            }
+        }
+        else if (char === ':') {
+            capture = false;
+        }
+        else if (char === '#') {
+            for (;;) {
+                if (source.next === null)
+                    throw new PyReError('missing ), unterminated comment');
+                if (source.get() === ')')
+                    break;
+            }
+            return null;
+        }
+        else if (char === '=' || char === '!' || char === '<') {
+            let dir = 1;
+            let kind = char;
+            let saved = null;
+            if (char === '<') {
+                const next = source.get();
+                if (next === null)
+                    throw new PyReError('unexpected end of pattern');
+                if (next !== '=' && next !== '!')
+                    throw new PyReError(`unknown extension ?<${next}`);
+                kind = next;
+                dir = -1;
+                saved = state.lookbehindgroups;
+                if (saved === null)
+                    state.lookbehindgroups = state.groups;
+                state.unsupported = true; // look-behind
+            }
+            const body = parseSub(source, state, verbose, nested + 1);
+            if (dir < 0 && saved === null)
+                state.lookbehindgroups = null;
+            if (!source.match(')'))
+                throw new PyReError('missing ), unterminated subpattern');
+            return { kind: 'atom', src: `(?${dir < 0 ? '<' : ''}${kind}${body})` };
+        }
+        else if (char === '(') {
+            // A conditional group: parsed for validity, then refused.
+            const condname = source.getuntil(')', 'group name');
+            if (/^\d+$/.test(condname)) {
+                const big = BigInt(condname);
+                if (big === 0n)
+                    throw new PyReError('bad group number');
+                if (big >= MAXGROUPS)
+                    throw new PyReError(`invalid group reference ${big}`);
+                const gid = Number(big);
+                // A forward reference is legal here; `parse` checks it against the final count.
+                state.grouprefs.push(gid);
+                checkLookbehindGroup(state, gid);
+            }
+            else {
+                checkGroupName(condname);
+                const gid = state.groupdict.get(condname);
+                if (gid === undefined)
+                    throw new PyReError(`unknown group name ${JSON.stringify(condname)}`);
+                checkLookbehindGroup(state, gid);
+            }
+            const yes = parseSeq(source, state, verbose, nested + 1, false);
+            if (source.match('|')) {
+                parseSeq(source, state, verbose, nested + 1, false);
+                if (source.next === '|')
+                    throw new PyReError('conditional backref with more than two branches');
+            }
+            if (!source.match(')'))
+                throw new PyReError('missing ), unterminated subpattern');
+            state.unsupported = true;
+            return { kind: 'atom', src: `(?:${yes})` };
+        }
+        else if (char === '>') {
+            capture = false;
+            state.unsupported = true; // an atomic group
+        }
+        else if (RE_FLAGS.has(char) || char === '-') {
+            const flags = parseFlags(source, state, char);
+            if (flags === null) {
+                if (!first)
+                    throw new PyReError('global flags not at the start of the expression');
+                return 'global-flags';
+            }
+            const [add, del] = flags;
+            state.unsupported = true; // scoped inline flags
+            capture = false;
+            subVerbose = (verbose || (add & FLAG_VERBOSE) !== 0) && (del & FLAG_VERBOSE) === 0;
+        }
+        else {
+            throw new PyReError(`unknown extension ?${char}`);
+        }
+    }
+    let group = null;
+    if (capture) {
+        group = state.groups;
+        state.groups += 1;
+        if (name !== null) {
+            const ogid = state.groupdict.get(name);
+            if (ogid !== undefined) {
+                throw new PyReError(`redefinition of group name ${JSON.stringify(name)} as group ${group}; was group ${ogid}`);
+            }
+            state.groupdict.set(name, group);
+        }
+        wrap = (body) => `(${body})`;
+    }
+    const body = parseSub(source, state, subVerbose, nested + 1);
+    if (!source.match(')'))
+        throw new PyReError('missing ), unterminated subpattern');
+    if (group !== null)
+        state.closed.add(group);
+    return { kind: 'atom', src: wrap(body) };
+}
+/** A `\N` escape anywhere, an escaped backslash skipped — `contract._names_a_character`. */
+function namesACharacter(pattern) {
+    for (let i = 0; i < pattern.length; i += 1) {
+        if (pattern[i] === '\\') {
+            if (pattern[i + 1] === 'N')
+                return true;
+            i += 1;
+        }
+    }
+    return false;
+}
+/** `re._parser.parse(pattern)` + `fix_flags`, re-emitted for a `v`-mode RegExp. */
+export function translatePyPattern(pattern) {
+    // `\N{…}` is refused before the parse, on both runtimes, whatever else the pattern holds:
+    // without a Unicode name table the port cannot tell a defined name from an undefined one.
+    if (namesACharacter(pattern))
+        return { source: null };
+    const source = new ReSource(pattern);
+    const state = {
+        flags: 0,
+        groups: 1,
+        groupdict: new Map(),
+        closed: new Set(),
+        lookbehindgroups: null,
+        grouprefs: [],
+        unsupported: false,
+    };
+    let body;
+    try {
+        body = parseSub(source, state, false, 0);
+    }
+    catch (e) {
+        // A pattern nested past the JS stack is past anything `re` would be asked to compile.
+        if (e instanceof RangeError)
+            throw new PyReError('pattern too deeply nested');
+        throw e;
+    }
+    if (source.next !== null)
+        throw new PyReError('unbalanced parenthesis');
+    for (const g of state.grouprefs)
+        if (g >= state.groups)
+            throw new PyReError(`invalid group reference ${g}`);
+    if (state.flags & FLAG_ASCII && state.flags & FLAG_UNICODE) {
+        throw new PyJsonSchemaUnsupported('ValueError: ASCII and UNICODE flags are incompatible');
+    }
+    // `(?u)` alone is the default and changes nothing; every other global flag is refused.
+    if (state.flags & ~FLAG_UNICODE)
+        state.unsupported = true;
+    return { source: state.unsupported ? null : body };
+}
+/** The sentence both runtimes answer for a pattern outside the shared dialect (#131). */
+export function unsupportedPatternSentence(pattern) {
+    return (`the pattern ${clipText(reprValue({ t: 'str', v: pattern }))} is not supported: this validator ` +
+        'refuses inline flags, look-behind, backreferences, atomic groups, possessive quantifiers, ' +
+        'conditional groups and \\N{...} escapes');
+}
+/** The milliseconds a document's patterns may spend, in total, before the validation is refused (#132). */
+export const PATTERN_BUDGET_MS = 500;
+/** The sentence both runtimes answer when a document's patterns run past the budget (#132). */
+export function patternBudgetSentence(pattern) {
+    return (`the pattern ${clipText(reprValue({ t: 'str', v: pattern }))} did not finish within the ` +
+        `${PATTERN_BUDGET_MS} ms this validator allows a document's patterns; rewrite it so it cannot ` +
+        'backtrack catastrophically, as (a+)+$ does');
+}
+/**
+ * At most `limit` codepoints of `text`, then `…(N more)` (#153). Codepoints, not UTF-16
+ * units, because `len()` on the reference counts codepoints.
+ */
+export function clipText(text, limit = 200) {
+    const cps = [...text];
+    if (cps.length <= limit)
+        return text;
+    return `${cps.slice(0, limit).join('')}…(${cps.length - limit} more)`;
+}
+const compiled = new Map();
+/** The `v`-mode RegExp for a supported pattern; `PyReError` for one `re` refuses. */
+function compilePyPattern(pattern) {
+    let re = compiled.get(pattern);
+    if (re !== undefined)
+        return re;
+    let translation;
     try {
-        re = new RegExp(pattern, 'u');
+        translation = translatePyPattern(pattern);
     }
-    catch {
-        try {
-            re = new RegExp(pattern);
+    catch (e) {
+        if (e instanceof PyReError) {
+            throw new PyJsonSchemaUnsupported(`pattern ${JSON.stringify(pattern)} is not a regular expression: ${e.message}`);
         }
-        catch (e) {
-            throw new PyJsonSchemaUnsupported(`pattern ${JSON.stringify(pattern)} is not a JS regular expression: ${e.message}`);
+        throw e;
+    }
+    if (translation.source === null)
+        throw new PyJsonSchemaRefusal(unsupportedPatternSentence(pattern));
+    try {
+        re = new RegExp(translation.source, 'v');
+    }
+    catch (e) {
+        throw new PyJsonSchemaUnsupported(`pattern ${JSON.stringify(pattern)} translated to a RegExp V8 will not compile: ${e.message}`);
+    }
+    if (compiled.size > 256)
+        compiled.clear();
+    compiled.set(pattern, re);
+    return re;
+}
+/**
+ * The running validation's pattern clock. `validate` opens one; `reSearch` charges every
+ * search to it and refuses — `PyJsonSchemaRefusal`, so the answer is `{valid: false,
+ * feedback}` — once the total passes `PATTERN_BUDGET_MS`. A catastrophic search is stopped
+ * mid-run by `vm`'s timeout, which interrupts the RegExp engine itself; the server's event
+ * loop is blocked for at most the budget, so a `ping` sent behind it is answered within it.
+ */
+let patternClock = null;
+let regexContext = null;
+const regexScript = new vm.Script('r.test(s)');
+function reSearch(pattern, text) {
+    const re = compilePyPattern(pattern);
+    if (patternClock === null)
+        return re.test(text);
+    const remaining = PATTERN_BUDGET_MS - patternClock.spentMs;
+    if (remaining <= 0)
+        throw new PyJsonSchemaRefusal(patternBudgetSentence(pattern));
+    regexContext ??= vm.createContext(Object.create(null));
+    regexContext['r'] = re;
+    regexContext['s'] = text;
+    const started = performance.now();
+    try {
+        return regexScript.runInContext(regexContext, { timeout: Math.max(1, Math.ceil(remaining)) }) === true;
+    }
+    catch (e) {
+        if (e.code === 'ERR_SCRIPT_EXECUTION_TIMEOUT') {
+            throw new PyJsonSchemaRefusal(patternBudgetSentence(pattern));
         }
+        throw e;
+    }
+    finally {
+        patternClock.spentMs += performance.now() - started;
+        regexContext['r'] = undefined;
+        regexContext['s'] = undefined;
     }
-    return re.test(text);
 }
 const sortedByStr = (names) => [...names].sort(cmpCodepoint);
 /** Python truthiness for a decoded JSON value: `not aP`, `if uI`. */
@@ -249,11 +1109,445 @@ function pyTruthy(value) {
             return value.v.size > 0;
     }
 }
+// ------------------------------------------------------------------- the one resource
+const REF_KEYWORDS = ['$ref', '$dynamicRef', '$recursiveRef'];
+/** The keywords whose value is a schema, in ANY dialect — the walk the pre-scan takes. */
+const WALK_SUBSCHEMA = new Set([
+    'additionalItems', 'additionalProperties', 'contains', 'else', 'if', 'items', 'not',
+    'propertyNames', 'then', 'unevaluatedItems', 'unevaluatedProperties',
+]);
+/** …whose value is an object whose VALUES are schemas (or, for `dependencies`, string lists). */
+const WALK_MAP = new Set(['$defs', 'definitions', 'dependencies', 'dependentSchemas', 'patternProperties', 'properties']);
+/** …whose value is an array of schemas. */
+const WALK_LIST = new Set(['allOf', 'anyOf', 'oneOf', 'prefixItems']);
+/**
+ * Every subschema of `schema`, root first, in document order, with its path in the form
+ * the refusal sentence prints. Structural, not blind: a PROPERTY named `$ref` is not a
+ * reference, and this walk never mistakes it for one. `contract.py`'s `_subschemas` is the
+ * same walk in the same order, which is what makes the two sentences name the same place.
+ */
+function* subschemas(schema, path = '') {
+    if (schema.t !== 'dict')
+        return;
+    yield [path, schema.v];
+    for (const [k, v] of schema.v) {
+        const at = path === '' ? k : `${path}/${k}`;
+        if (k === 'items' && v.t === 'list') {
+            for (let i = 0; i < v.v.length; i += 1)
+                yield* subschemas(v.v[i], `${at}/${i}`);
+        }
+        else if (WALK_SUBSCHEMA.has(k)) {
+            yield* subschemas(v, at);
+        }
+        else if (WALK_MAP.has(k) && v.t === 'dict') {
+            for (const [n, x] of v.v)
+                yield* subschemas(x, `${at}/${n}`);
+        }
+        else if (WALK_LIST.has(k) && v.t === 'list') {
+            for (let i = 0; i < v.v.length; i += 1)
+                yield* subschemas(v.v[i], `${at}/${i}`);
+        }
+    }
+}
+/**
+ * The eager half of the one-resource rule (#125), run BEFORE `checkSchema` as the Python
+ * pre-scan runs before `check_schema`. Three refusals, in document order, each one sentence
+ * that `contract._unsupported_schema` prints byte for byte:
+ *
+ *   - a subschema whose `$schema` names draft 3;
+ *   - a `$ref`/`$dynamicRef` that is not fragment-only (`$recursiveRef`'s value is never
+ *     read by the reference, so it is never judged here either);
+ *   - a `$id` (`id` under draft 4) below the root while the document holds any reference.
+ *
+ * Eager rather than on first use, deliberately: the reference resolves a `$ref` only when
+ * validation reaches it, but it resolves it against a base URI this port does not model,
+ * and the Python side cannot be made lazy about an absolute reference it CAN resolve.
+ * Both runtimes refusing the same document is the property; refusing a branch the
+ * instance never reached is the price, and it is the same trade `pattern` already takes.
+ */
+function refuseUnsupportedReferences(schema, draft) {
+    const idKey = draft === 4 ? 'id' : '$id';
+    const refs = [];
+    const ids = [];
+    for (const [path, sub] of subschemas(schema)) {
+        if (path !== '') {
+            const nested = sub.get('$schema');
+            if (nested !== undefined && nested.t === 'str' && DRAFT_BY_URI.get(pyUrlNormalize(nested.v)) === 3) {
+                throw new PyJsonSchemaRefusal(draft3Sentence(nested.v));
+            }
+            const id = sub.get(idKey);
+            if (id !== undefined && id.t === 'str')
+                ids.push(path);
+        }
+        for (const k of REF_KEYWORDS) {
+            const v = sub.get(k);
+            if (v !== undefined && v.t === 'str')
+                refs.push([k, v.v]);
+        }
+    }
+    for (const [k, v] of refs) {
+        if (k !== '$recursiveRef' && v !== '' && !v.startsWith('#')) {
+            throw new PyJsonSchemaRefusal(`the reference ${JSON.stringify(v)} cannot be resolved: only references into this ` +
+                'schema ("#", "#/..." and "#name") are supported');
+        }
+    }
+    if (refs.length > 0 && ids.length > 0) {
+        throw new PyJsonSchemaRefusal(`the schema declares "${idKey}" at ${ids[0]}; references are only resolved in a schema ` +
+            'with a single resource');
+    }
+}
+/**
+ * The eager half of #131, run after the one-resource scan as `contract._unsupported_schema`
+ * runs it: every `pattern` and every `patternProperties` key, in document order, that `re`
+ * parses but this port cannot translate faithfully is refused with one sentence. A pattern
+ * `re` itself refuses is left to `checkSchema`, which raises where the reference raises.
+ */
+function refuseUnsupportedPatterns(schema) {
+    for (const [, sub] of subschemas(schema)) {
+        const candidates = [];
+        const pattern = sub.get('pattern');
+        if (pattern !== undefined && pattern.t === 'str')
+            candidates.push(pattern.v);
+        const pp = sub.get('patternProperties');
+        if (pp !== undefined && pp.t === 'dict')
+            candidates.push(...pp.v.keys());
+        for (const candidate of candidates) {
+            let translation;
+            try {
+                translation = translatePyPattern(candidate);
+            }
+            catch {
+                continue;
+            }
+            if (translation.source === null)
+                throw new PyJsonSchemaRefusal(unsupportedPatternSentence(candidate));
+        }
+    }
+}
+/** `urllib.parse.unquote(s)`: `%XX` runs decoded as UTF-8 with replacement, a lone `%` kept. */
+function pyUnquote(text) {
+    return text.replace(/(?:%[0-9A-Fa-f]{2})+/g, (run) => {
+        const bytes = Uint8Array.from(run.split('%').slice(1), (h) => parseInt(h, 16));
+        return new TextDecoder('utf-8').decode(bytes);
+    });
+}
+/** `int(segment)` for a list index: sign, digits, underscores between them, surrounding whitespace. */
+function pyInt(segment) {
+    const m = /^\s*([+-]?)(\d+(?:_\d+)*)\s*$/.exec(segment);
+    if (m === null) {
+        throw new PyJsonSchemaUnsupported(`invalid literal for int() with base 10: ${JSON.stringify(segment)}`);
+    }
+    const n = Number(m[2].replace(/_/g, ''));
+    return m[1] === '-' ? -n : n;
+}
+const nowhere = (pointer) => new PyJsonSchemaRefusal(`the reference ${JSON.stringify(`#${pointer}`)} points at nothing in this schema`);
+/**
+ * `referencing.Resource.pointer`: the fragment is percent-decoded AS A WHOLE and then split
+ * on `/`; a segment into a sequence goes through `int()` (so `-1` is the last element and
+ * `a` is a `ValueError`, which escapes), a segment into an object has `~1` then `~0`
+ * unescaped. A `str` is a `Sequence` in Python, so a pointer can index into one.
+ */
+function resolvePointer(pointer, root) {
+    let contents = root;
+    for (const raw of pyUnquote(pointer.slice(1)).split('/')) {
+        if (contents.t === 'list' || contents.t === 'str') {
+            const seq = contents.t === 'list' ? contents.v : [...contents.v].map((ch) => ({ t: 'str', v: ch }));
+            const index = pyInt(raw);
+            const i = index < 0 ? seq.length + index : index;
+            if (i < 0 || i >= seq.length)
+                throw nowhere(pointer);
+            contents = seq[i];
+        }
+        else if (contents.t === 'dict') {
+            const next = contents.v.get(raw.replace(/~1/g, '/').replace(/~0/g, '~'));
+            if (next === undefined)
+                throw nowhere(pointer);
+            contents = next;
+        }
+        else {
+            // `3["x"]` — a TypeError in Python, not a LookupError, so not a PointerToNowhere.
+            throw new PyJsonSchemaUnsupported(`${contents.t} object is not subscriptable`);
+        }
+    }
+    return contents;
+}
+/** `Resource.anchor(name)`: the subschema carrying `$anchor` (or, under 2020-12, `$dynamicAnchor`) `name`. */
+function resolveAnchor(name, ctx) {
+    const keys = ctx.rootDraft === 2020 ? ['$anchor', '$dynamicAnchor'] : ctx.rootDraft === 2019 ? ['$anchor'] : [];
+    // Under draft 7 and earlier an anchor is a fragment-only `$id` below the root, which the
+    // eager scan refused with the document; nothing is left here to match.
+    for (const [, sub] of subschemas(ctx.root)) {
+        for (const k of keys) {
+            const v = sub.get(k);
+            if (v !== undefined && v.t === 'str' && v.v === name)
+                return { t: 'dict', v: sub };
+        }
+    }
+    throw new PyJsonSchemaRefusal(`the reference ${JSON.stringify(`#${name}`)} names no anchor in this schema`);
+}
+/** `Resolver.lookup(ref)` inside the one resource: `""` and `"#"` are the root. */
+function resolveRef(ref, ctx) {
+    if (ref === '' || ref === '#')
+        return ctx.root;
+    const fragment = ref.slice(1);
+    if (fragment.startsWith('/'))
+        return resolvePointer(fragment, ctx.root);
+    return resolveAnchor(fragment, ctx);
+}
+const refValue = (keyword, value) => {
+    // `lookup(3)` → `urljoin("", 3)` → TypeError. Both raise.
+    if (value.t !== 'str')
+        throw new PyJsonSchemaUnsupported(`${keyword} must be a string, got ${value.t}`);
+    return value.v;
+};
+// --------------------------------------------------------------- unevaluated*, two ways
+/**
+ * `_utils.find_evaluated_property_keys_by_schema` (2020-12). A list, not a set, because the
+ * reference's is — membership is all it is used for, so the duplicates do not matter.
+ */
+function evaluatedKeys2020(instance, schema, ctx) {
+    if (typeof schema === 'boolean' || schema.t === 'bool')
+        return [];
+    const keys = [];
+    const sub = (child) => evaluatedKeys2020(instance, child, ctx);
+    for (const k of ['$ref', '$dynamicRef']) {
+        const ref = get(schema, k);
+        if (ref !== undefined && ref.t !== 'null')
+            keys.push(...sub(resolveRef(refValue(k, ref), ctx)));
+    }
+    const properties = get(schema, 'properties');
+    if (properties !== undefined && properties.t === 'dict') {
+        for (const name of properties.v.keys())
+            if (instance.has(name))
+                keys.push(name);
+    }
+    for (const k of ['additionalProperties', 'unevaluatedProperties']) {
+        const child = get(schema, k);
+        if (child === undefined || child.t === 'null')
+            continue;
+        for (const [name, value] of instance)
+            if (isValid(value, child, ctx))
+                keys.push(name);
+    }
+    const pp = get(schema, 'patternProperties');
+    if (pp !== undefined && pp.t === 'dict') {
+        for (const name of instance.keys())
+            for (const pattern of pp.v.keys())
+                if (reSearch(pattern, name))
+                    keys.push(name);
+    }
+    const ds = get(schema, 'dependentSchemas');
+    if (ds !== undefined && ds.t === 'dict') {
+        for (const [name, child] of ds.v)
+            if (instance.has(name))
+                keys.push(...sub(child));
+    }
+    for (const k of ['allOf', 'oneOf', 'anyOf']) {
+        const list = get(schema, k);
+        if (list === undefined || list.t !== 'list')
+            continue;
+        for (const child of list.v)
+            if (isValid({ t: 'dict', v: instance }, child, ctx))
+                keys.push(...sub(child));
+    }
+    keys.push(...evaluatedByIf(schema, { t: 'dict', v: instance }, ctx, sub));
+    return keys;
+}
+/** The `if`/`then`/`else` arm all four walkers share. */
+function evaluatedByIf(schema, instance, ctx, walk) {
+    const cond = get(schema, 'if');
+    if (cond === undefined)
+        return [];
+    if (isValid(instance, cond, ctx)) {
+        const then = get(schema, 'then');
+        return [...walk(cond), ...(then === undefined ? [] : walk(then))];
+    }
+    const otherwise = get(schema, 'else');
+    return otherwise === undefined ? [] : walk(otherwise);
+}
+/**
+ * `_legacy_keywords.find_evaluated_property_keys_by_schema` (2019-09). Note the second
+ * loop: for an OBJECT `additionalProperties`/`unevaluatedProperties` it reads the
+ * subschema's KEYS (`type`, `minLength`, …) as property names. Reproduced, not corrected —
+ * the sentence that comes out of it is the reference's sentence.
+ */
+function evaluatedKeys2019(instance, schema, ctx) {
+    if (typeof schema === 'boolean' || schema.t === 'bool')
+        return [];
+    const keys = [];
+    const sub = (child) => evaluatedKeys2019(instance, child, ctx);
+    const ref = get(schema, '$ref');
+    if (ref !== undefined && ref.t !== 'null')
+        keys.push(...sub(resolveRef(refValue('$ref', ref), ctx)));
+    if (get(schema, '$recursiveRef') !== undefined)
+        keys.push(...sub(ctx.root));
+    for (const k of ['properties', 'additionalProperties', 'unevaluatedProperties']) {
+        const value = get(schema, k);
+        if (value === undefined)
+            continue;
+        if (value.t === 'bool' && value.v)
+            keys.push(...instance.keys());
+        else if (value.t === 'dict')
+            for (const name of value.v.keys())
+                if (instance.has(name))
+                    keys.push(name);
+    }
+    const pp = get(schema, 'patternProperties');
+    if (pp !== undefined && pp.t === 'dict') {
+        for (const name of instance.keys())
+            for (const pattern of pp.v.keys())
+                if (reSearch(pattern, name))
+                    keys.push(name);
+    }
+    const ds = get(schema, 'dependentSchemas');
+    if (ds !== undefined && ds.t === 'dict') {
+        for (const [name, child] of ds.v)
+            if (instance.has(name))
+                keys.push(...sub(child));
+    }
+    for (const k of ['allOf', 'oneOf', 'anyOf']) {
+        const list = get(schema, k);
+        if (list === undefined || list.t !== 'list')
+            continue;
+        for (const child of list.v)
+            if (isValid({ t: 'dict', v: instance }, child, ctx))
+                keys.push(...sub(child));
+    }
+    keys.push(...evaluatedByIf(schema, { t: 'dict', v: instance }, ctx, sub));
+    return keys;
+}
+const range = (n) => Array.from({ length: n }, (_, i) => i);
+/** `_utils.find_evaluated_item_indexes_by_schema` (2020-12). */
+function evaluatedIndexes2020(instance, schema, ctx) {
+    if (typeof schema === 'boolean' || schema.t === 'bool')
+        return [];
+    if (get(schema, 'items') !== undefined)
+        return range(instance.length);
+    const idx = [];
+    const sub = (child) => evaluatedIndexes2020(instance, child, ctx);
+    for (const k of ['$ref', '$dynamicRef']) {
+        const ref = get(schema, k);
+        if (ref !== undefined && ref.t !== 'null')
+            idx.push(...sub(resolveRef(refValue(k, ref), ctx)));
+    }
+    const prefix = get(schema, 'prefixItems');
+    if (prefix !== undefined)
+        idx.push(...range(pyLen(prefix)));
+    const list = { t: 'list', v: instance };
+    idx.push(...evaluatedByIf(schema, list, ctx, sub));
+    for (const k of ['contains', 'unevaluatedItems']) {
+        const child = get(schema, k);
+        if (child === undefined)
+            continue;
+        instance.forEach((v, i) => {
+            if (isValid(v, child, ctx))
+                idx.push(i);
+        });
+    }
+    for (const k of ['allOf', 'oneOf', 'anyOf']) {
+        const children = get(schema, k);
+        if (children === undefined || children.t !== 'list')
+            continue;
+        for (const child of children.v)
+            if (isValid(list, child, ctx))
+                idx.push(...sub(child));
+    }
+    return idx;
+}
+/** `_legacy_keywords.find_evaluated_item_indexes_by_schema` (2019-09). */
+function evaluatedIndexes2019(instance, schema, ctx) {
+    if (typeof schema === 'boolean' || schema.t === 'bool')
+        return [];
+    const idx = [];
+    const sub = (child) => evaluatedIndexes2019(instance, child, ctx);
+    const ref = get(schema, '$ref');
+    if (ref !== undefined && ref.t !== 'null')
+        idx.push(...sub(resolveRef(refValue('$ref', ref), ctx)));
+    if (get(schema, '$recursiveRef') !== undefined)
+        idx.push(...sub(ctx.root));
+    const items = get(schema, 'items');
+    if (items !== undefined) {
+        if (get(schema, 'additionalItems') !== undefined)
+            return range(instance.length);
+        if (items.t === 'dict')
+            return range(instance.length);
+        idx.push(...range(pyLen(items)));
+    }
+    const list = { t: 'list', v: instance };
+    idx.push(...evaluatedByIf(schema, list, ctx, sub));
+    for (const k of ['contains', 'unevaluatedItems']) {
+        const child = get(schema, k);
+        if (child === undefined)
+            continue;
+        instance.forEach((v, i) => {
+            if (isValid(v, child, ctx))
+                idx.push(i);
+        });
+    }
+    for (const k of ['allOf', 'oneOf', 'anyOf']) {
+        const children = get(schema, k);
+        if (children === undefined || children.t !== 'list')
+            continue;
+        for (const child of children.v)
+            if (isValid(list, child, ctx))
+                idx.push(...sub(child));
+    }
+    return idx;
+}
+/** `len(value)` where the reference calls it on a schema value: a list, a dict, a string — never a bool. */
+function pyLen(value) {
+    if (value.t === 'list')
+        return value.v.length;
+    if (value.t === 'dict')
+        return value.v.size;
+    if (value.t === 'str')
+        return cpLength(value.v);
+    throw new PyJsonSchemaUnsupported(`object of type '${value.t}' has no len()`);
+}
+function unevaluatedItemsWith(walker) {
+    return (_value, instance, schema, emit, _descend, ctx) => {
+        if (instance.t !== 'list')
+            return [];
+        const evaluated = new Set(walker(instance.v, schema, ctx));
+        const unevaluated = instance.v.filter((_, i) => !evaluated.has(i));
+        if (unevaluated.length === 0)
+            return [];
+        const [joined, verb] = extrasMsgValues(unevaluated);
+        return [emit(`Unevaluated items are not allowed (${joined} ${verb} unexpected)`)];
+    };
+}
+function unevaluatedPropertiesWith(walker) {
+    return (value, instance, schema, emit, _descend, ctx) => {
+        if (instance.t !== 'dict')
+            return [];
+        const evaluated = new Set(walker(instance.v, schema, ctx));
+        const unevaluated = [];
+        for (const [name, v] of instance.v) {
+            if (evaluated.has(name))
+                continue;
+            // `for _ in validator.descend(...)`: appended ONCE PER ERROR, so a subschema that
+            // fails a property twice names it twice. Reproduced.
+            for (const _ of iterErrors(v, value, ctx))
+                unevaluated.push(name);
+        }
+        if (unevaluated.length === 0)
+            return [];
+        if (value.t === 'bool' && !value.v) {
+            const [joined, verb] = extrasMsg(sortedByStr(unevaluated));
+            return [emit(`Unevaluated properties are not allowed (${joined} ${verb} unexpected)`)];
+        }
+        const [joined, verb] = extrasMsg(unevaluated);
+        return [
+            emit(`Unevaluated properties are not valid under the given schema (${joined} ${verb} unevaluated and invalid)`),
+        ];
+    };
+}
+// ------------------------------------------------------------------------- the keywords
 const KEYWORDS = {
-    type(value, instance, _schema, emit) {
+    type(value, instance, _schema, emit, _descend, ctx) {
         // `ensure_list`: a bare string becomes a one-element list, anything else passes through.
         const types = value.t === 'str' ? [value] : value.t === 'list' ? value.v : [value];
-        if (types.some((t) => t.t === 'str' && isType(instance, t.v)))
+        if (types.some((t) => t.t === 'str' && isType(instance, t.v, ctx.draft)))
             return [];
         const reprs = types.map(reprValue).join(', ');
         return [emit(`${reprValue(instance)} is not of type ${reprs}`)];
@@ -341,6 +1635,7 @@ const KEYWORDS = {
             out.push(...descend(instance.v[i], value.v[i], i));
         return out;
     },
+    /** `_keywords.items` (2020-12): everything past `prefixItems`. */
     items(value, instance, schema, emit, descend) {
         if (instance.t !== 'list')
             return [];
@@ -360,7 +1655,8 @@ const KEYWORDS = {
             out.push(...descend(instance.v[i], value, i));
         return out;
     },
-    contains(value, instance, schema, emit) {
+    /** `_keywords.contains` (2019-09 and 2020-12): with `minContains`/`maxContains`. */
+    contains(value, instance, schema, emit, _descend, ctx) {
         if (instance.t !== 'list')
             return [];
         const minRaw = get(schema, 'minContains');
@@ -369,7 +1665,7 @@ const KEYWORDS = {
         const maxContains = maxRaw === undefined ? instance.v.length : asNumber(maxRaw);
         let matches = 0;
         for (const each of instance.v) {
-            if (isValid(each, value)) {
+            if (isValid(each, value, ctx)) {
                 matches += 1;
                 if (matches > maxContains) {
                     return [
@@ -561,12 +1857,12 @@ const KEYWORDS = {
             out.push(...descend(instance, subschema));
         return out;
     },
-    anyOf(value, instance, _schema, emit) {
+    anyOf(value, instance, _schema, emit, _descend, ctx) {
         if (value.t !== 'list')
             return [];
         const allErrors = [];
         for (const subschema of value.v) {
-            const errs = iterErrors(instance, subschema);
+            const errs = iterErrors(instance, subschema, ctx);
             if (errs.length === 0)
                 return [];
             allErrors.push(...errs);
@@ -578,7 +1874,7 @@ const KEYWORDS = {
             child.parent = error;
         return [error];
     },
-    oneOf(value, instance, _schema, emit) {
+    oneOf(value, instance, _schema, emit, _descend, ctx) {
         if (value.t !== 'list')
             return [];
         const out = [];
@@ -586,7 +1882,7 @@ const KEYWORDS = {
         let firstValid = null;
         let index = 0;
         for (; index < value.v.length; index += 1) {
-            const errs = iterErrors(instance, value.v[index]);
+            const errs = iterErrors(instance, value.v[index], ctx);
             if (errs.length === 0) {
                 firstValid = value.v[index];
                 break;
@@ -603,26 +1899,218 @@ const KEYWORDS = {
         }
         // `subschemas` is one shared iterator in Python: the comprehension below resumes where
         // the loop above broke, so the schemas already tried are never re-checked.
-        const moreValid = value.v.slice(index + 1).filter((each) => isValid(instance, each));
+        const moreValid = value.v.slice(index + 1).filter((each) => isValid(instance, each, ctx));
         if (moreValid.length > 0) {
             const reprs = [...moreValid, firstValid].map(reprValue).join(', ');
             out.push(emit(`${reprValue(instance)} is valid under each of ${reprs}`));
         }
         return out;
     },
-    not(value, instance, _schema, emit) {
-        if (!isValid(instance, value))
+    not(value, instance, _schema, emit, _descend, ctx) {
+        if (!isValid(instance, value, ctx))
             return [];
         return [emit(`${reprValue(instance)} should not be valid under ${reprValue(value)}`)];
     },
-    if(value, instance, schema, _emit, descend) {
-        if (isValid(instance, value)) {
+    if(value, instance, schema, _emit, descend, ctx) {
+        if (isValid(instance, value, ctx)) {
             const then = get(schema, 'then');
             return then === undefined ? [] : descend(instance, then);
         }
         const otherwise = get(schema, 'else');
         return otherwise === undefined ? [] : descend(instance, otherwise);
     },
+    /** `_keywords.ref`: `descend(instance, resolved.contents)` — no path, no `$ref` in the schema path. */
+    $ref(value, instance, _schema, _emit, descend, ctx) {
+        return descend(instance, resolveRef(refValue('$ref', value), ctx));
+    },
+    /** `_keywords.dynamicRef` is `_validate_reference(ref=dynamicRef)` — the same lookup. */
+    $dynamicRef(value, instance, _schema, _emit, descend, ctx) {
+        return descend(instance, resolveRef(refValue('$dynamicRef', value), ctx));
+    },
+    /** `_legacy_keywords.recursiveRef` never reads its value; in one resource it is the root. */
+    $recursiveRef(_value, instance, _schema, _emit, descend, ctx) {
+        return descend(instance, ctx.root);
+    },
+    unevaluatedItems: unevaluatedItemsWith(evaluatedIndexes2020),
+    unevaluatedProperties: unevaluatedPropertiesWith(evaluatedKeys2020),
+};
+/** `_legacy_keywords`: the keywords whose shape or sentence is older than 2020-12. */
+const LEGACY = {
+    /** `items_draft3_draft4`: an object applies to every item, anything else is zipped. */
+    itemsDraft4(value, instance, _schema, _emit, descend) {
+        if (instance.t !== 'list')
+            return [];
+        const out = [];
+        if (value.t === 'dict') {
+            instance.v.forEach((item, i) => out.push(...descend(item, value, i)));
+        }
+        else if (value.t === 'list') {
+            const n = Math.min(instance.v.length, value.v.length);
+            for (let i = 0; i < n; i += 1)
+                out.push(...descend(instance.v[i], value.v[i], i));
+        }
+        return out;
+    },
+    /** `items_draft6_draft7_draft201909`: an array is zipped, anything else applies to every item. */
+    itemsDraft6(value, instance, _schema, _emit, descend) {
+        if (instance.t !== 'list')
+            return [];
+        const out = [];
+        if (value.t === 'list') {
+            const n = Math.min(instance.v.length, value.v.length);
+            for (let i = 0; i < n; i += 1)
+                out.push(...descend(instance.v[i], value.v[i], i));
+        }
+        else {
+            instance.v.forEach((item, i) => out.push(...descend(item, value, i)));
+        }
+        return out;
+    },
+    additionalItems(value, instance, schema, emit, descend) {
+        if (instance.t !== 'list')
+            return [];
+        // `schema.get("items", {})` is an object when absent, so the keyword applies only
+        // beside a LIST `items`; `len(True)` beside a boolean one is a TypeError that escapes.
+        const items = get(schema, 'items');
+        if (items === undefined || items.t === 'dict')
+            return [];
+        const lenItems = pyLen(items);
+        if (value.t === 'dict') {
+            const out = [];
+            for (let i = lenItems; i < instance.v.length; i += 1)
+                out.push(...descend(instance.v[i], value, i));
+            return out;
+        }
+        if (!pyTruthy(value) && instance.v.length > lenItems) {
+            const [joined, verb] = extrasMsgValues(instance.v.slice(lenItems));
+            return [emit(`Additional items are not allowed (${joined} ${verb} unexpected)`)];
+        }
+        return [];
+    },
+    /** `dependencies_draft4_draft6_draft7`: a list is `dependentRequired`, anything else a schema. */
+    dependencies(value, instance, _schema, emit, descend) {
+        if (instance.t !== 'dict' || value.t !== 'dict')
+            return [];
+        const out = [];
+        for (const [property, dependency] of value.v) {
+            if (!instance.v.has(property))
+                continue;
+            if (dependency.t === 'list') {
+                for (const each of dependency.v) {
+                    const name = each.v;
+                    if (!instance.v.has(name)) {
+                        out.push(emit(`${reprValue(each)} is a dependency of ${reprValue({ t: 'str', v: property })}`));
+                    }
+                }
+            }
+            else {
+                out.push(...descend(instance, dependency));
+            }
+        }
+        return out;
+    },
+    /** `maximum_draft3_draft4`: a truthy `exclusiveMaximum` sibling makes the bound exclusive. */
+    maximumDraft4(value, instance, schema, emit) {
+        if (!isType(instance, 'number'))
+            return [];
+        const exclusive = get(schema, 'exclusiveMaximum');
+        if (exclusive !== undefined && pyTruthy(exclusive)) {
+            if (!numLess(instance, value)) {
+                return [emit(`${reprValue(instance)} is greater than or equal to the maximum of ${reprValue(value)}`)];
+            }
+            return [];
+        }
+        if (numLess(value, instance)) {
+            return [emit(`${reprValue(instance)} is greater than the maximum of ${reprValue(value)}`)];
+        }
+        return [];
+    },
+    minimumDraft4(value, instance, schema, emit) {
+        if (!isType(instance, 'number'))
+            return [];
+        const exclusive = get(schema, 'exclusiveMinimum');
+        if (exclusive !== undefined && pyTruthy(exclusive)) {
+            if (!numLess(value, instance)) {
+                return [emit(`${reprValue(instance)} is less than or equal to the minimum of ${reprValue(value)}`)];
+            }
+            return [];
+        }
+        if (numLess(instance, value)) {
+            return [emit(`${reprValue(instance)} is less than the minimum of ${reprValue(value)}`)];
+        }
+        return [];
+    },
+    /** `contains_draft6_draft7`: no `minContains`, and a different sentence. */
+    containsDraft6(value, instance, _schema, emit, _descend, ctx) {
+        if (instance.t !== 'list')
+            return [];
+        if (instance.v.some((element) => isValid(element, value, ctx)))
+            return [];
+        return [emit(`None of ${reprValue(instance)} are valid under the given schema`)];
+    },
+    unevaluatedItems2019: unevaluatedItemsWith(evaluatedIndexes2019),
+    unevaluatedProperties2019: unevaluatedPropertiesWith(evaluatedKeys2019),
+};
+const pick = (names) => Object.fromEntries(names.map((n) => [n, KEYWORDS[n]]));
+/** `Draft4Validator.VALIDATORS` … `Draft202012Validator.VALIDATORS`, name for name. */
+const KEYWORDS_BY_DRAFT = {
+    4: {
+        ...pick([
+            '$ref', 'additionalProperties', 'allOf', 'anyOf', 'enum', 'format', 'maxItems', 'maxLength',
+            'maxProperties', 'minItems', 'minLength', 'minProperties', 'multipleOf', 'not', 'oneOf',
+            'pattern', 'patternProperties', 'properties', 'required', 'type', 'uniqueItems',
+        ]),
+        additionalItems: LEGACY['additionalItems'],
+        dependencies: LEGACY['dependencies'],
+        items: LEGACY['itemsDraft4'],
+        maximum: LEGACY['maximumDraft4'],
+        minimum: LEGACY['minimumDraft4'],
+    },
+    6: {
+        ...pick([
+            '$ref', 'additionalProperties', 'allOf', 'anyOf', 'const', 'enum', 'exclusiveMaximum',
+            'exclusiveMinimum', 'format', 'maxItems', 'maxLength', 'maxProperties', 'maximum', 'minItems',
+            'minLength', 'minProperties', 'minimum', 'multipleOf', 'not', 'oneOf', 'pattern',
+            'patternProperties', 'properties', 'propertyNames', 'required', 'type', 'uniqueItems',
+        ]),
+        additionalItems: LEGACY['additionalItems'],
+        contains: LEGACY['containsDraft6'],
+        dependencies: LEGACY['dependencies'],
+        items: LEGACY['itemsDraft6'],
+    },
+    7: {
+        ...pick([
+            '$ref', 'additionalProperties', 'allOf', 'anyOf', 'const', 'enum', 'exclusiveMaximum',
+            'exclusiveMinimum', 'format', 'if', 'maxItems', 'maxLength', 'maxProperties', 'maximum',
+            'minItems', 'minLength', 'minProperties', 'minimum', 'multipleOf', 'not', 'oneOf', 'pattern',
+            'patternProperties', 'properties', 'propertyNames', 'required', 'type', 'uniqueItems',
+        ]),
+        additionalItems: LEGACY['additionalItems'],
+        contains: LEGACY['containsDraft6'],
+        dependencies: LEGACY['dependencies'],
+        items: LEGACY['itemsDraft6'],
+    },
+    2019: {
+        ...pick([
+            '$recursiveRef', '$ref', 'additionalProperties', 'allOf', 'anyOf', 'const', 'contains',
+            'dependentRequired', 'dependentSchemas', 'enum', 'exclusiveMaximum', 'exclusiveMinimum',
+            'format', 'if', 'maxItems', 'maxLength', 'maxProperties', 'maximum', 'minItems', 'minLength',
+            'minProperties', 'minimum', 'multipleOf', 'not', 'oneOf', 'pattern', 'patternProperties',
+            'properties', 'propertyNames', 'required', 'type', 'uniqueItems',
+        ]),
+        additionalItems: LEGACY['additionalItems'],
+        items: LEGACY['itemsDraft6'],
+        unevaluatedItems: LEGACY['unevaluatedItems2019'],
+        unevaluatedProperties: LEGACY['unevaluatedProperties2019'],
+    },
+    2020: pick([
+        '$dynamicRef', '$ref', 'additionalProperties', 'allOf', 'anyOf', 'const', 'contains',
+        'dependentRequired', 'dependentSchemas', 'enum', 'exclusiveMaximum', 'exclusiveMinimum',
+        'format', 'if', 'items', 'maxItems', 'maxLength', 'maxProperties', 'maximum', 'minItems',
+        'minLength', 'minProperties', 'minimum', 'multipleOf', 'not', 'oneOf', 'pattern',
+        'patternProperties', 'prefixItems', 'properties', 'propertyNames', 'required', 'type',
+        'unevaluatedItems', 'unevaluatedProperties', 'uniqueItems',
+    ]),
 };
 /** `a < b` over Python numbers, exact for two ints of any size. */
 function numLess(a, b) {
@@ -641,9 +2129,9 @@ function matchesType(error) {
     if (expected === undefined)
         return false;
     if (expected.t === 'str')
-        return isType(error.instance, expected.v);
+        return isType(error.instance, expected.v, error.draft);
     if (expected.t === 'list') {
-        return expected.v.some((t) => isType(error.instance, t.v));
+        return expected.v.some((t) => isType(error.instance, t.v, error.draft));
     }
     return false;
 }
@@ -732,10 +2220,10 @@ export function bestMatch(errors) {
 }
 // ------------------------------------------------------------------ the schema, checked
 /**
- * `cls.check_schema(schema)`, reduced to the SHAPE of each keyword's value.
+ * `cls.check_schema(schema)`, reduced to the SHAPE of each keyword's value, per dialect.
  *
  * WHY THIS EXISTS, and why it is not the metaschema. `jsonschema.validate` runs
- * `check_schema` BEFORE it looks at the instance, so a caller schema the 2020-12 metaschema
+ * `check_schema` BEFORE it looks at the instance, so a caller schema the metaschema
  * refuses never reaches a keyword. Without it, this port ran the keywords anyway and the
  * keywords are written to SKIP a value they do not recognise — which is correct behaviour
  * inside `iter_errors` and a wrong ANSWER at the tool boundary. N8 measured it on the wire:
@@ -748,96 +2236,175 @@ export function bestMatch(errors) {
  *
  * The last one is the worst of the five: a sentence about a schema that is not a schema.
  *
- * WHAT IS CHECKED, AND THE RULING ON WHAT IS NOT. Running the real metaschema is not
- * available to this port — the 2020-12 metaschema is eight documents wired together with
- * `$ref` and `$dynamicRef`, which is exactly the vocabulary this file refuses to implement,
- * so `check_schema` would have to be more capable than `validate`. What is here instead is
- * the SHAPE TABLE: for every keyword this port implements, the type the metaschema demands
- * of its value, applied recursively through the keywords whose values hold subschemas. That
- * is narrower than the metaschema — it does not enforce `uniqueItems` on `required`, the
- * `minLength: 1` on `allOf`, or that a `pattern` compiles — and every gap is a schema Python
- * refuses and this port answers on. Each keyword listed below is MEASURED against the
- * reference in `tools/conformance/suites/validate.mjs`; the gaps are listed there too, as
- * cases that are deliberately absent rather than quietly ruled.
+ * WHAT IS CHECKED, AND THE RULING ON WHAT IS NOT. Running the real metaschemas is not
+ * available to this port — each is several documents wired together across resources with
+ * `$ref`/`$dynamicRef`, and one resource is all this file resolves. What is here instead
+ * is the SHAPE TABLE: for every keyword this port implements, the type the dialect's
+ * metaschema demands of its value, applied recursively through the keywords whose values
+ * hold subschemas, and GATED BY DIALECT — the metaschema of draft 4 knows no `if`, so
+ * `{"if": 3}` is data there and a `SchemaError` from draft 7 on; draft 4 allows no boolean
+ * subschema, requires `maximum` beside `exclusiveMaximum: true`, refuses an empty
+ * `required`/`enum` and reads `2.0` as a non-integer. That is narrower than the metaschema
+ * — it does not check `title`, `description`, `$comment` or `examples`, nor
+ * `dependentRequired`'s uniqueness — and every gap is a schema Python refuses and this port
+ * answers on. Each keyword listed below is MEASURED against the reference in
+ * `tools/conformance/suites/validate.mjs`, under every dialect; the gaps are listed there
+ * too, as rows deliberately absent from the grid rather than quietly ruled.
  *
- * BOTH RUNTIMES NOW REFUSE, AND THE SENTENCE DIFFERS. Python raises `SchemaError` with the
+ * BOTH RUNTIMES REFUSE, AND THE SENTENCE DIFFERS. Python raises `SchemaError` with the
  * metaschema's own wording and it ESCAPES `validate_json` to the caller (a registered
  * `runtime-py` defect — a tool should not let an exception out on caller input; not fixed
  * here, invariant 8). This raises `PyJsonSchemaUnsupported`, which escapes the same way,
  * because agreeing that the tool raises is the behaviour and inventing an answer is not.
  */
 const SIMPLE_TYPES = new Set(['array', 'boolean', 'integer', 'null', 'number', 'object', 'string']);
-/** Keywords whose value is itself a schema. */
-const SUBSCHEMA = [
-    'additionalProperties',
-    'contains',
-    'else',
-    'if',
-    'items',
-    'not',
-    'propertyNames',
-    'then',
-    'unevaluatedItems',
-    'unevaluatedProperties',
-];
+/** Keywords whose value is itself a schema, and the first dialect that knows them. */
+const SUBSCHEMA = {
+    additionalProperties: 4,
+    contains: 6,
+    else: 7,
+    if: 7,
+    not: 4,
+    propertyNames: 6,
+    then: 7,
+    unevaluatedItems: 2019,
+    unevaluatedProperties: 2019,
+};
 /** Keywords whose value is an object whose VALUES are schemas. */
-const SUBSCHEMA_MAP = ['$defs', 'definitions', 'dependentSchemas', 'patternProperties', 'properties'];
-/** Keywords whose value is an array of schemas. */
-const SUBSCHEMA_LIST = ['allOf', 'anyOf', 'oneOf', 'prefixItems'];
+const SUBSCHEMA_MAP = { $defs: 2019, definitions: 4, dependentSchemas: 2019, patternProperties: 4, properties: 4 };
+/** Keywords whose value is a non-empty array of schemas. */
+const SUBSCHEMA_LIST = { allOf: 4, anyOf: 4, oneOf: 4 };
 /** Keywords whose value is any JSON number. */
-const NUMBER_KEYWORDS = ['exclusiveMaximum', 'exclusiveMinimum', 'maximum', 'minimum'];
-/** Keywords whose value is a non-negative integer. */
-const COUNT_KEYWORDS = [
-    'maxContains',
-    'maxItems',
-    'maxLength',
-    'maxProperties',
-    'minContains',
-    'minItems',
-    'minLength',
-    'minProperties',
-];
+const NUMBER_KEYWORDS = ['maximum', 'minimum'];
+/** Keywords whose value is a non-negative integer, and the first dialect that knows them. */
+const COUNT_KEYWORDS = {
+    maxContains: 2019,
+    maxItems: 4,
+    maxLength: 4,
+    maxProperties: 4,
+    minContains: 2019,
+    minItems: 4,
+    minLength: 4,
+    minProperties: 4,
+};
+/** `$anchor`'s pattern changed between the two dialects that have it. */
+const ANCHOR_PATTERN = {
+    2019: /^[A-Za-z][-A-Za-z0-9.:_]*$/,
+    2020: /^[A-Za-z_][-A-Za-z0-9._]*$/,
+};
+const knows = (draft, since) => draft >= since;
 function refuse(where, expected, got) {
     const kind = typeof got === 'boolean' ? 'boolean' : got.t;
     throw new PyJsonSchemaUnsupported(`${where} must be ${expected}, got ${kind}`);
 }
-const isSchemaValue = (v) => v.t === 'dict' || v.t === 'bool';
-export function checkSchema(schema, where = 'the schema') {
+/** Draft 4's metaschema says `"type": "object"` for every subschema; draft 6 added the booleans. */
+const isSchemaValue = (v, draft) => v.t === 'dict' || (v.t === 'bool' && draft !== 4);
+const schemaWord = (draft) => (draft === 4 ? 'an object' : 'an object or a boolean');
+export function checkSchema(schema, where = 'the schema', draft) {
     if (typeof schema === 'boolean' || schema.t === 'bool')
         return;
+    const d = draft ?? dialectOf(schema, 2020);
     if (schema.t !== 'dict')
         refuse(where, 'an object or a boolean', schema);
+    const subschema = (v, at, boolOk = false) => {
+        if (!(boolOk && v.t === 'bool') && !isSchemaValue(v, d))
+            refuse(at, schemaWord(d), v);
+        checkSchema(v, at, d);
+    };
+    const schemaList = (value, at, nonEmpty) => {
+        if (value.t !== 'list')
+            refuse(at, 'an array', value);
+        if (nonEmpty && value.v.length === 0)
+            throw new PyJsonSchemaUnsupported(`${at} must be a non-empty array`);
+        value.v.forEach((v, i) => subschema(v, `${at}/${i}`));
+    };
+    const stringList = (value, at, nonEmpty) => {
+        if (value.t !== 'list')
+            refuse(at, 'an array', value);
+        if (nonEmpty && value.v.length === 0)
+            throw new PyJsonSchemaUnsupported(`${at} must be a non-empty array`);
+        const seen = new Set();
+        value.v.forEach((v, i) => {
+            if (v.t !== 'str')
+                refuse(`${at}/${i}`, 'a string', v);
+            if (seen.has(v.v)) {
+                throw new PyJsonSchemaUnsupported(`${at} must have unique items, got ${reprValue(v)} twice`);
+            }
+            seen.add(v.v);
+        });
+    };
+    const string = (value, at) => {
+        if (value.t !== 'str')
+            refuse(at, 'a string', value);
+        return value.v;
+    };
+    const anchor = (value, at) => {
+        const pattern = ANCHOR_PATTERN[d === 2019 ? 2019 : 2020];
+        if (!pattern.test(string(value, at))) {
+            throw new PyJsonSchemaUnsupported(`${at} must match ${pattern.source}, got ${reprValue(value)}`);
+        }
+    };
     for (const [keyword, value] of schema.v) {
         const at = `${where}: ${keyword}`;
-        if (SUBSCHEMA_LIST.includes(keyword) && keyword !== 'prefixItems') {
-            // `allOf`/`anyOf`/`oneOf` carry `"minItems": 1` in the applicator vocabulary.
-            if (value.t === 'list' && value.v.length === 0) {
-                throw new PyJsonSchemaUnsupported(`${at} must be a non-empty array`);
+        if (keyword in SUBSCHEMA_LIST) {
+            // `allOf`/`anyOf`/`oneOf` carry `"minItems": 1` in every dialect's metaschema.
+            schemaList(value, at, true);
+        }
+        else if (keyword === 'prefixItems') {
+            if (d === 2020)
+                schemaList(value, at, false);
+        }
+        else if (keyword === 'items') {
+            if (value.t === 'list') {
+                // A tuple `items` is `schemaArray` (non-empty) through 2019-09 and not a schema at all in 2020-12.
+                if (d === 2020)
+                    refuse(at, 'an object or a boolean', value);
+                schemaList(value, at, true);
             }
+            else
+                subschema(value, at);
+        }
+        else if (keyword === 'additionalItems') {
+            // Draft 4 allows no boolean subschema EXCEPT here and on `additionalProperties`, whose
+            // metaschema entries are `anyOf: [{type: boolean}, {$ref: "#"}]`.
+            if (d !== 2020)
+                subschema(value, at, true);
         }
-        if (SUBSCHEMA.includes(keyword)) {
-            if (!isSchemaValue(value))
-                refuse(at, 'an object or a boolean', value);
-            checkSchema(value, at);
+        else if (keyword === 'additionalProperties') {
+            subschema(value, at, true);
+        }
+        else if (keyword in SUBSCHEMA) {
+            if (knows(d, SUBSCHEMA[keyword]))
+                subschema(value, at);
+        }
+        else if (keyword in SUBSCHEMA_MAP) {
+            if (!knows(d, SUBSCHEMA_MAP[keyword]))
+                continue;
+            if (value.t !== 'dict')
+                refuse(at, 'an object', value);
+            // From draft 6 the metaschema says `"propertyNames": {"format": "regex"}` here, so a key
+            // `re` cannot compile is a SchemaError even when no property ever meets it (job65, #131;
+            // until then this port compiled a key only on first use and answered `valid` otherwise).
+            if (keyword === 'patternProperties' && d >= 6)
+                for (const k of value.v.keys())
+                    compilePyPattern(k);
+            for (const [k, v] of value.v)
+                subschema(v, `${at}/${k}`);
         }
-        else if (SUBSCHEMA_MAP.includes(keyword)) {
+        else if (keyword === 'dependencies') {
+            // Each value is a schema or a `stringArray` (non-empty under draft 4). Still a SHAPE in
+            // the 2019-09 and 2020-12 metaschemas — deprecated there, but `{"dependencies": {"a": 3}}`
+            // is a `SchemaError` under every dialect — even though it is no longer a keyword either
+            // validator runs. Measured: `check_schema/gated` in `tools/conformance/suites/validate.mjs`.
             if (value.t !== 'dict')
                 refuse(at, 'an object', value);
             for (const [k, v] of value.v) {
-                if (!isSchemaValue(v))
-                    refuse(`${at}/${k}`, 'an object or a boolean', v);
-                checkSchema(v, `${at}/${k}`);
+                if (v.t === 'list')
+                    stringList(v, `${at}/${k}`, d === 4);
+                else
+                    subschema(v, `${at}/${k}`);
             }
         }
-        else if (SUBSCHEMA_LIST.includes(keyword)) {
-            if (value.t !== 'list')
-                refuse(at, 'an array', value);
-            value.v.forEach((v, i) => {
-                if (!isSchemaValue(v))
-                    refuse(`${at}/${i}`, 'an object or a boolean', v);
-                checkSchema(v, `${at}/${i}`);
-            });
-        }
         else if (keyword === 'type') {
             const each = (v, place) => {
                 if (v.t !== 'str')
@@ -866,19 +2433,12 @@ export function checkSchema(schema, where = 'the schema') {
                 each(value, at);
         }
         else if (keyword === 'required') {
-            if (value.t !== 'list')
-                refuse(at, 'an array', value);
-            const seen = new Set();
-            value.v.forEach((v, i) => {
-                if (v.t !== 'str')
-                    refuse(`${at}/${i}`, 'a string', v);
-                if (seen.has(v.v)) {
-                    throw new PyJsonSchemaUnsupported(`${at} must have unique items, got ${reprValue(v)} twice`);
-                }
-                seen.add(v.v);
-            });
+            // Draft 4's `stringArray` carries `"minItems": 1`; later drafts default it to `[]`.
+            stringList(value, at, d === 4);
         }
         else if (keyword === 'dependentRequired') {
+            if (d < 2019)
+                continue;
             if (value.t !== 'dict')
                 refuse(at, 'an object', value);
             for (const [k, v] of value.v) {
@@ -893,6 +2453,16 @@ export function checkSchema(schema, where = 'the schema') {
         else if (keyword === 'enum') {
             if (value.t !== 'list')
                 refuse(at, 'an array', value);
+            if (d === 4) {
+                // Draft 4: `"minItems": 1, "uniqueItems": true`; draft 6 on, any array.
+                if (value.v.length === 0)
+                    throw new PyJsonSchemaUnsupported(`${at} must be a non-empty array`);
+                value.v.forEach((v, i) => {
+                    if (value.v.slice(0, i).some((seen) => pyEqual(seen, v))) {
+                        throw new PyJsonSchemaUnsupported(`${at} must have unique items, got ${reprValue(v)} twice`);
+                    }
+                });
+            }
         }
         else if (keyword === 'uniqueItems') {
             if (value.t !== 'bool')
@@ -903,18 +2473,12 @@ export function checkSchema(schema, where = 'the schema') {
                 refuse(at, 'a string', value);
             // `"format": "regex"` on `pattern` in the metaschema, and jsonschema's own format
             // checker compiles it — `{"pattern": "("}` is a SchemaError there, and was
-            // `{"valid": true}` here. `reSearch` already refuses a pattern it cannot compile;
-            // this only moves the refusal to where Python's is, which is before the instance.
-            //
-            // THE PRICE, measured and accepted: `re` accepts patterns `RegExp` does not
-            // (`(?P<x>…)`, `\A`, `\Z`), so a schema carrying one now refuses HERE even when the
-            // keyword would never have fired. Before, it refused only when it fired, and answered
-            // otherwise. Both are the same ruled divergence — see the `python re and JS RegExp`
-            // ruling — and a refusal in an unreached branch is a smaller error than `{"valid":
-            // true}` for a pattern that is not a pattern. Both directions are pinned as ruled
-            // cases in `tools/conformance/suites/validate.mjs`.
+            // `{"valid": true}` here. Compiling it here puts the refusal where Python's is, before
+            // the instance. Since job65 (#131) the compile is `re`'s grammar, not `RegExp`'s, so
+            // `(?P<x>…)`, `\A` and `\Z` compile on both sides and the old ruled price — a
+            // Python-only pattern refused here in a branch that never fired — is gone.
             if (keyword === 'pattern')
-                reSearch(value.v, '');
+                compilePyPattern(value.v);
         }
         else if (keyword === 'multipleOf') {
             if (value.t !== 'int' && value.t !== 'float')
@@ -927,25 +2491,92 @@ export function checkSchema(schema, where = 'the schema') {
             if (value.t !== 'int' && value.t !== 'float')
                 refuse(at, 'a number', value);
         }
-        else if (COUNT_KEYWORDS.includes(keyword)) {
-            const integral = value.t === 'int' || (value.t === 'float' && Number.isInteger(value.v));
+        else if (keyword === 'exclusiveMaximum' || keyword === 'exclusiveMinimum') {
+            if (d === 4) {
+                // Draft 4: a boolean modifier, and the metaschema's `dependencies` demand the bound.
+                if (value.t !== 'bool')
+                    refuse(at, 'a boolean', value);
+                const bound = keyword === 'exclusiveMaximum' ? 'maximum' : 'minimum';
+                if (!schema.v.has(bound)) {
+                    throw new PyJsonSchemaUnsupported(`${where}: '${bound}' is a dependency of '${keyword}'`);
+                }
+            }
+            else if (value.t !== 'int' && value.t !== 'float')
+                refuse(at, 'a number', value);
+        }
+        else if (keyword in COUNT_KEYWORDS) {
+            if (!knows(d, COUNT_KEYWORDS[keyword]))
+                continue;
+            // `draft4_type_checker` has no float-with-no-fraction clause: `2.0` is not an integer there.
+            const integral = value.t === 'int' || (d !== 4 && value.t === 'float' && Number.isInteger(value.v));
             if (!integral)
                 refuse(at, 'a non-negative integer', value);
             if (value.t === 'int' ? value.v < 0n : value.v < 0) {
                 throw new PyJsonSchemaUnsupported(`${at} must be a non-negative integer, got ${reprValue(value)}`);
             }
         }
+        else if (keyword === '$schema') {
+            string(value, at);
+        }
+        else if (keyword === '$ref') {
+            // Draft 4's metaschema has no `$ref` property; the lookup refuses a non-string lazily.
+            if (d !== 4)
+                string(value, at);
+        }
+        else if (keyword === '$dynamicRef') {
+            if (d === 2020)
+                string(value, at);
+        }
+        else if (keyword === '$recursiveRef') {
+            if (d >= 2019)
+                string(value, at);
+        }
+        else if (keyword === '$id') {
+            if (d === 4)
+                continue;
+            const id = string(value, at);
+            // 2019-09 and 2020-12: `"pattern": "^[^#]*#?$"` — an empty fragment at most.
+            if (d >= 2019 && !/^[^#]*#?$/.test(id)) {
+                throw new PyJsonSchemaUnsupported(`${at} must match ^[^#]*#?$, got ${reprValue(value)}`);
+            }
+        }
+        else if (keyword === 'id') {
+            if (d === 4)
+                string(value, at);
+        }
+        else if (keyword === '$anchor') {
+            if (d >= 2019)
+                anchor(value, at);
+        }
+        else if (keyword === '$dynamicAnchor') {
+            if (d === 2020)
+                anchor(value, at);
+        }
     }
 }
 /**
  * `jsonschema.validate(instance, schema)` reduced to what `contract.schema_error` needs:
  * the single error `best_match` chooses, or `null`.
  *
- * `check_schema` runs FIRST, as it does in the reference. See `checkSchema` for what that
- * means here and for the five wrong answers it replaced.
+ * In the reference's order: `validator_for` (the dialect, which raises on a non-string
+ * `$schema`), then the one-resource pre-scan `contract.py` runs before `validate`, then
+ * `check_schema`, then the instance. A `PyJsonSchemaRefusal` out of here is an ANSWER —
+ * `contract.schemaError` returns its sentence — and a `PyJsonSchemaUnsupported` is a raise.
  */
 export function validate(instance, schema) {
-    checkSchema(schema);
-    return bestMatch(iterErrors(instance, schema));
+    const draft = dialectOf(schema, 2020);
+    if (schema.t === 'dict') {
+        refuseUnsupportedReferences(schema, draft);
+        refuseUnsupportedPatterns(schema);
+    }
+    checkSchema(schema, 'the schema', draft);
+    const outer = patternClock;
+    patternClock = { spentMs: 0 };
+    try {
+        return bestMatch(iterErrors(instance, schema, { root: schema, draft, rootDraft: draft }));
+    }
+    finally {
+        patternClock = outer;
+    }
 }
 export { iterErrors };