@worker-protocol/conformance 0.1.0

package/dist/checks/metrics.js

@@ -0,0 +1,422 @@
+import { metricPage, metricsEntry } from "@worker-protocol/schemas";
+import { ruleFor } from "../attribution.js";
+import { verdicts } from "../report.js";
+/**
+ * The `metrics` Capability.
+ *
+ * The most checkable file in the specification — nineteen of its twenty rules have a witness a
+ * tool holding one ordinary credential can reach — and the one that needs a Worker with numbers in
+ * it. Several checks below report `notExercised` against a Worker that has accumulated nothing,
+ * which is not a weaker verdict than `passes`: it says a check exists and this run did not reach
+ * it, which is a gap somebody can close by pointing the tool at a Worker that has been running.
+ */
+export const CLAIMS = [
+    "MET-1",
+    "MET-21",
+    "MET-3",
+    "MET-4",
+    "MET-5",
+    "MET-6",
+    "MET-7",
+    "MET-8",
+    "MET-9",
+    "MET-10",
+    "MET-11",
+    "MET-12",
+    "MET-13",
+    "MET-14",
+    "MET-16",
+    "MET-17",
+    "MET-18",
+    "MET-19",
+    "MET-20",
+    "NAME-1",
+    // Judged here because this check already holds a valid page. A generic probe cannot construct a
+    // read for an arbitrary surface — which parameters a surface requires is each Capability file's
+    // to say — and a metric read is the collection that needs the most of them. Tasks and Alerts are
+    // collections too and answer a bare GET, so `checks/surfaces.ts` reaches those; this is the one
+    // that would otherwise go unjudged.
+    "ENDP-20",
+    "ENDP-23",
+];
+/**
+ * MET-5: the parameters this protocol defines on a read, which a dimension may not be named after.
+ *
+ * The list is here rather than generated because metrics.md states it in prose and nothing in
+ * `schemas/` can: the rule exists precisely because expressing *not one of these names* in a JSON
+ * Schema pattern needs a negative lookahead that RE2-backed validators refuse.
+ *
+ * `dimensions` joined the list when `openapi/` gained a parameter of that name to carry the
+ * dimension filters — which is MET-5's own warning arriving: *the list will grow, and when it does
+ * it may strand a Worker that declared the name first.* Nothing declares it today, and this is
+ * where a Worker that did would be told.
+ */
+const OWN_PARAMETERS = ["metric", "granularity", "from", "to", "by", "cursor", "dimensions"];
+/** The wall-clock reading of an instant in a zone, for judging where a boundary was cut. */
+function localParts(iso, zone) {
+    const format = new Intl.DateTimeFormat("en-CA", {
+        timeZone: zone,
+        hour12: false,
+        year: "numeric",
+        month: "2-digit",
+        day: "2-digit",
+        hour: "2-digit",
+        minute: "2-digit",
+        second: "2-digit",
+        weekday: "short",
+    });
+    const parts = {};
+    for (const part of format.formatToParts(new Date(iso)))
+        parts[part.type] = part.value;
+    // `en-CA` renders midnight as `24` rather than `00` in some ICU versions, which is the same
+    // instant under another name and would otherwise read as a boundary cut in the wrong place.
+    if (parts.hour === "24")
+        parts.hour = "00";
+    return parts;
+}
+export async function checkMetrics(entry, url, rules, attribution, transcript) {
+    const { results, say, allExcept } = verdicts(rules, CLAIMS);
+    if (entry === undefined) {
+        allExcept("notExercised", "the Worker declares no `metrics`");
+        return results;
+    }
+    // MET-1 through MET-6 are read off the Descriptor, and a verifier fails the Worker on them
+    // without calling anything. The rule each failure belongs to is read off `schemas/`.
+    const declared = metricsEntry.safeParse(entry);
+    if (!declared.success) {
+        const blamed = new Set();
+        for (const issue of declared.error.issues) {
+            const id = ruleFor(attribution, "metrics-entry", issue.path) ?? "MET-1";
+            if (blamed.has(id))
+                continue;
+            blamed.add(id);
+            say(id, "fails", `${issue.path.join(".") || "(root)"}: ${issue.message}`);
+        }
+        allExcept("notExercised", "the `metrics` entry did not validate", [...blamed]);
+        return results;
+    }
+    const { timeZone, publishes } = declared.data;
+    for (const id of ["MET-1", "MET-21", "MET-3", "MET-4", "MET-6"])
+        say(id, "passes");
+    // MET-5: a dimension named after a parameter this protocol defines on a read would be
+    // unreachable — the Worker could never tell the filter from the parameter.
+    const collisions = [];
+    for (const [metric, declaration] of Object.entries(publishes)) {
+        for (const dimension of Object.keys(declaration.dimensions)) {
+            if (OWN_PARAMETERS.includes(dimension))
+                collisions.push(`${metric}.${dimension}`);
+        }
+    }
+    if (collisions.length > 0) {
+        say("MET-5", "fails", `${collisions.join(", ")}: named after a parameter of a read`);
+    }
+    else {
+        say("MET-5", "passes");
+    }
+    if (url === null) {
+        allExcept("notExercised", "the declared address did not resolve", [
+            "MET-1",
+            "MET-21",
+            "MET-3",
+            "MET-4",
+            "MET-5",
+            "MET-6",
+        ]);
+        return results;
+    }
+    const readUrl = (parameters) => {
+        const target = new URL(url);
+        for (const [key, value] of Object.entries(parameters)) {
+            for (const one of Array.isArray(value) ? value : [value])
+                target.searchParams.append(key, one);
+        }
+        return target.toString();
+    };
+    // The metric with the most to say: the most granularities, then the most dimensions. A Worker
+    // that declares one metric with one granularity and no dimension is checked on less, and the
+    // report says which rules that left unexercised rather than passing them.
+    const [name, declaration] = Object.entries(publishes).sort(([, a], [, b]) => b.granularities.length - a.granularities.length ||
+        Object.keys(b.dimensions).length - Object.keys(a.dimensions).length)[0] ?? [];
+    if (name === undefined || declaration === undefined) {
+        allExcept("notExercised", "the entry declares no metric to read", [
+            "MET-1",
+            "MET-21",
+            "MET-3",
+            "MET-4",
+            "MET-5",
+            "MET-6",
+        ]);
+        return results;
+    }
+    const granularity = declaration.granularities.includes("day")
+        ? "day"
+        : declaration.granularities[0];
+    // MET-9: a metric the entry does not declare is 404, with the code `not_found`. A name no
+    // Worker would declare is the only way to ask without a Worker having to cooperate.
+    const absent = await transcript.send(readUrl({ metric: "no-such-metric-a4f1c7", granularity }), "a metric the entry does not declare", { permanent: true });
+    const absentCode = absent.json?.code;
+    if (absent.status === 404 && absentCode === "not_found")
+        say("MET-9", "passes");
+    else
+        say("MET-9", "fails", `answered ${absent.status} with \`${absentCode ?? "no code"}\``);
+    // MET-10: a granularity the metric does not declare is 400 with `invalid_parameter`, and so is
+    // an omitted one where the metric declares more than one — which is also MET-8's condition.
+    const wrongGrain = await transcript.send(readUrl({ metric: name, granularity: "fortnight" }), "a granularity the metric does not declare", { permanent: true });
+    const wrongCode = wrongGrain.json?.code;
+    if (wrongGrain.status === 400 && wrongCode === "invalid_parameter")
+        say("MET-10", "passes");
+    else
+        say("MET-10", "fails", `answered ${wrongGrain.status} with \`${wrongCode ?? "no code"}\``);
+    if (declaration.granularities.length > 1) {
+        const omitted = await transcript.send(readUrl({ metric: name }), "a read with no granularity, where the metric declares more than one");
+        if (omitted.status === 400)
+            say("MET-8", "passes");
+        else
+            say("MET-8", "fails", `answered ${omitted.status} rather than refusing`);
+    }
+    else {
+        const omitted = await transcript.send(readUrl({ metric: name }), "a read with no granularity, where the metric declares exactly one");
+        if (omitted.status === 200)
+            say("MET-8", "passes");
+        else
+            say("MET-8", "fails", `refused an omitted granularity with ${omitted.status}`);
+    }
+    // A window wide enough to hold something, and explicit so that two reads can be compared.
+    const now = Date.now();
+    const span = 30 * 24 * 3_600_000;
+    const iso = (ms) => new Date(ms).toISOString().replace(/\.\d{3}Z$/, "Z");
+    const whole = await transcript.send(readUrl({ metric: name, granularity, from: iso(now - span), to: iso(now + 3_600_000) }), "the metric over a month");
+    const page = metricPage.safeParse(whole.json);
+    if (whole.status !== 200 || !page.success) {
+        const why = whole.status !== 200
+            ? `the read answered ${whole.status}`
+            : `the answer did not validate: ${page.success ? "" : page.error.issues[0]?.message}`;
+        allExcept("notExercised", why, [
+            "MET-1",
+            "MET-21",
+            "MET-3",
+            "MET-4",
+            "MET-5",
+            "MET-6",
+            "MET-8",
+            "MET-9",
+            "MET-10",
+        ]);
+        if (whole.status === 200)
+            say("MET-13", "fails", why);
+        return results;
+    }
+    const buckets = page.data.items;
+    say("MET-13", "passes");
+    // ENDP-20: every surface that answers a list answers it in the shared page envelope. `metricPage`
+    // narrows that envelope's items, which is the narrowing ENDP-20 says each surface performs, so
+    // the page having validated above is the witness.
+    say("ENDP-20", "passes");
+    // ENDP-23: a collection declares an order and holds it, so that paging terminates. The witness
+    // is an unchanged read answering the same items in the same order — a collection whose order
+    // moves between two reads has none for a cursor to resume from.
+    const repeated = await transcript.send(readUrl({ metric: name, granularity, from: iso(now - span), to: iso(now + 3_600_000) }), "the same read again, to see whether the order holds");
+    const second = metricPage.safeParse(repeated.json);
+    if (!second.success) {
+        say("ENDP-23", "notExercised", "the repeated read did not validate");
+    }
+    else if (JSON.stringify(second.data.items) !== JSON.stringify(buckets)) {
+        say("ENDP-23", "fails", "an unchanged read answered its buckets in a different order");
+    }
+    else {
+        say("ENDP-23", "passes");
+    }
+    if (buckets.length === 0) {
+        allExcept("notExercised", "the Worker has accumulated nothing over the last month", [
+            "MET-1",
+            "MET-21",
+            "MET-3",
+            "MET-4",
+            "MET-5",
+            "MET-6",
+            "MET-8",
+            "MET-9",
+            "MET-10",
+            "MET-13",
+        ]);
+        return results;
+    }
+    // MET-14: buckets ascend by start.
+    const starts = buckets.map((b) => Date.parse(b.start));
+    const ascending = starts.every((at, i) => i === 0 || at >= starts[i - 1]);
+    if (ascending)
+        say("MET-14", "passes");
+    else
+        say("MET-14", "fails", "buckets are not ascending by start");
+    // MET-20, and MET-7 for a week. Every boundary is cut in the zone the entry declares — so the
+    // wall-clock reading of a bucket's start in that zone is midnight, or the top of an hour.
+    const misaligned = buckets.filter((bucket) => {
+        const at = localParts(bucket.start, timeZone);
+        if (granularity === "hour")
+            return at.minute !== "00" || at.second !== "00";
+        return at.hour !== "00" || at.minute !== "00" || at.second !== "00";
+    });
+    if (misaligned.length === 0) {
+        say("MET-20", "passes");
+    }
+    else {
+        const at = localParts(misaligned[0].start, timeZone);
+        say("MET-20", "fails", `${misaligned[0].start} is ${at.hour}:${at.minute} in ${timeZone}`);
+    }
+    if (granularity === "week") {
+        const notMonday = buckets.filter((b) => localParts(b.start, timeZone).weekday !== "Mon");
+        if (notMonday.length === 0)
+            say("MET-7", "passes");
+        else
+            say("MET-7", "fails", `${notMonday[0].start} does not begin a Monday in ${timeZone}`);
+    }
+    else if (declaration.granularities.includes("week")) {
+        const weekly = await transcript.send(readUrl({ metric: name, granularity: "week", from: iso(now - span), to: iso(now) }), "the metric by week");
+        const weeks = metricPage.safeParse(weekly.json);
+        const notMonday = weeks.success
+            ? weeks.data.items.filter((b) => localParts(b.start, timeZone).weekday !== "Mon")
+            : [];
+        if (!weeks.success)
+            say("MET-7", "notExercised", "the weekly read did not validate");
+        else if (weeks.data.items.length === 0)
+            say("MET-7", "notExercised", "no week accumulated");
+        else if (notMonday.length === 0)
+            say("MET-7", "passes");
+        else
+            say("MET-7", "fails", `${notMonday[0].start} does not begin a Monday in ${timeZone}`);
+    }
+    else {
+        say("MET-7", "notExercised", "the metric declares no `week` granularity");
+    }
+    // MET-12: an interval that begins inside a bucket never cuts one. Asking from the midpoint of
+    // the first whole bucket must not return a bucket whose start is before that midpoint.
+    const first = buckets[0];
+    const midpoint = Date.parse(first.start) + (Date.parse(first.end) - Date.parse(first.start)) / 2;
+    const fromMid = await transcript.send(readUrl({ metric: name, granularity, from: iso(midpoint), to: iso(now + 3_600_000) }), "an interval beginning inside a bucket");
+    const mid = metricPage.safeParse(fromMid.json);
+    if (!mid.success) {
+        say("MET-12", "notExercised", "the read from a midpoint did not validate");
+        say("MET-11", "notExercised", "the read from a midpoint did not validate");
+    }
+    else {
+        const cut = mid.data.items.filter((b) => Date.parse(b.start) < midpoint);
+        if (cut.length === 0)
+            say("MET-12", "passes");
+        else
+            say("MET-12", "fails", `${cut[0].start} begins before the interval did`);
+        // MET-11: the interval is half-open, so a bucket starting exactly at `to` is excluded and the
+        // two halves of a split interval share a boundary without sharing a bucket.
+        const boundary = buckets[Math.floor(buckets.length / 2)];
+        const before = await transcript.send(readUrl({ metric: name, granularity, from: iso(now - span), to: boundary.start }), "the interval up to a bucket's own start");
+        const head = metricPage.safeParse(before.json);
+        if (!head.success) {
+            say("MET-11", "notExercised", "the half-open read did not validate");
+        }
+        else if (head.data.items.some((b) => b.start === boundary.start)) {
+            say("MET-11", "fails", `\`to\` of ${boundary.start} returned the bucket starting there`);
+        }
+        else {
+            say("MET-11", "passes");
+        }
+    }
+    const closed = Object.entries(declaration.dimensions).find(([, d]) => d.values !== undefined);
+    const free = Object.entries(declaration.dimensions).find(([, d]) => d.values === undefined);
+    // MET-17: a value outside a declared set is 400 with `invalid_parameter`.
+    if (closed) {
+        const [dimension] = closed;
+        const bad = await transcript.send(readUrl({ metric: name, granularity, [dimension]: "no-such-value-9c2e" }), "a dimension value outside the declared set", { permanent: true });
+        const code = bad.json?.code;
+        if (bad.status === 400 && code === "invalid_parameter")
+            say("MET-17", "passes");
+        else
+            say("MET-17", "fails", `answered ${bad.status} with \`${code ?? "no code"}\``);
+    }
+    else {
+        say("MET-17", "notExercised", "no dimension declares a closed set of values");
+    }
+    // NAME-1: two names are the same name when their bytes are identical — no case folding, no
+    // normalisation, no trimming. Its witness is any declared name carrying an uppercase letter,
+    // sent back folded where the Worker matches names: a dimension whose parameter is `taskType`
+    // must not answer to `tasktype`. A Worker that folds passes every test anybody writes until the
+    // day somebody declares a name with a capital in it, which is exactly why this is worth a check.
+    const foldable = Object.keys(declaration.dimensions).find((d) => d !== d.toLowerCase());
+    if (foldable === undefined) {
+        say("NAME-1", "notExercised", "no declared dimension name carries an uppercase letter");
+    }
+    else {
+        const folded = await transcript.send(readUrl({ metric: name, granularity, [foldable.toLowerCase()]: "anything" }), "a declared dimension name, folded to lowercase", { permanent: true });
+        const code = folded.json?.code;
+        if (folded.status === 400 && code === "unknown_filter") {
+            say("NAME-1", "passes");
+        }
+        else {
+            say("NAME-1", "fails", `\`${foldable.toLowerCase()}\` was matched against \`${foldable}\``);
+        }
+    }
+    // MET-16 and MET-18: a dimension is fixed with a parameter of its own name, and one a read
+    // neither fixes nor groups by is accumulated over — so on a metric that only accumulates upward
+    // the unfiltered total is never smaller than any slice of it.
+    const total = buckets.reduce((sum, b) => sum + (b.value ?? 0), 0);
+    if (closed && declaration.additive) {
+        const [dimension, { values }] = closed;
+        const slice = await transcript.send(readUrl({
+            metric: name,
+            granularity,
+            from: iso(now - span),
+            to: iso(now + 3_600_000),
+            [dimension]: values[0],
+        }), "the metric fixed to one value of a dimension");
+        const sliced = metricPage.safeParse(slice.json);
+        if (slice.status !== 200 || !sliced.success) {
+            say("MET-16", "fails", `fixing \`${dimension}\` answered ${slice.status}`);
+            say("MET-18", "notExercised", "the filtered read did not answer");
+        }
+        else {
+            say("MET-16", "passes");
+            const part = sliced.data.items.reduce((sum, b) => sum + (b.value ?? 0), 0);
+            if (part <= total)
+                say("MET-18", "passes");
+            else
+                say("MET-18", "fails", `fixing \`${dimension}\` answered ${part} against a total of ${total}`);
+        }
+    }
+    else {
+        say("MET-16", "notExercised", "no dimension declares a closed set to filter by");
+        say("MET-18", "notExercised", "no additive metric with a closed dimension to compare over");
+    }
+    // MET-19: a read breaks down with `by`, and only by a dimension that declared its values. Each
+    // bucket then carries what it is broken down by, and the same period appears once per
+    // combination.
+    if (closed) {
+        const [dimension] = closed;
+        const grouped = await transcript.send(readUrl({
+            metric: name,
+            granularity,
+            from: iso(now - span),
+            to: iso(now + 3_600_000),
+            by: dimension,
+        }), "the metric broken down by a declared dimension");
+        const parts = metricPage.safeParse(grouped.json);
+        const freeRefused = free
+            ? await transcript
+                .send(readUrl({ metric: name, granularity, by: free[0] }), "a breakdown by a free dimension")
+                .then((r) => r.status === 400)
+            : true;
+        if (grouped.status !== 200 || !parts.success) {
+            say("MET-19", "fails", `a breakdown by \`${dimension}\` answered ${grouped.status}`);
+        }
+        else if (parts.data.items.some((b) => b.dimensions?.[dimension] === undefined)) {
+            say("MET-19", "fails", "a broken-down bucket carries no value for the dimension");
+        }
+        else if (!freeRefused) {
+            say("MET-19", "fails", `a breakdown by the free dimension \`${free?.[0]}\` was not refused`);
+        }
+        else {
+            say("MET-19", "passes");
+        }
+    }
+    else {
+        say("MET-19", "notExercised", "no dimension declares a closed set to group by");
+    }
+    return results;
+}

