mailschema 0.2.1 → 0.3.0

package/dist/core/patterns.js

@@ -0,0 +1,165 @@
+// The regular expressions a contract's schemas may use: the subset that ECMA-262 (with the
+// u flag) and other engines read alike, so every implementation enforces the same contract.
+const SYNTAX_CHARACTERS = '^$\\.*+?()[]{}|/';
+const CONTROL_ESCAPES = { t: 0x09, n: 0x0a, f: 0x0c, r: 0x0d };
+const QUANTIFIERS = '*+?{';
+/**
+ * Why a pattern is outside the portable subset, or undefined. The subset is printable ASCII
+ * text, with any other code point written as \uXXXX. It has literal characters and escaped
+ * syntax characters; \t, \n, \f, \r and \d, the ASCII digits; non-empty classes of literal or
+ * escaped members and ranges, with a literal hyphen only first or last; (?: groups;
+ * alternation; ^ and $; and one *, +, ?, {n}, {n,} or {n,m} after an atom. Other class
+ * escapes and the dot match different characters in different engines, and brackets, && or a
+ * stray brace inside a class, or a quantifier on a quantifier, are read differently or refused
+ * by one of them. ^ and $ anchor the whole value, as in ECMA-262; an engine whose anchors also
+ * match at line breaks must read them so.
+ */
+export function unportablePattern(pattern) {
+    if (!/^[\x20-\x7e]*$/.test(pattern))
+        return 'a character outside printable ASCII';
+    let at = 0;
+    // One escaped code point, the digit class outside a class, or a problem.
+    const escape = (inClass) => {
+        const next = pattern[at + 1];
+        if (next === undefined)
+            return 'a trailing backslash';
+        if (next === 'u') {
+            const digits = pattern.slice(at + 2, at + 6);
+            if (!/^[0-9a-fA-F]{4}$/.test(digits))
+                return 'a malformed \\u escape';
+            const code = parseInt(digits, 16);
+            if (code >= 0xd800 && code <= 0xdfff)
+                return 'a surrogate \\u escape';
+            at += 6;
+            return code;
+        }
+        at += 2;
+        if (next === 'd' && !inClass)
+            return -1;
+        if (Object.hasOwn(CONTROL_ESCAPES, next))
+            return CONTROL_ESCAPES[next];
+        if (SYNTAX_CHARACTERS.includes(next) || (inClass && next === '-'))
+            return next.charCodeAt(0);
+        return `the escape \\${next}`;
+    };
+    const characterClass = () => {
+        at += pattern[at + 1] === '^' ? 2 : 1;
+        // Each member's code point, or null for an unescaped hyphen.
+        const members = [];
+        while (pattern[at] !== ']') {
+            const char = pattern[at];
+            if (char === undefined)
+                return 'an unclosed character class';
+            if (char === '[')
+                return 'a bracket inside a class';
+            if (char === '&' && pattern[at + 1] === '&')
+                return '&& inside a class';
+            if (char === '\\') {
+                const code = escape(true);
+                if (typeof code === 'string')
+                    return code;
+                members.push(code);
+            }
+            else {
+                members.push(char === '-' ? null : char.charCodeAt(0));
+                at += 1;
+            }
+        }
+        at += 1;
+        if (!members.length)
+            return 'an empty character class';
+        for (let index = 0; index < members.length; index += 1) {
+            const low = members[index];
+            if (low === null) {
+                if (index !== 0 && index !== members.length - 1)
+                    return 'an ambiguous hyphen in a class';
+                continue;
+            }
+            if (members[index + 1] !== null || index + 2 >= members.length)
+                continue;
+            const high = members[index + 2];
+            if (high === null)
+                return 'an ambiguous hyphen in a class';
+            if (high < low)
+                return 'a class range out of order';
+            index += 2;
+            if (members[index + 1] === null && index + 1 !== members.length - 1)
+                return 'an ambiguous hyphen in a class';
+        }
+    };
+    const quantifier = () => {
+        if (pattern[at] === '{') {
+            const bounds = /^\{([0-9]{1,4})(?:(,)([0-9]{1,4})?)?\}/.exec(pattern.slice(at));
+            if (!bounds)
+                return 'a malformed {n,m} quantifier';
+            if (bounds[3] !== undefined && Number(bounds[3]) < Number(bounds[1]))
+                return 'a {n,m} quantifier with m below n';
+            at += bounds[0].length;
+        }
+        else
+            at += 1;
+        const next = pattern[at];
+        if (next !== undefined && QUANTIFIERS.includes(next))
+            return 'a quantifier on a quantifier';
+    };
+    const disjunction = (depth) => {
+        let quantifiable = false;
+        while (at < pattern.length) {
+            const char = pattern[at];
+            if (char === '|') {
+                at += 1;
+                quantifiable = false;
+            }
+            else if (char === ')') {
+                if (depth === 0)
+                    return 'an unmatched )';
+                return;
+            }
+            else if (char === '^' || char === '$') {
+                at += 1;
+                quantifiable = false;
+            }
+            else if (QUANTIFIERS.includes(char)) {
+                if (!quantifiable)
+                    return char === '{' ? 'an unescaped {' : 'a quantifier with nothing to repeat';
+                const problem = quantifier();
+                if (problem)
+                    return problem;
+                quantifiable = false;
+            }
+            else if (char === '(') {
+                if (!pattern.startsWith('(?:', at))
+                    return 'a group other than (?:';
+                at += 3;
+                const problem = disjunction(depth + 1);
+                if (problem)
+                    return problem;
+                if (pattern[at] !== ')')
+                    return 'an unclosed group';
+                at += 1;
+                quantifiable = true;
+            }
+            else if (char === '[') {
+                const problem = characterClass();
+                if (problem)
+                    return problem;
+                quantifiable = true;
+            }
+            else if (char === '\\') {
+                const code = escape(false);
+                if (typeof code === 'string')
+                    return code;
+                quantifiable = true;
+            }
+            else if (char === '.')
+                return 'an unescaped dot';
+            else if (char === ']' || char === '}')
+                return `an unescaped ${char}`;
+            else {
+                at += 1;
+                quantifiable = true;
+            }
+        }
+    };
+    return disjunction(0);
+}

