@bkazemi/verily 0.1.0

package/dist/browser/logo.d.ts

@@ -0,0 +1,2 @@
+/** The logotype, drawn as nodes: nothing in the badge sets innerHTML. */
+export declare function verilyLogo(): SVGSVGElement;

package/dist/browser/logo.js

@@ -0,0 +1,17 @@
+import { logoPaths, logoViewBox } from '../logo.js';
+/** The logotype, drawn as nodes: nothing in the badge sets innerHTML. */
+export function verilyLogo() {
+    const namespace = 'http://www.w3.org/2000/svg';
+    const svg = document.createElementNS(namespace, 'svg');
+    svg.setAttribute('viewBox', logoViewBox);
+    svg.setAttribute('class', 'logo');
+    svg.setAttribute('role', 'img');
+    svg.setAttribute('aria-label', 'Verily');
+    for (const { d, fill } of logoPaths) {
+        const path = document.createElementNS(namespace, 'path');
+        path.setAttribute('d', d);
+        path.setAttribute('fill', fill);
+        svg.append(path);
+    }
+    return svg;
+}

package/dist/browser/mark.d.ts

@@ -0,0 +1,19 @@
+/**
+ * How sure the mark is: `current` for a verification that holds, `inactive` for one that
+ * does not, and `pending` for one nobody has confirmed yet, which claims nothing and is
+ * drawn in the surrounding text colour.
+ */
+export type MarkTone = 'current' | 'inactive' | 'pending';
+/**
+ * The check draws itself in from its left end once the verification holds: when a pill's
+ * mark first becomes `current`, and each time the dialog opens on a current one.
+ */
+export declare const markStyles = "\n  @media (prefers-reduced-motion: no-preference) {\n    .mark.current path:last-child { animation: verily-draw .8s cubic-bezier(.65, 0, .35, 1) .1s backwards; }\n  }\n  @keyframes verily-draw { from { stroke-dasharray: 0 176; } to { stroke-dasharray: 108 176; } }\n";
+/** Repaints a mark in place, so answering a check never replaces the drawing. */
+export declare function paintMark(svg: SVGSVGElement, tone: MarkTone): void;
+/** V2: the green check fills its section of the symmetric red V. */
+export declare function verificationMark(tone?: MarkTone): SVGSVGElement;
+/** The clock on an expired record: a face, and hands at three o'clock. */
+export declare const clockMark: () => SVGSVGElement;
+/** The dash on a record that is revoked or cannot be shown. */
+export declare const dashMark: () => SVGSVGElement;

package/dist/browser/mark.js

