mailschema 0.2.2 → 0.3.1

package/dist/core/binding.d.ts

@@ -1,24 +0,0 @@
-import type { MapDescription } from './types.ts';
-/** The Content-Type of the part that carries a description, labelled with the profile. */
-export declare const DESCRIPTION_MEDIA_TYPE = "application/ld+json; profile=\"https://mailschema.org/profiles/map/0.2\"";
-/**
- * Whether a designated part carries a description of this profile: its media type is
- * application/ld+json, compared case-insensitively, and its profile parameter lists the
- * profile among its space-separated URIs.
- */
-export declare const isDescriptionPart: (mediaType: string, profileParameter: string | undefined) => boolean;
-/** The path of an absolute URL exactly as written, with no dot segments removed and nothing decoded. */
-export declare const writtenPath: (url: string) => string;
-/** The possession capability: the last segment of the execution URL path, as written. */
-export declare const capability: (description: MapDescription) => string;
-/** The rules a possession description's capability URLs meet when it is issued. */
-export declare function capabilityProblems(description: MapDescription): string[];
-/**
- * Whether a Content-Type admits a request rather than a 415: the media type
- * application/json, compared case-insensitively, with no parameter other than a UTF-8
- * charset. Only HTTP's optional whitespace, spaces and tabs, may surround each part, and
- * empty parameter slots are ignored, as RFC 9110 permits.
- */
-export declare function isJsonRequest(contentType: string | undefined): boolean;
-/** The result resource of a request: the description's template with the identifier encoded. */
-export declare const resultUrl: (description: MapDescription, requestId: string) => string;

package/dist/core/binding.js