package/dist/core/sha256.d.ts

@@ -0,0 +1,2 @@
+/** The lowercase hexadecimal SHA-256 of the bytes, or of the text's UTF-8 encoding. */
+export declare function sha256(input: string | Uint8Array): string;

package/dist/core/sha256.js

@@ -0,0 +1,59 @@
+// SHA-256 (FIPS 180-4) over bytes, so the core needs no platform crypto and runs the same
+// in Node, browsers and workers.
+const K = Uint32Array.from([
+    0x428a2f98, 0x71374491, 0xb5c0fbcf, 0xe9b5dba5, 0x3956c25b, 0x59f111f1, 0x923f82a4, 0xab1c5ed5,
+    0xd807aa98, 0x12835b01, 0x243185be, 0x550c7dc3, 0x72be5d74, 0x80deb1fe, 0x9bdc06a7, 0xc19bf174,
+    0xe49b69c1, 0xefbe4786, 0x0fc19dc6, 0x240ca1cc, 0x2de92c6f, 0x4a7484aa, 0x5cb0a9dc, 0x76f988da,
+    0x983e5152, 0xa831c66d, 0xb00327c8, 0xbf597fc7, 0xc6e00bf3, 0xd5a79147, 0x06ca6351, 0x14292967,
+    0x27b70a85, 0x2e1b2138, 0x4d2c6dfc, 0x53380d13, 0x650a7354, 0x766a0abb, 0x81c2c92e, 0x92722c85,
+    0xa2bfe8a1, 0xa81a664b, 0xc24b8b70, 0xc76c51a3, 0xd192e819, 0xd6990624, 0xf40e3585, 0x106aa070,
+    0x19a4c116, 0x1e376c08, 0x2748774c, 0x34b0bcb5, 0x391c0cb3, 0x4ed8aa4a, 0x5b9cca4f, 0x682e6ff3,
+    0x748f82ee, 0x78a5636f, 0x84c87814, 0x8cc70208, 0x90befffa, 0xa4506ceb, 0xbef9a3f7, 0xc67178f2,
+]);
+const rotate = (value, bits) => (value >>> bits) | (value << (32 - bits));
+/** The lowercase hexadecimal SHA-256 of the bytes, or of the text's UTF-8 encoding. */
+export function sha256(input) {
+    const bytes = typeof input === 'string' ? new TextEncoder().encode(input) : input;
+    // The message, a 1 bit, zeros, and its length in bits as a 64-bit big-endian integer.
+    const padded = new Uint8Array(Math.ceil((bytes.length + 9) / 64) * 64);
+    padded.set(bytes);
+    padded[bytes.length] = 0x80;
+    const view = new DataView(padded.buffer);
+    view.setUint32(padded.length - 8, Math.floor(bytes.length / 0x20000000));
+    view.setUint32(padded.length - 4, (bytes.length * 8) >>> 0);
+    const hash = Uint32Array.from([
+        0x6a09e667, 0xbb67ae85, 0x3c6ef372, 0xa54ff53a, 0x510e527f, 0x9b05688c, 0x1f83d9ab, 0x5be0cd19,
+    ]);
+    const w = new Uint32Array(64);
+    for (let block = 0; block < padded.length; block += 64) {
+        for (let t = 0; t < 16; t += 1)
+            w[t] = view.getUint32(block + t * 4);
+        for (let t = 16; t < 64; t += 1) {
+            const s0 = rotate(w[t - 15], 7) ^ rotate(w[t - 15], 18) ^ (w[t - 15] >>> 3);
+            const s1 = rotate(w[t - 2], 17) ^ rotate(w[t - 2], 19) ^ (w[t - 2] >>> 10);
+            w[t] = w[t - 16] + s0 + w[t - 7] + s1;
+        }
+        let [a, b, c, d, e, f, g, h] = hash;
+        for (let t = 0; t < 64; t += 1) {
+            const t1 = h + (rotate(e, 6) ^ rotate(e, 11) ^ rotate(e, 25)) + ((e & f) ^ (~e & g)) + K[t] + w[t];
+            const t2 = (rotate(a, 2) ^ rotate(a, 13) ^ rotate(a, 22)) + ((a & b) ^ (a & c) ^ (b & c));
+            h = g;
+            g = f;
+            f = e;
+            e = (d + t1) >>> 0;
+            d = c;
+            c = b;
+            b = a;
+            a = (t1 + t2) >>> 0;
+        }
+        hash[0] += a;
+        hash[1] += b;
+        hash[2] += c;
+        hash[3] += d;
+        hash[4] += e;
+        hash[5] += f;
+        hash[6] += g;
+        hash[7] += h;
+    }
+    return Array.from(hash, (word) => word.toString(16).padStart(8, '0')).join('');
+}

