mailschema 0.2.1 → 0.2.2

package/dist/core/documents.js

@@ -0,0 +1,145 @@
+// 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/index.d.ts

@@ -0,0 +1,6 @@
+export { MAP_PROFILE, CORE_SCHEMA, FORMS_SCHEMA, CONTRACT_FORMAT, CONTEXT, mapErrors, descriptionErrors, requestErrors, resultErrors, problemErrors, isRequestId, reached, } from './artifacts.ts';
+export { InvalidDocument, parse, canonicalize, digest } from './document.ts';
+export { APPROVAL_REASONS, Contract, InvalidContract, type RequestProblem } from './contract.ts';
+export { PROBLEM_STATUS, type ProblemCode, result, transition, problem, resultStatus, retainUntil, settle, } from './documents.ts';
+export { DESCRIPTION_MEDIA_TYPE, isDescriptionPart, capability, writtenPath, isJsonRequest, resultUrl, } from './binding.ts';
+export type { Authority, Consequence, ContractOperation, InputError, JsonObject, MapDescription, MapProblem, MapRequest, MapResult, ResultState, SchemaReference, Target, TypeContract, TypeReference, } from './types.ts';

package/dist/core/index.js

@@ -0,0 +1,9 @@
+// Mail Action Protocol 0.2 processing. It parses, canonicalizes, digests and validates MAP
+// documents, checks the type contracts an implementation vendors, and builds results and
+// problems. It does not establish endpoint trust, verify email authentication, grant
+// authority or send email.
+export { MAP_PROFILE, CORE_SCHEMA, FORMS_SCHEMA, CONTRACT_FORMAT, CONTEXT, mapErrors, descriptionErrors, requestErrors, resultErrors, problemErrors, isRequestId, reached, } from "./artifacts.js";
+export { InvalidDocument, parse, canonicalize, digest } from "./document.js";
+export { APPROVAL_REASONS, Contract, InvalidContract } from "./contract.js";
+export { PROBLEM_STATUS, result, transition, problem, resultStatus, retainUntil, settle, } from "./documents.js";
+export { DESCRIPTION_MEDIA_TYPE, isDescriptionPart, capability, writtenPath, isJsonRequest, resultUrl, } from "./binding.js";

package/dist/core/limits.d.ts

@@ -0,0 +1,19 @@
+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

@@ -0,0 +1,55 @@
+// 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

@@ -0,0 +1,12 @@
+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

@@ -0,0 +1,48 @@
+// 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

@@ -0,0 +1,21 @@
+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

@@ -0,0 +1,125 @@
+// 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`;
+        }
+    }
+}

package/dist/core/types.d.ts

@@ -0,0 +1,127 @@
+/** The documents MAP 0.2 defines and the type contracts that give them meaning. */
+export type JsonObject = Record<string, unknown>;
+export type Authority = 'credential' | 'possession';
+export type ResultState = 'accepted' | 'completed' | 'failed' | 'pending' | 'approval-required';
+export type Consequence = 'refusal' | 'protection' | 'record' | 'disclosure' | 'commitment' | 'authorization' | 'assertion';
+export interface SchemaReference {
+    url: string;
+    canonicalDigest: string;
+}
+export interface ContractOperation {
+    id: string;
+    effect: string;
+    authority: Authority[];
+    consequences: Consequence[];
+    repeatable?: boolean;
+    fieldBindings?: {
+        input: string;
+        fields: string;
+    }[];
+    results: {
+        state: ResultState;
+        reasons?: string[];
+        outputSchema: JsonObject;
+    }[];
+}
+export interface TypeContract {
+    kind: 'MapTypeContract';
+    id: string;
+    version: string;
+    profile: string;
+    target: string;
+    dependencies?: SchemaReference[];
+    detailsSchema?: JsonObject;
+    requestSchema: SchemaReference;
+    operations: ContractOperation[];
+}
+/** The exact type a description and its requests name. */
+export type TypeReference = {
+    id: string;
+    version: string;
+    contractDigest: string;
+};
+export type Target = {
+    id: string;
+    revision: string;
+    digest: string;
+    title?: string;
+};
+export type MapDescription = {
+    '@context': string;
+    '@type': 'MailAction';
+    '@id': string;
+    profile: string;
+    type: TypeReference;
+    describedAt: string;
+    expiresAt: string;
+    service: {
+        id: string;
+        name: string;
+        authority: Authority;
+        resource?: string;
+        execution: {
+            url: string;
+            resultUrlTemplate: string;
+            resultRetentionSeconds: number;
+        };
+        onBehalfOf?: {
+            id: string;
+            name: string;
+        };
+        humanUrl: string;
+    };
+    recipient?: string;
+    target: Target;
+    details?: JsonObject;
+    operations: {
+        id: string;
+        name: string;
+        description: string;
+    }[];
+};
+export type MapRequest = {
+    kind: 'MapRequest';
+    profile: string;
+    requestId: string;
+    interactionId: string;
+    descriptionDigest: string;
+    type: TypeReference;
+    operation: string;
+    input: JsonObject;
+};
+export type MapResult = {
+    kind: 'MapResult';
+    profile: string;
+    requestId: string;
+    interactionId: string;
+    descriptionDigest: string;
+    type: TypeReference;
+    operation: string;
+    state: ResultState;
+    target: Target;
+    recordedAt: string;
+    resultUrl: string;
+    actor?: string;
+    approvalUrl?: string;
+    reason?: string;
+    output: JsonObject;
+};
+/** An RFC 9457 problem, with MAP's correlation members when it is correlated. */
+export type MapProblem = {
+    type: string;
+    title: string;
+    status: number;
+    detail: string;
+    instance?: string;
+    profile?: string;
+    requestId?: string;
+    interactionId?: string;
+    code?: string;
+    target?: Target;
+    errors?: InputError[];
+};
+/** One way a request's input fails its contract, with a JSON Pointer into the input. */
+export type InputError = {
+    detail: string;
+    pointer: string;
+};

