@bkazemi/verily 0.5.0 → 0.7.0

package/dist/browser/index.js

@@ -1,7 +1,8 @@
+import { accountsOf } from '../core/index.js';
 import { routePath } from '../core/routes.js';
 import { badgeShown, quietBadge, renderBadge, renderBadgeMessage, renderBadgePending, renderConnectPill, } from './badge.js';
 import { openConnectDialog, } from './connect-dialog.js';
-import { openEvidenceDialog } from './evidence-dialog.js';
+import { openEvidenceDialog, subjectUrl, } from './evidence-dialog.js';
 import { drawSignedWith, standing, watchSigned } from './signed.js';
 /**
  * What each host's dialog opens on and how it reads again, kept apart from the pill: the
@@ -91,15 +92,17 @@ function details(element) {
                         throw error;
                 }
             }
-        }, latestGroup.get(element), accounts, managers.get(element));
+        }, latestGroup.get(element), accounts, managers.get(element), openHosts.has(element));
     }
 }
 /**
- * Hosts whose pill is stacked, and hosts whose pill opens no panel, where the page asked
- * for either. Kept here so every later refresh of the host draws it the same way.
+ * Hosts whose pill is stacked, hosts whose pill opens no panel, and hosts whose dialog
+ * starts with its details open, where the page asked for any of them. Kept here so every
+ * later refresh of the host draws it the same way.
  */
 const stackedHosts = new WeakSet();
 const quietHosts = new WeakSet();
+const openHosts = new WeakSet();
 /**
  * How many accounts a pill names before it counts the rest. A stacked pill pays for each
  * row in the page's height. A panel floats over the page and pays nothing, but it cannot
@@ -108,7 +111,11 @@ const quietHosts = new WeakSet();
 const stackedAccounts = 4;
 const peekedAccounts = 8;
 /** Records how a host's pill is arranged, from what the page last said. */