@@ -1,50 +0,0 @@
-// The HTTP and Structured Email bindings: capability URLs, the requests the execution URL
-// admits, where results live and which message part carries a description.
-import { MAP_PROFILE } from "./artifacts.js";
-/** The Content-Type of the part that carries a description, labelled with the profile. */
-export const DESCRIPTION_MEDIA_TYPE = `application/ld+json; profile="${MAP_PROFILE}"`;
-/**
- * Whether a designated part carries a description of this profile: its media type is
- * application/ld+json, compared case-insensitively, and its profile parameter lists the
- * profile among its space-separated URIs.
- */
-export const isDescriptionPart = (mediaType, profileParameter) => mediaType.toLowerCase() === 'application/ld+json' &&
-    (profileParameter ?? '').split(/[ \t]+/).includes(MAP_PROFILE);
-/** The path of an absolute URL exactly as written, with no dot segments removed and nothing decoded. */
-export const writtenPath = (url) => /^[A-Za-z][A-Za-z0-9+.-]*:\/\/[^/?#]*([^?#]*)/.exec(url)?.[1] ?? '';
-/** The possession capability: the last segment of the execution URL path, as written. */
-export const capability = (description) => writtenPath(description.service.execution.url).split('/').at(-1) ?? '';
-const UNGUESSABLE = /^[A-Za-z0-9_-]{22,}$/;
-const dotSegment = (url) => writtenPath(url)
-    .split('/')
-    .some((segment) => /^(?:\.|%2e){1,2}$/i.test(segment));
-/** The rules a possession description's capability URLs meet when it is issued. */
-export function capabilityProblems(description) {
-    const { url, resultUrlTemplate } = description.service.execution;
-    const issued = capability(description);
-    const problems = [];
-    if (!UNGUESSABLE.test(issued))
-        problems.push('The capability is too short to be unguessable.');
-    if ([url, resultUrlTemplate].some(dotSegment))
-        problems.push('A capability URL must not contain dot segments.');
-    if (!resultUrlTemplate.startsWith(`${url}/`))
-        problems.push('The result template must extend the execution URL and its capability.');
-    if (description.service.humanUrl.includes(issued))
-        problems.push('The human route must not carry the capability.');
-    return problems;
-}
-/**
- * Whether a Content-Type admits a request rather than a 415: the media type
- * application/json, compared case-insensitively, with no parameter other than a UTF-8
- * charset. Only HTTP's optional whitespace, spaces and tabs, may surround each part, and
- * empty parameter slots are ignored, as RFC 9110 permits.
- */
-export function isJsonRequest(contentType) {
-    const [type, ...parameters] = (contentType ?? '')
-        .split(';')
-        .map((part) => part.replace(/^[ \t]+|[ \t]+$/g, '').toLowerCase());
-    return (type === 'application/json' &&
-        parameters.every((parameter) => parameter === '' || /^charset=(?:utf-8|"utf-8")$/.test(parameter)));
-}
-/** The result resource of a request: the description's template with the identifier encoded. */
-export const resultUrl = (description, requestId) => description.service.execution.resultUrlTemplate.replace('{requestId}', () => encodeURIComponent(requestId));

package/dist/core/document.d.ts

@@ -1,24 +0,0 @@
-/** A MAP document that is not I-JSON within the core limits. */
-export declare class InvalidDocument extends Error {
-}
-export declare const MAX_BYTES: number;
-export declare const MAX_DEPTH = 32;
-/**
- * Parse a MAP document as I-JSON (RFC 7493) within the core limits: valid UTF-8 with no
- * byte order mark, at most 64 KiB, no duplicate member names, no lone surrogates,
- * noncharacters or U+0000 in any string, every number within ±(2^53−1), and arrays and
- * objects nested at most 32 deep, the outermost counting as one. Text is measured in its
- * UTF-8 bytes; bytes must be strict UTF-8.
- */
-export declare function parse(input: string | Uint8Array): unknown;
-/**
- * The RFC 8785 canonical form of a JSON value: members sorted by their UTF-16 code units,
- * ECMAScript's minimal string escapes and its number format. An undefined member is
- * left out and an undefined array item is null, as JSON.stringify writes them.
- */
-export declare function canonicalize(value: unknown): string;
-/**
- * `sha-256:` and the SHA-256 of the RFC 8785 canonical form: the digest MAP uses for
- * descriptions, contracts and pinned schemas.
- */
-export declare const digest: (value: unknown) => string;

package/dist/core/documents.d.ts

@@ -1,68 +0,0 @@
-import type { InputError, JsonObject, MapDescription, MapProblem, MapRequest, MapResult, ResultState, Target } from './types.ts';
-/** The HTTP status of every MAP problem code, as the core schema fixes it. */
-export declare const PROBLEM_STATUS: {
-    readonly 'invalid-request': 400;
-    readonly 'authentication-required': 401;
-    readonly refused: 403;
-    readonly 'result-not-found': 404;
-    readonly 'stale-target': 409;
-    readonly 'idempotency-conflict': 409;
-    readonly 'request-in-progress': 409;
-    readonly 'already-decided': 409;
-    readonly 'expired-interaction': 410;
-    readonly 'unsupported-type': 422;
-    readonly 'unsupported-operation': 422;
-};
-export type ProblemCode = keyof typeof PROBLEM_STATUS;
-/**
- * A result for a request, with every correlation member. `approvalUrl` is given exactly for
- * approval-required and `reason` exactly for failed. Like every builder here, it throws
- * rather than return a document the core refuses.
- */
-export declare function result(request: MapRequest, { state, target, resultUrl, recordedAt, output, reason, approvalUrl, actor, }: {
-    state: ResultState;
-    target: Target;
-    resultUrl: string;
-    recordedAt: Date;
-    output?: JsonObject;
-    reason?: string;
-    approvalUrl?: string;
-    actor?: string;
-}): MapResult;
-/**
- * The next state of a pending or approval-required result. Every correlation member and the
- * actor stay; the state, reason, output and recording time change.
- */
-export declare function transition(previous: MapResult, { state, recordedAt, reason, output, }: {
-    state: ResultState;
-    recordedAt: Date;
-    reason?: string;
-    output?: JsonObject;
-}): MapResult;
-/**
- * A problem. With `requestId` it is correlated and carries `instance`, `profile`,
- * `requestId`, `interactionId` and `code`; without, it is plain RFC 9457. It stays within
- * the core limits: a long detail is cut, each input error is bounded, and only as many of
- * the first 100 errors as fit within 64 KiB are kept.
- */
-export declare function problem(code: ProblemCode, { title, detail, requestId, interactionId, resultUrl, target, errors, }: {
-    title: string;
-    detail: string;
-    requestId?: string;
-    interactionId?: string;
-    resultUrl?: string;
-    target?: Target;
-    errors?: InputError[];
-}): MapProblem;
-/** The HTTP status of a result: 202 while work is pending, otherwise 200. */
-export declare const resultStatus: (document: MapResult) => 200 | 202;
-/**
- * Results stay retrievable until the later of the interaction's expiry and the retention
- * interval measured from the latest recorded state.
- */
-export declare const retainUntil: (description: MapDescription, recordedAt: Date) => Date;
-/**
- * An undecided approval ends as failed, with reason expired, at the interaction's expiry,
- * whether or not anyone looks. The settled result, or undefined when nothing changes.
- */
-export declare function settle(document: MapResult, description: MapDescription, now: Date): MapResult | undefined;

package/dist/core/documents.js

@@ -1,145 +0,0 @@
-// Building MAP results and problems, and the lifecycle rules every service applies.
-import { MAP_PROFILE, problemErrors, reached, resultErrors } from "./artifacts.js";
-import { problemMembers, withinDocument } from "./limits.js";
-/** The HTTP status of every MAP problem code, as the core schema fixes it. */
-export const PROBLEM_STATUS = {
-    'invalid-request': 400,
-    'authentication-required': 401,
-    refused: 403,
-    'result-not-found': 404,
-    'stale-target': 409,
-    'idempotency-conflict': 409,
-    'request-in-progress': 409,
-    'already-decided': 409,
-    'expired-interaction': 410,
-    'unsupported-type': 422,
-    'unsupported-operation': 422,
-};
-const PROBLEM_TYPES = 'https://mailschema.org/problems/';
-const NON_TERMINAL = ['pending', 'approval-required'];
-/** The document, once the core definition `check` names accepts it. */
-function built(document, check) {
-    const refused = check(document);
-    if (refused.length)
-        throw new TypeError(`The core refuses this document: ${refused.slice(0, 3).join('; ')}`);
-    return document;
-}
-const defined = (document) => Object.fromEntries(Object.entries(document).filter(([, value]) => value !== undefined));
-/** A result with its members in one order, whichever builder made it, checked by the core. */
-const resultDocument = (members) => built(defined({
-    kind: 'MapResult',
-    profile: MAP_PROFILE,
-    requestId: members.requestId,
-    interactionId: members.interactionId,
-    descriptionDigest: members.descriptionDigest,
-    type: members.type,
-    operation: members.operation,
-    state: members.state,
-    target: members.target,
-    recordedAt: members.recordedAt,
-    resultUrl: members.resultUrl,
-    actor: members.actor,
-    approvalUrl: members.approvalUrl,
-    reason: members.reason,
-    output: members.output,
-}), resultErrors);
-/**
- * A result for a request, with every correlation member. `approvalUrl` is given exactly for
- * approval-required and `reason` exactly for failed. Like every builder here, it throws
- * rather than return a document the core refuses.
- */
-export function result(request, { state, target, resultUrl, recordedAt, output = {}, reason, approvalUrl, actor, }) {
-    if ((state === 'approval-required') !== (approvalUrl !== undefined))
-        throw new TypeError('approvalUrl is given exactly when the state is approval-required.');
-    if ((state === 'failed') !== (reason !== undefined))
-        throw new TypeError('reason is given exactly when the state is failed.');
-    return resultDocument({
-        requestId: request.requestId,
-        interactionId: request.interactionId,
-        descriptionDigest: request.descriptionDigest,
-        type: request.type,
-        operation: request.operation,
-        state,
-        target,
-        recordedAt: recordedAt.toISOString(),
-        resultUrl,
-        actor,
-        approvalUrl,
-        reason,
-        output,
-    });
-}
-/**
- * The next state of a pending or approval-required result. Every correlation member and the
- * actor stay; the state, reason, output and recording time change.
- */
-export function transition(previous, { state, recordedAt, reason, output = {}, }) {
-    if (!NON_TERMINAL.includes(previous.state))
-        throw new TypeError(`A ${previous.state} result is terminal.`);
-    if (NON_TERMINAL.includes(state))
-        throw new TypeError('A transition ends pending work.');
-    if ((state === 'failed') !== (reason !== undefined))
-        throw new TypeError('reason is given exactly when the state is failed.');
-    return resultDocument({
-        ...previous,
-        approvalUrl: undefined,
-        state,
-        reason,
-        output,
-        recordedAt: recordedAt.toISOString(),
-    });
-}
-/**
- * A problem. With `requestId` it is correlated and carries `instance`, `profile`,
- * `requestId`, `interactionId` and `code`; without, it is plain RFC 9457. It stays within
- * the core limits: a long detail is cut, each input error is bounded, and only as many of
- * the first 100 errors as fit within 64 KiB are kept.
- */
-export function problem(code, { title, detail, requestId, interactionId, resultUrl, target, errors, }) {
-    const members = problemMembers(title, detail, errors);
-    if (interactionId && !requestId)
-        throw new TypeError('An interaction is named only with its request.');
-    if (requestId && code === 'authentication-required')
-        throw new TypeError('authentication-required is never correlated.');
-    if (members.errors && !(requestId && code === 'invalid-request'))
-        throw new TypeError('Errors belong to a correlated invalid-request.');
-    let correlation = {};
-    if (requestId) {
-        if (!resultUrl)
-            throw new TypeError('A correlated problem names its result URL.');
-        if (!interactionId && code !== 'result-not-found')
-            throw new TypeError('A correlated problem names its interaction.');
-        if (code === 'stale-target' && !target)
-            throw new TypeError('A stale-target problem carries the current target.');
-        correlation = { instance: resultUrl, profile: MAP_PROFILE, requestId, interactionId, code };
-    }
-    return built(withinDocument(defined({
-        type: `${PROBLEM_TYPES}${code}`,
-        title: members.title,
-        status: PROBLEM_STATUS[code],
-        detail: members.detail,
-        ...correlation,
-        target,
-        errors: members.errors,
-    })), problemErrors);
-}
-/** The HTTP status of a result: 202 while work is pending, otherwise 200. */
-export const resultStatus = (document) => NON_TERMINAL.includes(document.state) ? 202 : 200;
-/**
- * Results stay retrievable until the later of the interaction's expiry and the retention
- * interval measured from the latest recorded state.
- */
-export const retainUntil = (description, recordedAt) => new Date(Math.max(Date.parse(description.expiresAt), recordedAt.getTime() + description.service.execution.resultRetentionSeconds * 1000));
-/**
- * An undecided approval ends as failed, with reason expired, at the interaction's expiry,
- * whether or not anyone looks. The settled result, or undefined when nothing changes.
- */
-export function settle(document, description, now) {
-    if (document.state !== 'approval-required' || !reached(now, description.expiresAt))
-        return;
-    return transition(document, {
-        state: 'failed',
-        reason: 'expired',
-        recordedAt: new Date(description.expiresAt),
-    });
-}

package/dist/core/limits.d.ts

@@ -1,19 +0,0 @@
-import type { InputError, JsonObject } from './types.ts';
-/** The text, or its first limit - 1 code points and an ellipsis. */
-export declare const cut: (text: string, limit: number) => string;
-/**
- * An input error within the core problem's limits. A pointer too long to report names its
- * nearest ancestor that fits, with a detail that says so, and a detail too long is cut.
- */
-export declare function inputError(detail: string, pointer: string): InputError;
-/**
- * A problem's title, detail and input errors within the core limits. An empty or overlong
- * title, an empty detail or an empty error list is the caller's mistake.
- */
-export declare function problemMembers(title: string, detail: string, errors?: InputError[]): {
-    title: string;
-    detail: string;
-    errors: InputError[] | undefined;
-};
-/** The problem with as many of its errors, in order, as fit within the document limit. */
-export declare function withinDocument(problem: JsonObject): JsonObject;

package/dist/core/limits.js

@@ -1,55 +0,0 @@
-// MAP documents within the core limits, with lengths counted in code points as JSON
-// Schema counts them.
-import { MAX_BYTES } from "./document.js";
-import { codePoints, within } from "./pointer.js";
-const TITLE = 240;
-const DETAIL = 4000;
-const POINTER = 1000;
-const ERROR_DETAIL = 2000;
-const ERRORS = 100;
-/** The text, or its first limit - 1 code points and an ellipsis. */
-export const cut = (text, limit) => codePoints(text) > limit ? `${[...text].slice(0, limit - 1).join('')}…` : text;
-/**
- * An input error within the core problem's limits. A pointer too long to report names its
- * nearest ancestor that fits, with a detail that says so, and a detail too long is cut.
- */
-export function inputError(detail, pointer) {
-    if (codePoints(pointer) > POINTER)
-        return {
-            detail: 'A member within this value does not satisfy the contract.',
-            pointer: within(pointer, POINTER),
-        };
-    return { detail: cut(detail, ERROR_DETAIL), pointer };
-}
-/**
- * A problem's title, detail and input errors within the core limits. An empty or overlong
- * title, an empty detail or an empty error list is the caller's mistake.
- */
-export function problemMembers(title, detail, errors) {
-    if (codePoints(title) < 1 || codePoints(title) > TITLE)
-        throw new RangeError(`A problem title is 1 to ${TITLE} characters.`);
-    if (!detail)
-        throw new RangeError('A problem detail is not empty.');
-    if (errors) {
-        if (!errors.length)
-            throw new RangeError('Errors, when given, name at least one input error.');
-        if (errors.some((error) => !error.detail))
-            throw new RangeError('An input error has a detail.');
-    }
-    return {
-        title,
-        detail: cut(detail, DETAIL),
-        errors: errors?.slice(0, ERRORS).map((error) => inputError(error.detail, error.pointer)),
-    };
-}
-/** The problem with as many of its errors, in order, as fit within the document limit. */
-export function withinDocument(problem) {
-    const errors = problem.errors;
-    if (!errors)
-        return problem;
-    const kept = [...errors];
-    const size = () => new TextEncoder().encode(JSON.stringify({ ...problem, errors: kept })).length;
-    while (kept.length > 1 && size() > MAX_BYTES)
-        kept.pop();
-    return { ...problem, errors: kept };
-}

package/dist/core/pointer.d.ts

@@ -1,12 +0,0 @@
-export declare const escape: (name: string) => string;
-export declare const segments: (pointer: string) => string[];
-export declare const codePoints: (text: string) => number;
-/** The pointer, or its nearest ancestor no longer than limit code points. */
-export declare function within(pointer: string, limit: number): string;
-/** The value a pointer names through objects and arrays, or undefined. */
-export declare function resolve(value: unknown, pointer: string): unknown;
-/**
- * The value a pointer names through object members only, or undefined. The contract
- * rules bind form fields only through object properties, so no binding indexes an array.
- */
-export declare function member(value: unknown, pointer: string): unknown;

package/dist/core/pointer.js

@@ -1,48 +0,0 @@
-// JSON Pointer (RFC 6901). Undefined stands for "nothing there", which no JSON value is.
-const INDEX = /^(?:0|[1-9][0-9]*)$/;
-export const escape = (name) => name.replaceAll('~', '~0').replaceAll('/', '~1');
-export const segments = (pointer) => pointer
-    .split('/')
-    .slice(1)
-    .map((segment) => segment.replaceAll('~1', '/').replaceAll('~0', '~'));
-// Lengths as JSON Schema counts them: in code points, not UTF-16 code units.
-export const codePoints = (text) => [...text].length;
-/** The pointer, or its nearest ancestor no longer than limit code points. */
-export function within(pointer, limit) {
-    const tokens = pointer.split('/');
-    while (codePoints(tokens.join('/')) > limit)
-        tokens.pop();
-    return tokens.join('/');
-}
-/** The value a pointer names through objects and arrays, or undefined. */
-export function resolve(value, pointer) {
-    let current = value;
-    for (const name of segments(pointer)) {
-        if (Array.isArray(current)) {
-            if (!INDEX.test(name) || Number(name) >= current.length)
-                return undefined;
-            current = current[Number(name)];
-        }
-        else if (current && typeof current === 'object' && Object.hasOwn(current, name))
-            current = current[name];
-        else
-            return undefined;
-    }
-    return current;
-}
-/**
- * The value a pointer names through object members only, or undefined. The contract
- * rules bind form fields only through object properties, so no binding indexes an array.
- */
-export function member(value, pointer) {
-    let current = value;
-    for (const name of segments(pointer)) {
-        if (!current ||
-            typeof current !== 'object' ||
-            Array.isArray(current) ||
-            !Object.hasOwn(current, name))
-            return undefined;
-        current = current[name];
-    }
-    return current;
-}

package/dist/core/schemas.d.ts

@@ -1,21 +0,0 @@
-import type { JsonObject } from './types.ts';
-/** Every schema object within a schema, the schema itself first. */
-export declare function nodes(schema: unknown): Generator<JsonObject>;
-/** Every value a keyword has in the schema objects within a schema. */
-export declare const values: (schema: unknown, keyword: string) => unknown[];
-/** Rules of a form fields block that JSON Schema cannot state. */
-export declare function formProblems(fields: JsonObject): string[];
-/**
- * The schema the values of a fields block satisfy: only its fields, each with a text
- * field's `format` read as the core lexical form of that name.
- */
-export declare function fieldValuesSchema(fields: JsonObject): JsonObject;
-/**
- * Why a contract's schemas would resolve anything but a pinned schema, or undefined. No
- * keyword resolves by scope, in the contract's schemas or the pinned ones it supplies. In
- * the contract's own schemas, no $id or $schema appears but at the request schema's root,
- * since it would move references or change the dialect a subschema is read in; no type is
- * a list; autocomplete, the form fields block's annotation, is absent; and every
- * reference is a string naming a schema in the pinned documents, by URL.
- */
-export declare function referenceProblem(inline: unknown[], requestSchema: JsonObject, pinned: ReadonlyMap<string, JsonObject>, supplied: JsonObject[]): string | undefined;

package/dist/core/schemas.js

@@ -1,125 +0,0 @@
-// The schema objects within a schema, the form fields block and the references a contract's
-// schemas make.
-import { CORE_SCHEMA } from "./artifacts.js";
-import { resolve } from "./pointer.js";
-// The keywords whose value is a schema, a list of schemas, or a map from names to schemas.
-// A name in a map is never a keyword, whatever it is called.
-const SUBSCHEMA = [
-    'additionalProperties',
-    'propertyNames',
-    'items',
-    'contains',
-    'not',
-    'if',
-    'then',
-    'else',
-    'unevaluatedItems',
-    'unevaluatedProperties',
-    'contentSchema',
-];
-const LISTS = ['allOf', 'anyOf', 'oneOf', 'prefixItems'];
-const MAPS = ['properties', 'patternProperties', '$defs', 'dependentSchemas'];
-/** Every schema object within a schema, the schema itself first. */
-export function* nodes(schema) {
-    if (!schema || typeof schema !== 'object' || Array.isArray(schema))
-        return;
-    const node = schema;
-    yield node;
-    for (const keyword of SUBSCHEMA)
-        yield* nodes(node[keyword]);
-    for (const keyword of LISTS)
-        if (Array.isArray(node[keyword]))
-            for (const item of node[keyword])
-                yield* nodes(item);
-    for (const keyword of MAPS) {
-        const map = node[keyword];
-        if (map && typeof map === 'object' && !Array.isArray(map))
-            for (const item of Object.values(map))
-                yield* nodes(item);
-    }
-}
-/** Every value a keyword has in the schema objects within a schema. */
-export const values = (schema, keyword) => [...nodes(schema)].filter((node) => Object.hasOwn(node, keyword)).map((node) => node[keyword]);
-// The core definitions that give a text field's `format` its lexical form.
-const FORMATS = {
-    email: 'address',
-    uri: 'identifier',
-    date: 'date',
-    'date-time': 'dateTime',
-};
-/** Rules of a form fields block that JSON Schema cannot state. */
-export function formProblems(fields) {
-    const properties = (fields.properties ?? {});
-    const problems = (fields.required ?? [])
-        .filter((name) => !Object.hasOwn(properties, name))
-        .map((name) => `required field ${name} is not defined`);
-    for (const [name, field] of Object.entries(properties)) {
-        const choices = (field.oneOf ?? field.items?.anyOf ?? []).map((choice) => choice.const);
-        if (new Set(choices).size !== choices.length)
-            problems.push(`field ${name} repeats a choice`);
-        const defaults = field.default === undefined ? [] : [field.default].flat();
-        if (choices.length && defaults.some((value) => !choices.includes(value)))
-            problems.push(`field ${name} defaults to a value it does not offer`);
-    }
-    return problems;
-}
-/**
- * The schema the values of a fields block satisfy: only its fields, each with a text
- * field's `format` read as the core lexical form of that name.
- */
-export function fieldValuesSchema(fields) {
-    const properties = Object.fromEntries(Object.entries((fields.properties ?? {})).map(([name, field]) => {
-        if (typeof field.format !== 'string')
-            return [name, field];
-        const { format, ...rest } = field;
-        return [name, { ...rest, $ref: `${CORE_SCHEMA}#/$defs/${FORMATS[format]}` }];
-    }));
-    return { ...fields, properties, additionalProperties: false };
-}
-// A plain JSON Pointer fragment: nothing percent-encoded, nothing to decode.
-const FRAGMENT = /^(?:\/[A-Za-z0-9._~!$&'()*+,;=:@-]*)*$/;
-// Keywords that resolve by scope rather than by a pinned address.
-const UNPINNED = ['$dynamicRef', '$recursiveRef', '$dynamicAnchor', '$recursiveAnchor', '$anchor'];
-/**
- * Why a contract's schemas would resolve anything but a pinned schema, or undefined. No
- * keyword resolves by scope, in the contract's schemas or the pinned ones it supplies. In
- * the contract's own schemas, no $id or $schema appears but at the request schema's root,
- * since it would move references or change the dialect a subschema is read in; no type is
- * a list; autocomplete, the form fields block's annotation, is absent; and every
- * reference is a string naming a schema in the pinned documents, by URL.
- */
-export function referenceProblem(inline, requestSchema, pinned, supplied) {
-    for (const schema of [...inline, requestSchema, ...supplied]) {
-        const found = UNPINNED.find((keyword) => values(schema, keyword).length);
-        if (found)
-            return `${found} is not pinned by any digest`;
-    }
-    for (const schema of [...inline, requestSchema]) {
-        const all = [...nodes(schema)];
-        const nested = schema === requestSchema ? all.slice(1) : all;
-        if (nested.some((node) => '$id' in node))
-            return 'a nested $id would move references';
-        if (nested.some((node) => '$schema' in node))
-            return 'a nested $schema would change the dialect';
-        if (all.some((node) => Array.isArray(node.type)))
-            return 'type names one type, never a list';
-        if (all.some((node) => 'autocomplete' in node))
-            return 'autocomplete belongs to the form fields block';
-        for (const ref of values(schema, '$ref')) {
-            if (typeof ref !== 'string')
-                return 'a $ref is not a string';
-            const [base, fragment = ''] = ref.split(/#(.*)/s);
-            const document = pinned.get(base);
-            if (!document)
-                return `${ref} is not a pinned dependency`;
-            if (fragment && !fragment.startsWith('/'))
-                return `${ref} names an anchor, not a JSON Pointer`;
-            if (!FRAGMENT.test(fragment))
-                return `${ref} is not a plain JSON Pointer`;
-            const target = resolve(document, fragment);
-            if (typeof target !== 'boolean' &&
-                !(target && typeof target === 'object' && !Array.isArray(target)))
-                return `${ref} does not name a schema`;
-        }
-    }
-}