@bkazemi/verily 0.4.0 → 0.5.0

package/dist/server/domain.d.ts

@@ -1,11 +1,25 @@
 import { type ArtifactProvider } from '../core/index.js';
-export interface DomainProviderOptions {
-    /** Shown as "Verify with …". */
-    name?: string;
-    /** Replaces the transport. For `dnsProvider()` that is only ever the resolver. */
+export interface DnsOptions {
+    /** Replaces the transport, which is only ever asked for the resolver. */
     fetch?: typeof fetch;
     timeoutMs?: number;
 }
+export interface DomainProviderOptions extends DnsOptions {
+    /** Shown as "Verify with …". */
+    name?: string;
+}
+/** What a domain publishes for Verily, as one lookup found it. */
+export interface Published {
+    /** The lookup that was run, which is also a link a reader can open. */
+    lookup: string;
+    /** The text of every TXT record at `_verily.<domain>` that could be read. */
+    values: string[];
+    /**
+     * Whether the resolver validated the answer with DNSSEC. Only a domain that signs its
+     * zone gets this, and without it the answer is as good as the resolver's own lookup.
+     */
+    dnssec: boolean;
+}
 export interface WellKnownProviderOptions extends DomainProviderOptions {
     /**
      * Domains this instance will read, lowercase. Omitted means any public host, which is
@@ -22,8 +36,8 @@ export interface WellKnownProviderOptions extends DomainProviderOptions {
     maxBytes?: number;
 }
 /**
- * Proves a domain by a record in its DNS. The holder publishes the local subject's address
- * in a TXT record at `_verily.<domain>` and names the domain; this looks the record up and
+ * Proves a domain by a record in its DNS. The holder publishes the local subject's address,
+ * or a string minted for them where the subject has none, in a TXT record at `_verily.<domain>` and names the domain; this looks the record up and
  * checks the address is there. It reaches a domain that serves no page of its own, or only
  * forwards somewhere else, which a link back never can.
  *
@@ -32,14 +46,66 @@ export interface WellKnownProviderOptions extends DomainProviderOptions {
  * nothing is said about a parent or a subdomain. A domain changes hands like an account,
  * and takes the record with it or drops it.
  *
- * Like a link back, the proof is a standing statement and not a per-flow token, so
- * freshness comes from `recheck()` looking it up again. A lookup that could not be made is
+ * Like a link back, the proof is a standing statement, so freshness comes from `recheck()`
+ * looking it up again and a renewal asks for the record already there. A lookup that could not be made is
  * unread, never absent.
  */
 export declare function dnsProvider(options?: DomainProviderOptions): ArtifactProvider;
 /**
- * Proves a domain by a file it serves. The holder puts the local subject's address on a
- * line of `/.well-known/verily.txt` and names the domain; this reads the file and checks
+ * Everything a domain publishes at `_verily.<domain>`, and whether the resolver validated
+ * it. One name carries every statement a domain makes here, told apart by how each begins:
+ * a subject's address or a minted proof, a signing key, a verifier.
+ *
+ * Throws `Refused` where the lookup gave no answer. A name with no records is an answer.
+ */
+export declare function published(domain: string, options?: DnsOptions): Promise<Published>;
+/**
+ * What a verifier publishes at `_verily.<its host>` to name a signing key: one record for
+ * each key. A reader holding a signed record and nothing else can then ask the verifier's
+ * domain, and not the verifier's server, whether the key that signed it is the domain's.
+ */
+export declare function keyRecord(fingerprint: string): string;
+/** What a site publishes at `_verily.<its host>` to name the verifier that speaks for it. */
+export declare function verifierRecord(host: string): string;
+/**
+ * The fingerprints of the signing keys a domain names in its DNS. A signed record names the
+ * key that signed it and the verifier's address, so a key found here is one the domain in
+ * that address answers for, for as long as the domain is kept and whatever became of the
+ * server. Check the signature with `verifySigned()` first: this says whose a key is, and
+ * nothing about what it signed.
+ */
+export declare function dnsKeys(domain: string, options?: DnsOptions): Promise<Omit<Published, 'values'> & {
+    ids: string[];
+}>;
+/**
+ * The hosts of the verifiers a site's domain names in its DNS. A record's local side is
+ * the verifier's word for what the site told it, so a verifier named here is one the site
+ * itself chose, which a reader can find out without visiting the site.
+ */
+export declare function dnsVerifiers(domain: string, options?: DnsOptions): Promise<Omit<Published, 'values'> & {
+    hosts: string[];
+}>;
+/**
+ * The fingerprints a domain's records name, in the upper case a key's id is kept in. A
+ * fingerprint is hexadecimal, so however it was typed it names the same key.
+ */
+export declare function namedKeys(values: string[]): string[];
+/**
+ * The verifier hosts a domain's records name, lowercase as a host compares, each with the
+ * record as it is published: that text is what a reader finds at the lookup.
+ */
+export declare function namedVerifiers(values: string[]): {
+    host: string;
+    record: string;
+}[];
+/**
+ * The name a URL's host is looked up under, or nothing where it is not a public domain: an
+ * address literal, a single label, a name inside the network.
+ */
+export declare function domainOf(url: string): string | undefined;
+/**
+ * Proves a domain by a file it serves. The holder puts the local subject's address, or a
+ * string minted for them where the subject has none, on a line of `/.well-known/verily.txt` and names the domain; this reads the file and checks
  * the line is there. It is for a holder who can add a file to a site and cannot reach its
  * DNS or its pages' markup.
  *

package/dist/server/domain.js

@@ -23,9 +23,13 @@ const label = '_verily';
 const path = '/.well-known/verily.txt';
 /** The TXT record type, as the resolver numbers it. */
 const txt = 16;
+/** What a signing key's record says, before the key's fingerprint. */
+const keyPrefix = 'verily-key=';
+/** What a site's record says, before the host of the verifier it chose. */
+const verifierPrefix = 'verily-verifier=';
 /**
- * Proves a domain by a record in its DNS. The holder publishes the local subject's address
- * in a TXT record at `_verily.<domain>` and names the domain; this looks the record up and
+ * Proves a domain by a record in its DNS. The holder publishes the local subject's address,
+ * or a string minted for them where the subject has none, in a TXT record at `_verily.<domain>` and names the domain; this looks the record up and
  * checks the address is there. It reaches a domain that serves no page of its own, or only
  * forwards somewhere else, which a link back never can.
  *
@@ -34,12 +38,18 @@ const txt = 16;
  * nothing is said about a parent or a subdomain. A domain changes hands like an account,
  * and takes the record with it or drops it.
  *
- * Like a link back, the proof is a standing statement and not a per-flow token, so
- * freshness comes from `recheck()` looking it up again. A lookup that could not be made is
+ * Like a link back, the proof is a standing statement, so freshness comes from `recheck()`
+ * looking it up again and a renewal asks for the record already there. A lookup that could not be made is
  * unread, never absent.
  */
 export function dnsProvider(options = {}) {
-    const request = options.fetch ?? fetch;
+    const prove = async ({ artifact, expect }) => {
+        const domain = looked(artifact);
+        const { values, dnssec } = await published(domain, options);
+        if (!values.includes(expect))
+            throw new Refused(`No TXT record at ${label}.${domain} has this value`);
+        return { account: account(domain), ...(dnssec ? { dnssec } : {}) };
+    };
     return {
         ...shared(options),
         method: 'dns',
@@ -53,47 +63,126 @@ export function dnsProvider(options = {}) {
             const domain = named(artifact);
             return domain ? lookup(domain) : artifact;
         },
-        async verify({ artifact, expect }) {
-            const domain = looked(artifact);
-            // Why the resolver could not be asked is about the network this runs in.
-            const response = await request(lookup(domain), {
-                redirect: 'manual',
-                headers: { Accept: 'application/dns-json', 'User-Agent': 'Verily-V0' },
-                signal: AbortSignal.timeout(options.timeoutMs ?? 15000),
-            }).catch(() => {
-                throw new Refused('DNS could not be read');
-            });
-            let answer;
-            try {
-                if (!response.ok)
-                    throw new Refused('DNS could not be read');
-                const { bytes, truncated } = await readBounded(response, 64 * 1024);
-                if (truncated)
-                    throw new Refused('DNS could not be read');
-                answer = parsed(new TextDecoder().decode(bytes));
-            }
-            finally {
-                await discard(response);
-            }
-            // A cut-off answer may have left out the record that would have matched.
-            if (!isRecord(answer) || answer.TC === true)
-                throw new Refused('DNS could not be read');
-            // The name not existing is an answer; anything else that is not success is no answer.
-            if (answer.Status !== 0 && answer.Status !== 3)
-                throw new Refused('DNS could not be read');
-            const records = Array.isArray(answer.Answer) ? answer.Answer : [];
-            if (!records.some((record) => isRecord(record) &&
-                record.type === txt &&
-                typeof record.data === 'string' &&
-                text(record.data) === expect))
-                throw new Refused(`No TXT record at ${label}.${domain} names this subject`);
-            return account(domain);
-        },
+        verify: async (input) => (await prove(input)).account,
+        // The resolver says whether it validated the answer, which is worth keeping with it.
+        prove,
+    };
+}
+/**
+ * Everything a domain publishes at `_verily.<domain>`, and whether the resolver validated
+ * it. One name carries every statement a domain makes here, told apart by how each begins:
+ * a subject's address or a minted proof, a signing key, a verifier.
+ *
+ * Throws `Refused` where the lookup gave no answer. A name with no records is an answer.
+ */
+export async function published(domain, options = {}) {
+    if (!valid(domain))
+        throw new Refused('Not a domain this can look up');
+    // Why the resolver could not be asked is about the network this runs in.
+    const response = await (options.fetch ?? fetch)(lookup(domain), {
+        redirect: 'manual',
+        headers: { Accept: 'application/dns-json', 'User-Agent': 'Verily-V0' },
+        signal: AbortSignal.timeout(options.timeoutMs ?? 15000),
+    }).catch(() => {
+        throw new Refused('DNS could not be read');
+    });
+    let answer;
+    try {
+        if (!response.ok)
+            throw new Refused('DNS could not be read');
+        const { bytes, truncated } = await readBounded(response, 64 * 1024);
+        if (truncated)
+            throw new Refused('DNS could not be read');
+        answer = parsed(new TextDecoder().decode(bytes));
+    }
+    finally {
+        await discard(response);
+    }
+    // A cut-off answer may have left out the record that would have matched.
+    if (!isRecord(answer) || answer.TC === true)
+        throw new Refused('DNS could not be read');
+    // The name not existing is an answer; anything else that is not success is no answer.
+    if (answer.Status !== 0 && answer.Status !== 3)
+        throw new Refused('DNS could not be read');
+    const records = Array.isArray(answer.Answer) ? answer.Answer : [];
+    return {
+        lookup: lookup(domain),
+        values: records
+            .map((record) => isRecord(record) && record.type === txt && typeof record.data === 'string'
+            ? text(record.data)
+            : undefined)
+            .filter((value) => value !== undefined),
+        // The resolver sets this only where every record in the answer validated.
+        dnssec: answer.AD === true,
     };
 }
 /**
- * Proves a domain by a file it serves. The holder puts the local subject's address on a
- * line of `/.well-known/verily.txt` and names the domain; this reads the file and checks
+ * What a verifier publishes at `_verily.<its host>` to name a signing key: one record for
+ * each key. A reader holding a signed record and nothing else can then ask the verifier's
+ * domain, and not the verifier's server, whether the key that signed it is the domain's.
+ */
+export function keyRecord(fingerprint) {
+    return `${keyPrefix}${fingerprint}`;
+}
+/** What a site publishes at `_verily.<its host>` to name the verifier that speaks for it. */
+export function verifierRecord(host) {
+    return `${verifierPrefix}${host.toLowerCase()}`;
+}
+/**
+ * The fingerprints of the signing keys a domain names in its DNS. A signed record names the
+ * key that signed it and the verifier's address, so a key found here is one the domain in
+ * that address answers for, for as long as the domain is kept and whatever became of the
+ * server. Check the signature with `verifySigned()` first: this says whose a key is, and
+ * nothing about what it signed.
+ */
+export async function dnsKeys(domain, options = {}) {
+    const { values, ...found } = await published(named(domain) ?? domain, options);
+    return { ...found, ids: namedKeys(values) };
+}
+/**
+ * The hosts of the verifiers a site's domain names in its DNS. A record's local side is
+ * the verifier's word for what the site told it, so a verifier named here is one the site
+ * itself chose, which a reader can find out without visiting the site.
+ */
+export async function dnsVerifiers(domain, options = {}) {
+    const { values, ...found } = await published(named(domain) ?? domain, options);
+    return { ...found, hosts: namedVerifiers(values).map(({ host }) => host) };
+}
+/**
+ * The fingerprints a domain's records name, in the upper case a key's id is kept in. A
+ * fingerprint is hexadecimal, so however it was typed it names the same key.
+ */
+export function namedKeys(values) {
+    return stated(values, keyPrefix).map((id) => id.toUpperCase());
+}
+/**
+ * The verifier hosts a domain's records name, lowercase as a host compares, each with the
+ * record as it is published: that text is what a reader finds at the lookup.
+ */
+export function namedVerifiers(values) {
+    return values
+        .filter((value) => value.startsWith(verifierPrefix))
+        .map((record) => ({ host: record.slice(verifierPrefix.length).trim().toLowerCase(), record }))
+        .filter(({ host }) => host);
+}
+/** What follows a prefix in each record that begins with it. */
+function stated(values, prefix) {
+    return values
+        .filter((value) => value.startsWith(prefix))
+        .map((value) => value.slice(prefix.length).trim())
+        .filter(Boolean);
+}
+/**
+ * The name a URL's host is looked up under, or nothing where it is not a public domain: an
+ * address literal, a single label, a name inside the network.
+ */
+export function domainOf(url) {
+    const host = URL.parse(url)?.hostname.toLowerCase().replace(/\.$/, '');
+    return host !== undefined && valid(host) ? host : undefined;
+}
+/**
+ * Proves a domain by a file it serves. The holder puts the local subject's address, or a
+ * string minted for them where the subject has none, on a line of `/.well-known/verily.txt` and names the domain; this reads the file and checks
  * the line is there. It is for a holder who can add a file to a site and cannot reach its
  * DNS or its pages' markup.
  *
@@ -110,7 +199,7 @@ export function wellKnownProvider(options = {}) {
         ...shared(options),
         method: 'wellknown',
         instructions: (expect) => [
-            'Serve a plain text file at this path on your domain, with this address on a line of its own, then enter the domain below.',
+            'Serve a plain text file at this path on your domain, with this on a line of its own, then enter the domain below.',
             { code: path },
             { code: expect },
         ],
@@ -144,7 +233,7 @@ export function wellKnownProvider(options = {}) {
                 if (truncated)
                     lines.pop();
                 if (!lines.some((line) => line.trim() === expect))
-                    throw new Refused(truncated ? 'File is too large to read' : 'File has no line naming this subject');
+                    throw new Refused(truncated ? 'File is too large to read' : 'File has no line with this value');
             }
             finally {
                 await discard(response);
@@ -161,12 +250,12 @@ function shared(options) {
         artifact: 'location',
         field: 'Your domain',
         input: 'text',
-        // The subject's own address is the entire claim, so there is nothing per-flow to mint.
-        expect(local) {
-            if (!local.profileUrl)
-                throw new Error('A domain proof needs a local subject with a profileUrl to name');
-            return local.profileUrl;
-        },
+        // The subject's own address is the entire claim, where it has one. A subject with no
+        // page a reader could open has nothing to name, and is proved by a minted string.
+        expect: (local) => local.profileUrl,
+        // DNS and a well-known path are read by anyone, unasked. A subject with no public page
+        // is one its site keeps private, so the string says nothing of the site either.
+        mint: (secret) => `verily-proof=${secret}`,
         // A domain is where it says it is, so a record of one already says where to look.
         known: (account) => (account.kind === 'domain' ? account.id : undefined),
     };

package/dist/server/index.d.ts

@@ -7,7 +7,7 @@ export { discordProvider } from './discord.js';
 export { youtubeProvider } from './youtube.js';
 export { githubGistProvider } from './github-gist.js';
 export { linkProvider, githubLinkProvider, type LinkProviderOptions } from './link.js';
-export { dnsProvider, wellKnownProvider, type DomainProviderOptions, type WellKnownProviderOptions, } from './domain.js';
+export { dnsProvider, wellKnownProvider, dnsKeys, dnsVerifiers, keyRecord, verifierRecord, type DnsOptions, type DomainProviderOptions, type Published, type WellKnownProviderOptions, } from './domain.js';
 export { pgpProvider } from './pgp.js';
 export { generateSigningKey, signer } from './signing.js';
 export { emailProvider, type EmailImage, type EmailMessage, type EmailProviderOptions, } from './email.js';

package/dist/server/index.js

@@ -10,8 +10,9 @@ export { discordProvider } from './discord.js';
 export { youtubeProvider } from './youtube.js';
 export { githubGistProvider } from './github-gist.js';
 export { linkProvider, githubLinkProvider } from './link.js';
-export { dnsProvider, wellKnownProvider, } from './domain.js';
+export { dnsProvider, wellKnownProvider, dnsKeys, dnsVerifiers, keyRecord, verifierRecord, } from './domain.js';
 export { pgpProvider } from './pgp.js';
+import { short } from './pgp.js';
 export { generateSigningKey, signer } from './signing.js';
 export { emailProvider, } from './email.js';
 export { resendSender } from './resend.js';
@@ -29,6 +30,25 @@ const headers = {
     'X-Content-Type-Options': 'nosniff',
     'Content-Security-Policy': "default-src 'none'; script-src 'self'; style-src 'self'; connect-src 'self'; base-uri 'none'; frame-ancestors 'none'; form-action 'self'",
 };
+/**
+ * What a request wants back, by one rule for every route that has more than one answer.
+ * The query says so first, where a route has that form. Then `Accept`, when it asks for
+ * JSON and not for a page. Then, for a POST, how the request itself was sent: a JSON body
+ * is answered in JSON, which is all a badge script published before `Accept` was read can
+ * say. Anything else is a page.
+ */
+function wants(request, url) {
+    const format = url.searchParams.get('format');
+    if (format === 'json' || format === 'signed')
+        return format;
+    const accept = request.headers.get('accept') ?? '';
+    if (/\bapplication\/json\b/i.test(accept) && !/\btext\/html\b/i.test(accept))
+        return 'json';
+    return request.method === 'POST' &&
+        request.headers.get('content-type')?.startsWith('application/json')
+        ? 'json'
+        : 'page';
+}
 const html = (body, status = 200) => new Response(body, {
     status,
     headers: { ...headers, 'Content-Type': 'text/html; charset=utf-8' },
@@ -74,7 +94,7 @@ function card(heading, name, url, reference, ...extra) {
  * named, never ranked.
  */
 function attestationNote(attestation, names, additional = false) {
-    const label = attestationLabel(attestation.method, names);
+    const label = attestationLabel(attestation.method, names, attestation);
     if (!label)
         return '';
     // Set by a provider implementation from holder-supplied input, so it reaches an href
@@ -140,7 +160,12 @@ function refusedNote(flow) {
     return `${flow.reason ? `That did not check out: ${flow.reason}.` : 'That could not be checked.'} ${left === 1 ? 'One try is' : `${left} tries are`} left.`;
 }
 /** Said beside every artifact method: what the holder publishes is public by design. */
-function artifactNote(provider) {
+function artifactNote(provider, expect) {
+    // A minted string names nobody, so there is nothing for a reader to follow. What names
+    // the subject is its address, which a site may give as http as well as https.
+    if (['dns', 'wellknown'].includes(provider.method) &&
+        !['https:', 'http:'].includes(URL.parse(expect ?? '')?.protocol ?? ''))
+        return `This ${provider.method === 'dns' ? 'record' : 'file'} is public, and anyone can look it up. It does not say what it is for.`;
     const notes = {
         backlink: 'This link is public, as is the page you point at. Anyone reading either one can follow it here.',
         dns: 'This record is public, as is the page it names. Anyone reading either one can follow it here.',
@@ -259,7 +284,7 @@ function visibilityChoice(local, allowed, signed) {
 function subjectNoun(kind) {
     return { account: 'account', page: 'page', site: 'website' }[kind ?? ''];
 }
-function evidencePage(e, base, report, keyId) {
+function evidencePage(e, base, report, keyId, named) {
     const names = { site: e.siteName, provider: e.providerName };
     const local = localSide(e.local, e.siteName);
     const current = e.status !== 'revoked' && e.expiresAt > Date.now();
@@ -298,19 +323,32 @@ function evidencePage(e, base, report, keyId) {
                 ['Sharing link expires', e.linkExpiresAt],
             ]) +
         `${e.linkExpiresAt ? '<p class="fine">Anyone with this link can view and forward it.</p>' : ''}
-    ${e.signedUrl ? `<p class="signed" id="signed"><strong>Signed by ${escape(e.verifierName)}</strong>${keyId ? ` with OpenPGP key <a href="${escape(base)}/keys.asc">${escape(keyId)}</a>` : ''}. <a href="${escape(safeUrl(e.signedUrl))}">Download the signed record</a>, which <a href="${escape(base)}/check">can be checked</a> without this page.</p>` : ''}
+    ${e.signedUrl ? `<p class="signed" id="signed"><strong>Signed by ${escape(e.verifierName)}</strong>${keyId ? `<br>${keyLine(base, keyId, named)}` : ''}<br><a href="${escape(safeUrl(e.signedUrl))}">Download signed record</a> · <a href="${escape(base)}/check">Check a record</a></p>` : ''}
     <p class="fine">This connection does not establish legal identity, trustworthiness, content authorship, or permanent ownership.</p>
     <p class="fine"><a href="${escape(base)}/external-revoke/${escape(e.id)}">Remove this connection using your external account</a></p>
     ${e.visibility === 'unlisted' ? `<p class="fine"><a href="${escape(base)}/external-share-revoke/${escape(e.id)}">Revoke only this sharing link using your external account</a></p>` : ''}
     <p class="fine"><a href="${escape(report)}" rel="noreferrer">Report an incorrect record</a></p>`);
 }
+/**
+ * Names a signing key on one line: its last sixteen digits, linked to the key itself with
+ * the whole fingerprint on hover, then whether a domain's DNS was read naming it. That is a
+ * link to the lookup that found it, a second place to learn whose the key is which is not
+ * this server, and its hover names the domain that was asked, whatever address the record
+ * beside it gives for its verifier.
+ */
+function keyLine(base, keyId, named) {
+    const key = `Key <a href="${escape(base)}/keys.asc" title="${escape(keyId)}">${escape(short(keyId))}</a>`;
+    return named
+        ? `${key} · <a href="${escape(named.lookup)}" rel="noreferrer" title="${escape(`View the lookup for ${named.domain}`)}">confirmed in DNS${named.dnssec ? ' (DNSSEC)' : ''}</a>`
+        : key;
+}
 const checkForm = '<form method="post"><label>Signed record <textarea name="record" rows="8" cols="72" required></textarea></label><button>Check</button></form>';
 /**
  * What a signed record says, once its signature has been checked against this verifier's
  * keys. It is a record of the past: the page says when, and sends the reader to the live
  * record for whether it still stands.
  */
-function checkedPage(d, keyId, base) {
+function checkedPage(d, keyId, base, named) {
     const names = { site: d.siteName, provider: d.providerName };
     const local = localSide(d.local, d.siteName);
     // A retired record did not stand when it was signed, and its heading says so first.
@@ -330,7 +368,7 @@ function checkedPage(d, keyId, base) {
                 ['Approved', d.approvedAt],
                 ['Valid until', d.expiresAt],
             ]) +
-        `<p class="fine">Signing key <a href="${escape(base)}/keys.asc">${escape(keyId)}</a>.</p>
+        `<p class="fine">${keyLine(base, keyId, named)}</p>
     <p class="fine"><a href="${escape(safeUrl(d.evidenceUrl))}">See whether this connection still stands</a></p>`);
 }
 export function createVerily(options) {
@@ -508,7 +546,7 @@ export function createVerily(options) {
                     ? { suggested: flow.artifact ?? flow.suggested }
                     : {}),
                 ...(flow.tries ? { refused: refusedNote(flow) } : {}),
-                note: artifactNote(provider),
+                note: artifactNote(provider, flow.expect),
             });
         if (flow.phase === 'pending' && isCodeProvider(provider))
             Object.assign(view, { code: codeStep(provider, flow), note: codeNote });
@@ -607,8 +645,11 @@ export function createVerily(options) {
                     if (kind === 'visibility' && visibilities(user).length < 2)
                         throw new Unavailable();
                     // One form per method. With one on offer the provider is all there is to name.
+                    // A new link started from this page always ends on its approval, as it did when
+                    // this form was a GET, so it says so: `/verify` is an address any site can send a
+                    // browser to, and the approval is where the holder sees what they are linking.
                     const forms = offered
-                        .map((p) => `<form method="${kind === 'connect' ? 'get' : 'post'}" action="${escape(prefix)}/sessions"><input type="hidden" name="kind" value="${kind}"><input type="hidden" name="connectionId" value="${escape(id)}"><input type="hidden" name="provider" value="${escape(p.id)}"><input type="hidden" name="method" value="${escape(providerMethod(p))}"><button>${escape(offered.length > 1 ? methodAction(p) : `Continue with ${p.name}`)}</button></form>`)
+                        .map((p) => `<form method="post" action="${escape(prefix)}/sessions"><input type="hidden" name="kind" value="${kind}">${kind === 'connect' ? '<input type="hidden" name="unattended" value="1">' : ''}<input type="hidden" name="connectionId" value="${escape(id)}"><input type="hidden" name="provider" value="${escape(p.id)}"><input type="hidden" name="method" value="${escape(providerMethod(p))}"><button>${escape(offered.length > 1 ? methodAction(p) : `Continue with ${p.name}`)}</button></form>`)
                         .join('');
                     return html(page(prefix, external
                         ? 'Remove a connection'
@@ -629,14 +670,6 @@ export function createVerily(options) {
                     const id = await service.callback(state, binding(request), url.searchParams.has('error') ? undefined : (url.searchParams.get('code') ?? undefined));
                     return redirect(`${prefix}/flows/${id}`);
                 }
-                if (path === '/sessions' && url.searchParams.get('kind') === 'connect') {
-                    const user = await local(request);
-                    const flow = await service.start(user, undefined, 'connect', await choose(user, undefined, {
-                        provider: url.searchParams.get('provider') ?? undefined,
-                        method: url.searchParams.get('method') ?? undefined,
-                    }), await context(request, 'connect'));
-                    return redirect(entry(flow), flowCookie(flow.binding));
-                }
                 // What the in-page dialog offers: every method the signed-in holder may use.
                 if (path === '/methods') {
                     const user = await local(request);
@@ -654,7 +687,7 @@ export function createVerily(options) {
                         })),
                     });
                 }
-                if (path.startsWith('/flows/') && url.searchParams.get('format') === 'json')
+                if (path.startsWith('/flows/') && wants(request, url) === 'json')
                     return json(await flowView(await ownFlow(request, path.slice(7))));
                 if (path.startsWith('/flows/')) {
                     const flow = await service.flow(path.slice(7), binding(request));
@@ -672,7 +705,7 @@ export function createVerily(options) {
                             ? `<textarea name="artifact" rows="14" cols="72" required>${escape(flow.artifact ?? '')}</textarea>`
                             : `<input name="artifact" type="${provider.input ?? 'url'}" value="${escape(flow.artifact ?? flow.suggested ?? '')}" autocapitalize="none" spellcheck="false" required>`}</label>
             <button>Check my proof</button></form>
-            <p class="fine">${escape(artifactNote(provider))}</p>
+            <p class="fine">${escape(artifactNote(provider, flow.expect))}</p>
             <script src="${escape(prefix)}/copy.js" defer></script>`));
                     }
                     // Holder-paced too, in two steps: where to send a code, then the code itself.
@@ -755,7 +788,9 @@ export function createVerily(options) {
                 }
                 // The keys a signed record is checked against. Public, like the records they sign.
                 if (path === '/keys') {
-                    const response = json({ keys: await service.keys() });
+                    const dns = await service.keyRecords();
+                    // With them, the records that name these keys in the DNS of this verifier's domain.
+                    const response = json({ keys: await service.keys(), ...(dns ? { dns } : {}) });
                     response.headers.set('Access-Control-Allow-Origin', '*');
                     return response;
                 }
@@ -768,7 +803,7 @@ export function createVerily(options) {
                     return json(await service.mine(await local(request)));
                 if (path.startsWith('/s/')) {
                     const evidence = await service.shared(path.slice(3));
-                    return url.searchParams.get('format') === 'json'
+                    return wants(request, url) === 'json'
                         ? json(evidence)
                         : html(evidencePage(evidence, prefix, options.reportUrl));
                 }
@@ -778,7 +813,7 @@ export function createVerily(options) {
                     return plain(await service.proof(hosted[1]));
                 if (path.startsWith('/connections/')) {
                     const id = path.slice(13);
-                    if (url.searchParams.get('format') === 'signed') {
+                    if (wants(request, url) === 'signed') {
                         const response = plain(await service.signed(id));
                         // Kept as a file, which is what `gpg --verify` is given.
                         response.headers.set('Content-Disposition', `attachment; filename="verily-${id}.asc"`);
@@ -786,13 +821,14 @@ export function createVerily(options) {
                     }
                     // Canonical routes and widgets never use local-session privileges.
                     const evidence = await service.read(id);
-                    if (url.searchParams.get('format') === 'json') {
+                    if (wants(request, url) === 'json') {
                         const response = json(evidence);
                         // Public evidence can be embedded on static sites without credentials.
                         response.headers.set('Access-Control-Allow-Origin', '*');
                         return response;
                     }
-                    return html(evidencePage(evidence, prefix, options.reportUrl, (await service.keys())[0]?.id));
+                    const keyId = (await service.keys())[0]?.id;
+                    return html(evidencePage(evidence, prefix, options.reportUrl, keyId, keyId && evidence.signedUrl ? await service.keyNamed(keyId) : undefined));
                 }
                 if (path.startsWith('/manage/'))
                     return json(await service.read(path.slice(8), await local(request)));
@@ -800,13 +836,14 @@ export function createVerily(options) {
             else {
                 const data = await body(request);
                 // The in-page dialog asks in JSON and is answered in JSON; a form gets its page.
-                const asJson = request.headers.get('content-type')?.startsWith('application/json');
+                const asJson = wants(request, url) === 'json';
                 if (path === '/check' && signs) {
                     try {
                         const signed = data.record ?? '';
                         const document = await service.checked(signed);
+                        const by = (await signedBy(signed));
                         if (document)
-                            return html(checkedPage(document, (await signedBy(signed)), prefix));
+                            return html(checkedPage(document, by, prefix, await service.keyNamed(by)));
                     }
                     catch {
                         // A record this build cannot draw is not one it can vouch for.
@@ -832,7 +869,8 @@ export function createVerily(options) {
                         method: data.method || undefined,
                     }), await context(request, kind), 
                     // Posted from this origin, which the check on every POST has already held it to.
-                    true);
+                    // A form may still ask to be held to an approval, which only ever adds one.
+                    !data.unattended);
                     if (asJson && ['connect', 'renew'].includes(kind))
                         return json(await flowView(await service.flow(flow.flowId, flow.binding), flow.authorizationUrl), flowCookie(flow.binding));
                     return redirect(entry(flow), flowCookie(flow.binding));

package/dist/server/pgp.d.ts

@@ -27,3 +27,5 @@ export declare function pgpProvider(options?: {
      */
     fetch?: typeof fetch;
 }): ArtifactProvider;
+/** The last sixteen digits, in the groups of four that fingerprints are read in. */
+export declare function short(fingerprint: string): string;

package/dist/server/pgp.js

@@ -193,6 +193,6 @@ function address(userId) {
     return (userId.match(/<([^>]{1,200})>/)?.[1] ?? userId).trim().slice(0, 200);
 }
 /** The last sixteen digits, in the groups of four that fingerprints are read in. */
-function short(fingerprint) {
+export function short(fingerprint) {
     return (fingerprint.slice(-16).match(/.{4}/g) ?? []).join(' ');
 }