bantamkit-mcp 0.35.7 → 0.35.9

package/dist/pyjsonschema.d.ts

@@ -2,6 +2,24 @@ import { type PyValue } from './pyjson.js';
 export declare class PyJsonSchemaUnsupported extends Error {
     constructor(message: string);
 }
+/**
+ * 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 declare class PyJsonSchemaRefusal extends Error {
+    constructor(message: string);
+}
+/** The drafts this port validates. Draft 3 is looked up so it can be refused by name. */
+export type Draft = 4 | 6 | 7 | 2019 | 2020;
+/**
+ * `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 declare function pyUrlNormalize(uri: string): string;
 /**
  * `jsonschema.exceptions.ValidationError`, narrowed to the fields the relevance heuristic
  * and `schema_error` read.
@@ -11,6 +29,9 @@ export declare class PyJsonSchemaUnsupported extends Error {
  * is what `schema_error` interpolates. Keeping the two apart is not pedantry: `best_match`
  * ranks context errors by their relative paths and then `schema_error` prints an absolute
  * one, and a port that conflated them would name the wrong field inside every `anyOf`.
+ *
+ * `draft` is the dialect the keyword ran under — `error._type_checker`, which
+ * `_matches_type` consults, and the one place the dialect reaches `best_match`.
  */
 export interface PyValidationError {
     message: string;
@@ -21,11 +42,69 @@ export interface PyValidationError {
     path: (string | number)[];
     context: PyValidationError[];
     parent: PyValidationError | null;
+    draft: Draft;
 }
 export declare function absolutePath(error: PyValidationError): (string | number)[];
 /** `jsonschema._utils.equal`: JSON equality that refuses `True == 1`. */
 export declare function pyEqual(a: PyValue, b: PyValue): boolean;
-declare function iterErrors(instance: PyValue, schema: PyValue | boolean): PyValidationError[];
+/** What a keyword needs beyond its own value: the root resource and the dialect in force. */
+interface Ctx {
+    root: PyValue;
+    draft: Draft;
+    /** The ROOT's dialect — anchors are found by the resource's specification, not the leaf's. */
+    rootDraft: Draft;
+}
+declare function iterErrors(instance: PyValue, schema: PyValue | boolean, ctx?: Ctx): PyValidationError[];
+/**
+ * `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.
+ *
+ * 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.
+ */
+export declare class PyReError extends Error {
+    constructor(message: string);
+}
+interface PyReTranslation {
+    /** The `v`-mode source, or `null` when the pattern uses a construct refused above. */
+    source: string | null;
+}
+/** `re._parser.parse(pattern)` + `fix_flags`, re-emitted for a `v`-mode RegExp. */
+export declare function translatePyPattern(pattern: string): PyReTranslation;
+/** The sentence both runtimes answer for a pattern outside the shared dialect (#131). */
+export declare function unsupportedPatternSentence(pattern: string): string;
+/** The milliseconds a document's patterns may spend, in total, before the validation is refused (#132). */
+export declare const PATTERN_BUDGET_MS = 500;
+/** The sentence both runtimes answer when a document's patterns run past the budget (#132). */
+export declare function patternBudgetSentence(pattern: string): string;
+/**
+ * At most `limit` codepoints of `text`, then `…(N more)` (#153). Codepoints, not UTF-16
+ * units, because `len()` on the reference counts codepoints.
+ */
+export declare function clipText(text: string, limit?: number): string;
 /**
  * `jsonschema.exceptions.best_match`.
  *
@@ -38,13 +117,15 @@ declare function iterErrors(instance: PyValue, schema: PyValue | boolean): PyVal
  * parent stands.
  */
 export declare function bestMatch(errors: PyValidationError[]): PyValidationError | null;
-export declare function checkSchema(schema: PyValue | boolean, where?: string): void;
+export declare function checkSchema(schema: PyValue | boolean, where?: string, draft?: Draft): void;
 /**
  * `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 declare function validate(instance: PyValue, schema: PyValue): PyValidationError | null;
 export { iterErrors };