@bkazemi/verily 0.7.0 → 0.8.0

package/dist/instance/sites.js

@@ -0,0 +1,413 @@
+import { createHmac, timingSafeEqual } from 'node:crypto';
+import { expired, } from '../core/index.js';
+import { hash, secret } from '../server/service.js';
+/** How long a handoff may take, from `/handoff/request` to `/handoff/accept`, and how far ahead a token may run. */
+export const handoffMs = 5 * 60000;
+/** How long a site session lasts once the handoff lands. */
+export const sessionMs = 3600000;
+/** How long a result stays acceptable. A flow expires sooner, so every retry of one is covered. */
+const resultMs = 10 * 60000;
+/** How many subjects one read may name. */
+const maxReadIds = 50;
+const stateCookie = 'verily_handoff';
+export const sessionCookie = 'verily_site';
+/** A loopback origin may be plain HTTP, as the library allows its own base URL to be. */
+function secureOrigin(value) {
+    const url = new URL(value);
+    return (url.origin === value &&
+        (url.protocol === 'https:' ||
+            (url.protocol === 'http:' && ['localhost', '127.0.0.1'].includes(url.hostname))));
+}
+/**
+ * The registered sites, from the `SITES` variable, each with its key from the secret
+ * `SITE_<ID>_KEY`. Anything wrong in the list refuses to start rather than serving a site
+ * half set up. A site whose key is missing or malformed is left out instead.
+ */
+export function registry(config, secrets) {
+    const list = typeof config === 'string' ? JSON.parse(config) : (config ?? []);
+    if (!Array.isArray(list))
+        throw new Error('SITES must be a list');
+    const sites = new Map();
+    for (const entry of list) {
+        const { id, name, origin, authorizeUrl, returnUrl, providers, visibility } = entry ?? {};
+        if (typeof id !== 'string' || !/^[a-z0-9-]{1,32}$/.test(id) || sites.has(id))
+            throw new Error('Each site needs a unique id of lowercase letters, digits and hyphens');
+        const key = secrets[`SITE_${id.toUpperCase().replace(/-/g, '_')}_KEY`];
+        if (typeof name !== 'string' || !name || name.length > 100)
+            throw new Error(`Site ${id} needs a name`);
+        if (typeof origin !== 'string' || !secureOrigin(origin))
+            throw new Error(`Site ${id} needs an HTTPS origin without a trailing slash`);
+        for (const url of [authorizeUrl, returnUrl])
+            if (typeof url !== 'string' || new URL(url).origin !== origin)
+                throw new Error(`Site ${id} must authorize and return on its own origin`);
+        if (providers !== undefined &&
+            (!Array.isArray(providers) ||
+                !providers.length ||
+                providers.some((p) => typeof p !== 'string' || !p)))
+            throw new Error(`Site ${id} must list at least one provider id, or none at all`);
+        if (visibility !== undefined &&
+            (!Array.isArray(visibility) ||
+                !visibility.length ||
+                visibility.some((v) => v !== 'public' && v !== 'unlisted')))
+            throw new Error(`Site ${id} must list "public", "unlisted" or both, or no visibility at all`);
+        // A secret is set apart from a deployment and cannot be checked before one. A wrong
+        // one leaves its own site unserved, and never takes the rest of the instance with it.
+        if (typeof key !== 'string' || !/^[A-Za-z0-9_-]{43,}$/.test(key)) {
+            console.error(`Site ${id} is not served: it needs a base64url key of at least 32 bytes`);
+            continue;
+        }
+        sites.set(id, {
+            id,
+            name,
+            origin,
+            authorizeUrl: authorizeUrl,
+            returnUrl: returnUrl,
+            key,
+            ...(providers ? { providers: providers } : {}),
+            ...(visibility ? { visibility: visibility } : {}),
+        });
+    }
+    return sites;
+}
+const mac = (key, payload) => createHmac('sha256', key).update(payload).digest();
+/** `base64url(payload) + "." + base64url(HMAC-SHA256(key, payload))`, the payload being JSON. */
+export function sign(key, payload) {
+    const bytes = Buffer.from(JSON.stringify(payload));
+    return `${bytes.toString('base64url')}.${mac(key, bytes).toString('base64url')}`;
+}
+/** The payload of a token, without checking it. Only good for choosing which key checks it. */
+export function peek(token) {
+    try {
+        const value = JSON.parse(Buffer.from(token.split('.')[0], 'base64url').toString());
+        return value && typeof value === 'object' && !Array.isArray(value)
+            ? value
+            : undefined;
+    }
+    catch {
+        return undefined;
+    }
+}
+/** The payload of a token whose MAC verifies under `key`, compared in constant time. */
+export function open(key, token) {
+    const parts = token.split('.');
+    if (parts.length !== 2)
+        return undefined;
+    const payload = Buffer.from(parts[0], 'base64url');
+    const given = Buffer.from(parts[1], 'base64url');
+    const expected = mac(key, payload);
+    if (given.length !== expected.length || !timingSafeEqual(given, expected))
+        return undefined;
+    return peek(token);
+}
+const cookie = (request, name) => request.headers
+    .get('cookie')
+    ?.split(';')
+    .map((part) => part.trim())
+    .find((part) => part.startsWith(`${name}=`))
+    ?.slice(name.length + 1);
+const setCookie = (name, value, ms) => `${name}=${value}; HttpOnly; Secure; SameSite=Lax; Path=/; Max-Age=${ms / 1000}`;
+const string = (value, max = 500) => typeof value === 'string' && value.length > 0 && value.length <= max;
+/**
+ * The subject a handoff vouches for, as the library will hold it, or undefined if the
+ * handoff describes one badly. `validate` is the library's own check of the subject, which
+ * the union of every site's origin would not make alone.
+ */
+function subject(site, payload, validate) {
+    if (!string(payload.id, 400) ||
+        !string(payload.label) ||
+        !string(payload.reference) ||
+        (payload.kind !== undefined && !['account', 'page', 'site'].includes(String(payload.kind))) ||
+        (payload.profileUrl !== undefined &&
+            (typeof payload.profileUrl !== 'string' ||
+                !URL.canParse(payload.profileUrl) ||
+                new URL(payload.profileUrl).origin !== site.origin)))
+        return undefined;
+    try {
+        return validate({
+            id: `${site.id}:${payload.id}`,
+            ...(payload.kind ? { kind: payload.kind } : {}),
+            label: payload.label,
+            reference: payload.reference,
+            ...(payload.profileUrl ? { profileUrl: payload.profileUrl } : {}),
+            siteName: site.name,
+        });
+    }
+    catch {
+        return undefined;
+    }
+}
+/**
+ * Handoffs from registered sites, the sessions they open, and the results sent back. The
+ * site vouches for its signed-in user; this is where that is checked, and a handoff is
+ * bound to the browser that asked for it, the way OAuth binds a callback with `state`.
+ */
+export class Sites {
+    storage;
+    sites;
+    constructor(storage, sites) {
+        this.storage = storage;
+        this.sites = sites;
+    }
+    /**
+     * Starts a handoff: a state stored with the site and purpose, set in this browser, and
+     * sent to the site to sign into its token. Returns where to go and the cookie to set.
+     */
+    async begin(site, purpose) {
+        const registered = this.sites.get(site ?? '');
+        if (!registered || !['connect', 'manage'].includes(purpose ?? ''))
+            return undefined;
+        const state = secret();
+        await this.storage.put(`site/state/${hash(state)}`, {
+            site: registered.id,
+            purpose: purpose,
+            expiresAt: Date.now() + handoffMs,
+        });
+        const location = new URL(registered.authorizeUrl);
+        location.searchParams.set('state', state);
+        return { location: location.href, cookie: setCookie(stateCookie, state, handoffMs) };
+    }
+    /**
+     * Redeems a signed handoff for a session, or refuses it. Every refusal is the same
+     * undefined, so a caller cannot tell which check failed. `validate` is the library's own
+     * check of the subject, which the union of every site's origin would not make alone.
+     */
+    async start(request, token, validate) {
+        const site = this.sites.get(String(peek(token)?.site ?? ''));
+        if (!site)
+            return undefined;
+        const payload = open(site.key, token);
+        const now = Date.now();
+        const held = cookie(request, stateCookie);
+        if (!payload ||
+            payload.site !== site.id ||
+            typeof payload.exp !== 'number' ||
+            payload.exp * 1000 <= now ||
+            payload.exp * 1000 > now + handoffMs ||
+            !string(payload.state) ||
+            !held ||
+            // The state this browser was given, which a browser sent someone else's link lacks.
+            !timingSafeEqual(Buffer.from(hash(held)), Buffer.from(hash(payload.state))) ||
+            !string(payload.txn))
+            return undefined;
+        const local = subject(site, payload, validate);
+        if (!local)
+            return undefined;
+        const session = secret();
+        const txn = payload.txn;
+        // The state is consumed with the session made, so the token and the state each work once.
+        const purpose = await this.storage.transaction(async (tx) => {
+            const key = `site/state/${hash(payload.state)}`;
+            const state = await tx.get(key);
+            if (!state || state.site !== site.id || expired(state, now))
+                return undefined;
+            await tx.delete(key);
+            await tx.put(`site/session/${hash(session)}`, {
+                site: site.id,
+                purpose: state.purpose,
+                txn,
+                local,
+                expiresAt: now + sessionMs,
+            });
+            return state.purpose;
+        });
+        if (!purpose)
+            return undefined;
+        return {
+            purpose,
+            cookies: [setCookie(sessionCookie, session, sessionMs), setCookie(stateCookie, '', 0)],
+        };
+    }
+    /**
+     * Redeems a handoff a site's own page presents, for the connect dialog on that page, and
+     * returns the session it opens. There is no redirect to bind with a state. The site's
+     * backend gave the token to its signed-in user's page, and a browser sends that page's
+     * origin with the request, so the token is marked for this use, taken only from the
+     * site's origin, and works once. The session is the same as a redirect opens, carried by
+     * the page in a header because the cookie would be another site's on that page.
+     *
+     * `admit` counts the handoff against the site that signed it, and is asked only once it
+     * has verified, before anything is stored: the request has no cookie to say whose it is,
+     * and a token that does not verify must spend nothing of the site it names. A handoff
+     * not admitted is 'limited', and is not used up.
+     */
+    async dialog(token, origin, validate, admit) {
+        const site = this.sites.get(String(peek(token)?.site ?? ''));
+        if (!site || origin !== site.origin)
+            return undefined;
+        const payload = open(site.key, token);
+        const now = Date.now();
+        if (!payload ||
+            payload.site !== site.id ||
+            payload.op !== 'dialog' ||
+            typeof payload.exp !== 'number' ||
+            payload.exp * 1000 <= now ||
+            payload.exp * 1000 > now + handoffMs ||
+            !string(payload.txn))
+            return undefined;
+        const local = subject(site, payload, validate);
+        if (!local)
+            return undefined;
+        if (!(await admit(site)))
+            return 'limited';
+        const session = secret();
+        const txn = payload.txn;
+        // Kept until the token would have expired anyway, so the token works once.
+        const used = `site/state/${hash(`dialog ${site.id} ${txn}`)}`;
+        const opened = await this.storage.transaction(async (tx) => {
+            if (await tx.get(used))
+                return false;
+            await tx.put(used, { site: site.id, purpose: 'connect', expiresAt: now + handoffMs });
+            await tx.put(`site/session/${hash(session)}`, {
+                site: site.id,
+                purpose: 'connect',
+                txn,
+                local,
+                expiresAt: now + sessionMs,
+                dialog: true,
+            });
+            return true;
+        });
+        return opened ? { site, session } : undefined;
+    }
+    /**
+     * Checks a site backend's request to read its own subjects' connections: a token under
+     * that site's key, marked as a read so that a handoff token, which passes through a
+     * browser, is never one. The ids are the site's own, as it sends them in a handoff, and
+     * are only ever looked up under its prefix, so no site reaches another's subjects.
+     */
+    read(token) {
+        const site = this.sites.get(String(peek(token)?.site ?? ''));
+        if (!site)
+            return undefined;
+        const payload = open(site.key, token);
+        const now = Date.now();
+        if (!payload ||
+            payload.site !== site.id ||
+            payload.op !== 'read' ||
+            typeof payload.exp !== 'number' ||
+            payload.exp * 1000 <= now ||
+            payload.exp * 1000 > now + handoffMs ||
+            !Array.isArray(payload.ids) ||
+            !payload.ids.length ||
+            payload.ids.length > maxReadIds ||
+            !payload.ids.every((id) => string(id, 400)))
+            return undefined;
+        return { site, ids: [...new Set(payload.ids)] };
+    }
+    /** This browser's site session, whether or not it has returned yet. */
+    async session(request) {
+        const token = cookie(request, sessionCookie);
+        if (!token)
+            return undefined;
+        const key = `site/session/${hash(token)}`;
+        const session = await this.storage.get(key);
+        if (!session || expired(session, Date.now()) || !this.sites.has(session.site))
+            return undefined;
+        return { key, session };
+    }
+    /**
+     * A session that can still start something: not yet returned, and not partway through a
+     * disconnect. A pending disconnect holds the session's one result, so nothing else may
+     * start that could end with another; only retrying that disconnect goes on.
+     */
+    async open(request) {
+        const found = await this.session(request);
+        return found && !found.session.closed && !found.session.operation ? found : undefined;
+    }
+    /**
+     * Where a flow that ended goes, as a function of the stored result alone: the same
+     * result signs the same token, since its expiry is counted from when the flow ended.
+     * Only the registry says where a site's holders return, and the first return closes the
+     * session to anything new.
+     */
+    async finish(flow, context, local, result) {
+        const site = this.sites.get(context?.site ?? '');
+        if (!site || !context?.txn || !local)
+            return undefined;
+        if (!['connect', 'renew', 'visibility'].includes(result.kind))
+            return undefined;
+        // The sign-in window of a dialog shows the flow's own result page and goes nowhere.
+        if (context.session?.startsWith('site/session/') &&
+            (await this.storage.get(context.session))?.dialog)
+            return undefined;
+        // Another flow's return, or a disconnect, already speaks for this transaction. This
+        // flow ended all the same, however it ended, and its holder sees the result page.
+        if (!(await this.claim(context.session, flow)))
+            return undefined;
+        return this.returnUrl(site, local, context.txn, {
+            operation: result.kind,
+            outcome: result.phase,
+            connection: result.connectionId,
+            visibility: result.visibility,
+            finishedAt: result.finishedAt,
+        });
+    }
+    /**
+     * Takes the session's one return for a flow, and closes the session with it. A site
+     * accepts one result for a transaction, so only one is ever signed: the first flow to end
+     * holds the return, every load of that flow holds it again, and no flow gets it once a
+     * disconnect is recorded, pending or done. Decided in one transaction, as `pending` is,
+     * so of a flow ending and a disconnect starting exactly one goes on.
+     */
+    async claim(key, flow) {
+        if (!key?.startsWith('site/session/'))
+            return false;
+        return this.storage.transaction(async (tx) => {
+            const session = await tx.get(key);
+            if (!session || expired(session, Date.now()) || session.operation)
+                return false;
+            if (session.returned)
+                return session.returned === flow;
+            await tx.put(key, { ...session, closed: true, returned: flow });
+            return true;
+        });
+    }
+    /** The signed result a holder carries back to their site. */
+    returnUrl(site, local, txn, result) {
+        if (!local.id.startsWith(`${site.id}:`))
+            throw new Error('Subject from another site');
+        const complete = result.outcome === 'complete';
+        const token = sign(site.key, {
+            site: site.id,
+            id: local.id.slice(site.id.length + 1),
+            operation: result.operation,
+            outcome: result.outcome,
+            ...(complete ? { connection: result.connection, visibility: result.visibility } : {}),
+            txn,
+            exp: Math.floor((result.finishedAt + resultMs) / 1000),
+        });
+        const url = new URL(site.returnUrl);
+        url.searchParams.set('result', token);
+        return url.href;
+    }
+    /**
+     * Records a disconnect or a mark as pending on the session before anything is changed, so
+     * a retry knows what it is finishing. A session already carrying one only resumes that one.
+     */
+    async pending(key, connection, visibility, mark) {
+        return this.storage.transaction(async (tx) => {
+            const session = await tx.get(key);
+            if (!session || expired(session, Date.now()))
+                return undefined;
+            if (session.operation)
+                return session.operation.connection === connection && session.operation.mark === mark
+                    ? session
+                    : undefined;
+            if (session.closed)
+                return undefined;
+            session.operation = { connection, visibility, ...(mark ? { mark } : {}) };
+            await tx.put(key, session);
+            return session;
+        });
+    }
+    /** Records an operation as done once its change has committed, and closes the session. */
+    async completed(key) {
+        return this.storage.transaction(async (tx) => {
+            const session = (await tx.get(key));
+            session.operation.finishedAt ??= Date.now();
+            session.closed = true;
+            await tx.put(key, session);
+            return session;
+        });
+    }
+}

