@bkazemi/verily 0.3.0 → 0.4.0

package/README.md

@@ -145,7 +145,7 @@ import { init } from '@bkazemi/verily'; // also registers <verily-badge>
 const client = init({ backendUrl: '/api/verily' });
 ```
 
-Without one, serve `node_modules/@bkazemi/verily/dist/verily.js` yourself, or load it from a CDN such as `https://cdn.jsdelivr.net/npm/@bkazemi/verily@0.3.0/dist/verily.js`. The script defines a global `Verily`.
+Without one, serve `node_modules/@bkazemi/verily/dist/verily.js` yourself, or load it from a CDN such as `https://cdn.jsdelivr.net/npm/@bkazemi/verily@0.4.0/dist/verily.js`. The script defines a global `Verily`.
 
 Then place the badge wherever the account appears:
 
@@ -208,6 +208,8 @@ import {
   githubGistProvider,
   linkProvider,
   githubLinkProvider,
+  dnsProvider,
+  wellKnownProvider,
   pgpProvider,
 } from '@bkazemi/verily';
 ```
@@ -220,10 +222,12 @@ import {
 | `githubGistProvider()` | publishing a public gist containing a line Verily gives them.                                                | None.                                   |
 | `linkProvider()`       | adding a `rel="me"` link to their profile on a page they control.                                            | The local account needs a `profileUrl`. |
 | `githubLinkProvider()` | putting their profile URL in the website field of their GitHub profile, then entering their GitHub username. | The local account needs a `profileUrl`. |
+| `dnsProvider()`        | adding a TXT record to their domain's DNS, then entering the domain.                                         | The local account needs a `profileUrl`. |
+| `wellKnownProvider()`  | serving a text file at a fixed path on their domain, then entering the domain.                               | The local account needs a `profileUrl`. |
 | `pgpProvider()`        | signing a line Verily gives them with their OpenPGP key, then pasting it and the key.                        | None.                                   |
 | `emailProvider()`      | pressing a button, or entering a code, that Verily mails to their address.                                   | A function that sends one message.      |
 
-All methods except the sign-ins and the mailed code let the user publish the proof in their own time and come back. A proof that does not check out can be put right and handed back on the same step, up to five times, so a mistyped address never means publishing or signing again. Gists and link-backs can be taken down later, so Verily re-reads them on a schedule. A PGP signature is kept by Verily and published at `<baseUrl>/connections/<id>/proof`.
+All methods except the sign-ins and the mailed code let the user publish the proof in their own time and come back. A proof that does not check out can be put right and handed back on the same step, up to five times, so a mistyped address never means publishing or signing again. Gists, link-backs, DNS records and files can be taken down later, so Verily re-reads them on a schedule. A PGP signature is kept by Verily and published at `<baseUrl>/connections/<id>/proof`.
 
 **Several at once.** List more than one, and `/verify` offers each method as its own button:
 
@@ -239,6 +243,8 @@ Proving the same account a second way adds that proof to the existing record ins
 
 **Link-backs.** Many people already have one, since GitHub and Mastodon mark profile links `rel="me"`. By default the page may be on any public host, and the account is named by the page's address. This mode needs Node, because Verily checks every connection it makes to stop the page's address from pointing inside your network. Pass `hosts` to read only certain hosts (required on Cloudflare Workers), and `profile` to name the account by handle, as `githubLinkProvider()` does for github.com. If you pass your own `fetch`, it replaces that network check, so it must enforce the same rule itself. Only real `<a>` and `<link>` elements in HTML pages, or a `Link:` header, count; [`src/server/link.ts`](src/server/link.ts) has the exact rules.
 
+**Domains.** `dnsProvider()` proves a domain that serves no page of its own, or only forwards elsewhere. The user adds a TXT record named `_verily` whose value is their `profileUrl`, and enters the domain. Verily looks up `_verily.<domain>` through `https://dns.google/resolve`, a fixed resolver, so it runs on Cloudflare Workers, and the evidence links to that lookup for a reader to repeat. `wellKnownProvider()` reads `https://<domain>/.well-known/verily.txt` instead and looks for the `profileUrl` on a line of its own. It fetches a host the user names, so it follows the link-back's rules: Node, or `hosts`. Both name the account by the exact domain entered, and say nothing about its subdomains. List both and a domain proved one way picks up the other if it is already there.
+
 **Your own method.** A provider is an object, and [`src/core/index.ts`](src/core/index.ts) documents each shape. An artifact provider may also set `field` and `input` to name what it asks for, `resolve` to turn something short such as a username into the address to read, and `known` to say where to look for an account already on record, which is what lets a proof be found without asking. A sign-in provider's `authorizationUrl` is passed `account` on a renewal or visibility change, so it can ask for that account by name.
 
 If you start flows by calling `service.start()` yourself, pass `true` as its last argument only where you have shown the request came from the user's own page, as a same-origin POST does. Without it the flow reads nothing at its start and always ends on an approval.