package/dist/core/types.js

@@ -0,0 +1,2 @@
+/** The documents MAP 0.2 defines and the type contracts that give them meaning. */
+export {};

package/dist/index.d.ts

@@ -1,8 +1,9 @@
+export * from './core/index.js';
 export { contributionErrors, assertContribution, assertTypeRecord, referenceErrors, } from './validation.js';
 export type { CatalogView } from './validation.js';
 export { typeStages } from './model.js';
 export type { Party, TypeDefinition, TypeRecord, Contribution, Implementation } from './model.js';
-export { MAP_PROFILE, getMapSchema, getMapContext, getContractFormatSchema, getFormsSchema, } from './map.js';
+export { getMapSchema, getMapContext, getContractFormatSchema, getFormsSchema } from './map.js';
 /** Return an independent copy of the contribution JSON Schema (Draft 2020-12). */
 export declare function getContributionSchema(): Record<string, unknown>;
 /** Return the schema for an expanded Registry record, including attribution and history. */

package/dist/index.js

@@ -1,8 +1,12 @@
-/** The MAP 0.2 core artifacts and validation tools for MailSchema Registry contributions. */
+/**
+ * Mail Action Protocol 0.2 processing and core artifacts, and validation tools for MailSchema
+ * Registry contributions.
+ */
 import schema from './contribution.schema.json' with { type: 'json' };
+export * from './core/index.js';
 export { contributionErrors, assertContribution, assertTypeRecord, referenceErrors, } from './validation.js';
 export { typeStages } from './model.js';
-export { MAP_PROFILE, getMapSchema, getMapContext, getContractFormatSchema, getFormsSchema, } from './map.js';
+export { getMapSchema, getMapContext, getContractFormatSchema, getFormsSchema } from './map.js';
 /** Return an independent copy of the contribution JSON Schema (Draft 2020-12). */
 export function getContributionSchema() {
     return structuredClone(schema);

package/dist/map.d.ts

@@ -1,5 +1,3 @@
-/** The MAP profile whose core artifacts this package carries. */
-export declare const MAP_PROFILE = "https://mailschema.org/profiles/map/0.2";
 /** A fresh copy of the MAP 0.2 core schema, as the profile record binds it by SHA-256. */
 export declare function getMapSchema(): Record<string, unknown>;
 /** A fresh copy of the MAP 0.2 JSON-LD context. */

package/dist/map.js

@@ -1,6 +1,4 @@
 import { readFileSync } from 'node:fs';
-/** The MAP profile whose core artifacts this package carries. */
-export const MAP_PROFILE = 'https://mailschema.org/profiles/map/0.2';
 const artifact = (name) => JSON.parse(readFileSync(new URL(`./${name}`, import.meta.url), 'utf8'));
 /** A fresh copy of the MAP 0.2 core schema, as the profile record binds it by SHA-256. */
 export function getMapSchema() {

package/dist/validation.d.ts

@@ -1,4 +1,4 @@
-import type { Contribution, TypeRecord } from './model.js';
+import type { Contribution, TypeRecord } from './model.ts';
 export declare function contributionErrors(value: unknown): string[];
 export declare function assertContribution(value: unknown): asserts value is Contribution;
 export declare function assertTypeRecord(value: unknown): asserts value is TypeRecord;

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "mailschema",
-  "version": "0.2.1",
-  "description": "Mail Action Protocol 0.2 core artifacts and MailSchema Registry validation",
+  "version": "0.2.2",
+  "description": "Mail Action Protocol 0.2 processing and core artifacts, and MailSchema Registry validation",
   "type": "module",
   "license": "MIT",
   "author": "MailSchema contributors",