nervur 0.21.4 → 0.22.0

package/dist/harbor/relay.js

@@ -1,406 +0,0 @@
-// SPDX-License-Identifier: Apache-2.0
-// The relay: a harbor nobody dials is reached through a harbor that is,
-// by relations alone. Both sides are kit faculties, opened by the root.
-//
-// On the reached harbor, `org.nervur.relay`:
-//
-//   invite   { id, wards }        a relay client invited under `id`, its
-//                                 notes naming the ward pks it collects for
-//   release  { id }               that client let go, and every box waiting
-//                                 for its wards answered with nothing
-//   collect  { replies?, wait? }  asked by a client: the replies to the boxes
-//                                 it took last, handed to their callers, then
-//                                 the boxes waiting for its wards; with
-//                                 `wait`, it waits for one first
-//   bell     { endpoint }         asked by a client: the push endpoint rung
-//                                 when a box waits for it, or null for none
-//   key                           asked by a client: the key its device
-//                                 subscribes to pushes with
-//
-// A box for a ward a client collects for reaches this harbor on any
-// carrier, and the caller's dial waits for its reply, or for nothing once
-// `RELAY_WAIT` passes. No box is opened here. A box no waiting collect
-// takes rings the client's bell once, through a `Push` faculty the relay
-// lends, until the client collects again.
-//
-// On the harbor nobody dials, `org.nervur.relay-client`:
-//
-//   hold  { invitation, line?, every? }  the relay's invitation taken; a
-//                                        line collects always, `every`
-//                                        rings on a schedule, in ms
-//   ring                                 every waiting box collected, handed
-//                                        to this harbor's doors, and the
-//                                        replies returned: a doorbell
-//   bell  { endpoint }                   the relay's `bell`, asked
-//   key                                  the relay's `key`, asked
-//   drop                                 the relay let go
-//
-// Its harbor's `reach` names the relay's address, so every invitation it
-// gives sends callers there. Whatever hears a push on the device asks
-// `ring`.
-import { Faculty, isSilence, isWord, told } from '../being/index.js';
-import { hex, isHex, unhex } from '../crypto/index.js';
-import { readInvitation } from '../quo/index.js';
-import { ownerAsk } from '../ward/index.js';
-import { CarrierFaculty, UNDIALED } from './carrying.js';
-export const RELAY = 'org.nervur.relay';
-export const RELAY_CLIENT = 'org.nervur.relay-client';
-export const PUSH = 'org.nervur.push';
-// How long a box waits for its reply: a caller's allowance, unless it
-// asks for another.
-export const RELAY_WAIT = 30_000;
-// How long a collect with `wait` holds, inside the client's allowance.
-export const RELAY_HOLD = 20_000;
-// How long a line rests after a collect that reached nothing.
-export const RELAY_REST = 1_000;
-// The largest box a relay carries, so the collect answering it stays a
-// box Quo carries.
-export const RELAYED = 262_144;
-// The longest push endpoint a relay keeps.
-const ENDPOINT = 2_048;
-// The most boxes one collect hands over.
-const BATCH = 16;
-const CLIENT = 'relay';
-const PUSHER = 'push';
-// The contract of a ring with no content: `key` answers the key a device
-// subscribes with, and `ring { endpoint }` answers `rung`, `gone` where
-// the push service has let the endpoint go, or an error.
-export class Push extends Faculty {
-    static kind = PUSH;
-}
-const text = (v) => typeof v === 'string';
-const wardsOf = (notes) => (Array.isArray(notes?.relay) ? notes.relay.filter(text) : []);
-const collects = (_, notes) => wardsOf(notes).length > 0;
-const clientAsk = (description, input = {}) => ({ description, input: { type: 'object', ...input }, for: collects });
-const readReplies = (v) => v === undefined
-    ? []
-    : Array.isArray(v) && v.every((r) => typeof r === 'object' && r !== null && Number.isInteger(r.n) && (r.box === null || isHex(r.box, (r.box ?? '').length / 2)))
-        ? v
-        : null;
-// An answer, or the error it stands for.
-const answered = (out) => (isSilence(out) ? { error: 'silence' } : isWord(out) ? { error: told(out) } : out);
-export const relayFaculty = (clock) => class Relay extends CarrierFaculty {
-    static kind = RELAY;
-    static cells = { clients: {}, bells: {} };
-    static asks = {
-        invite: ownerAsk('a relay client, collecting for the ward pks named', { required: ['id', 'wards'] }),
-        release: ownerAsk('a relay client let go', { required: ['id'] }),
-        collect: clientAsk('the replies to the boxes taken last, then the boxes waiting'),
-        bell: clientAsk('the push endpoint rung when a box waits, or null', { required: ['endpoint'] }),
-        key: clientAsk('the key a device subscribes to pushes with'),
-    };
-    #n = 0;
-    #waiting = [];
-    #taken = new Map();
-    #collectors = new Set();
-    // The clients rung since they last collected.
-    #rung = new Set();
-    #lending;
-    accepts() {
-        return false;
-    }
-    dial() {
-        return Promise.resolve(UNDIALED);
-    }
-    get #clients() {
-        return this.cells.clients;
-    }
-    get #bells() {
-        return this.cells.bells;
-    }
-    relays(pk) {
-        return Object.values(this.#clients).some((wards) => wards.includes(pk));
-    }
-    relay(pk, bytes) {
-        if (!this.relays(pk) || bytes.length > RELAYED)
-            return Promise.resolve(null);
-        return new Promise((resolve) => {
-            const wait = clock.wait(RELAY_WAIT);
-            const box = { n: ++this.#n, ward: pk, bytes, answer: resolve, cancel: wait.cancel };
-            void wait.done.then(() => this.#settle(box, null));
-            this.#waiting.push(box);
-            let woken = false;
-            for (const collector of this.#collectors) {
-                if (!collector.wards.includes(pk))
-                    continue;
-                collector.wake();
-                woken = true;
-            }
-            if (woken)
-                return;
-            for (const [id, wards] of Object.entries(this.#clients)) {
-                if (!wards.includes(pk) || !Object.hasOwn(this.#bells, id) || this.#rung.has(id))
-                    continue;
-                this.#rung.add(id);
-                void this.#ring(id);
-            }
-        });
-    }
-    // Every box answered with nothing, and every collect woken.
-    sleep() {
-        for (const box of [...this.#waiting, ...this.#taken.values()])
-            this.#settle(box, null);
-        for (const collector of this.#collectors)
-            collector.wake();
-        return Promise.resolve();
-    }
-    async invite(args) {
-        const { id, wards } = args;
-        if (!text(id) || !Array.isArray(wards) || wards.length === 0 || !wards.every((w) => isHex(w, 64)))
-            return { error: 'id is text and wards a list of ward pks' };
-        if (Object.hasOwn(this.#clients, id))
-            return { error: 'that client is invited' };
-        const invitation = await this.stance.occupants.invite(id, { relay: wards });
-        if (invitation === null)
-            return { error: 'not invited' };
-        this.#clients[id] = [...wards];
-        return { invitation };
-    }
-    release(args) {
-        if (!text(args.id) || !Object.hasOwn(this.#clients, args.id))
-            return { error: 'no such client' };
-        this.stance.occupants.remove(args.id);
-        delete this.#clients[args.id];
-        delete this.#bells[args.id];
-        this.#rung.delete(args.id);
-        for (const box of [...this.#waiting, ...this.#taken.values()])
-            if (!this.relays(box.ward))
-                this.#settle(box, null);
-        return { released: args.id };
-    }
-    async collect(args, asker) {
-        const replies = readReplies(args.replies);
-        if (replies === null)
-            return { error: 'replies are a list of { n, box }' };
-        const id = asker.id;
-        this.#rung.delete(id);
-        const replied = new Set(replies.map((r) => r.n));
-        for (const { n, box } of replies) {
-            const taken = this.#taken.get(n);
-            if (taken?.collector === id)
-                this.#settle(taken, box === null ? null : unhex(box));
-        }
-        // A client answers every box it took in its next collect, so a box it
-        // left out never reached its doors, and waits again. A door that
-        // hears it twice answers the second as repeated.
-        for (const taken of [...this.#taken.values()]) {
-            if (taken.collector !== id || replied.has(taken.n))
-                continue;
-            this.#taken.delete(taken.n);
-            delete taken.collector;
-            this.#waiting.unshift(taken);
-        }
-        const wards = wardsOf(this.notes(asker));
-        if (args.wait === true && !this.#waiting.some((b) => wards.includes(b.ward)))
-            await this.#hold(wards);
-        const boxes = this.#waiting.filter((b) => wards.includes(b.ward)).slice(0, BATCH);
-        for (const box of boxes) {
-            this.#waiting.splice(this.#waiting.indexOf(box), 1);
-            box.collector = id;
-            this.#taken.set(box.n, box);
-        }
-        return { boxes: boxes.map(({ n, ward, bytes }) => ({ n, ward, box: hex(bytes) })) };
-    }
-    bell(args, asker) {
-        const { endpoint } = args;
-        const id = asker.id;
-        if (endpoint === null) {
-            delete this.#bells[id];
-            return { bell: null };
-        }
-        if (!text(endpoint) || endpoint.length > ENDPOINT || !/^https?:\/\//.test(endpoint))
-            return { error: 'endpoint is a web URL, or null' };
-        this.#bells[id] = endpoint;
-        return { bell: endpoint };
-    }
-    async key() {
-        const push = await this.#push();
-        return push ? answered(await push.ask('key')) : { error: 'no push faculty is open' };
-    }
-    // The client's bell rung. An endpoint the push service calls gone is
-    // forgotten, and kept at the relay's next arrival.
-    async #ring(id) {
-        const push = await this.#push();
-        const endpoint = this.#bells[id];
-        if (!push || endpoint === undefined)
-            return;
-        const out = answered(await push.ask('ring', { endpoint }));
-        if (out.gone === true && this.#bells[id] === endpoint)
-            delete this.#bells[id];
-    }
-    async #push() {
-        if (!this.stance.standings.get(PUSHER)) {
-            this.#lending ??= this.stance.lend(Push, PUSHER).finally(() => (this.#lending = undefined));
-            await this.#lending;
-        }
-        return this.stance.standings.get(PUSHER);
-    }
-    #hold(wards) {
-        return new Promise((resolve) => {
-            const wait = clock.wait(RELAY_HOLD);
-            const collector = {
-                wards,
-                wake: () => {
-                    wait.cancel();
-                    this.#collectors.delete(collector);
-                    resolve();
-                },
-            };
-            this.#collectors.add(collector);
-            void wait.done.then(collector.wake);
-        });
-    }
-    #settle(box, reply) {
-        box.cancel();
-        const at = this.#waiting.indexOf(box);
-        if (at >= 0)
-            this.#waiting.splice(at, 1);
-        this.#taken.delete(box.n);
-        box.answer(reply);
-    }
-};
-export const relayClient = (ground, clock) => class RelayClient extends CarrierFaculty {
-    static kind = RELAY_CLIENT;
-    static asks = {
-        hold: ownerAsk("a relay's invitation, collected from on a line, a schedule or a ring", { required: ['invitation'] }),
-        ring: ownerAsk('every waiting box collected and answered now'),
-        bell: ownerAsk('the push endpoint the relay rings, or null', { required: ['endpoint'] }),
-        key: ownerAsk('the key this device subscribes to pushes with'),
-        drop: ownerAsk('the relay let go'),
-    };
-    #awake = false;
-    #replies = [];
-    #turn = Promise.resolve();
-    // Ends every rest and schedule when the client sleeps or lets go.
-    #stop = () => { };
-    accepts() {
-        return false;
-    }
-    dial() {
-        return Promise.resolve(UNDIALED);
-    }
-    awake() {
-        if (!this.#awake) {
-            this.#awake = true;
-            this.#start();
-        }
-        return Promise.resolve();
-    }
-    sleep() {
-        this.#awake = false;
-        this.#stop();
-        return Promise.resolve();
-    }
-    async hold(args) {
-        const invitation = readInvitation(args.invitation);
-        const { line, every } = args;
-        if (invitation === null || (line !== undefined && typeof line !== 'boolean') || (every !== undefined && !(Number.isInteger(every) && every > 0))) {
-            return { error: 'an invitation, line a boolean and every a positive integer' };
-        }
-        if (this.stance.standings.get(CLIENT))
-            return { error: 'a relay is held' };
-        if ((await this.stance.standings.take(CLIENT, invitation)) === null)
-            return { error: 'not taken' };
-        this.cells.line = line === true;
-        if (every !== undefined)
-            this.cells.every = every;
-        this.#start();
-        return { held: invitation.ward };
-    }
-    async ring() {
-        if (!this.stance.standings.get(CLIENT))
-            return { error: 'no relay is held' };
-        let carried = 0;
-        for (;;) {
-            const sent = this.#replies.length;
-            const got = await this.#collect(false);
-            if (got === null)
-                return { error: 'the relay was not reached', carried };
-            carried += got;
-            if (got === 0 && sent === 0)
-                return { carried };
-        }
-    }
-    bell(args) {
-        return this.#relay('bell', { endpoint: args.endpoint ?? null });
-    }
-    key() {
-        return this.#relay('key');
-    }
-    drop() {
-        if (!this.stance.standings.remove(CLIENT))
-            return { error: 'no relay is held' };
-        delete this.cells.line;
-        delete this.cells.every;
-        this.#stop();
-        return { dropped: true };
-    }
-    async #relay(method, args = {}) {
-        const standing = this.stance.standings.get(CLIENT);
-        return standing ? answered(await standing.ask(method, args)) : { error: 'no relay is held' };
-    }
-    #start() {
-        if (!this.#awake || !this.stance.standings.get(CLIENT))
-            return;
-        this.#stop();
-        let stopped = false;
-        const rests = new Set();
-        this.#stop = () => {
-            stopped = true;
-            for (const end of rests)
-                end();
-        };
-        const rest = (ms) => new Promise((resolve) => {
-            const wait = clock.wait(ms);
-            const end = () => {
-                wait.cancel();
-                rests.delete(end);
-                resolve();
-            };
-            rests.add(end);
-            void wait.done.then(end);
-        });
-        const going = () => !stopped && this.stance.standings.get(CLIENT) !== undefined;
-        if (this.cells.line === true) {
-            void (async () => {
-                while (going())
-                    if ((await this.#collect(true)) === null && going())
-                        await rest(RELAY_REST);
-            })();
-        }
-        const every = this.cells.every;
-        if (every !== undefined) {
-            void (async () => {
-                for (await rest(every); going(); await rest(every))
-                    await this.ring();
-            })();
-        }
-    }
-    // One collect: the replies owed go with it, and each box it brings is
-    // handed to this harbor's doors. The number of boxes, or null where the
-    // relay was not reached.
-    // Collects run one after another, so each carries the replies to every
-    // box the one before it brought, as the relay counts on.
-    #collect(wait) {
-        const run = this.#turn.then(() => this.#collectNow(wait));
-        this.#turn = run.catch(() => undefined);
-        return run;
-    }
-    async #collectNow(wait) {
-        const standing = this.stance.standings.get(CLIENT);
-        if (!standing)
-            return null;
-        const replies = this.#replies.splice(0);
-        const out = await standing.ask('collect', { replies, wait });
-        const boxes = !isSilence(out) && !isWord(out) && Array.isArray(out.boxes) ? out.boxes : null;
-        if (boxes === null) {
-            this.#replies.unshift(...replies);
-            return null;
-        }
-        for (const { n, ward, box } of boxes) {
-            const reply = text(ward) && text(box) && isHex(box, box.length / 2) ? await ground.arrive(ward, unhex(box)) : null;
-            this.#replies.push({ n: n, box: reply === null ? null : hex(reply) });
-        }
-        return boxes.length;
-    }
-};

package/dist/harbor/root-line.d.ts

@@ -1,9 +0,0 @@
-import { type JsonObject } from '../being/index.ts';
-import type { Harbor } from './harbor.ts';
-export type RootRequest = {
-    ward?: string;
-    method?: string;
-    args?: JsonObject;
-};
-export declare const readRootRequest: (value: unknown) => RootRequest | null;
-export declare const rootLine: (harbor: Harbor, value: unknown) => Promise<JsonObject>;

package/dist/harbor/root-line.js

@@ -1,38 +0,0 @@
-// SPDX-License-Identifier: Apache-2.0
-// The root line: one request, one answer, both plain JSON, for whatever
-// carries the root's asks to a harbor in its own process. The command line
-// carries it over a local socket, and an edge route carries it the same way.
-//
-//   request  { ward?, method?, args? }    no ward is the box ward, no
-//                                         method the census
-//   answer   { answer }                   what the ward-being said
-//            { silence: true }            she said nothing
-//            { word }                     a kit word: unreached, late, ...
-//            { error }                    the request was not one, or the
-//                                         ward is none this harbor holds
-import { isSilence, isWord, told } from '../being/index.js';
-const object = (v) => typeof v === 'object' && v !== null && !Array.isArray(v);
-export const readRootRequest = (value) => {
-    if (!object(value))
-        return null;
-    const { ward, method, args } = value;
-    if ((ward !== undefined && typeof ward !== 'string') || (method !== undefined && typeof method !== 'string') || (args !== undefined && !object(args)))
-        return null;
-    return { ...(ward === undefined ? {} : { ward }), ...(method === undefined ? {} : { method }), ...(args === undefined ? {} : { args }) };
-};
-export const rootLine = async (harbor, value) => {
-    const request = readRootRequest(value);
-    if (request === null)
-        return { error: 'not a root request' };
-    const ward = request.ward === undefined ? harbor.box : harbor.ward(request.ward);
-    if (ward === undefined) {
-        const failed = request.ward === undefined ? undefined : harbor.failures().wards[request.ward];
-        return failed === undefined ? { error: 'no such ward' } : { error: 'the ward did not stand', reason: failed };
-    }
-    const out = await ward.root(request.method, request.args);
-    if (isSilence(out))
-        return { silence: true };
-    if (isWord(out))
-        return { word: told(out) };
-    return { answer: out };
-};

package/dist/harbor/store.d.ts

@@ -1,13 +0,0 @@
-import { Faculty, type BeingClass } from '../being/index.ts';
-import type { Memory } from '../contract/index.ts';
-export declare const STORE = "org.nervur.store";
-export declare const GROUND_STORE = "org.nervur.ground-store";
-export declare abstract class Store extends Faculty {
-    static readonly kind: string;
-    abstract read(place: string): Promise<Map<string, Uint8Array>>;
-    abstract write(place: string, entries: ReadonlyMap<string, Uint8Array | null>): Promise<void>;
-    abstract places(): Promise<string[]>;
-    abstract forget(place: string): Promise<void>;
-    occupies(_place: string): boolean;
-}
-export declare const groundStore: (memory: Memory) => BeingClass;

package/dist/harbor/store.js

@@ -1,53 +0,0 @@
-// SPDX-License-Identifier: Apache-2.0
-// The store: a faculty that keeps a hosted ward's place, where the root
-// memory does not. It makes the same promise the Memory body makes, lent
-// once the dock stands: sealed entries in places, each keep whole or not
-// at all. The box ward never moves off the root memory, since the store
-// itself stands from the box ward's cells.
-//
-// A ward is the unit a keeper holds: its head, its ward-being and every
-// being of it are one place and one keep, so an answer's cells and the
-// door's keys move together, whoever keeps them.
-//
-// The kit ships `org.nervur.ground-store` on every ground: places of the
-// terrain's own memory under the faculty's key, so a store stands wherever
-// a harbor does. A store of a cloud, a database or a ledger is a class
-// fulfilling `org.nervur.store`, handed to the catalogue in a module.
-import { Faculty } from '../being/index.js';
-import { hex, utf8 } from '../crypto/index.js';
-export const STORE = 'org.nervur.store';
-export const GROUND_STORE = 'org.nervur.ground-store';
-export class Store extends Faculty {
-    static kind = STORE;
-    // Whether a place of the root memory is this store's own, so the root's
-    // sweep leaves it.
-    occupies(_place) {
-        return false;
-    }
-}
-// A place of the package is thirty-two hex digits.
-const PLACE = 32;
-// The store over the terrain's memory, made for one harbor. Its places are
-// the package's, behind the hex of the faculty's key, so two stores and the
-// root never meet in one place.
-export const groundStore = (memory) => class GroundStore extends Store {
-    static kind = GROUND_STORE;
-    get #prefix() {
-        return hex(utf8(this.stance.key));
-    }
-    occupies(place) {
-        return place.length === this.#prefix.length + PLACE && place.startsWith(this.#prefix);
-    }
-    read(place) {
-        return memory.read(this.#prefix + place);
-    }
-    write(place, entries) {
-        return memory.write(this.#prefix + place, entries);
-    }
-    async places() {
-        return (await memory.places()).filter((place) => this.occupies(place)).map((place) => place.slice(this.#prefix.length));
-    }
-    forget(place) {
-        return memory.forget(this.#prefix + place);
-    }
-};

package/dist/http/index.d.ts

@@ -1,4 +0,0 @@
-import type { Ground, GroundFaculty } from '../harbor/index.ts';
-import { type WebListen, type WebListener } from '../line/index.ts';
-export declare const webServe: (ground: Ground, listen: WebListen) => Promise<WebListener>;
-export declare const webGround: GroundFaculty;

package/dist/line/ground.js

@@ -1,9 +0,0 @@
-import { HeldLoader, PointerTerrain } from '../pointer/index.js';
-import { webPush } from './push.js';
-import { WEB_OPENING, webFaculty } from './web.js';
-export const NEUTRAL = 'neutral';
-export const neutralGround = {
-    name: NEUTRAL,
-    fits: () => true,
-    terrain: ({ modules = [] }) => new PointerTerrain({ loader: new HeldLoader(modules), faculties: [webFaculty(), webPush], opens: [WEB_OPENING] }),
-};

package/dist/line/index.d.ts

@@ -1,5 +0,0 @@
-export { ASK, askBody, askFrame, FrameReader, MAX_BODY, NOTHING, nothingBody, nothingFrame, readBody, REPLY, replyBody, replyFrame, TCP, TCP_OPENING, type Frame } from './frame.ts';
-export { answerHeld, answerPost, type HeldSide } from './answer.ts';
-export { NEUTRAL, neutralGround } from './ground.ts';
-export { base64url, PUSH_TTL, pushEndpoint, VAPID_LIFE, WEB_PUSH, webPush } from './push.ts';
-export { MAX_POST, MIN_POST, readPost, WEB, WEB_OPENING, WebDialer, webFaculty, type WebListen, type WebListener, type WebServe } from './web.ts';

package/dist/line/index.js

@@ -1,9 +0,0 @@
-// SPDX-License-Identifier: Apache-2.0
-// The lines Quo is carried on, with no platform under them: the frames
-// both published carriers share, the web carrier on fetch and the
-// WebSocket client, and a ring with no content as Web Push sends it.
-export { ASK, askBody, askFrame, FrameReader, MAX_BODY, NOTHING, nothingBody, nothingFrame, readBody, REPLY, replyBody, replyFrame, TCP, TCP_OPENING } from './frame.js';
-export { answerHeld, answerPost } from './answer.js';
-export { NEUTRAL, neutralGround } from './ground.js';
-export { base64url, PUSH_TTL, pushEndpoint, VAPID_LIFE, WEB_PUSH, webPush } from './push.js';
-export { MAX_POST, MIN_POST, readPost, WEB, WEB_OPENING, WebDialer, webFaculty } from './web.js';

package/dist/line/push.d.ts

@@ -1,7 +0,0 @@
-import { type GroundFaculty } from '../harbor/index.ts';
-export declare const WEB_PUSH = "org.nervur.web-push";
-export declare const PUSH_TTL = 60;
-export declare const VAPID_LIFE = 43200;
-export declare const base64url: (bytes: Uint8Array) => string;
-export declare const pushEndpoint: (value: unknown) => URL | null;
-export declare const webPush: GroundFaculty;

package/dist/line/push.js

@@ -1,92 +0,0 @@
-import { concat, utf8 } from '../crypto/index.js';
-import { Push } from '../harbor/index.js';
-import { ownerAsk } from '../ward/index.js';
-export const WEB_PUSH = 'org.nervur.web-push';
-// How long a push service holds a ring for a device, in seconds.
-export const PUSH_TTL = 60;
-// How long a VAPID token stands, in seconds, inside RFC 8292's day.
-export const VAPID_LIFE = 43_200;
-const EC = { name: 'ECDSA', namedCurve: 'P-256' };
-export const base64url = (bytes) => {
-    let s = '';
-    for (const b of bytes)
-        s += String.fromCharCode(b);
-    return btoa(s).replace(/\+/g, '-').replace(/\//g, '_').replace(/=+$/, '');
-};
-const unbase64url = (text) => Uint8Array.from(atob(text.replace(/-/g, '+').replace(/_/g, '/')), (c) => c.charCodeAt(0));
-const local = (host) => host === '127.0.0.1' || host === 'localhost' || host === '[::1]';
-// A push endpoint: an https URL, or plain http to this machine alone.
-export const pushEndpoint = (value) => {
-    if (typeof value !== 'string')
-        return null;
-    try {
-        const url = new URL(value);
-        return url.protocol === 'https:' || (url.protocol === 'http:' && local(url.hostname)) ? url : null;
-    }
-    catch {
-        return null;
-    }
-};
-const isSubject = (value) => typeof value === 'string' && /^(mailto:.+|https:\/\/.+)$/.test(value);
-export const webPush = () => class WebPush extends Push {
-    static kind = WEB_PUSH;
-    static asks = {
-        subject: ownerAsk('the contact a push service reaches, a mailto: or https: URI', { required: ['subject'] }),
-        key: { description: 'the key a device subscribes to pushes with', input: { type: 'object' } },
-        ring: { description: 'a ring with no content to a push endpoint', input: { type: 'object', required: ['endpoint'] } },
-    };
-    #drawing;
-    subject(args) {
-        if (!isSubject(args.subject))
-            return { error: 'subject is a mailto: or https: URI' };
-        this.cells.subject = args.subject;
-        return { subject: args.subject };
-    }
-    async key() {
-        return { key: WebPush.#public(await this.#vapid()) };
-    }
-    async ring(args) {
-        const endpoint = pushEndpoint(args.endpoint);
-        if (endpoint === null)
-            return { error: 'endpoint is an https URL' };
-        const sub = this.cells.subject;
-        if (!isSubject(sub))
-            return { error: 'no subject is set' };
-        const vapid = await this.#vapid();
-        const signing = await crypto.subtle.importKey('jwk', { kty: 'EC', crv: 'P-256', ...vapid }, EC, false, ['sign']);
-        const part = (value) => base64url(utf8(JSON.stringify(value)));
-        const unsigned = `${part({ typ: 'JWT', alg: 'ES256' })}.${part({ aud: endpoint.origin, exp: Math.floor(Date.now() / 1000) + VAPID_LIFE, sub })}`;
-        const signature = new Uint8Array(await crypto.subtle.sign({ name: 'ECDSA', hash: 'SHA-256' }, signing, new Uint8Array(utf8(unsigned))));
-        let status;
-        try {
-            const response = await fetch(endpoint, {
-                method: 'POST',
-                headers: { TTL: String(PUSH_TTL), Urgency: 'high', 'Content-Length': '0', Authorization: `vapid t=${unsigned}.${base64url(signature)}, k=${WebPush.#public(vapid)}` },
-            });
-            status = response.status;
-            await response.body?.cancel();
-        }
-        catch {
-            return { error: 'the push service was not reached' };
-        }
-        if (status === 404 || status === 410)
-            return { gone: true };
-        return status >= 200 && status < 300 ? { rung: true } : { error: `the push service answered ${String(status)}` };
-    }
-    static #public({ x, y }) {
-        return base64url(concat(Uint8Array.of(4), unbase64url(x), unbase64url(y)));
-    }
-    #vapid() {
-        const kept = this.cells.vapid;
-        if (kept)
-            return Promise.resolve(kept);
-        this.#drawing ??= (async () => {
-            const pair = await crypto.subtle.generateKey(EC, true, ['sign']);
-            const { d, x, y } = await crypto.subtle.exportKey('jwk', pair.privateKey);
-            const vapid = { d: d, x: x, y: y };
-            this.cells.vapid = vapid;
-            return vapid;
-        })();
-        return this.#drawing;
-    }
-};