package/dist/core.schema.json

@@ -0,0 +1,210 @@
+{
+  "$schema": "https://json-schema.org/draft/2020-12/schema",
+  "$id": "https://mailschema.org/artifacts/map-0.3/schemas/core.schema.json",
+  "title": "MAP 0.3 description shape; semantic checks in Core are additionally required",
+  "type": "object",
+  "additionalProperties": false,
+  "required": [
+    "@context",
+    "@type",
+    "@id",
+    "profile",
+    "type",
+    "issuedAt",
+    "expiresAt",
+    "inLanguage",
+    "service",
+    "recipient",
+    "subject",
+    "terms",
+    "details",
+    "operations",
+    "human"
+  ],
+  "properties": {
+    "@context": {
+      "const": "https://mailschema.org/contexts/map-0.3.jsonld"
+    },
+    "@type": {
+      "const": "MailAction"
+    },
+    "@id": {
+      "type": "string",
+      "minLength": 1,
+      "format": "uri",
+      "maxLength": 2048
+    },
+    "profile": {
+      "const": "https://mailschema.org/profiles/map/0.3"
+    },
+    "type": {
+      "type": "object",
+      "additionalProperties": false,
+      "required": [
+        "id",
+        "version",
+        "contractDigest"
+      ],
+      "properties": {
+        "id": {
+          "type": "string",
+          "minLength": 1,
+          "format": "uri",
+          "pattern": "^https://",
+          "maxLength": 2048
+        },
+        "version": {
+          "type": "string",
+          "minLength": 1,
+          "maxLength": 64
+        },
+        "contractDigest": {
+          "type": "string",
+          "minLength": 1,
+          "pattern": "^sha-256:[0-9a-f]{64}$"
+        }
+      }
+    },
+    "issuedAt": {
+      "type": "string",
+      "minLength": 1,
+      "format": "date-time",
+      "pattern": "^\\d{4}-(0[1-9]|1[0-2])-(0[1-9]|[12]\\d|3[01])T([01]\\d|2[0-3]):[0-5]\\d:[0-5]\\dZ$"
+    },
+    "expiresAt": {
+      "type": "string",
+      "minLength": 1,
+      "format": "date-time",
+      "pattern": "^\\d{4}-(0[1-9]|1[0-2])-(0[1-9]|[12]\\d|3[01])T([01]\\d|2[0-3]):[0-5]\\d:[0-5]\\dZ$"
+    },
+    "inLanguage": {
+      "type": "string",
+      "minLength": 1,
+      "maxLength": 255
+    },
+    "service": {
+      "type": "object",
+      "additionalProperties": false,
+      "required": [
+        "id"
+      ],
+      "properties": {
+        "id": {
+          "type": "string",
+          "minLength": 1,
+          "format": "uri",
+          "pattern": "^https://(?![0-9.]+(:[0-9]+)?$)[A-Za-z0-9-]+(\\.[A-Za-z0-9-]+)*(:[0-9]{1,5})?$",
+          "maxLength": 2048
+        },
+        "tenant": {
+          "type": "string",
+          "minLength": 1,
+          "format": "uri",
+          "maxLength": 2048
+        }
+      }
+    },
+    "recipient": {
+      "type": "string",
+      "minLength": 1,
+      "maxLength": 320
+    },
+    "subject": {
+      "type": "object",
+      "additionalProperties": false,
+      "required": [
+        "id",
+        "title"
+      ],
+      "properties": {
+        "id": {
+          "type": "string",
+          "minLength": 1,
+          "format": "uri",
+          "maxLength": 2048
+        },
+        "title": {
+          "type": "string",
+          "minLength": 1,
+          "maxLength": 2048
+        }
+      }
+    },
+    "terms": {
+      "type": "object",
+      "additionalProperties": false,
+      "required": [
+        "id",
+        "version"
+      ],
+      "properties": {
+        "id": {
+          "type": "string",
+          "minLength": 1,
+          "format": "uri",
+          "maxLength": 2048
+        },
+        "version": {
+          "type": "string",
+          "minLength": 1,
+          "pattern": "^[ -~]+$",
+          "maxLength": 1024
+        }
+      }
+    },
+    "details": {
+      "type": "object"
+    },
+    "operations": {
+      "type": "array",
+      "items": {
+        "type": "object",
+        "additionalProperties": false,
+        "required": [
+          "id"
+        ],
+        "properties": {
+          "id": {
+            "type": "string",
+            "minLength": 1,
+            "pattern": "^[a-z][a-z0-9-]{0,63}$"
+          },
+          "capability": {
+            "type": "object",
+            "additionalProperties": false,
+            "required": [
+              "url"
+            ],
+            "properties": {
+              "url": {
+                "type": "string",
+                "minLength": 1,
+                "format": "uri",
+                "pattern": "^https://[^/?#@]+([/?][^#]*)?$",
+                "maxLength": 4096
+              }
+            }
+          }
+        }
+      },
+      "minItems": 1,
+      "maxItems": 32
+    },
+    "human": {
+      "type": "object",
+      "additionalProperties": false,
+      "required": [
+        "url"
+      ],
+      "properties": {
+        "url": {
+          "type": "string",
+          "minLength": 1,
+          "format": "uri",
+          "pattern": "^https://[^/?#@]+([/?][^#]*)?$",
+          "maxLength": 4096
+        }
+      }
+    }
+  }
+}

