mailschema 0.2.1 → 0.2.2

package/dist/core/contract.js

@@ -0,0 +1,327 @@
+import { BUNDLED, CORE_SCHEMA, JSON_SCHEMA_2020_12, MAP_PROFILE, contractFormatErrors, createValidator, descriptionErrors, errorList, reached, requestErrors, resultErrors, } from "./artifacts.js";
+import { capabilityProblems } from "./binding.js";
+import { digest } from "./document.js";
+import { inputError } from "./limits.js";
+import { escape, member } from "./pointer.js";
+import { fieldValuesSchema, formProblems, referenceProblem, values } from "./schemas.js";
+/** A type contract that fails its own checks or its pinned digest. */
+export class InvalidContract extends Error {
+}
+/** Reasons the core assigns to the approval lifecycle. */
+export const APPROVAL_REASONS = ['declined', 'stale-target', 'expired', 'superseded'];
+const FIELD_VALIDATORS = 128;
+function frozen(value) {
+    const copy = structuredClone(value);
+    const freeze = (item) => {
+        if (item && typeof item === 'object') {
+            Object.values(item).forEach(freeze);
+            Object.freeze(item);
+        }
+    };
+    freeze(copy);
+    return copy;
+}
+/** Each operation's branch of a request schema, with its input schema. */
+function branches(requestSchema) {
+    const last = (requestSchema.allOf ?? []).at(-1) ?? {};
+    return (last.oneOf ?? [last]).map((branch) => {
+        const properties = (branch.properties ?? {});
+        return {
+            operation: properties.operation?.const,
+            input: properties.input ?? {},
+        };
+    });
+}
+/** A JSON Pointer to the failing member, naming a missing or extra member itself. */
+function pointerOf(error) {
+    const name = error.params.missingProperty ?? error.params.additionalProperty;
+    return name === undefined ? error.instancePath : `${error.instancePath}/${escape(String(name))}`;
+}
+/** Input errors as a detail and a pointer, each within the core limits, the first 100 kept. */
+function inputErrors(errors, prefix = '') {
+    const seen = new Set();
+    return (errors ?? [])
+        .filter((error) => error.keyword !== 'if')
+        .map((error) => inputError(error.message ?? 'invalid', `${prefix}${pointerOf(error)}`))
+        .filter(({ detail, pointer }) => {
+        const key = JSON.stringify([pointer, detail]);
+        return !seen.has(key) && Boolean(seen.add(key));
+    })
+        .slice(0, 100);
+}
+/**
+ * A type contract an implementation vendors, verified against the digest it was pinned by
+ * and compiled once. It checks the descriptions, requests, inputs and results of that exact
+ * type. The Registry has already applied the contract rules, such as portable patterns, to
+ * the contract that digest names; loading refuses anything that would otherwise fail when a
+ * request arrives.
+ */
+export class Contract {
+    document;
+    digest;
+    requestSchema;
+    #ajv = createValidator();
+    #details;
+    #request;
+    #inputs = new Map();
+    #outputs = new Map();
+    #fields = new Map();
+    /**
+     * `digest` is the contract digest the implementation pinned; `dependencies` supplies, by
+     * URL, any pinned schema the package does not bundle.
+     */
+    constructor(contract, requestSchema, { digest: pinned, dependencies = {}, }) {
+        const errors = contractFormatErrors(contract);
+        if (errors.length)
+            throw new InvalidContract(`invalid type contract: ${errors.join('; ')}`);
+        this.document = frozen(contract);
+        if (this.document.profile !== MAP_PROFILE)
+            throw new InvalidContract('the contract is for another MAP profile');
+        this.digest = digest(this.document);
+        if (this.digest !== pinned)
+            throw new InvalidContract(`the contract digest is ${this.digest}, not the pinned ${pinned}`);
+        this.requestSchema = frozen(requestSchema);
+        const references = this.#pin(dependencies);
+        const supplied = [...references]
+            .filter(([url]) => !BUNDLED.has(url))
+            .map(([, schema]) => schema);
+        this.#verify(references, supplied);
+        try {
+            // Every schema compiles now, so a pattern or reference fails the contract, not a request.
+            for (const schema of [...supplied, this.requestSchema])
+                this.#ajv.addSchema(schema);
+            for (const schema of supplied)
+                this.#ajv.getSchema(String(schema.$id));
+            this.#request = this.#ajv.getSchema(String(this.requestSchema.$id));
+            if (this.document.detailsSchema)
+                this.#details = this.#ajv.compile(this.document.detailsSchema);
+            for (const branch of branches(this.requestSchema))
+                this.#inputs.set(branch.operation, this.#ajv.compile(branch.input));
+            for (const operation of this.document.operations)
+                for (const result of operation.results)
+                    this.#outputs.set(`${operation.id}/${result.state}`, this.#ajv.compile(result.outputSchema));
+        }
+        catch (error) {
+            throw new InvalidContract(`a schema does not compile: ${error.message}`);
+        }
+    }
+    get id() {
+        return this.document.id;
+    }
+    get version() {
+        return this.document.version;
+    }
+    /** The type reference a description and a request of this contract name exactly. */
+    get typeReference() {
+        return { id: this.id, version: this.version, contractDigest: this.digest };
+    }
+    operation(id) {
+        return this.document.operations.find((operation) => operation.id === id);
+    }
+    /** Whether completing the operation decides the interaction. */
+    isDecision(id) {
+        const found = this.operation(id);
+        if (!found)
+            throw new TypeError(`${id} is not an operation of this type.`);
+        return !found.repeatable;
+    }
+    /**
+     * Every rule a description must satisfy beyond the core schema, for the service that issues
+     * it and the client that receives it.
+     */
+    descriptionErrors(description) {
+        const errors = descriptionErrors(description);
+        if (errors.length)
+            return errors;
+        const issued = description;
+        if (!this.#names(issued.type))
+            return ['The description names another type contract.'];
+        const problems = [...this.#detailsProblems(issued), ...this.#operationProblems(issued)];
+        if (!(Date.parse(issued.describedAt) < Date.parse(issued.expiresAt)))
+            problems.push('The interaction expires before it was described.');
+        if (issued.service.authority === 'possession')
+            problems.push(...capabilityProblems(issued));
+        return problems;
+    }
+    /**
+     * The checks a service makes on a request once it has resolved the description it issued,
+     * compared the description digest and established the caller: the exact type, an offered
+     * operation the authority permits, and expiry. Undefined when they pass. The service then
+     * applies its own state (a decided interaction, a stale target) and `inputErrors`, in that
+     * order, before any effect.
+     */
+    requestProblem(description, request, { now }) {
+        if (!this.#names(request.type) || !this.#names(description.type))
+            return {
+                code: 'unsupported-type',
+                title: 'Unsupported interaction type',
+                detail: 'The service does not implement this exact interaction type contract.',
+            };
+        if (!this.#offered(description, request.operation))
+            return {
+                code: 'unsupported-operation',
+                title: 'Unsupported operation',
+                detail: 'The operation was not offered in this interaction.',
+            };
+        if (reached(now, description.expiresAt))
+            return {
+                code: 'expired-interaction',
+                title: 'Interaction expired',
+                detail: 'The interaction expired before the request was processed.',
+            };
+    }
+    /**
+     * Input problems for one request, each with a detail and a JSON Pointer into its input: the
+     * operation's input schema, then its field bindings against the description's details. Type
+     * rules a contract cannot express are the caller's.
+     */
+    inputErrors(description, request) {
+        const found = this.operation(request.operation);
+        const validate = this.#inputs.get(request.operation);
+        if (!found || !validate)
+            return [inputError('The operation is not part of this type.', '')];
+        if (!validate(request.input))
+            return inputErrors(validate.errors);
+        return (found.fieldBindings ?? [])
+            .flatMap((binding) => {
+            const fields = member(description.details, binding.fields);
+            const supplied = member(request.input, binding.input);
+            if (!fields)
+                return supplied === undefined
+                    ? []
+                    : [inputError('This interaction defines no fields for these values.', binding.input)];
+            if (supplied === undefined)
+                return (fields.required ?? []).length
+                    ? [inputError('Values for the required fields are missing.', binding.input)]
+                    : [];
+            const schema = this.#fieldValues(fields);
+            return schema(supplied) ? [] : inputErrors(schema.errors, binding.input);
+        })
+            .slice(0, 100);
+    }
+    /** A request against the core request definition and this contract's request schema. */
+    requestErrors(request) {
+        return [
+            ...requestErrors(request),
+            ...(this.#request(request) ? [] : errorList(this.#request.errors)),
+        ];
+    }
+    /** The core result definition, then the output schema and reason the operation declares. */
+    resultErrors(result) {
+        const errors = resultErrors(result);
+        if (errors.length)
+            return errors;
+        const recorded = result;
+        if (!this.#names(recorded.type))
+            return ['The result names another type contract.'];
+        const found = this.operation(recorded.operation);
+        if (!found)
+            return [`${recorded.operation} is not an operation of this type.`];
+        const declared = found.results.find((entry) => entry.state === recorded.state);
+        if (!declared)
+            return [`${found.id} does not declare the state ${recorded.state}.`];
+        const validate = this.#outputs.get(`${found.id}/${declared.state}`);
+        const problems = validate(recorded.output) ? [] : errorList(validate.errors, '/output');
+        if (recorded.state === 'failed' && !declared.reasons?.includes(recorded.reason))
+            problems.push(`${found.id} does not declare the reason ${recorded.reason}.`);
+        return problems;
+    }
+    #names(type) {
+        return (type.id === this.id && type.version === this.version && type.contractDigest === this.digest);
+    }
+    #offered(description, id) {
+        return (description.operations.some((offered) => offered.id === id) &&
+            Boolean(this.operation(id)?.authority.includes(description.service.authority)));
+    }
+    #operationProblems(description) {
+        const ids = description.operations.map((offered) => offered.id);
+        const authority = description.service.authority;
+        return [
+            ...(new Set(ids).size === ids.length ? [] : ['An operation is offered twice.']),
+            ...ids
+                .filter((id) => !this.operation(id)?.authority.includes(authority))
+                .map((id) => `${id} is not a ${authority} operation of this type.`),
+        ];
+    }
+    #detailsProblems(description) {
+        const present = Object.hasOwn(description, 'details');
+        const valid = this.#details ? present && this.#details(description.details) : !present;
+        if (!valid)
+            return ['The details do not satisfy the type contract.'];
+        const blocks = new Set(this.document.operations.flatMap((operation) => (operation.fieldBindings ?? []).map((binding) => binding.fields)));
+        return [...blocks].flatMap((pointer) => {
+            const fields = member(description.details, pointer);
+            return fields ? formProblems(fields).map((problem) => `${pointer}: ${problem}`) : [];
+        });
+    }
+    /**
+     * The compiled schema of a fields block's values. Least recently used blocks leave first,
+     * with their compiled copies, so a long-running service stays bounded.
+     */
+    #fieldValues(fields) {
+        const key = digest(fields);
+        let entry = this.#fields.get(key);
+        if (entry)
+            this.#fields.delete(key);
+        else {
+            const schema = fieldValuesSchema(fields);
+            entry = { schema, validate: this.#ajv.compile(schema) };
+        }
+        this.#fields.set(key, entry);
+        if (this.#fields.size > FIELD_VALIDATORS) {
+            const [oldest, evicted] = this.#fields.entries().next().value;
+            this.#fields.delete(oldest);
+            this.#ajv.removeSchema(evicted.schema);
+        }
+        return entry.validate;
+    }
+    /** The pinned schemas by URL, bundled or supplied, each matching its pinned digest. */
+    #pin(dependencies) {
+        const references = new Map();
+        for (const dependency of this.document.dependencies ?? []) {
+            const schema = (BUNDLED.get(dependency.url) ?? dependencies[dependency.url]);
+            if (!schema)
+                throw new InvalidContract(`unknown dependency ${dependency.url}`);
+            if (digest(schema) !== dependency.canonicalDigest)
+                throw new InvalidContract(`the pinned digest of ${dependency.url} differs`);
+            if (schema.$id !== dependency.url)
+                throw new InvalidContract(`the schema pinned as ${dependency.url} has another $id`);
+            references.set(dependency.url, BUNDLED.has(dependency.url) ? schema : frozen(schema));
+        }
+        if (!references.has(CORE_SCHEMA))
+            throw new InvalidContract('the core schema must be pinned');
+        return references;
+    }
+    #verify(references, supplied) {
+        const inline = [
+            this.document.detailsSchema,
+            ...this.document.operations.flatMap((operation) => operation.results.map((result) => result.outputSchema)),
+        ].filter(Boolean);
+        // Every schema is valid JSON Schema 2020-12, so no malformed keyword fails at request time.
+        for (const schema of [...inline, this.requestSchema, ...supplied])
+            if (!this.#ajv.validateSchema(schema))
+                throw new InvalidContract(`a schema is not valid JSON Schema 2020-12: ${this.#ajv.errorsText(this.#ajv.errors)}`);
+        const reference = this.document.requestSchema;
+        if (this.requestSchema.$schema !== JSON_SCHEMA_2020_12)
+            throw new InvalidContract('the request schema must declare JSON Schema 2020-12');
+        if (this.requestSchema.$id !== reference.url)
+            throw new InvalidContract('the request schema $id differs from the contract');
+        if (digest(this.requestSchema) !== reference.canonicalDigest)
+            throw new InvalidContract('the request schema digest differs from the contract');
+        const constants = new Set(values(this.requestSchema, 'const'));
+        const ids = this.document.operations.map((operation) => operation.id);
+        for (const expected of [this.id, this.version, ...ids])
+            if (!constants.has(expected))
+                throw new InvalidContract(`the request schema does not bind ${expected}`);
+        if (new Set(ids).size !== ids.length)
+            throw new InvalidContract('duplicate operation identifiers');
+        for (const operation of this.document.operations) {
+            const states = operation.results.map((result) => result.state);
+            if (new Set(states).size !== states.length)
+                throw new InvalidContract(`duplicate ${operation.id} result states`);
+        }
+        const problem = referenceProblem(inline, this.requestSchema, references, supplied);
+        if (problem)
+            throw new InvalidContract(problem);
+    }
+}

package/dist/core/document.d.ts

@@ -0,0 +1,24 @@
+/** 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/document.js

@@ -0,0 +1,190 @@
+// Parsing MAP documents as I-JSON within the core limits.
+import { createHash } from 'node:crypto';
+/** A MAP document that is not I-JSON within the core limits. */
+export class InvalidDocument extends Error {
+}
+export const MAX_BYTES = 64 * 1024;
+export const MAX_DEPTH = 32;
+const LONE_SURROGATE = /[\uD800-\uDBFF](?![\uDC00-\uDFFF])|(?<![\uD800-\uDBFF])[\uDC00-\uDFFF]/;
+// Unicode's noncharacters: U+FDD0 to U+FDEF, and the last two code points of every plane.
+const NONCHARACTER = new RegExp(`[\\u{FDD0}-\\u{FDEF}${Array.from({ length: 17 }, (_, plane) => `\\u{${(plane * 0x10000 + 0xfffe).toString(16)}}\\u{${(plane * 0x10000 + 0xffff).toString(16)}}`).join('')}]`, 'u');
+/**
+ * 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 function parse(input) {
+    let text;
+    if (typeof input === 'string')
+        text = input;
+    else {
+        try {
+            // The byte order mark is kept, so the parser refuses it.
+            text = new TextDecoder('utf-8', { fatal: true, ignoreBOM: true }).decode(input);
+        }
+        catch {
+            throw new InvalidDocument('The MAP document is not valid UTF-8.');
+        }
+    }
+    if (new TextEncoder().encode(text).length > MAX_BYTES)
+        throw new InvalidDocument(`The MAP document exceeds ${MAX_BYTES} bytes.`);
+    let index = 0;
+    const fail = (message) => {
+        throw new InvalidDocument(`Invalid MAP JSON at offset ${index}: ${message}`);
+    };
+    const space = () => {
+        while (' \t\n\r'.includes(text[index] ?? '-'))
+            index += 1;
+    };
+    const string = () => {
+        const start = index;
+        index += 1;
+        while (index < text.length && text[index] !== '"')
+            index += text[index] === '\\' ? 2 : 1;
+        if (text[index] !== '"')
+            fail('unterminated string');
+        index += 1;
+        let value;
+        try {
+            value = JSON.parse(text.slice(start, index));
+        }
+        catch {
+            return fail('malformed string');
+        }
+        if (LONE_SURROGATE.test(value))
+            fail('lone surrogate');
+        if (value.includes('\u0000'))
+            fail('U+0000 in a string');
+        if (NONCHARACTER.test(value))
+            fail('a noncharacter in a string');
+        return value;
+    };
+    // `depth` counts the arrays and objects enclosing the value.
+    const value = (depth) => {
+        space();
+        const next = text[index];
+        if ((next === '{' || next === '[') && depth >= MAX_DEPTH)
+            fail(`nesting deeper than ${MAX_DEPTH}`);
+        if (next === '{') {
+            index += 1;
+            const result = {};
+            const names = new Set();
+            space();
+            if (text[index] === '}') {
+                index += 1;
+                return result;
+            }
+            for (;;) {
+                space();
+                if (text[index] !== '"')
+                    fail('expected a member name');
+                const name = string();
+                if (names.has(name))
+                    fail(`duplicate member ${JSON.stringify(name)}`);
+                names.add(name);
+                space();
+                if (text[index] !== ':')
+                    fail('expected ":"');
+                index += 1;
+                // A member named __proto__ is data, never the object's prototype.
+                Object.defineProperty(result, name, {
+                    value: value(depth + 1),
+                    enumerable: true,
+                    writable: true,
+                    configurable: true,
+                });
+                space();
+                if (text[index] === ',') {
+                    index += 1;
+                    continue;
+                }
+                if (text[index] === '}') {
+                    index += 1;
+                    return result;
+                }
+                fail('expected "," or "}"');
+            }
+        }
+        if (next === '[') {
+            index += 1;
+            const result = [];
+            space();
+            if (text[index] === ']') {
+                index += 1;
+                return result;
+            }
+            for (;;) {
+                result.push(value(depth + 1));
+                space();
+                if (text[index] === ',') {
+                    index += 1;
+                    continue;
+                }
+                if (text[index] === ']') {
+                    index += 1;
+                    return result;
+                }
+                fail('expected "," or "]"');
+            }
+        }
+        if (next === '"')
+            return string();
+        const literal = /^(?:true|false|null|-?(?:0|[1-9][0-9]*)(?:\.[0-9]+)?(?:[eE][+-]?[0-9]+)?)/.exec(text.slice(index));
+        if (!literal)
+            fail('unexpected token');
+        index += literal[0].length;
+        const parsed = JSON.parse(literal[0]);
+        if (typeof parsed === 'number' &&
+            (!Number.isFinite(parsed) || Math.abs(parsed) > Number.MAX_SAFE_INTEGER))
+            fail('number outside the I-JSON range');
+        return parsed;
+    };
+    const result = value(0);
+    space();
+    if (index !== text.length)
+        fail('trailing content');
+    return result;
+}
+const ESCAPES = {
+    '"': '\\"',
+    '\\': '\\\\',
+    '\b': '\\b',
+    '\f': '\\f',
+    '\n': '\\n',
+    '\r': '\\r',
+    '\t': '\\t',
+};
+/**
+ * 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 function canonicalize(value) {
+    if (value === null || typeof value === 'boolean')
+        return String(value);
+    if (typeof value === 'number') {
+        if (!Number.isFinite(value))
+            throw new TypeError('Numbers must be finite.');
+        return String(value);
+    }
+    if (typeof value === 'string')
+        return `"${value.replace(/["\\\u0000-\u001f]/g, (char) => ESCAPES[char] ?? `\\u${char.charCodeAt(0).toString(16).padStart(4, '0')}`)}"`;
+    if (Array.isArray(value))
+        return `[${value.map((item) => (item === undefined ? 'null' : canonicalize(item))).join(',')}]`;
+    if (typeof value === 'object') {
+        const members = value;
+        return `{${Object.keys(members)
+            .filter((name) => members[name] !== undefined)
+            .sort()
+            .map((name) => `${canonicalize(name)}:${canonicalize(members[name])}`)
+            .join(',')}}`;
+    }
+    throw new TypeError(`${typeof value} is not a JSON value.`);
+}
+/**
+ * `sha-256:` and the SHA-256 of the RFC 8785 canonical form: the digest MAP uses for
+ * descriptions, contracts and pinned schemas.
+ */
+export const digest = (value) => `sha-256:${createHash('sha256').update(canonicalize(value)).digest('hex')}`;

package/dist/core/documents.d.ts

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