package/dist/instance/starter.d.ts

@@ -0,0 +1,6 @@
+/**
+ * The files of a project that runs an instance on Cloudflare. All of the instance is in the
+ * package, so the project is its settings and one line that names the entry, and it takes
+ * a new release by updating the dependency.
+ */
+export declare const cloudflareStarter: Record<string, string>;

package/dist/instance/starter.js

@@ -0,0 +1,99 @@
+import { version } from '../version.js';
+/** The package as a project depends on it: this release, and later ones compatible with it. */
+const release = `^${version.slice(1)}`;
+const wrangler = `// Your instance's Cloudflare settings. Fill in account_id and the vars below.
+//
+// Secrets are never set here. Use \`npx wrangler secret put NAME\` for OWNER_KEY, the
+// secret you sign in with: at least 32 random bytes, base64url, such as the output of
+//   node -e "console.log(require('crypto').randomBytes(32).toString('base64url'))"
+//
+// A link back from a GitHub profile, a DNS record and an OpenPGP signature are always
+// offered. Each sign-in is offered once both of its secrets are set:
+//   GITHUB_CLIENT_ID and GITHUB_CLIENT_SECRET
+//   DISCORD_CLIENT_ID and DISCORD_CLIENT_SECRET
+//   GOOGLE_CLIENT_ID and GOOGLE_CLIENT_SECRET (YouTube)
+// Each app needs <PUBLIC_ORIGIN>/callback as a redirect.
+// Email is offered once the RESEND_API_KEY secret and EMAIL_FROM below are set.
+{
+  "$schema": "node_modules/wrangler/config-schema.json",
+  "name": "verily",
+  "account_id": "YOUR_CLOUDFLARE_ACCOUNT_ID",
+  "main": "worker.ts",
+  "compatibility_date": "2026-07-01",
+  "compatibility_flags": ["nodejs_compat"],
+  // The library loads undici only on Node, so the Worker build gets a stand-in for it.
+  "alias": { "undici": "@bkazemi/verily/instance/undici" },
+
+  // Serve the backend from a host a reader can tie to the site making the
+  // claim. Keep workers_dev true until the custom domain answers, then set it
+  // false: the Worker rejects every origin except PUBLIC_ORIGIN, so only one
+  // of the two can serve at a time.
+  "workers_dev": true,
+  // "routes": [{ "pattern": "verily.example.org", "custom_domain": true }],
+  "preview_urls": false,
+  "observability": { "enabled": false },
+
+  // Keep the object name, binding and class identity stable across deploys:
+  // changing them abandons the stored connections.
+  "durable_objects": {
+    "bindings": [{ "name": "VERILY", "class_name": "VerilyStore" }],
+  },
+  "migrations": [{ "tag": "v1", "new_sqlite_classes": ["VerilyStore"] }],
+
+  "vars": {
+    // Drives baseUrl, every evidenceUrl and the verifier name. HTTPS, no
+    // trailing slash, and it must match the origin actually serving requests.
+    "PUBLIC_ORIGIN": "https://verily.example.org",
+    // The site whose local subject is being linked. This is a claim the
+    // evidence attributes to the site, not something the backend demonstrates.
+    "SITE_NAME": "example.org",
+    // What is linked: "account", "page" or "site". Omit for an account.
+    "OWNER_KIND": "site",
+    "OWNER_LABEL": "your-handle",
+    "OWNER_REFERENCE": "example.org author",
+    "OWNER_PROFILE_URL": "https://example.org/about/",
+    "REPORT_URL": "mailto:you@example.org",
+    // The sender of emailed codes, on a domain verified with Resend. Email is offered
+    // only when this and the RESEND_API_KEY secret are both set.
+    // "EMAIL_FROM": "Verily <verify@example.org>",
+    // Messages mailed in a day, across everyone. Omit for 100, Resend's free allowance.
+    // "EMAIL_DAILY_LIMIT": 100,
+    // Public records are signed with a key this installation makes and keeps. Set "off"
+    // to sign nothing, or set the SIGNING_KEY secret to supply the key yourself.
+    // "SIGNING": "off",
+    // Sites that send their users here instead of hosting Verily; each also needs
+    // its key as the secret SITE_<ID>_KEY.
+    // "SITES": [
+    //   {
+    //     "id": "partner",
+    //     "name": "partner.example",
+    //     "origin": "https://partner.example",
+    //     "authorizeUrl": "https://partner.example/verily/authorize",
+    //     "returnUrl": "https://partner.example/verily/return",
+    //     // Optional: the provider ids its holders may use. Omit for all of them.
+    //     "providers": ["discord", "youtube"],
+    //     // Optional: the visibilities its holders may choose. Omit for both.
+    //     "visibility": ["unlisted"],
+    //   },
+    // ],
+  },
+}
+`;
+/**
+ * The files of a project that runs an instance on Cloudflare. All of the instance is in the
+ * package, so the project is its settings and one line that names the entry, and it takes
+ * a new release by updating the dependency.
+ */
+export const cloudflareStarter = {
+    'package.json': `${JSON.stringify({
+        name: 'verily-instance',
+        private: true,
+        type: 'module',
+        scripts: { dev: 'wrangler dev --local', deploy: 'wrangler deploy' },
+        dependencies: { '@bkazemi/verily': release },
+        devDependencies: { wrangler: '^4.132.0' },
+    }, null, 2)}\n`,
+    'worker.ts': "export { default, VerilyStore } from '@bkazemi/verily/instance/cloudflare';\n",
+    'wrangler.jsonc': wrangler,
+    '.gitignore': 'node_modules\n.wrangler\n.dev.vars\n',
+};