package/dist/implementation.schema.json

@@ -0,0 +1,173 @@
+{
+  "$schema": "https://json-schema.org/draft/2020-12/schema",
+  "$id": "https://mailschema.org/artifacts/map-0.3/schemas/implementation.schema.json",
+  "title": "MAP implementation record",
+  "type": "object",
+  "additionalProperties": false,
+  "required": [
+    "service",
+    "maintainer",
+    "type",
+    "operations",
+    "binding",
+    "status",
+    "documentation",
+    "evidence"
+  ],
+  "dependentRequired": {
+    "artifact": ["format"],
+    "format": ["artifact"]
+  },
+  "properties": {
+    "service": {
+      "type": "string",
+      "minLength": 1,
+      "format": "uri",
+      "pattern": "^https://"
+    },
+    "maintainer": {
+      "type": "object",
+      "additionalProperties": false,
+      "required": [
+        "name",
+        "url"
+      ],
+      "properties": {
+        "name": {
+          "type": "string",
+          "minLength": 1
+        },
+        "url": {
+          "type": "string",
+          "minLength": 1,
+          "format": "uri",
+          "pattern": "^https://"
+        }
+      }
+    },
+    "type": {
+      "type": "object",
+      "additionalProperties": false,
+      "required": [
+        "id",
+        "version",
+        "contractDigest"
+      ],
+      "properties": {
+        "id": {
+          "type": "string",
+          "minLength": 1,
+          "format": "uri",
+          "pattern": "^https://"
+        },
+        "version": {
+          "type": "string",
+          "minLength": 1
+        },
+        "contractDigest": {
+          "type": "string",
+          "pattern": "^sha-256:[0-9a-f]{64}$"
+        }
+      }
+    },
+    "operations": {
+      "type": "array",
+      "minItems": 1,
+      "uniqueItems": true,
+      "items": {
+        "type": "string",
+        "minLength": 1
+      }
+    },
+    "binding": {
+      "type": "string",
+      "format": "uri",
+      "pattern": "^https://",
+      "description": "Identifier of the binding specification or documented service binding. It is not a request destination. Clients must explicitly support it."
+    },
+    "artifact": {
+      "type": "object",
+      "additionalProperties": false,
+      "required": [
+        "url",
+        "digest",
+        "digestMode"
+      ],
+      "properties": {
+        "url": {
+          "type": "string",
+          "minLength": 1,
+          "format": "uri",
+          "pattern": "^https://"
+        },
+        "digest": {
+          "type": "string",
+          "pattern": "^sha-256:[0-9a-f]{64}$"
+        },
+        "digestMode": {
+          "enum": [
+            "canonical-json",
+            "bytes"
+          ],
+          "description": "canonical-json hashes the RFC 8785 representation; bytes hashes the exact downloaded artifact. Both use SHA-256."
+        }
+      }
+    },
+    "format": {
+      "type": "string",
+      "minLength": 1
+    },
+    "status": {
+      "enum": [
+        "Draft",
+        "Experimental",
+        "Stable",
+        "Deprecated",
+        "Superseded"
+      ]
+    },
+    "documentation": {
+      "type": "string",
+      "minLength": 1,
+      "format": "uri",
+      "pattern": "^https://"
+    },
+    "evidence": {
+      "type": "array",
+      "minItems": 1,
+      "items": {
+        "type": "object",
+        "additionalProperties": false,
+        "required": [
+          "kind",
+          "url",
+          "summary"
+        ],
+        "properties": {
+          "kind": {
+            "enum": [
+              "declaration",
+              "test-report"
+            ]
+          },
+          "url": {
+            "type": "string",
+            "minLength": 1,
+            "format": "uri",
+            "pattern": "^https://"
+          },
+          "summary": {
+            "type": "string",
+            "minLength": 1
+          }
+        }
+      }
+    },
+    "successor": {
+      "type": "string",
+      "minLength": 1,
+      "format": "uri",
+      "pattern": "^https://"
+    }
+  }
+}

