@bkazemi/verily 0.4.0 → 0.6.0

package/dist/server/index.js

@@ -1,4 +1,4 @@
-import { attestationLabel, externalId, externalLink, externalName, isArtifactProvider, isCodeProvider, isRedirectProvider, lastProved, localSide, proofTitle, providerMethod, statusLabel, signedBy, } from '../core/index.js';
+import { attestationLabel, externalId, externalIdGroups, externalLink, externalName, isArtifactProvider, isCodeProvider, isRedirectProvider, lastProved, accountsOf, localSide, proofTitle, providerMethod, statusLabel, signedBy, } from '../core/index.js';
 import { artifactAttempts, codeAttempts, VerilyService, Unavailable, } from './service.js';
 import { copyScript, waitScript } from './copy.js';
 import { escape } from './escape.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' },
@@ -65,7 +85,11 @@ const redirect = (url, cookie) => new Response(null, {
  */
 function card(heading, name, url, reference, ...extra) {
     const profile = url && safeUrl(url);
-    return `<div class="side"><p class="who">${escape(heading)}</p><p class="name">${profile ? `<a href="${escape(profile)}" rel="noreferrer">${escape(name)}</a>` : escape(name)}</p>${reference ? `<p class="reference">${escape(reference)}</p>` : ''}${extra.join('')}</div>`;
+    return `<div class="side"><p class="who">${escape(heading)}</p><p class="name">${profile ? `<a href="${escape(profile)}" rel="noreferrer">${escape(name)}</a>` : escape(name)}</p>${typeof reference === 'string'
+        ? `<p class="reference">${escape(reference)}</p>`
+        : reference
+            ? `<p class="reference fingerprint">${reference.map((group) => `<span>${escape(group)}</span>`).join('')}</p>`
+            : ''}${extra.join('')}</div>`;
 }
 /**
  * Names how one side was established, inside that side's card. Where the method published
@@ -74,7 +98,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 +164,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 +288,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();
@@ -270,7 +299,7 @@ function evidencePage(e, base, report, keyId) {
     card(local.heading, local.value, e.local.profileUrl, undefined, attestationNote(e.attestations.local, names)) +
         card(names.provider, externalName(e.external), externalLink(e.external), 
         // A mailbox's address or a domain is its name already, so there is no second identifier.
-        externalId(e.external), externalNotes(e.attestations, names)) +
+        externalIdGroups(e.external) ?? externalId(e.external), externalNotes(e.attestations, names)) +
         times(e.status === 'retired'
             ? [
                 ['Approved', e.approvedAt],
@@ -298,26 +327,99 @@ 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>`);
 }
+/** Joins a subject's card to its accounts: the link itself, drawn as the dialog draws it. */
+const joiner = '<svg class="joiner" viewBox="0 0 24 24" fill="none" aria-hidden="true" focusable="false">' +
+    [
+        'M10.5 7.5 13 5a4.95 4.95 0 0 1 7 7l-2.5 2.5',
+        'M13.5 16.5 11 19a4.95 4.95 0 0 1-7-7l2.5-2.5',
+        'M9 15l6-6',
+    ]
+        .map((d) => `<path d="${d}" stroke="currentColor" stroke-width="2" stroke-linecap="round"/>`)
+        .join('') +
+    '</svg>';
+/**
+ * One account as a badge's dialog draws it: what it is and how it stands, the verifier's
+ * own page for it, how it was shown, how its holder lists it, and its times.
+ */
+function accountCard(e, external, now) {
+    const retired = e.status === 'retired';
+    const record = escape(safeUrl(e.evidenceUrl));
+    return card(e.providerName, externalName(e.external), externalLink(e.external), externalIdGroups(e.external) ?? externalId(e.external), `<p class="how">${escape(statusLabel(e, now))} · via: <a href="${record}">${escape(e.verifierName)}</a>${e.signedUrl ? ` · <a href="${record}#signed">signed</a>` : ''}</p>`, externalNotes({ ...e.attestations, external }, { site: e.siteName, provider: e.providerName }), times(retired
+        ? [
+            ['Approved', e.approvedAt],
+            ['Last verified', lastProved(e)],
+            ['Retired', e.retiredAt],
+        ]
+        : [
+            ['Approved', e.approvedAt],
+            [e.expiresAt > now ? 'Valid until' : 'Expired on', e.expiresAt],
+            ['Last checked', external[0].artifactUrl ? external[0].confirmedAt : undefined],
+        ]), 
+    // The holder's own word on the account, which nothing checked, so it sits apart from
+    // the methods, in the card's corner as the dialog has it.
+    retired || !e.mark
+        ? ''
+        : e.mark === 'preferred'
+            ? '<div class="listing preferred">Preferred</div>'
+            : '<div class="listing">No longer used</div>');
+}
+/**
+ * The public records given, as a page that shows what a badge's dialog does: a card to a
+ * subject, then one to each of its accounts in the badge's own order.
+ */
+function publishedPage(records, base) {
+    const now = Date.now();
+    const subjects = new Map();
+    for (const e of records) {
+        const key = JSON.stringify([e.siteName, e.local.reference]);
+        subjects.set(key, [...(subjects.get(key) ?? []), e]);
+    }
+    return page(base, 'Public connections', records.length
+        ? [...subjects.values()]
+            .map((held) => {
+            const local = localSide(held[0].local, held[0].siteName);
+            return (card(local.heading, local.value, held[0].local.profileUrl) +
+                joiner +
+                `<div class="accounts">${accountsOf(held, now)
+                    .map(({ lead, external }) => accountCard(lead, external, now))
+                    .join('')}</div>`);
+        })
+            .join('')
+        : '<p>No public connections.</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.
     const retired = d.version === 2;
     return page(base, retired ? 'Retired connection' : 'Signed record', `<p>${escape(d.verifierName)} signed this record. It shows what stood when it was signed, not what stands now.</p>` +
         card(local.heading, local.value, d.local.profileUrl, undefined, attestationNote(d.attestations.local, names)) +
-        card(names.provider, externalName(d.external), externalLink(d.external), externalId(d.external), externalNotes(d.attestations, names)) +
+        card(names.provider, externalName(d.external), externalLink(d.external), externalIdGroups(d.external) ?? externalId(d.external), externalNotes(d.attestations, names)) +
         times(retired
             ? [
                 ['Signed', d.issuedAt],
@@ -330,7 +432,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 +610,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 });
@@ -606,15 +708,22 @@ export function createVerily(options) {
                     // With one visibility there is nothing for the holder to change it to.
                     if (kind === 'visibility' && visibilities(user).length < 2)
                         throw new Unavailable();
+                    // Several providers are named by their buttons, not strung together in the heading.
+                    const several = new Set(offered.map((p) => p.name)).size > 1;
                     // 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'
                         : kind === 'renew'
                             ? 'Renew this connection'
-                            : `Verify with ${providerNames(offered)}`, `
+                            : several
+                                ? 'Verify an account'
+                                : `Verify with ${providerNames(offered)}`, `
             ${user
                         ? card(subject(user).heading, subject(user).value, user.profileUrl)
                         : '<p>Authenticate with the matching external account to review and remove this link.</p>'}
@@ -629,14 +738,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 +755,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 +773,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.
@@ -711,7 +812,7 @@ export function createVerily(options) {
                                 ? 'Add to connection'
                                 : 'Confirm connection', `
             ${card(subject(flow.local).heading, subject(flow.local).value, flow.local.profileUrl)}
-            ${card(provider.name, externalName(flow.external), externalLink(flow.external), externalId(flow.external))}
+            ${card(provider.name, externalName(flow.external), externalLink(flow.external), externalIdGroups(flow.external) ?? externalId(flow.external))}
             ${joined ? `<p>This account is already linked here. Confirming adds this method to that connection, beneath the one it was first shown by, and it stays ${escape(joined.visibility)}.</p>` : ''}
             ${found ? `<p>${escape(found)}</p>` : ''}
             <p class="fine">${escape(service.siteOf(flow.local))} receives the result. Verified via ${escape(options.verifierName)}.</p>
@@ -749,13 +850,23 @@ export function createVerily(options) {
                 }
                 // Lets a static embed track current connections without hardcoding an id.
                 if (path === '/published') {
-                    const response = json(await service.published());
+                    const site = url.searchParams.get('site');
+                    const reference = url.searchParams.get('reference') ?? undefined;
+                    const subject = site === null ? undefined : { site, reference };
+                    // A page only where one is asked for by name. An embed published before `Accept`
+                    // was sent asks for nothing, and must go on getting the list.
+                    if (url.searchParams.get('format') !== 'json' &&
+                        /\btext\/html\b/i.test(request.headers.get('accept') ?? ''))
+                        return html(publishedPage(await service.listed(subject), prefix));
+                    const response = json(await service.published(subject));
                     response.headers.set('Access-Control-Allow-Origin', '*');
                     return response;
                 }
                 // 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 +879,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 +889,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 +897,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 +912,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 +945,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/openpgp.d.ts

@@ -10,6 +10,10 @@ import { Refused } from '../core/index.js';
 export declare class Malformed extends Refused {
     constructor(what: string, options?: ErrorOptions);
 }
+/** The block is not there at all: a holder who pasted half is told which half is missing. */
+export declare class Missing extends Malformed {
+    constructor(what: string);
+}
 export type Certificate = Key;
 export type Cleartext = CleartextMessage;
 /** The public key in armored text, wherever in the text its block is. */

package/dist/server/openpgp.js

@@ -34,6 +34,13 @@ export class Malformed extends Refused {
         super(`Malformed OpenPGP ${what}`, options);
     }
 }
+/** The block is not there at all: a holder who pasted half is told which half is missing. */
+export class Missing extends Malformed {
+    constructor(what) {
+        super(what);
+        this.message = `No OpenPGP ${what} found`;
+    }
+}
 /**
  * The one armored block of the named kind out of text that may hold others: a holder
  * pastes the signed message and the key together, and the library reads only the first
@@ -43,8 +50,10 @@ function block(text, begin, end, what) {
     if (text.length > maxArmorBytes)
         throw new Malformed(what);
     const start = text.indexOf(`-----BEGIN PGP ${begin}-----`);
+    if (start < 0)
+        throw new Missing(what);
     const stop = text.indexOf(`-----END PGP ${end}-----`, start);
-    if (start < 0 || stop < 0)
+    if (stop < 0)
         throw new Malformed(what);
     return text.slice(start, stop + `-----END PGP ${end}-----`.length);
 }

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(' ');
 }

package/dist/server/service.d.ts

@@ -1,6 +1,15 @@
 import { type Attestations, type Connection, type Evidence, type ExternalAccount, type Flow, type LocalAccount, type Mark, type Provider, type SignedDocument, type SignedEvidence, type Storage, type VerifierKey, type Visibility } from '../core/index.js';
+import { type DnsOptions, type Published } from './domain.js';
 export declare const secret: () => string;
 export declare const hash: (value: string) => string;
+/**
+ * A subject as its public records name it: the site it belongs to and its reference there.
+ * A reference means nothing outside its site, so with none this is everyone on the site.
+ */
+export interface Subject {
+    site: string;
+    reference?: string;
+}
 export declare class Unavailable extends Error {
     constructor();
 }
@@ -45,6 +54,17 @@ export interface ServiceOptions {
     signingKey?: string | (() => Promise<string>);
     /** Public keys this instance signed with before, so what they signed still checks. */
     retiredKeys?: VerifierKey[];
+    /**
+     * Reads what DNS says of this verifier, through the one resolver `dnsProvider()` asks.
+     * Two statements are looked for, both TXT records at `_verily.<domain>`. On this
+     * verifier's own domain, `verily-key=<fingerprint>` names a signing key, and the pages
+     * that name the key then link to that lookup. On the domain of a subject's `profileUrl`,
+     * `verily-verifier=<this verifier's host>` names this verifier as the site's own, and
+     * the record's local side then carries that lookup as its proof. That one is read when a
+     * link is approved and again by `recheck()`, and is not looked for where this verifier
+     * is on the site's domain or a subdomain of it. Unset reads nothing.
+     */
+    dns?: boolean | DnsOptions;
     now?: () => number;
 }
 export declare class VerilyService {
@@ -58,6 +78,42 @@ export declare class VerilyService {
     private signer;
     /** Every key a record of this instance may be signed by: the current one first. */
     keys(): Promise<VerifierKey[]>;
+    /**
+     * What this verifier's domain publishes to name its keys: one TXT record for each, all
+     * under the one name. Nothing where it signs nothing, or is not on a domain at all.
+     */
+    keyRecords(): Promise<{
+        name: string;
+        values: string[];
+    } | undefined>;
+    /**
+     * Where a reader can see this verifier's domain name a key, if it was read doing so, and
+     * which domain that was. It is always the domain this instance is on now: a record it
+     * signed while on another names that one, and nothing here was asked about it. The
+     * answer is kept for ten minutes, so a page that asks on every view costs one lookup.
+     */
+    keyNamed(id: string): Promise<(Pick<Published, 'lookup' | 'dnssec'> & {
+        domain: string;
+    }) | undefined>;
+    /** What each domain was last read publishing, and when. Nothing found is a failed read. */
+    private readonly lookups;
+    /**
+     * What a domain publishes for Verily, read again once the last read is older than
+     * `maxAgeMs`. Nothing where it could not be read, which is never the same as nothing
+     * published.
+     */
+    private lookedUp;
+    /**
+     * The domain whose DNS can say a subject's site chose this verifier, or nothing where
+     * there is nothing to ask: no address, or a site this verifier shares a domain with,
+     * since whoever holds a domain already holds every name beneath it.
+     */
+    private siteDomain;
+    /**
+     * The local side as a site's DNS bears it out: the site's word, with the lookup that
+     * found the site naming this verifier. Nothing where it does not, or could not be read.
+     */
+    private stated;
     /** The same keys as one armored text, which is what `gpg --import` takes. */
     armoredKeys(): Promise<string>;
     /**
@@ -275,7 +331,10 @@ export declare class VerilyService {
      * subject, and holds whatever the subject's address becomes.
      */
     private names;
-    /** The site is the only authority on its own namespace, so it declares the local subject. */
+    /**
+     * The site is the only authority on its own namespace, so it declares the local subject.
+     * Where the flow read the site's DNS naming this verifier, that goes with it.
+     */
     private declared;
     /** How the provider established the external account, by whatever method the flow ran. */
     private attestation;
@@ -294,7 +353,19 @@ export declare class VerilyService {
      * hardcoding an id that dies whenever one is revoked and replaced. Unlisted records are
      * never included: they must not appear in any directory listing.
      */
-    published(): Promise<Evidence[]>;
+    published(subject?: Subject): Promise<Evidence[]>;
+    /**
+     * Every public record a badge could show, for the page a person reads: one that has lapsed
+     * or been retired is there to be marked, and one removed is not. `subject` narrows it to
+     * one site or one subject, named by what its records already publish. Earliest connected first.
+     */
+    listed(subject?: Subject): Promise<Evidence[]>;
+    /**
+     * Every record this instance holds, public and unlisted, for whoever runs it. No route
+     * of the library serves this: a deployment that shows it must first know the reader is
+     * its operator, who can read the storage it comes from anyway. Earliest connected first.
+     */
+    all(): Promise<Evidence[]>;
     mine(local: LocalAccount): Promise<Evidence[]>;
     private owned;
     revoke(id: string, local: LocalAccount): Promise<void>;
@@ -372,6 +443,20 @@ export declare class VerilyService {
      * Returns how many were confirmed. A connection revoked here is not one of them.
      */
     recheck(budget?: number): Promise<number>;
+    /**
+     * Asks each site's DNS again whether it names this verifier, and writes the answer to
+     * every record of that site. One lookup answers for all of a site's records, and
+     * `budget` bounds the sites asked in a run, longest unread first. A site that could not
+     * be read is left as it was: its records lose the proof only once it has gone unread
+     * past `freshnessMs`, or once an answer comes back without the statement.
+     *
+     * When each site was last asked is kept in storage, as a record of its own that `prune()`
+     * removes only with the site's last record. It is apart from the lookups a flow makes
+     * and from anything that expires: an instance restarted or pruned between runs must not
+     * start again from the same few sites, and a site whose holders connect often must
+     * still have its older records rewritten.
+     */
+    private restate;
     /**
      * The configured method that can ask again about one attestation, or nothing when there
      * is nothing to ask: no published proof, a method this instance no longer runs, or a