package/dist/instance/store.d.ts

@@ -0,0 +1,20 @@
+import type { Storage } from '../core/index.js';
+/** Reads and writes values by key. Values are plain JSON. */
+export interface KeyValue {
+    get<T>(key: string): Promise<T | undefined>;
+    put<T>(key: string, value: T): Promise<void>;
+    delete(key: string): Promise<void>;
+    /** Every entry whose key starts with `prefix`. */
+    list<T>(prefix: string): Promise<[string, T][]>;
+}
+/**
+ * Where an instance keeps everything: the library's records and its own data, such as
+ * owner sessions, site sessions, handoffs and rate limits. A host supplies one of these.
+ *
+ * `transaction` must run one at a time and write nothing if `work` rejects.
+ */
+export interface Store extends KeyValue {
+    transaction<T>(work: (tx: KeyValue) => Promise<T>): Promise<T>;
+}
+/** The library's record storage, kept in a store under `verily/<kind>/<id>`. */
+export declare function recordStorage(store: Store): Storage;

package/dist/instance/store.js

@@ -0,0 +1,11 @@
+/** The library's record storage, kept in a store under `verily/<kind>/<id>`. */
+export function recordStorage(store) {
+    return {
+        transaction: (work) => store.transaction((tx) => work({
+            get: (kind, id) => tx.get(`verily/${kind}/${id}`),
+            put: (kind, id, value) => tx.put(`verily/${kind}/${id}`, value),
+            delete: (kind, id) => tx.delete(`verily/${kind}/${id}`),
+            list: async (kind) => (await tx.list(`verily/${kind}/`)).map(([, value]) => value),
+        })),
+    };
+}