package/dist/index.d.ts

@@ -1,9 +1,5 @@
-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';
-/** 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. */
-export declare function getRecordSchema(): Record<string, unknown>;
+/**
+ * Mail Action Protocol 0.3 processing: parse and check descriptions, type contracts and
+ * implementation records, and compute the RFC 8785 digests that identify contracts.
+ */
+export * from './core/index.js';

package/dist/index.js

@@ -1,13 +1,5 @@
-/** The MAP 0.2 core artifacts and validation tools for MailSchema Registry contributions. */
-import schema from './contribution.schema.json' with { type: 'json' };
-export { contributionErrors, assertContribution, assertTypeRecord, referenceErrors, } from './validation.js';
-export { typeStages } from './model.js';
-export { MAP_PROFILE, 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);
-}
-/** Return the schema for an expanded Registry record, including attribution and history. */
-export function getRecordSchema() {
-    return { $schema: schema.$schema, $defs: structuredClone(schema.$defs), $ref: '#/$defs/record' };
-}
+/**
+ * Mail Action Protocol 0.3 processing: parse and check descriptions, type contracts and
+ * implementation records, and compute the RFC 8785 digests that identify contracts.
+ */
+export * from './core/index.js';

package/dist/profile.json

@@ -0,0 +1,27 @@
+{
+  "id": "https://mailschema.org/profiles/map/0.3",
+  "name": "Mail Action Protocol 0.3",
+  "status": "working-draft",
+  "description": "An action description carried in Structured Email. A trusted service binding maps each decision to the service's existing operations, and the service enforces permission and exact terms. Types are defined by digest-bound contracts.",
+  "context": "https://mailschema.org/contexts/map-0.3.jsonld",
+  "schema": "https://mailschema.org/artifacts/map-0.3/schemas/core.schema.json",
+  "contractFormat": "https://mailschema.org/artifacts/map-0.3/schemas/contract.schema.json",
+  "specification": "https://mailschema.org/specification/core",
+  "artifacts": {
+    "context": {
+      "url": "https://mailschema.org/contexts/map-0.3.jsonld",
+      "sha256": "a51490d1fe8af695c14ea508aad88fd0429d18564791b6b52f3ab07d5c51aab3"
+    },
+    "schema": {
+      "url": "https://mailschema.org/artifacts/map-0.3/schemas/core.schema.json",
+      "sha256": "0ad09a6955a47e7a2c1c1eec0747a3e0b15c08a79860e90ce4e65da11983aeb3"
+    },
+    "contractFormat": {
+      "url": "https://mailschema.org/artifacts/map-0.3/schemas/contract.schema.json",
+      "sha256": "86bf057529c4fd2c7f0a880825774afeed31e9f7ba1d99760858a585fe28d18d"
+    },
+    "conformance": {
+      "url": "https://github.com/mailschema/mailschema/blob/main/conformance/map-0.3/README.md"
+    }
+  }
+}