package/dist/checks/nudges.d.ts

@@ -0,0 +1,20 @@
+import { type Attribution } from "../attribution.ts";
+import { type Result, type Rule } from "../report.ts";
+import type { Transcript } from "../transcript.ts";
+/**
+ * The `nudges` Capability: being told there is work of a Task type.
+ *
+ * The only surface in this protocol whose body is fixed by the protocol rather than by the Worker,
+ * which is what a check gets to use: it can write a nudge without reading anything, and both of the
+ * answers below are shapes `spec/nudges.md` states rather than shapes this Worker chose.
+ *
+ * **NDG-3 is asked first and NDG-2 second, and the order is the same one `spec/` argues for.** A
+ * nudge for a type the Worker declares no Skill for is refused, so nothing happened; a nudge it
+ * accepts sends it to read somebody's Tasks. The second is why the register classes NDG-2 `H` — it
+ * needs a Worker whose operators agreed it could be told — and the first is `W` for the reason
+ * ACT-6 is: the witness is a refusal.
+ */
+export declare const CLAIMS: readonly ["NDG-1", "NDG-2", "NDG-3"];
+export declare function checkNudges(entry: Record<string, unknown> | undefined, url: string | null, 
+/** TASK-31's declaration, read off the Descriptor root: the types this Worker may be nudged for. */
+skills: string[], rules: Map<string, Rule>, attribution: Attribution, transcript: Transcript, mayPerform: boolean): Promise<Result[]>;

