@bkazemi/verily 0.3.0 → 0.5.0

package/dist/server/index.js

@@ -1,4 +1,4 @@
-import { attestationLabel, externalLink, externalName, isArtifactProvider, isCodeProvider, isRedirectProvider, lastProved, localSide, proofTitle, providerMethod, statusLabel, signedBy, } from '../core/index.js';
+import { attestationLabel, externalId, externalLink, externalName, isArtifactProvider, isCodeProvider, isRedirectProvider, lastProved, 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,7 +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, 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';
@@ -28,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' },
@@ -73,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
@@ -98,6 +119,8 @@ function methodAction(provider) {
         oauth: `Sign in with ${provider.name}`,
         gist: `Publish a proof on ${provider.name}`,
         backlink: `Link back from ${provider.name}`,
+        dns: 'Add a DNS record',
+        wellknown: 'Serve a file',
         signature: `Sign with ${provider.name}`,
         code: `Confirm by ${provider.name.toLowerCase()}`,
     };
@@ -118,9 +141,13 @@ function artifactField(provider) {
  * standing: it goes on the record with this one, and they did not ask for it by name.
  */
 function standingNote(flow, site) {
-    return flow.standing?.some((a) => a.method === 'backlink')
-        ? `This account already links back to ${site}. Confirming records that too.`
-        : undefined;
+    const found = {
+        backlink: `This account already links back to ${site}.`,
+        dns: `This domain already names ${site} in a DNS record.`,
+        wellknown: `This domain already names ${site} in a file it serves.`,
+    };
+    const note = flow.standing?.map((a) => found[a.method]).find((said) => said !== undefined);
+    return note ? `${note} Confirming records that too.` : undefined;
 }
 /**
  * Said above a proof that was handed back and refused, while the flow still waits for it:
@@ -133,10 +160,19 @@ 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) {
-    return provider.method === 'backlink'
-        ? 'This link is public, as is the page you point at. Anyone reading either one can follow it here.'
-        : 'This line is public, as is whatever published it. Publish nothing else alongside it.';
+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.',
+        wellknown: 'This file is public, as is the page it names. Anyone reading either one can follow it here.',
+    };
+    return (notes[provider.method] ??
+        'This line is public, as is whatever published it. Publish nothing else alongside it.');
 }
 /**
  * Where a mailed code stands, for whichever renderer asks the holder for the next thing:
@@ -161,6 +197,21 @@ const codeNote = "We'll email this address to confirm it's yours. The address is
 function providerNames(providers) {
     return [...new Set(providers.map((p) => p.name))].join(' or ');
 }
+/**
+ * What the holder would be linking, for the sentence that asks them to: an account with a
+ * sign-in provider, a key, an address, a domain. Each is named once, however many ways it
+ * can be shown.
+ */
+function heldNames(providers) {
+    const held = (p) => ({
+        signature: `${p.name} key`,
+        code: `${p.name.toLowerCase()} address`,
+        dns: 'domain',
+        wellknown: 'domain',
+    })[providerMethod(p)] ?? `${p.name} account`;
+    const names = [...new Set(providers.map(held))];
+    return names.length > 1 ? `${names.slice(0, -1).join(', ')} or ${names.at(-1)}` : names[0];
+}
 /** Seconds are the finest thing a record measured in days can mean; milliseconds are noise. */
 const moment = (time) => new Date(time).toISOString().replace(/\.\d{3}Z$/, 'Z');
 /**
@@ -233,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();
@@ -243,8 +294,8 @@ function evidencePage(e, base, report, keyId) {
     // identifier stays: that one is the provider's word, not the site's own wording.
     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 is its name already, so there is no second identifier.
-        e.external.kind === 'mailbox' ? undefined : e.external.id, externalNotes(e.attestations, names)) +
+        // A mailbox's address or a domain is its name already, so there is no second identifier.
+        externalId(e.external), externalNotes(e.attestations, names)) +
         times(e.status === 'retired'
             ? [
                 ['Approved', e.approvedAt],
@@ -272,26 +323,39 @@ 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.
     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), d.external.kind === 'mailbox' ? undefined : d.external.id, externalNotes(d.attestations, names)) +
+        card(names.provider, externalName(d.external), externalLink(d.external), externalId(d.external), externalNotes(d.attestations, names)) +
         times(retired
             ? [
                 ['Signed', d.issuedAt],
@@ -304,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) {
@@ -482,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 });
@@ -581,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'
@@ -592,7 +659,7 @@ export function createVerily(options) {
             ${user
                         ? card(subject(user).heading, subject(user).value, user.profileUrl)
                         : '<p>Authenticate with the matching external account to review and remove this link.</p>'}
-            <p>Confirm the connection between this ${escape(subjectNoun(user?.kind) ?? 'site')} and your ${escape(providerNames(offered))} account.</p>
+            <p>Confirm the connection between this ${escape(subjectNoun(user?.kind) ?? 'site')} and your ${escape(heldNames(offered))}.</p>
             ${kind === 'renew' && offered.length > 1 ? '<p class="fine">Renewing another way adds that method beneath the one this connection was first shown by.</p>' : ''}
             ${forms}`));
                 }
@@ -603,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);
@@ -628,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));
@@ -646,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.
@@ -685,7 +744,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), flow.external.kind === 'mailbox' ? undefined : flow.external.id)}
+            ${card(provider.name, externalName(flow.external), externalLink(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>
@@ -729,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;
                 }
@@ -742,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));
                 }
@@ -752,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"`);
@@ -760,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)));
@@ -774,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.
@@ -806,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/link.js

@@ -4,7 +4,7 @@ import { MIMEType } from 'node:util';
 import { html, parse } from 'parse5';
 import { Refused, } from '../core/index.js';
 import { discard, readBounded } from './body.js';
-import { pinnable, publicFetch } from './public-fetch.js';
+import { transport } from './public-fetch.js';
 /**
  * Domain suffixes that must never be fetched. The holder names the address, so it names
  * the host, and these are the names that can resolve to something inside the network
@@ -134,21 +134,6 @@ async function backlinked(response, page, subject, maxBytes) {
     // Not finding it in part of a page is not the same as it not being there.
     throw new Refused(truncated ? 'Page is too large to read' : 'Page has no rel="me" link to this subject');
 }
-/**
- * How pages are fetched. A deployment that named its hosts has vouched for where they
- * resolve, so the platform's own fetch will do. One that reads any host has vouched for
- * nothing, and the holder picks the name: every address it resolves to is checked, on the
- * connection that uses it, which only Node lets this do.
- */
-function transport(options) {
-    if (options.fetch)
-        return options.fetch;
-    if (options.hosts)
-        return (url, init) => fetch(url, init);
-    if (!pinnable())
-        throw new Error('Reading any host needs Node, which lets it check where a name resolves; name the hosts to read instead');
-    return publicFetch();
-}
 /**
  * The address the holder handed back, once it is one this may fetch. They choose it, so
  * an unguarded fetch here is an open proxy: HTTPS only, a public-looking name rather than

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/public-fetch.d.ts

@@ -19,5 +19,15 @@ export type Fetch = (url: string, init: RequestInit) => Promise<Response>;
  * `allowed` decides which addresses may be connected to, and is only for tests.
  */
 export declare function publicFetch(resolve?: Resolve, allowed?: (address: string) => boolean): Fetch;
+/**
+ * How an address the holder named is fetched. A deployment that named its hosts has
+ * vouched for where they resolve, so the platform's own fetch will do. One that reads any
+ * host has vouched for nothing, and the holder picks the name: every address it resolves
+ * to is checked, on the connection that uses it, which only Node lets this do.
+ */
+export declare function transport(options: {
+    fetch?: typeof fetch;
+    hosts?: string[];
+}): Fetch;
 /** Whether this runtime is Node, the only one that lets `publicFetch()` pin its lookup. */
 export declare function pinnable(): boolean;

package/dist/server/public-fetch.js

@@ -37,6 +37,21 @@ export function publicFetch(resolve = system, allowed) {
         }
     };
 }
+/**
+ * How an address the holder named is fetched. A deployment that named its hosts has
+ * vouched for where they resolve, so the platform's own fetch will do. One that reads any
+ * host has vouched for nothing, and the holder picks the name: every address it resolves
+ * to is checked, on the connection that uses it, which only Node lets this do.
+ */
+export function transport(options) {
+    if (options.fetch)
+        return options.fetch;
+    if (options.hosts)
+        return (url, init) => fetch(url, init);
+    if (!pinnable())
+        throw new Error('Reading any host needs Node, which lets it check where a name resolves; name the hosts to read instead');
+    return publicFetch();
+}
 /** A lookup that answers only with addresses that are all permitted, or not at all. */
 function pinned(resolve, permitted) {
     return (hostname, options, callback) => {

package/dist/server/service.d.ts

@@ -1,4 +1,5 @@
 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;
 export declare class Unavailable extends Error {
@@ -45,6 +46,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 +70,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 +323,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;
@@ -295,6 +346,12 @@ export declare class VerilyService {
      * never included: they must not appear in any directory listing.
      */
     published(): 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 +429,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