@@ -293,7 +299,7 @@ A static site only needs the script and the badge markup; the backend runs somew
 4. Add the script and the badge to your site:
 
 ```html
-<script src="https://cdn.jsdelivr.net/npm/@bkazemi/verily@0.3.0/dist/verily.js" defer></script>
+<script src="https://cdn.jsdelivr.net/npm/@bkazemi/verily@0.4.0/dist/verily.js" defer></script>
 <verily-badge
   backend-url="https://your-backend.example/api/verily"
   connection-id="CONNECTION_ID"

package/dist/browser/connect-dialog.js

@@ -1,4 +1,4 @@
-import { externalLink, externalName } from '../core/index.js';
+import { externalId, externalLink, externalName } from '../core/index.js';
 import { accountCard, linkMark, node, outward, stampLink, styles } from './evidence-dialog.js';
 import { providerMark } from './provider-mark.js';
 import { version } from '../version.js';
@@ -433,7 +433,7 @@ renew) {
         const logo = providerMark(flow.provider.id, flow.provider.method);
         const external = accountCard(logo
             ? [logo, document.createTextNode(flow.provider.name)]
-            : [document.createTextNode(flow.provider.name)], externalName(flow.external), flow.external.kind === 'mailbox' ? undefined : flow.external.id, externalLink(flow.external));
+            : [document.createTextNode(flow.provider.name)], externalName(flow.external), externalId(flow.external), externalLink(flow.external));
         const parts = [subjectCard(flow.local), linkMark(), external];
         const choice = node('fieldset');
         const visibilityText = {

package/dist/browser/evidence-dialog.js

@@ -1,4 +1,4 @@
-import { attestationLabel, externalLink, externalName, lastProved, localSide, proofTitle, statusLabel, } from '../core/index.js';
+import { attestationLabel, externalId, externalLink, externalName, lastProved, localSide, proofTitle, statusLabel, } from '../core/index.js';
 import { markStyles, verificationMark } from './mark.js';
 import { providerMark } from './provider-mark.js';
 import { onSignatureResult, signature, standing } from './signed.js';
@@ -384,8 +384,8 @@ function externalCard(evidence, manage, later = () => { }) {
     // The mark and the name, or just the name. A mark that falls back to writing the name
     // would print it twice here, since this heading writes it either way.
     logo ? [logo, document.createTextNode(provider)] : [document.createTextNode(provider)], externalName(evidence.external), 
-    // A mailbox's address is its name already, so there is no second identifier.
-    evidence.external.kind === 'mailbox' ? undefined : evidence.external.id, externalLink(evidence.external), 
+    // A mailbox's address or a domain is its name already, so there is no second identifier.
+    externalId(evidence.external), externalLink(evidence.external), 
     // Status first, then how it was shown, then when. The proof explains the state
     // above it, so it cannot sit before that state has been given.
     summary, ...attestationNote(main, names), ...evidence.attestations.external.slice(1).flatMap((a) => attestationNote(a, names, true)), 

package/dist/browser/index.js

@@ -669,7 +669,7 @@ function validEvidence(value) {
         validAttestations(value.attestations) &&
         (value.local.kind === undefined || typeof value.local.kind === 'string') &&
         (value.external.kind === undefined ||
-            ['account', 'key', 'page', 'mailbox'].includes(String(value.external.kind))) &&
+            ['account', 'key', 'page', 'mailbox', 'domain'].includes(String(value.external.kind))) &&
         (value.revokedAt === undefined ||
             (typeof value.revokedAt === 'number' && Number.isFinite(value.revokedAt))) &&
         ['verified', 'unconfirmed', 'expired', 'retired', 'revoked'].includes(String(value.status)) &&

package/dist/browser/provider-mark.js

@@ -53,7 +53,7 @@ function key() {
         'M9.4 6.6l1.6 1.6',
     ]);
 }
-/** A globe, drawn here like the key, for a link back from a page on the open web. */
+/** A globe, drawn here like the key, for a page or a domain on the open web. */
 function globe() {
     return lines([
         'M8 1.5a6.5 6.5 0 1 0 0 13 6.5 6.5 0 0 0 0-13Z',
@@ -94,6 +94,8 @@ export function providerMark(provider, method) {
         openpgp: key,
         email: envelope,
     };
-    // A site names its own link-back providers, so those fall back on the method's mark.
-    return marks[provider]?.() ?? (method === 'backlink' ? globe() : undefined);
+    // A site names its own link-back providers, so those fall back on the method's mark,
+    // which a domain shown by its DNS or by a file shares.
+    return (marks[provider]?.() ??
+        (['backlink', 'dns', 'wellknown'].includes(method ?? '') ? globe() : undefined));
 }

package/dist/core/index.d.ts

@@ -37,9 +37,11 @@ export interface ExternalAccount {
      * A page is an address that was read and nothing more: a method that only fetches a
      * document learns what it says, never whose account the address is. A mailbox is an
      * account in all but how it is written: its domain issued it and can hand it to somebody
-     * else, but its address is already its whole name and it has no profile to link to.
+     * else, but its address is already its whole name and it has no profile to link to. A
+     * domain is likewise issued and can be handed over, and is named by itself: what was
+     * shown is control of the name, whatever is or is not served at it.
      */
-    kind?: 'account' | 'key' | 'page' | 'mailbox';
+    kind?: 'account' | 'key' | 'page' | 'mailbox' | 'domain';
     handle: string;
     /** Where a reader goes to see the subject. For a mailbox, its `mailto:` address. */
     profileUrl: string;
@@ -54,7 +56,7 @@ export interface ExternalAccount {
  * source could improve on it. A sign-in and a mailed code happen once, between the holder
  * and this backend. The rest publish an artifact a reader can fetch.
  */
-export type Method = 'declared' | 'oauth' | 'gist' | 'backlink' | 'signature' | 'code';
+export type Method = 'declared' | 'oauth' | 'gist' | 'backlink' | 'dns' | 'wellknown' | 'signature' | 'code';
 /** Who vouches for one side: this backend from its own records, or the account's provider. */
 export type Attester = 'backend' | 'provider';
 /**
@@ -514,6 +516,11 @@ export declare function attestationLabel(method: string, names: {
     site: string;
     provider: string;
 }): string | undefined;
+/**
+ * A subject's second identifier, shown beneath its name, or nothing where the name is
+ * already all of it: a mailbox's address and a domain are each their own id.
+ */
+export declare function externalId(external: ExternalAccount): string | undefined;
 /**
  * Where a subject's name may link, or nothing where it has no page of its own. A mailbox's
  * address is `mailto:`, which opens a message to it and shows a reader nothing.

package/dist/core/index.js

@@ -121,10 +121,19 @@ export function attestationLabel(method, names) {
         oauth: `Signed in with ${names.provider}`,
         gist: `Published a proof on ${names.provider}`,
         backlink: `Linked back to ${names.site}`,
+        dns: `Named ${names.site} in a DNS record`,
+        wellknown: `Named ${names.site} in a file it serves`,
         signature: 'Proved with a signature',
         code: 'Entered a code sent to this address',
     }[method];
 }
+/**
+ * A subject's second identifier, shown beneath its name, or nothing where the name is
+ * already all of it: a mailbox's address and a domain are each their own id.
+ */
+export function externalId(external) {
+    return external.kind === 'mailbox' || external.kind === 'domain' ? undefined : external.id;
+}
 /**
  * Where a subject's name may link, or nothing where it has no page of its own. A mailbox's
  * address is `mailto:`, which opens a message to it and shows a reader nothing.

package/dist/server/domain.d.ts

@@ -0,0 +1,51 @@
+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. */
+    fetch?: typeof fetch;
+    timeoutMs?: number;
+}
+export interface WellKnownProviderOptions extends DomainProviderOptions {
+    /**
+     * Domains this instance will read, lowercase. Omitted means any public host, which is
+     * the point of the method and needs Node: see `linkProvider()`.
+     */
+    hosts?: string[];
+    /**
+     * Replaces the transport, and with it the check that keeps an instance reading any host
+     * out of the network it runs in. Pass one only where it enforces that itself, such as
+     * through an egress proxy, or where `hosts` already confines it.
+     */
+    fetch?: typeof fetch;
+    /** How much of the file is read before giving up on finding the line. */
+    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
+ * 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.
+ *
+ * What it establishes is that whoever wrote the record could write that domain's DNS. That
+ * is the domain's holder or somebody they delegated to, and it is the exact name proved:
+ * 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
+ * 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
+ * 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.
+ *
+ * The domain names the host that is fetched, so the read is the web key directory's: HTTPS
+ * on the default port, a public address, no redirect followed, a deadline and a bounded
+ * read. Only `text/plain` is read, because a line in anything else may be an example of a
+ * line and not one.
+ */
+export declare function wellKnownProvider(options?: WellKnownProviderOptions): ArtifactProvider;

package/dist/server/domain.js

@@ -0,0 +1,285 @@
+import { MIMEType } from 'node:util';
+import { Refused, } from '../core/index.js';
+import { discard, readBounded } from './body.js';
+import { transport } from './public-fetch.js';
+/**
+ * Domain suffixes that must never be fetched. The holder names the domain, so it names the
+ * host, and these are the names that can resolve to something inside the network running
+ * this. Reserved suffixes that resolve nowhere are left alone: asking about them is
+ * pointless rather than dangerous, and they are what tests use.
+ */
+const reserved = ['local', 'internal', 'localhost', 'home', 'lan', 'corp', 'intranet'];
+const name = /^[a-z0-9]([a-z0-9-]*[a-z0-9])?(\.[a-z0-9]([a-z0-9-]*[a-z0-9])?)+$/;
+/**
+ * The one resolver every lookup goes to. Fixed, because the holder chooses the name and
+ * nothing else: a resolver they could choose would answer whatever they liked. It is asked
+ * over HTTPS because a Worker has no resolver of its own, and at an address that answers a
+ * plain GET with JSON, so the lookup that was run is also a link a reader can open.
+ */
+const resolver = 'https://dns.google/resolve';
+/** The label the record is published under, so it sits apart from the domain's own records. */
+const label = '_verily';
+/** Where on a domain the file is served. */
+const path = '/.well-known/verily.txt';
+/** The TXT record type, as the resolver numbers it. */
+const txt = 16;
+/**
+ * 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
+ * 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.
+ *
+ * What it establishes is that whoever wrote the record could write that domain's DNS. That
+ * is the domain's holder or somebody they delegated to, and it is the exact name proved:
+ * 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
+ * unread, never absent.
+ */
+export function dnsProvider(options = {}) {
+    const request = options.fetch ?? fetch;
+    return {
+        ...shared(options),
+        method: 'dns',
+        instructions: (expect) => [
+            'Add a TXT record to your domain’s DNS with this name and value, then enter the domain below.',
+            { code: label },
+            { code: expect },
+            'A new record can take a few minutes to be seen.',
+        ],
+        resolve(artifact) {
+            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);
+        },
+    };
+}
+/**
+ * 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
+ * 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.
+ *
+ * The domain names the host that is fetched, so the read is the web key directory's: HTTPS
+ * on the default port, a public address, no redirect followed, a deadline and a bounded
+ * read. Only `text/plain` is read, because a line in anything else may be an example of a
+ * line and not one.
+ */
+export function wellKnownProvider(options = {}) {
+    const request = transport(options);
+    const hosts = options.hosts?.map((host) => host.toLowerCase());
+    const maxBytes = options.maxBytes ?? 64 * 1024;
+    return {
+        ...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.',
+            { code: path },
+            { code: expect },
+        ],
+        resolve(artifact) {
+            const domain = named(artifact);
+            return domain ? `https://${domain}${path}` : artifact;
+        },
+        async verify({ artifact, expect }) {
+            const domain = served(artifact);
+            if (hosts && !hosts.includes(domain))
+                throw new Refused('Not a host this instance reads');
+            const response = await request(`https://${domain}${path}`, {
+                // Workers refuse 'error', so a redirect comes back as a response and is refused below.
+                redirect: 'manual',
+                headers: { Accept: 'text/plain', 'User-Agent': 'Verily-V0' },
+                signal: AbortSignal.timeout(options.timeoutMs ?? 15000),
+            }).catch(() => {
+                throw new Refused('File could not be reached');
+            });
+            try {
+                // The holder named this domain, so a redirect would take the check somewhere else.
+                if (response.type === 'opaqueredirect' || (response.status >= 300 && response.status < 400))
+                    throw new Refused('File redirects, and a redirect is not followed');
+                if (!response.ok)
+                    throw new Refused('File unavailable');
+                if (mediaType(response.headers.get('content-type')) !== 'text/plain')
+                    throw new Refused('File is not plain text');
+                const { bytes, truncated } = await readBounded(response, maxBytes);
+                const lines = new TextDecoder().decode(bytes).split(/\r?\n/);
+                // The last line of a file cut short may be the start of some longer address.
+                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');
+            }
+            finally {
+                await discard(response);
+            }
+            return account(domain);
+        },
+    };
+}
+/** What both methods say of themselves: they name the same thing, and differ in how. */
+function shared(options) {
+    return {
+        id: 'domain',
+        name: options.name ?? 'Domain',
+        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;
+        },
+        // 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),
+    };
+}
+/**
+ * A domain, named by itself. The id is the name as DNS compares it: lowercase, and in
+ * punycode where it was typed in another script.
+ */
+function account(domain) {
+    return { id: domain, kind: 'domain', handle: domain, profileUrl: `https://${domain}/` };
+}
+/**
+ * The domain a holder typed, or nothing where it is not one. Taken bare or as the address
+ * of its front page, since both are how a domain is written, and never with a path: a path
+ * is somebody's page, and this proves no page.
+ */
+function named(typed) {
+    const trimmed = typed.trim();
+    if (trimmed.length > 300)
+        return undefined;
+    const url = URL.parse(/^https?:\/\//i.test(trimmed) ? trimmed : `https://${trimmed}`);
+    if (!url || url.username || url.password || url.port || url.search || url.hash)
+        return undefined;
+    if (url.pathname !== '/')
+        return undefined;
+    const domain = url.hostname.toLowerCase().replace(/\.$/, '');
+    return valid(domain) ? domain : undefined;
+}
+/** A dotted public-looking name, as DNS limits one, and not an address literal. */
+function valid(domain) {
+    return (domain.length <= 253 - label.length - 1 &&
+        name.test(domain) &&
+        domain.split('.').every((part) => part.length <= 63) &&
+        !/^[\d.]+$/.test(domain) &&
+        !reserved.includes(domain.split('.').pop()));
+}
+/** The lookup for a domain's record: the address that is fetched, and kept as the proof's. */
+function lookup(domain) {
+    return `${resolver}?name=${label}.${domain}&type=TXT`;
+}
+/**
+ * The domain a lookup address asks about, once it is exactly a lookup this would make. The
+ * address comes back from the holder or from a record, and anything else is somewhere this
+ * has no business fetching.
+ */
+function looked(artifact) {
+    const url = artifact.length <= 600 ? URL.parse(artifact) : null;
+    const asked = url?.searchParams.get('name') ?? '';
+    const domain = asked.startsWith(`${label}.`) ? asked.slice(label.length + 1) : '';
+    if (!url || !valid(domain) || url.href !== lookup(domain))
+        throw new Refused('Not a domain this can look up');
+    return domain;
+}
+/** The domain a file address is on, once it is exactly where this would read one. */
+function served(artifact) {
+    const url = artifact.length <= 600 ? URL.parse(artifact) : null;
+    const domain = url?.hostname.toLowerCase() ?? '';
+    if (!url || !valid(domain) || url.href !== `https://${domain}${path}`)
+        throw new Refused('Not a domain this can read');
+    return domain;
+}
+/**
+ * A TXT record's text. A record is one or more strings joined end to end, and a resolver
+ * writes them either already joined or each in quotes with a backslash before anything
+ * awkward. One this cannot read is no text at all, since a guess could read as a match.
+ */
+function text(data) {
+    if (!data.startsWith('"'))
+        return data.trim();
+    let out = '';
+    let at = 0;
+    while (at < data.length) {
+        if (data[at] === ' ') {
+            at++;
+            continue;
+        }
+        if (data[at] !== '"')
+            return undefined;
+        at++;
+        while (at < data.length && data[at] !== '"') {
+            if (data[at] === '\\') {
+                const code = /^\d{3}/.exec(data.slice(at + 1))?.[0];
+                out += code ? String.fromCharCode(Number(code)) : (data[at + 1] ?? '');
+                at += code ? 4 : 2;
+            }
+            else
+                out += data[at++];
+        }
+        if (data[at] !== '"')
+            return undefined;
+        at++;
+    }
+    return out.trim();
+}
+function parsed(body) {
+    try {
+        return JSON.parse(body);
+    }
+    catch {
+        return undefined;
+    }
+}
+/** A `Content-Type`'s essence, or nothing where it is missing or malformed. */
+function mediaType(header) {
+    if (header === null)
+        return undefined;
+    try {
+        return new MIMEType(header).essence;
+    }
+    catch {
+        return undefined;
+    }
+}
+function isRecord(value) {
+    return value !== null && typeof value === 'object';
+}

package/dist/server/index.d.ts

@@ -7,6 +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 { 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

@@ -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,6 +10,7 @@ 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 { pgpProvider } from './pgp.js';
 export { generateSigningKey, signer } from './signing.js';
 export { emailProvider, } from './email.js';
@@ -98,6 +99,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 +121,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:
@@ -134,9 +141,13 @@ function refusedNote(flow) {
 }
 /** 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.';
+    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 +172,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');
 /**
@@ -243,8 +269,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],
@@ -291,7 +317,7 @@ function checkedPage(d, keyId, base) {
     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],
@@ -592,7 +618,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}`));
                 }
@@ -685,7 +711,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>

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/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/verily.js

@@ -9575,6 +9575,7 @@ var Verily = (() => {
   __export(browser_exports, {
     Refused: () => Refused,
     attestationLabel: () => attestationLabel,
+    externalId: () => externalId,
     externalLink: () => externalLink,
     externalName: () => externalName,
     fresh: () => fresh,
@@ -9715,10 +9716,15 @@ var Verily = (() => {
       oauth: `Signed in with ${names.provider}`,
       gist: `Published a proof on ${names.provider}`,
       backlink: `Linked back to ${names.site}`,
+      dns: `Named ${names.site} in a DNS record`,
+      wellknown: `Named ${names.site} in a file it serves`,
       signature: "Proved with a signature",
       code: "Entered a code sent to this address"
     }[method];
   }
+  function externalId(external) {
+    return external.kind === "mailbox" || external.kind === "domain" ? void 0 : external.id;
+  }
   function externalLink(external) {
     return external.kind === "mailbox" ? void 0 : external.profileUrl;
   }
@@ -9882,7 +9888,7 @@ var Verily = (() => {
       openpgp: key,
       email: envelope
     };
-    return marks2[provider]?.() ?? (method === "backlink" ? globe() : void 0);
+    return marks2[provider]?.() ?? (["backlink", "dns", "wellknown"].includes(method ?? "") ? globe() : void 0);
   }
 
   // src/browser/badge.ts
@@ -10428,7 +10434,7 @@ ${claims(evidence)}`;
   }
 
   // src/version.ts
-  var version = "v0.3.0";
+  var version = "v0.4.0";
 
   // src/browser/evidence-dialog.ts
   function stampLink() {
@@ -10737,8 +10743,8 @@ ${claims(evidence)}`;
       // would print it twice here, since this heading writes it either way.
       logo2 ? [logo2, document.createTextNode(provider)] : [document.createTextNode(provider)],
       externalName(evidence.external),
-      // A mailbox's address is its name already, so there is no second identifier.
-      evidence.external.kind === "mailbox" ? void 0 : evidence.external.id,
+      // A mailbox's address or a domain is its name already, so there is no second identifier.
+      externalId(evidence.external),
       externalLink(evidence.external),
       // Status first, then how it was shown, then when. The proof explains the state
       // above it, so it cannot sit before that state has been given.
@@ -11353,7 +11359,7 @@ ${claims(evidence)}`;
       const external = accountCard(
         logo2 ? [logo2, document.createTextNode(flow.provider.name)] : [document.createTextNode(flow.provider.name)],
         externalName(flow.external),
-        flow.external.kind === "mailbox" ? void 0 : flow.external.id,
+        externalId(flow.external),
         externalLink(flow.external)
       );
       const parts = [subjectCard(flow.local), linkMark(), external];
@@ -11914,7 +11920,7 @@ ${claims(evidence)}`;
       (k2) => typeof value.external[k2] === "string"
     ) && (value.local.profileUrl === void 0 || typeof value.local.profileUrl === "string") && // A signed record lives beside the record it was made from and nowhere else, since the
     // keys it is checked against are read from where the record lives.
-    (value.signedUrl === void 0 || value.signedUrl === `${value.evidenceUrl}?format=signed`) && validAttestations(value.attestations) && (value.local.kind === void 0 || typeof value.local.kind === "string") && (value.external.kind === void 0 || ["account", "key", "page", "mailbox"].includes(String(value.external.kind))) && (value.revokedAt === void 0 || typeof value.revokedAt === "number" && Number.isFinite(value.revokedAt)) && ["verified", "unconfirmed", "expired", "retired", "revoked"].includes(String(value.status)) && // A retired record stands on its dates, so one that does not say when is not one.
+    (value.signedUrl === void 0 || value.signedUrl === `${value.evidenceUrl}?format=signed`) && validAttestations(value.attestations) && (value.local.kind === void 0 || typeof value.local.kind === "string") && (value.external.kind === void 0 || ["account", "key", "page", "mailbox", "domain"].includes(String(value.external.kind))) && (value.revokedAt === void 0 || typeof value.revokedAt === "number" && Number.isFinite(value.revokedAt)) && ["verified", "unconfirmed", "expired", "retired", "revoked"].includes(String(value.status)) && // A retired record stands on its dates, so one that does not say when is not one.
     (value.status === "retired" ? typeof value.retiredAt === "number" && Number.isFinite(value.retiredAt) : value.retiredAt === void 0) && (value.mark === void 0 || ["preferred", "unused"].includes(String(value.mark))) && ["public", "unlisted"].includes(String(value.visibility)) && (value.connectedAt === void 0 || typeof value.connectedAt === "number" && Number.isFinite(value.connectedAt)) && ["authenticatedAt", "approvedAt", "expiresAt"].every(
       (k2) => typeof value[k2] === "number" && Number.isFinite(value[k2])
     );

package/dist/version.d.ts

@@ -7,4 +7,4 @@
  * output stays what tsc emitted and nothing has to be substituted into it. A version bump
  * changes this line with package.json.
  */
-export declare const version = "v0.3.0";
+export declare const version = "v0.4.0";

package/dist/version.js

@@ -7,4 +7,4 @@
  * output stays what tsc emitted and nothing has to be substituted into it. A version bump
  * changes this line with package.json.
  */
-export const version = 'v0.3.0';
+export const version = 'v0.4.0';

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@bkazemi/verily",
-  "version": "0.3.0",
+  "version": "0.4.0",
   "description": "Self-hosted account-to-account verification for Node.js",
   "type": "module",
   "license": "MIT",