-function arrange(element, { stacked, peek }) {
+function arrange(element, { stacked, peek, detailsOpen }) {
+    if (detailsOpen)
+        openHosts.add(element);
+    else
+        openHosts.delete(element);
     if (stacked)
         stackedHosts.add(element);
     else
@@ -133,45 +140,16 @@ const live = (evidence) => evidence.status === 'verified' && evidence.expiresAt
  * Each entry names every record of the account not yet revoked, shown or not, so removing
  * the account removes them all. One left behind, lapsed or unconfirmed, could be confirmed
  * again later and bring the account back without its holder approving anything.
- *
- * A record from a backend older than `connectedAt` is placed by when it was approved.
  */
 function accounts(records) {
-    const when = (e) => e.connectedAt ?? e.approvedAt;
-    const byAccount = new Map();
-    for (const record of records) {
-        const key = JSON.stringify([record.provider, record.external.id]);
-        byAccount.set(key, [...(byAccount.get(key) ?? []), record]);
-    }
-    return [...byAccount.values()]
-        .map((held) => {
-        const sorted = [...held].sort((a, b) => when(a) - when(b));
-        const verified = sorted.filter(live);
-        const base = verified[0] ?? sorted.reduce((a, b) => (b.approvedAt > a.approvedAt ? b : a));
-        const external = [...base.attestations.external];
-        for (const other of verified.slice(1))
-            for (const attestation of other.attestations.external)
-                if (!external.some((shown) => shown.method === attestation.method))
-                    external.push(attestation);
-        return {
-            ...base,
-            connectedAt: when(sorted[0]),
-            attestations: { ...base.attestations, external },
-            links: sorted.filter((e) => e.status !== 'revoked').map((e) => e.id),
-            // Every record the card speaks for, so its signature mark answers for all of them.
-            sources: verified.length ? verified : [base],
-        };
-    })
-        .sort((a, b) => place(a) - place(b) || a.connectedAt - b.connectedAt);
-}
-/**
- * Where an account is listed among a subject's others, before the order they were
- * connected in. This is all there is to preferring an account: there is no separate pin.
- */
-function place(account) {
-    if (account.status === 'retired')
-        return 3;
-    return account.mark === 'preferred' ? 0 : account.mark === 'unused' ? 2 : 1;
+    return accountsOf(records, Date.now()).map(({ lead, held, verified, external, connectedAt }) => ({
+        ...lead,
+        connectedAt,
+        attestations: { ...lead.attestations, external },
+        links: held.filter((e) => e.status !== 'revoked').map((e) => e.id),
+        // Every record the card speaks for, so its signature mark answers for all of them.
+        sources: verified.length ? verified : [lead],
+    }));
 }
 /**
  * One subject's accounts as a single pill: the first of them, then how many more stand
@@ -198,6 +176,8 @@ function presentGroup(element, records, load) {
     const badge = renderBadge(element, lead, {
         more: Math.max(verified.length - 1, 0),
         linked: lead.visibility === 'public',
+        // A modified click follows the link, and must reach what a plain one shows: every account.
+        ...(ordered.length > 1 ? { href: subjectUrl(lead) } : {}),
         rows: stacked
             ? verified.slice(1, stackedAccounts)
             : peek
@@ -669,6 +649,9 @@ function validEvidence(value) {
         ['label', 'reference'].every((k) => typeof value.local[k] === 'string') &&
         ['id', 'handle', 'profileUrl'].every((k) => typeof value.external[k] === 'string') &&
         (value.local.profileUrl === undefined || typeof value.local.profileUrl === 'string') &&
+        (value.external.createdAt === undefined ||
+            (typeof value.external.createdAt === 'number' &&
+                Number.isFinite(value.external.createdAt))) &&
         // 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 === undefined || value.signedUrl === `${value.evidenceUrl}?format=signed`) &&
@@ -729,6 +712,7 @@ if (typeof customElements !== 'undefined' && !customElements.get('verily-badge')
             'connect',
             'stacked',
             'peek',
+            'details-open',
         ];
         handed;
         /**
@@ -788,6 +772,7 @@ if (typeof customElements !== 'undefined' && !customElements.get('verily-badge')
             const arrangement = {
                 stacked: this.getAttribute('stacked') !== null,
                 peek: this.getAttribute('peek') !== 'off',
+                detailsOpen: this.getAttribute('details-open') !== null,
             };
             // The holder's own badge, where the page says so: its dialog connects another
             // account, renews one and removes one, through the backend named. The host hears

package/dist/core/index.d.ts

@@ -45,6 +45,12 @@ export interface ExternalAccount {
     handle: string;
     /** Where a reader goes to see the subject. For a mailbox, its `mailto:` address. */
     profileUrl: string;
+    /**
+     * When the account was created, in milliseconds, as reported by the provider. It lets a
+     * reader tell an old account from one opened just to be linked. Only sign-in providers
+     * set it. Once a record has it, later proofs by other methods keep it.
+     */
+    createdAt?: number;
 }
 /**
  * How control of one side was shown. A provider is who an account belongs to; a method is
@@ -96,6 +102,13 @@ export interface Attestation {
      * is reconfirmed like any other.
      */
     confirmedAt: number;
+    /** When `recheck()` last tried to read the proof, whether or not the read worked. */
+    readAt?: number;
+    /**
+     * When a recheck first read the proof and found it missing. The proof does not count
+     * while this is set. Cleared by the next read that finds it.
+     */
+    absentAt?: number;
 }
 /** Each side of a link is attested separately, by different parties under different methods. */
 export interface Attestations {
@@ -137,9 +150,44 @@ export interface Connection {
      * last proof: never renewed by another method, never reread, never verified.
      */
     retiredAt?: number;
+    /** The state last delivered to `onChange`. Absent until the first delivery. */
+    reported?: Reported;
+    /**
+     * When the last delivery to `onChange` started, while it has not been confirmed. Set when
+     * a delivery starts and cleared when it succeeds, so a record with it set is delivered
+     * again even if its state matches `reported`.
+     */
+    reportTriedAt?: number;
+    /** The revision given to the last delivery. Each delivery of the record adds one. */
+    reportRevision?: number;
+}
+/** The parts of a record that `onChange` reports a change in. */
+export interface Reported {
+    status: Status;
+    visibility: Visibility;
+    expiresAt: number;
+    mark?: Mark;
+}
+/** One record whose status, visibility, expiry or mark changed, as `onChange` receives it. */
+export interface Change {
+    /** The record as it stands now. */
+    evidence: Evidence;
+    /** The subject the record belongs to, with its private id. */
+    local: LocalAccount;
+    /** What the last confirmed delivery reported. Absent until one is confirmed. */
+    previous?: Reported;
+    /**
+     * Counts the deliveries of this record, starting at 1. A higher revision always carries
+     * a state read later, across processes too. Keep the last one applied for each record
+     * and ignore a change whose revision is not higher: a slow or repeated delivery can
+     * arrive after a newer one.
+     */
+    revision: number;
 }
 export interface Flow {
     id: string;
+    /** Saved DNS setup; grants no authority to finish a flow. */
+    dnsDraftId?: string;
     stateHash: string;
     bindingHash: string;
     verifier?: string;
@@ -155,7 +203,8 @@ export interface Flow {
     reason?: string;
     /**
      * The string an artifact must contain. Public by design: the holder publishes it. It is
-     * unguessable and per-flow, so an artifact made for one flow cannot complete another.
+     * normally unguessable and per-flow. DNS setup can retain the same value across
+     * fresh flows for the same subject and operation while propagation is pending.
      */
     expect?: string;
     /** Whether `expect` was minted for a method that had nothing of the subject's to state. */
@@ -269,7 +318,16 @@ export interface SiteRead {
     /** Whether that read got an answer. One that did not is asked again sooner. */
     answered: boolean;
 }
+/** DNS setup retained across short-lived, authenticated flows for seven days. */
+export interface DnsDraft {
+    id: string;
+    flowId: string;
+    expect: string;
+    artifact?: string;
+    expiresAt: number;
+}
 export interface Records {
+    dnsDrafts: DnsDraft;
     connections: Connection;
     flows: Flow;
     shares: Share;
@@ -349,8 +407,9 @@ export interface ArtifactProvider {
      * Told to the holder verbatim. Must name what they are publishing and where. Returned in
      * pieces so a renderer can set a command as one: a command is copied character for
      * character, and prose that reflows is prose a holder cannot safely copy.
+     * `artifact` is the last submitted or suggested location, when one is known.
      */
-    instructions(expect: string): Instruction[];
+    instructions(expect: string, artifact?: string): Instruction[];
     /**
      * What the holder is asked to hand back, where the method takes something a holder knows
      * by a better name than "an address". `input` says how to ask for it: `text` where it
@@ -451,6 +510,14 @@ export interface CodeProvider {
  */
 export declare class Refused extends Error {
 }
+/**
+ * A proof that was read and is not there: the page, file, gist or DNS answer came back and
+ * the expected value was missing. Thrown by `verify` or `prove`. On a recheck it makes the
+ * proof unconfirmed at once. Any other error means the read itself failed, and the proof
+ * keeps counting until `freshnessMs` runs out.
+ */
+export declare class Absent extends Refused {
+}
 /**
  * A piece of what the holder is told: a paragraph, a paragraph with links in it, or
  * something they run or publish as is.
@@ -525,6 +592,10 @@ export * from './routes.js';
  * telling anyone, so a confirmation is a heartbeat rather than a permanent fact.
  */
 export declare const freshnessMs: number;
+/** Whether a record has reached its deadline, including the exact expiry instant. */
+export declare function expired(record: {
+    expiresAt: number;
+}, now: number): boolean;
 /**
  * `freshness` bounds how stale a published proof may be before it stops counting. A
  * backend that never rechecks must leave it unbounded, since an unread proof going stale
@@ -547,6 +618,29 @@ export declare function lastProved(evidence: Pick<Evidence, 'authenticatedAt' |
  * that has run out since reads as expired whatever status it was issued with.
  */
 export declare function statusLabel(evidence: Pick<Evidence, 'status' | 'expiresAt'>, now: number): string;
+/**
+ * Where an account is listed among a subject's others, before the order they were
+ * connected in. This is all there is to preferring an account: there is no separate pin.
+ */
+export declare function place(account: Pick<Evidence, 'status' | 'mark'>): number;
+/**
+ * One subject's records as its accounts, in the order they are listed everywhere: the
+ * preferred one, then the rest as first connected, then those unused, then those retired.
+ * Records are not accounts: the same account can stand on several. `held` is every record
+ * of the account, earliest first, and `verified` those of them that stand now. `lead`
+ * speaks for the account: the earliest that stands, or else the latest approved, which
+ * says what became of it. `external` is how the account was shown: the lead's methods,
+ * then any other its standing records add.
+ *
+ * A record from a backend older than `connectedAt` is placed by when it was approved.
+ */
+export declare function accountsOf(records: Evidence[], now: number): {
+    lead: Evidence;
+    held: Evidence[];
+    verified: Evidence[];
+    external: Attestations['external'];
+    connectedAt: number;
+}[];
 /**
  * What to call a link's local side, and what to write as its value. When the site itself is
  * what was linked there is no subject on it to name, so the site is the value rather than a
@@ -584,6 +678,16 @@ export declare function attestationLabel(method: string, names: {
  * already all of it: a mailbox's address and a domain are each their own id.
  */
 export declare function externalId(external: ExternalAccount): string | undefined;
+/**
+ * A key's fingerprint in groups of four, as gpg prints it, so a renderer can break the line
+ * between groups. Nothing for any other subject, whose id is written as it stands.
+ */
+export declare function externalIdGroups(external: ExternalAccount): string[] | undefined;
+/**
+ * The text for an account's creation date, such as "Joined 2014-03-02", or undefined if
+ * the date is unknown. `day` formats the date, to the day.
+ */
+export declare function externalSince(external: ExternalAccount, day: (time: number) => string): 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

@@ -4,6 +4,14 @@
  */
 export class Refused extends Error {
 }
+/**
+ * A proof that was read and is not there: the page, file, gist or DNS answer came back and
+ * the expected value was missing. Thrown by `verify` or `prove`. On a recheck it makes the
+ * proof unconfirmed at once. Any other error means the read itself failed, and the proof
+ * keeps counting until `freshnessMs` runs out.
+ */
+export class Absent extends Refused {
+}
 /** Only an artifact provider is holder-paced, and only it needs a url handed back. */
 export function isArtifactProvider(provider) {
     return 'verify' in provider;
@@ -28,6 +36,10 @@ export * from './routes.js';
  * telling anyone, so a confirmation is a heartbeat rather than a permanent fact.
  */
 export const freshnessMs = 7 * 86400000;
+/** Whether a record has reached its deadline, including the exact expiry instant. */
+export function expired(record, now) {
+    return record.expiresAt <= now;
+}
 /**
  * `freshness` bounds how stale a published proof may be before it stops counting. A
  * backend that never rechecks must leave it unbounded, since an unread proof going stale
@@ -39,7 +51,7 @@ export function status(connection, now, freshness = freshnessMs) {
     // Frozen at its last proof, so neither its expiry nor its freshness is read again.
     if (connection.retiredAt !== undefined)
         return 'retired';
-    if (now >= connection.expiresAt)
+    if (expired(connection, now))
         return 'expired';
     const main = connection.attestations?.external[0];
     if (main && !fresh(main, now, freshness))
@@ -52,6 +64,9 @@ export function status(connection, now, freshness = freshnessMs) {
  * reverses the moment it reads again.
  */
 export function fresh(attestation, now, freshness = freshnessMs) {
+    // Read and found missing, which is not the same as not having been read lately.
+    if (attestation.absentAt !== undefined)
+        return false;
     return (!attestation.artifactUrl ||
         attestation.hosted === true ||
         freshness === Infinity ||
@@ -75,10 +90,51 @@ export function statusLabel(evidence, now) {
     // Before expiry: a retired record's approval has long run out, and that is not its state.
     if (evidence.status === 'retired')
         return 'Retired';
-    if (evidence.status === 'expired' || evidence.expiresAt <= now)
+    if (evidence.status === 'expired' || expired(evidence, now))
         return 'Expired';
     return evidence.status === 'unconfirmed' ? 'Unconfirmed' : 'Verified';
 }
+/**
+ * Where an account is listed among a subject's others, before the order they were
+ * connected in. This is all there is to preferring an account: there is no separate pin.
+ */
+export function place(account) {
+    if (account.status === 'retired')
+        return 3;
+    return account.mark === 'preferred' ? 0 : account.mark === 'unused' ? 2 : 1;
+}
+/**
+ * One subject's records as its accounts, in the order they are listed everywhere: the
+ * preferred one, then the rest as first connected, then those unused, then those retired.
+ * Records are not accounts: the same account can stand on several. `held` is every record
+ * of the account, earliest first, and `verified` those of them that stand now. `lead`
+ * speaks for the account: the earliest that stands, or else the latest approved, which
+ * says what became of it. `external` is how the account was shown: the lead's methods,
+ * then any other its standing records add.
+ *
+ * A record from a backend older than `connectedAt` is placed by when it was approved.
+ */
+export function accountsOf(records, now) {
+    const when = (e) => e.connectedAt ?? e.approvedAt;
+    const byAccount = new Map();
+    for (const record of records) {
+        const key = JSON.stringify([record.provider, record.external.id]);
+        byAccount.set(key, [...(byAccount.get(key) ?? []), record]);
+    }
+    return [...byAccount.values()]
+        .map((unsorted) => {
+        const held = [...unsorted].sort((a, b) => when(a) - when(b));
+        const verified = held.filter((e) => e.status === 'verified' && e.expiresAt > now);
+        const lead = verified[0] ?? held.reduce((a, b) => (b.approvedAt > a.approvedAt ? b : a));
+        const external = [...lead.attestations.external];
+        for (const other of verified.slice(1))
+            for (const attestation of other.attestations.external)
+                if (!external.some((shown) => shown.method === attestation.method))
+                    external.push(attestation);
+        return { lead, held, verified, external, connectedAt: when(held[0]) };
+    })
+        .sort((a, b) => place(a.lead) - place(b.lead) || a.connectedAt - b.connectedAt);
+}
 /**
  * What to call a link's local side, and what to write as its value. When the site itself is
  * what was linked there is no subject on it to name, so the site is the value rather than a
@@ -140,6 +196,22 @@ export function attestationLabel(method, names, proof = {}) {
 export function externalId(external) {
     return external.kind === 'mailbox' || external.kind === 'domain' ? undefined : external.id;
 }
+/**
+ * A key's fingerprint in groups of four, as gpg prints it, so a renderer can break the line
+ * between groups. Nothing for any other subject, whose id is written as it stands.
+ */
+export function externalIdGroups(external) {
+    return external.kind === 'key' ? (external.id.match(/.{1,4}/g) ?? undefined) : undefined;
+}
+/**
+ * The text for an account's creation date, such as "Joined 2014-03-02", or undefined if
+ * the date is unknown. `day` formats the date, to the day.
+ */
+export function externalSince(external, day) {
+    return typeof external.createdAt === 'number' && Number.isFinite(external.createdAt)
+        ? `Joined ${day(external.createdAt)}`
+        : 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/server/discord.js

@@ -62,6 +62,9 @@ export function discordProvider(options) {
                 id: user.id,
                 handle: user.username,
                 profileUrl: `https://discord.com/users/${user.id}`,
+                // A Discord id encodes its creation time: the bits above the low 22 are
+                // milliseconds since 2015-01-01 UTC.
+                createdAt: Number(BigInt(user.id) >> 22n) + 1420070400000,
             };
         },
     };

package/dist/server/domain.js

@@ -1,5 +1,5 @@
 import { MIMEType } from 'node:util';
-import { Refused, } from '../core/index.js';
+import { Absent, Refused, } from '../core/index.js';
 import { discard, readBounded } from './body.js';
 import { transport } from './public-fetch.js';
 /**
@@ -47,18 +47,39 @@ export function dnsProvider(options = {}) {
         const domain = looked(artifact);
         const { values, dnssec } = await published(domain, options);
         if (!values.includes(expect))
-            throw new Refused(`No TXT record at ${label}.${domain} has this value`);
+            throw new Absent(`No TXT record at ${label}.${domain} has this value`);
         return { account: account(domain), ...(dnssec ? { dnssec } : {}) };
     };
     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.',
-        ],
+        instructions(expect, artifact) {
+            let domain = artifact ? named(artifact) : undefined;
+            if (!domain && artifact) {
+                try {
+                    domain = looked(artifact);
+                }
+                catch {
+                    /* An invalid input is never a command. */
+                }
+            }
+            const record = domain ? `${label}.${domain}` : `${label}.YOUR-DOMAIN`;
+            return [
+                domain
+                    ? 'Add a TXT record with this name and value.'
+                    : 'Add a TXT record with this name and value. Replace YOUR-DOMAIN with the exact domain you enter below.',
+                { code: record },
+                'If your DNS host adds the domain automatically, enter only _verily for the root domain. For a subdomain such as www.example.com in the example.com zone, enter _verily.www.',
+                { code: expect },
+                domain
+                    ? `Proves control of ${domain} only. Parent domains and subdomains must be verified separately.`
+                    : 'Proves control of the exact domain you enter. Parent domains and subdomains must be verified separately.',
+                'DNS changes can take up to 72 hours to appear. Check the published record with:',
+                { code: `dig TXT ${record} +short` },
+                ...(domain ? [[{ text: 'Look up this TXT record', href: lookup(domain) }]] : []),
+                'Keep the TXT record in place after verification so Verily can check it again.',
+            ];
+        },
         resolve(artifact) {
             const domain = named(artifact);
             return domain ? lookup(domain) : artifact;
@@ -223,6 +244,9 @@ export function wellKnownProvider(options = {}) {
                 // 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');
+                // The file is gone. Any other failure is a failed read.
+                if (response.status === 404 || response.status === 410)
+                    throw new Absent('File unavailable');
                 if (!response.ok)
                     throw new Refused('File unavailable');
                 if (mediaType(response.headers.get('content-type')) !== 'text/plain')
@@ -232,8 +256,11 @@ export function wellKnownProvider(options = {}) {
                 // 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 with this value');
+                if (!lines.some((line) => line.trim() === expect)) {
+                    if (truncated)
+                        throw new Refused('File is too large to read');
+                    throw new Absent('File has no line with this value');
+                }
             }
             finally {
                 await discard(response);

package/dist/server/github-gist.js

@@ -1,4 +1,4 @@
-import { Refused } from '../core/index.js';
+import { Absent, Refused } from '../core/index.js';
 /**
  * Proves control of a GitHub account by having its holder publish a given line in a public
  * gist. No app registration, no client secret, and no token: the proof is a public document
@@ -34,11 +34,14 @@ export function githubGistProvider(options = {}) {
                 signal: AbortSignal.timeout(15000),
             });
             const gist = await response.json();
+            // GitHub answers 404 for a gist that was deleted. Any other failure is a failed read.
+            if (response.status === 404)
+                throw new Absent('Gist unavailable');
             if (!response.ok || !isRecord(gist))
                 throw new Refused('Gist unavailable');
             // A secret gist proves nothing a reader could check for themselves.
             if (gist.public !== true)
-                throw new Refused('Gist is not public');
+                throw new Absent('Gist is not public');
             const owner = gist.owner;
             if (!isRecord(owner) ||
                 !Number.isSafeInteger(owner.id) ||
@@ -46,8 +49,13 @@ export function githubGistProvider(options = {}) {
                 typeof owner.login !== 'string' ||
                 !/^[a-zA-Z0-9-]+$/.test(owner.login))
                 throw new Refused('Invalid gist owner');
-            if (!isRecord(gist.files) || !contains(gist.files, expect))
-                throw new Refused('Gist does not contain the expected line');
+            if (!isRecord(gist.files) || !contains(gist.files, expect)) {
+                // Part of the gist was left out of the answer, and the line may be in that part.
+                // That is a failed read, so the proof keeps counting.
+                if (!isRecord(gist.files) || gist.truncated === true || partial(gist.files))
+                    throw new Refused('Gist is too large to read');
+                throw new Absent('Gist does not contain the expected line');
+            }
             return {
                 id: String(owner.id),
                 handle: owner.login,
@@ -63,6 +71,10 @@ function contains(files, expect) {
         typeof file.content === 'string' &&
         file.content.includes(expect));
 }
+/** Whether any file came back cut short or without its content. */
+function partial(files) {
+    return Object.values(files).some((file) => !isRecord(file) || file.truncated === true || typeof file.content !== 'string');
+}
 function isRecord(value) {
     return value !== null && typeof value === 'object';
 }

package/dist/server/github.js

@@ -54,10 +54,13 @@ export function githubProvider(options) {
                 typeof user.login !== 'string' ||
                 !/^[a-zA-Z0-9-]+$/.test(user.login))
                 throw new Error('Invalid provider identity');
+            // Optional: a missing or unparseable date is left off and the sign-in still succeeds.
+            const createdAt = typeof user.created_at === 'string' ? Date.parse(user.created_at) : NaN;
             return {
                 id: String(user.id),
                 handle: user.login,
                 profileUrl: `https://github.com/${user.login}`,
+                ...(Number.isFinite(createdAt) ? { createdAt } : {}),
             };
         },
     };