package/dist/checks/nudges.js

@@ -0,0 +1,77 @@
+import { nudgesEntry } from "@worker-protocol/schemas";
+import { ruleFor } from "../attribution.js";
+import { verdicts } from "../report.js";
+/**
+ * The `nudges` Capability: being told there is work of a Task type.
+ *
+ * The only surface in this protocol whose body is fixed by the protocol rather than by the Worker,
+ * which is what a check gets to use: it can write a nudge without reading anything, and both of the
+ * answers below are shapes `spec/nudges.md` states rather than shapes this Worker chose.
+ *
+ * **NDG-3 is asked first and NDG-2 second, and the order is the same one `spec/` argues for.** A
+ * nudge for a type the Worker declares no Skill for is refused, so nothing happened; a nudge it
+ * accepts sends it to read somebody's Tasks. The second is why the register classes NDG-2 `H` — it
+ * needs a Worker whose operators agreed it could be told — and the first is `W` for the reason
+ * ACT-6 is: the witness is a refusal.
+ */
+export const CLAIMS = ["NDG-1", "NDG-2", "NDG-3"];
+/** A type namespaced under a domain nobody owns, so no Worker could honestly declare a Skill for it. */
+const NO_SUCH_TYPE = "tech.rowing.no-such.task-type-4c1f";
+export async function checkNudges(entry, url, 
+/** TASK-31's declaration, read off the Descriptor root: the types this Worker may be nudged for. */
+skills, rules, attribution, transcript, mayPerform) {
+    const { results, say, allExcept } = verdicts(rules, CLAIMS);
+    if (entry === undefined) {
+        allExcept("notExercised", "the Worker declares no `nudges`");
+        return results;
+    }
+    const declared = nudgesEntry.safeParse(entry);
+    if (!declared.success) {
+        const issue = declared.error.issues[0];
+        const id = ruleFor(attribution, "nudges-entry", issue?.path ?? []) ?? "NDG-1";
+        say(id, "fails", `${issue?.path.join(".") || "(root)"}: ${issue?.message}`);
+        allExcept("notExercised", "the `nudges` entry did not validate", [id]);
+        return results;
+    }
+    say("NDG-1", "passes");
+    if (url === null) {
+        allExcept("notExercised", "the declared address did not resolve", ["NDG-1"]);
+        return results;
+    }
+    if (!mayPerform) {
+        allExcept("notExercised", "the verifier was not permitted to POST to this Worker", ["NDG-1"]);
+        return results;
+    }
+    const nudge = (type, intent, permanent = false) => transcript.send(url, intent, {
+        method: "POST",
+        body: JSON.stringify({ type }),
+        headers: { "content-type": "application/json" },
+        permanent,
+    });
+    // NDG-3: a Worker that took a nudge for a type it does not answer would be telling an owner it
+    // had been told, and the owner would stop nudging whoever could actually help.
+    const refused = await nudge(NO_SUCH_TYPE, "a nudge for a Task type no Worker answers", true);
+    const code = refused.json?.code;
+    if (refused.status === 404 && code === "not_found")
+        say("NDG-3", "passes");
+    else
+        say("NDG-3", "fails", `answered ${refused.status} with \`${code ?? "no code"}\``);
+    // NDG-2: `204` and no body, because there is nothing to say. This is the one call here that the
+    // Worker acts on, and a type it declares a Skill for is the only one it may be sent for.
+    const answerable = skills[0];
+    if (answerable === undefined) {
+        say("NDG-2", "notExercised", "the Worker declares no Skill, so there is no type to nudge it for");
+        return results;
+    }
+    const told = await nudge(answerable, `a nudge for \`${answerable}\`, which it answers`);
+    if (told.status !== 204) {
+        say("NDG-2", "fails", `answered ${told.status} rather than 204`);
+    }
+    else if (told.body.length > 0) {
+        say("NDG-2", "fails", "answered 204 with a body");
+    }
+    else {
+        say("NDG-2", "passes");
+    }
+    return results;
+}

package/dist/checks/surfaces.d.ts

@@ -0,0 +1,14 @@
+import { type Result, type Rule } from "../report.ts";
+import type { Transcript } from "../transcript.ts";
+/**
+ * What calling each declared address establishes, before any Capability's own file is consulted.
+ *
+ * DESC-18 is here rather than beside the Descriptor because its witness is a declared address
+ * answering `404`, which needs the call the Descriptor check deliberately does not make.
+ */
+export declare const CLAIMS: readonly ["DESC-18", "REG-3", "REG-7", "REG-21", "ENDP-2", "ENDP-6", "ENDP-24"];
+export type Surface = {
+    capability: string;
+    url: string;
+};
+export declare function callSurfaces(surfaces: Surface[], descriptorUrl: string, writeAddresses: string[], rules: Map<string, Rule>, transcript: Transcript, credential: string | undefined, mayPerform: boolean): Promise<Result[]>;