@@ -0,0 +1,77 @@
+const tones = {
+    current: ['#D3444C', '#149766'],
+    inactive: ['#149766', '#D3444C'],
+    pending: ['currentColor', 'currentColor'],
+};
+/**
+ * The check draws itself in from its left end once the verification holds: when a pill's
+ * mark first becomes `current`, and each time the dialog opens on a current one.
+ */
+export const markStyles = `
+  @media (prefers-reduced-motion: no-preference) {
+    .mark.current path:last-child { animation: verily-draw .8s cubic-bezier(.65, 0, .35, 1) .1s backwards; }
+  }
+  @keyframes verily-draw { from { stroke-dasharray: 0 176; } to { stroke-dasharray: 108 176; } }
+`;
+/** Repaints a mark in place, so answering a check never replaces the drawing. */
+export function paintMark(svg, tone) {
+    const colors = tones[tone];
+    svg.setAttribute('class', `mark ${tone}`);
+    for (const [layer, path] of [...svg.children].entries())
+        path.setAttribute('stroke', colors[layer] ?? colors[0]);
+}
+/** V2: the green check fills its section of the symmetric red V. */
+export function verificationMark(tone = 'current') {
+    const namespace = 'http://www.w3.org/2000/svg';
+    const svg = document.createElementNS(namespace, 'svg');
+    svg.setAttribute('viewBox', '-4 -4 264 264');
+    svg.setAttribute('fill', 'none');
+    svg.setAttribute('aria-hidden', 'true');
+    svg.setAttribute('focusable', 'false');
+    for (const layer of [0, 1]) {
+        const path = document.createElementNS(namespace, 'path');
+        path.setAttribute('d', 'M40 36 128 220 216 36');
+        path.setAttribute('stroke-width', '32');
+        path.setAttribute('stroke-linejoin', 'miter');
+        if (layer === 1) {
+            path.setAttribute('pathLength', '176');
+            path.setAttribute('stroke-dasharray', '108 176');
+            path.setAttribute('stroke-dashoffset', '-54');
+        }
+        svg.append(path);
+    }
+    paintMark(svg, tone);
+    return svg;
+}
+/**
+ * A small drawing inside a status circle. Drawn, not typed: a character sits where its
+ * font's metrics put it, which is never quite the middle of the circle around it, and
+ * differently so on each platform. A drawing is centred by its own geometry, in the
+ * surrounding colour. Each one is drawn about the middle of the same sixteen-unit box.
+ */
+function statusMark(name, shapes) {
+    const namespace = 'http://www.w3.org/2000/svg';
+    const svg = document.createElementNS(namespace, 'svg');
+    svg.setAttribute('viewBox', '0 0 16 16');
+    svg.setAttribute('fill', 'none');
+    svg.setAttribute('stroke', 'currentColor');
+    svg.setAttribute('stroke-width', '1.6');
+    svg.setAttribute('stroke-linecap', 'round');
+    svg.setAttribute('stroke-linejoin', 'round');
+    svg.setAttribute('class', `glyph ${name}`);
+    svg.setAttribute('focusable', 'false');
+    for (const [tag, attributes] of shapes) {
+        const shape = document.createElementNS(namespace, tag);
+        for (const [key, value] of Object.entries(attributes))
+            shape.setAttribute(key, value);
+        svg.append(shape);
+    }
+    return svg;
+}
+/** The clock on an expired record: a face, and hands at three o'clock. */
+export const clockMark = () => statusMark('clock', [
+    ['circle', { cx: '8', cy: '8', r: '6.2' }],
+    ['path', { d: 'M8 4.6V8h2.6' }],
+]);
+/** The dash on a record that is revoked or cannot be shown. */
+export const dashMark = () => statusMark('dash', [['path', { d: 'M4.4 8h7.2' }]]);

package/dist/browser/provider-mark.d.ts