package/dist/instance/undici.d.ts

@@ -0,0 +1,8 @@
+/**
+ * Stands in for undici in the Worker build. Only `publicFetch()` loads it, and only on
+ * Node, so on Workers the real one would be a megabyte of code that can never run.
+ */
+declare function unavailable(): never;
+export declare const Agent: typeof unavailable;
+export declare const fetch: typeof unavailable;
+export {};

package/dist/instance/undici.js

@@ -0,0 +1,9 @@
+/**
+ * Stands in for undici in the Worker build. Only `publicFetch()` loads it, and only on
+ * Node, so on Workers the real one would be a megabyte of code that can never run.
+ */
+function unavailable() {
+    throw new Error('undici is not available on Workers');
+}
+export const Agent = unavailable;
+export const fetch = unavailable;

package/dist/marks.d.ts

@@ -0,0 +1,44 @@
+/**
+ * The provider marks, as data, so the badge script and the server's pages draw the same
+ * ones. Filled marks are in the text colour; the ones drawn here are rounded strokes.
+ */
+export interface Mark {
+    viewBox: string;
+    paths: string[];
+    /** Drawn as strokes rather than filled. */
+    stroke?: boolean;
+}
+/**
+ * The mark for a provider, or nothing where there is none. Returning nothing rather than
+ * the provider's name keeps this to one job: a caller that also writes the name would
+ * otherwise print it twice, and only the caller knows where the name belongs.
+ */
+export declare function markOf(provider: string, method?: string): Mark | undefined;
+/** The attributes every path of a mark gets, as name and value pairs. */
+export declare const pathAttributes: (mark: Mark) => [string, string][];
+/**
+ * How sure the verification mark is: `current` for a verification that holds, `inactive`
+ * for one that does not, and `pending` for one that claims nothing, such as a retired
+ * account, which is drawn in the surrounding text colour.
+ */
+export type MarkTone = 'current' | 'inactive' | 'pending';
+/** The V's two strokes in each tone: the V, then the check drawn inside it. */
+export declare const tones: Record<MarkTone, [string, string]>;
+/** The tone a record's mark is drawn in. A retired account claims nothing, not a failure. */
+export declare function toneOf(evidence: {
+    status: string;
+    expiresAt: number;
+}, now: number): MarkTone;
+/** V2: the green check fills its section of the symmetric red V. */
+export declare const verification: {
+    viewBox: string;
+    /** The box around the strokes alone: the arms' squared ends and the mitred foot. */
+    strokes: string;
+    path: string;
+    /** The check's stretch of the V, as a dash along a path measured as 176 long. */
+    check: {
+        pathLength: string;
+        'stroke-dasharray': string;
+        'stroke-dashoffset': string;
+    };
+};