@@ -0,0 +1,6 @@
+/**
+ * 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 providerMark(provider: string, method?: string): SVGSVGElement | undefined;

package/dist/browser/provider-mark.js

@@ -0,0 +1,99 @@
+const namespace = 'http://www.w3.org/2000/svg';
+function mark() {
+    const svg = document.createElementNS(namespace, 'svg');
+    svg.setAttribute('viewBox', '0 0 16 16');
+    svg.setAttribute('class', 'provider');
+    svg.setAttribute('aria-hidden', 'true');
+    svg.setAttribute('focusable', 'false');
+    return svg;
+}
+/** GitHub mark from Primer Octicons (MIT); license in docs/licenses/octicons.txt. */
+function github() {
+    const svg = mark();
+    const path = document.createElementNS(namespace, 'path');
+    svg.setAttribute('fill', 'currentColor');
+    path.setAttribute('d', 'M6.766 11.328c-2.063-.25-3.516-1.734-3.516-3.656 0-.781.281-1.625.75-2.188-.203-.515-.172-1.609.063-2.062.625-.078 1.468.25 1.968.703.594-.187 1.219-.281 1.985-.281.765 0 1.39.094 1.953.265.484-.437 1.344-.765 1.969-.687.218.422.25 1.515.046 2.047.5.593.766 1.39.766 2.203 0 1.922-1.453 3.375-3.547 3.64.531.344.89 1.094.89 1.954v1.625c0 .468.391.734.86.547C13.781 14.359 16 11.53 16 8.03 16 3.61 12.406 0 7.984 0 3.563 0 0 3.61 0 8.031a7.88 7.88 0 0 0 5.172 7.422c.422.156.828-.125.828-.547v-1.25c-.219.094-.5.156-.75.156-1.031 0-1.64-.562-2.078-1.609-.172-.422-.36-.672-.719-.719-.187-.015-.25-.093-.25-.187 0-.188.313-.328.625-.328.453 0 .844.281 1.25.86.313.452.64.655 1.031.655s.641-.14 1-.5c.266-.265.47-.5.657-.656');
+    svg.append(path);
+    return svg;
+}
+/**
+ * Discord mark from Simple Icons (CC0); notice in docs/licenses/simple-icons.txt. The mark
+ * itself is Discord's trademark, used here only to say an account is a Discord account.
+ */
+function discord() {
+    const svg = mark();
+    const path = document.createElementNS(namespace, 'path');
+    svg.setAttribute('viewBox', '0 0 24 24');
+    svg.setAttribute('fill', 'currentColor');
+    path.setAttribute('d', 'M20.317 4.3698a19.7913 19.7913 0 00-4.8851-1.5152.0741.0741 0 00-.0785.0371c-.211.3753-.4447.8648-.6083 1.2495-1.8447-.2762-3.68-.2762-5.4868 0-.1636-.3933-.4058-.8742-.6177-1.2495a.077.077 0 00-.0785-.037 19.7363 19.7363 0 00-4.8852 1.515.0699.0699 0 00-.0321.0277C.5334 9.0458-.319 13.5799.0992 18.0578a.0824.0824 0 00.0312.0561c2.0528 1.5076 4.0413 2.4228 5.9929 3.0294a.0777.0777 0 00.0842-.0276c.4616-.6304.8731-1.2952 1.226-1.9942a.076.076 0 00-.0416-.1057c-.6528-.2476-1.2743-.5495-1.8722-.8923a.077.077 0 01-.0076-.1277c.1258-.0943.2517-.1923.3718-.2914a.0743.0743 0 01.0776-.0105c3.9278 1.7933 8.18 1.7933 12.0614 0a.0739.0739 0 01.0785.0095c.1202.099.246.1981.3728.2924a.077.077 0 01-.0066.1276 12.2986 12.2986 0 01-1.873.8914.0766.0766 0 00-.0407.1067c.3604.698.7719 1.3628 1.225 1.9932a.076.076 0 00.0842.0286c1.961-.6067 3.9495-1.5219 6.0023-3.0294a.077.077 0 00.0313-.0552c.5004-5.177-.8382-9.6739-3.5485-13.6604a.061.061 0 00-.0312-.0286zM8.02 15.3312c-1.1825 0-2.1569-1.0857-2.1569-2.419 0-1.3332.9555-2.4189 2.157-2.4189 1.2108 0 2.1757 1.0952 2.1568 2.419 0 1.3332-.9555 2.4189-2.1569 2.4189zm7.9748 0c-1.1825 0-2.1569-1.0857-2.1569-2.419 0-1.3332.9554-2.4189 2.1569-2.4189 1.2108 0 2.1757 1.0952 2.1568 2.419 0 1.3332-.946 2.4189-2.1568 2.4189Z');
+    svg.append(path);
+    return svg;
+}
+/** YouTube mark from Simple Icons (CC0); notice in docs/licenses/simple-icons.txt. */
+function youtube() {
+    const svg = mark();
+    const path = document.createElementNS(namespace, 'path');
+    svg.setAttribute('viewBox', '0 0 24 24');
+    svg.setAttribute('fill', 'currentColor');
+    path.setAttribute('d', 'M23.498 6.186a3.016 3.016 0 0 0-2.122-2.136C19.505 3.545 12 3.545 12 3.545s-7.505 0-9.377.505A3.017 3.017 0 0 0 .502 6.186C0 8.07 0 12 0 12s0 3.93.502 5.814a3.016 3.016 0 0 0 2.122 2.136c1.871.505 9.376.505 9.376.505s7.505 0 9.377-.505a3.015 3.015 0 0 0 2.122-2.136C24 15.93 24 12 24 12s0-3.93-.502-5.814zM9.545 15.568V8.432L15.818 12l-6.273 3.568z');
+    svg.append(path);
+    return svg;
+}
+/**
+ * A key, drawn here rather than taken from anywhere. It is not the OpenPGP logo: that mark
+ * is somebody's to license and this repository does not ship artwork it cannot account for.
+ * A key is also the truer picture, since what was proved is control of one, not membership
+ * of an organisation.
+ */
+function key() {
+    return lines([
+        'M7.4 8.6a3.3 3.3 0 1 0-4.7 4.7 3.3 3.3 0 0 0 4.7-4.7Z',
+        'M7.4 8.6 14 2',
+        'M11.2 4.8l1.6 1.6',
+        '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. */
+function globe() {
+    return lines([
+        'M8 1.5a6.5 6.5 0 1 0 0 13 6.5 6.5 0 0 0 0-13Z',
+        'M1.5 8h13',
+        'M8 1.5C6.1 3.3 5.1 5.5 5.1 8s1 4.7 2.9 6.5',
+        'M8 1.5c1.9 1.8 2.9 4 2.9 6.5s-1 4.7-2.9 6.5',
+    ]);
+}
+/** An envelope, drawn here like the key, for a mailbox that read a code sent to it. */
+function envelope() {
+    return lines(['M2 3.5h12v9H2z', 'M2.4 4l5.6 4.6L13.6 4']);
+}
+/** A mark drawn as rounded strokes in the text colour. */
+function lines(paths) {
+    const svg = mark();
+    svg.setAttribute('fill', 'none');
+    for (const d of paths) {
+        const path = document.createElementNS(namespace, 'path');
+        path.setAttribute('d', d);
+        path.setAttribute('stroke', 'currentColor');
+        path.setAttribute('stroke-width', '1.6');
+        path.setAttribute('stroke-linecap', 'round');
+        path.setAttribute('stroke-linejoin', 'round');
+        svg.append(path);
+    }
+    return svg;
+}
+/**
+ * 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 function providerMark(provider, method) {
+    const marks = {
+        github,
+        discord,
+        youtube,
+        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);
+}

package/dist/browser/signed.d.ts

@@ -0,0 +1,40 @@
+import { type Evidence } from '../core/index.js';
+/**
+ * What came of checking a record against its signed record in this browser: the same
+ * record as its verifier serves it with a signature.
+ *
+ * `valid` is a signed record of this very record, signed by one of its verifier's
+ * published keys. The record is then drawn from the signed one, so what stands beside the
+ * mark is what was signed. `invalid` is a signed record that was read and no published key
+ * signed, or one signed over some other record. `unchecked` is no verdict, and says why:
+ * the check ran out of time, or the signed record or the keys could not be read. Either is
+ * worth trying again.
+ */
+export type Signature = {
+    state: 'valid';
+    keyId: string;
+} | {
+    state: 'invalid';
+} | {
+    state: 'unchecked';
+    why: 'timeout' | 'unreadable';
+};
+/** Sets the test a signed record's contents must pass before a record is drawn from them. */
+export declare function drawSignedWith(test: (record: unknown) => record is Evidence): void;
+/** Checks a record, as shown, against its signed record and its verifier's published keys. */
+export declare function signature(evidence: Evidence): Promise<Signature>;
+/**
+ * The record as it may be shown. One whose signed record checked is shown as that has
+ * it, with only its present state taken from the record as read, so what stands beside the
+ * signature mark is what was signed. One whose signed record failed is not shown as verified: the
+ * verifier's own signature does not bear it out, so it reads as unconfirmed.
+ */
+export declare function standing<T extends Evidence>(evidence: T): T;
+/**
+ * Checks each signed record given and calls back when a check changes how one is to be
+ * drawn, so whoever drew them can draw them again. A record whose check has already come
+ * back is not asked about twice.
+ */
+export declare function watchSigned(records: Evidence[], changed: () => void): void;
+/** Tells a listener whenever a check changes how a record is to be drawn. Returns how to stop. */
+export declare function onSignatureResult(listener: () => void): () => void;

package/dist/browser/signed.js

@@ -0,0 +1,219 @@
+import { signedBy, verifySigned } from '../core/index.js';
+/** One check per record as shown while it holds, since a card is drawn again at every read. */
+const checks = new Map();
+/** Each verifier's keys, read once for all of its records. */
+const published = new Map();
+/** What each record's signed record says, once it has checked: the record is drawn from this. */
+const signedAs = new Map();
+/** The records, as shown, whose signed records failed. */
+const failures = new Set();
+/** Who is told when a check changes how a record is to be drawn. */
+const listeners = new Set();
+/** Whether a record may be drawn at all, as whoever draws records decides it. */
+let drawable = (record) => false;
+/** Sets the test a signed record's contents must pass before a record is drawn from them. */
+export function drawSignedWith(test) {
+    drawable = test;
+}
+/** A value written the same way whatever order its fields were set in. */
+function canonical(value) {
+    if (Array.isArray(value))
+        return `[${value.map(canonical).join(',')}]`;
+    if (value === null || typeof value !== 'object')
+        return JSON.stringify(value) ?? 'null';
+    return `{${Object.entries(value)
+        .filter(([, field]) => field !== undefined)
+        .sort(([a], [b]) => (a < b ? -1 : a > b ? 1 : 0))
+        .map(([key, field]) => `${JSON.stringify(key)}:${canonical(field)}`)
+        .join(',')}}`;
+}
+/** What a record claims, apart from whether it stands now: all a signed record can bear out. */
+function claims(record) {
+    const { status: _status, revokedAt: _revokedAt, signedUrl: _signedUrl, links: _links, type: _type, version: _version, issuedAt: _issuedAt, ...rest } = record;
+    return canonical(rest);
+}
+/**
+ * What a verdict is kept under: the signed record's address and everything the record shown
+ * claims.
+ * Another record at the same address, or the same one once it reads differently, is checked
+ * for itself and never given the first one's verdict.
+ */
+const shown = (evidence) => `${evidence.signedUrl}\n${claims(evidence)}`;
+/**
+ * How long a signed record or a key list is waited for. A card is veiled and out of reach
+ * while its check is out, so a verifier that never answers must not hold it there: past
+ * this the check is no verdict, and the record is shown as it was read.
+ */
+const checkLimitMs = 5000;
+/** What a read gives when it ran out of time, as against one that failed. */
+const late = Symbol('late');
+/** Reads something, giving nothing if it fails and `late` if it takes longer than the limit. */
+function limited(read) {
+    const stop = typeof AbortController === 'undefined' ? undefined : new AbortController();
+    return new Promise((resolve) => {
+        const timer = setTimeout(() => {
+            stop?.abort();
+            resolve(late);
+        }, checkLimitMs);
+        void read(stop?.signal)
+            .catch(() => undefined)
+            .then((value) => {
+            clearTimeout(timer);
+            resolve(value);
+        });
+    });
+}
+function keysAt(url, afresh = false) {
+    let reading = afresh ? undefined : published.get(url);
+    if (!reading) {
+        const read = limited(async (signal) => {
+            const listed = await fetch(url, { signal });
+            return listed.ok ? (await listed.json()).keys : undefined;
+        });
+        reading = read;
+        published.set(url, read);
+        // Keys that could not be read are asked for again by the next check.
+        void read.then((keys) => {
+            if (!Array.isArray(keys) && published.get(url) === read)
+                published.delete(url);
+        });
+    }
+    return reading;
+}
+async function check(evidence) {
+    try {
+        // Both are read from where the record itself lives, never from an address the record
+        // names for the purpose: whoever handed the record over could name a signed record and
+        // keys of their own. The verifier's keys sit beside its records, `<base>/keys` for
+        // `<base>/connections/<id>`, and a signed record anywhere else is not this record's.
+        const expected = `${evidence.evidenceUrl}?format=signed`;
+        if (evidence.signedUrl !== expected)
+            return { state: 'invalid' };
+        const keysUrl = new URL('../keys', evidence.evidenceUrl).href;
+        const [signed, held] = await Promise.all([
+            limited(async (signal) => {
+                const served = await fetch(expected, { signal });
+                return served.ok ? await served.text() : undefined;
+            }),
+            keysAt(keysUrl),
+        ]);
+        if (signed === late || held === late)
+            return { state: 'unchecked', why: 'timeout' };
+        if (signed === undefined || !Array.isArray(held))
+            return { state: 'unchecked', why: 'unreadable' };
+        let keys = held;
+        const by = await signedBy(signed);
+        // Something else was served in a signed record's place, which is no verdict on this one.
+        if (by === undefined)
+            return { state: 'unchecked', why: 'unreadable' };
+        // A verifier may have changed keys since its list was read. A key this list does not
+        // have is looked for in the list as it is now, before the record is called unsigned.
+        if (!held.some((key) => key?.id === by)) {
+            keys = await keysAt(keysUrl, true);
+            if (!Array.isArray(keys))
+                return { state: 'unchecked', why: keys === late ? 'timeout' : 'unreadable' };
+        }
+        const document = await verifySigned(signed, keys);
+        // A good signature over some other record says nothing about this one.
+        if (!document ||
+            document.id !== evidence.id ||
+            document.verifierName !== evidence.verifierName ||
+            document.evidenceUrl !== evidence.evidenceUrl ||
+            document.siteName !== evidence.siteName ||
+            document.local.reference !== evidence.local.reference ||
+            document.provider !== evidence.provider ||
+            document.external.id !== evidence.external.id)
+            return { state: 'invalid' };
+        // The record as it was signed. Whether it stands now is no part of a signed record, so
+        // that alone is kept from the record as it was read.
+        const { type: _type, version: _version, issuedAt: _issuedAt, ...said } = document;
+        const record = {
+            ...said,
+            status: evidence.status,
+            ...(evidence.revokedAt === undefined ? {} : { revokedAt: evidence.revokedAt }),
+            signedUrl: evidence.signedUrl,
+        };
+        // Signed, but not something a page may draw: it is shown as read, with no mark.
+        return drawable(record)
+            ? { state: 'valid', keyId: by, record }
+            : { state: 'unchecked', why: 'unreadable' };
+    }
+    catch {
+        return { state: 'unchecked', why: 'unreadable' };
+    }
+}
+/** Checks a record, as shown, against its signed record and its verifier's published keys. */
+export function signature(evidence) {
+    const key = shown(evidence);
+    let checking = checks.get(key);
+    if (!checking) {
+        const checked = check(evidence);
+        checking = checked.then(({ record: _record, ...result }) => result);
+        checks.set(key, checking);
+        void checked.then((result) => {
+            // Nothing was learned, so the next card drawn asks again.
+            if (result.state === 'unchecked')
+                checks.delete(key);
+            if (result.state === 'invalid')
+                failures.add(key);
+            if (result.record) {
+                signedAs.set(key, result.record);
+                // Drawn from the signed record, it is asked about again as that has it. That is the
+                // same signed record and the same answer, so it is not read a second time.
+                const drawn = shown(result.record);
+                signedAs.set(drawn, result.record);
+                checks.set(drawn, checking);
+            }
+            // Told only where the record is now to be drawn some other way than it was read.
+            if (result.state === 'invalid' ||
+                (result.record && claims(result.record) !== claims(evidence)))
+                for (const listener of [...listeners])
+                    listener();
+        });
+    }
+    return checking;
+}
+/**
+ * The record as it may be shown. One whose signed record checked is shown as that has
+ * it, with only its present state taken from the record as read, so what stands beside the
+ * signature mark is what was signed. One whose signed record failed is not shown as verified: the
+ * verifier's own signature does not bear it out, so it reads as unconfirmed.
+ */
+export function standing(evidence) {
+    if (evidence.signedUrl === undefined)
+        return evidence;
+    const key = shown(evidence);
+    const signed = signedAs.get(key);
+    if (signed)
+        return {
+            ...signed,
+            status: evidence.status,
+            ...(evidence.revokedAt === undefined ? {} : { revokedAt: evidence.revokedAt }),
+        };
+    return evidence.status === 'verified' && failures.has(key)
+        ? { ...evidence, status: 'unconfirmed' }
+        : evidence;
+}
+/**
+ * Checks each signed record given and calls back when a check changes how one is to be
+ * drawn, so whoever drew them can draw them again. A record whose check has already come
+ * back is not asked about twice.
+ */
+export function watchSigned(records, changed) {
+    for (const record of records) {
+        if (record.signedUrl === undefined)
+            continue;
+        const key = shown(record);
+        if (failures.has(key) || signedAs.has(key))
+            continue;
+        void signature(record).then((result) => {
+            if (result.state === 'invalid' || claims(standing(record)) !== claims(record))
+                changed();
+        });
+    }
+}
+/** Tells a listener whenever a check changes how a record is to be drawn. Returns how to stop. */
+export function onSignatureResult(listener) {
+    listeners.add(listener);
+    return () => void listeners.delete(listener);
+}

package/dist/browser.d.ts

@@ -0,0 +1,3 @@
+/** Browser-safe public entry point: no Node, provider, or database modules. */
+export * from './core/index.js';
+export { init, presentConnections, type Result } from './browser/index.js';

package/dist/browser.js

@@ -0,0 +1,3 @@
+/** Browser-safe public entry point: no Node, provider, or database modules. */
+export * from './core/index.js';
+export { init, presentConnections } from './browser/index.js';