nervur 0.23.0 → 0.24.0

package/dist/bodies/web-carry.js

@@ -1,245 +0,0 @@
-import { ASK, NOTHING, PK, REPLY, body, privateHost, read } from '../quo/frame.js';
-import { vouchesOf } from './vouch.js';
-/** The longest post: a ward pk and the longest box. */
-const LONGEST_POST = 1_048_640;
-const PROTOCOL = 'quo';
-// Errors of a connection never made: the box went nowhere.
-const UNREACHED = new Set(['ECONNREFUSED', 'ENOTFOUND', 'EAI_AGAIN', 'EHOSTUNREACH', 'ENETUNREACH', 'UND_ERR_CONNECT_TIMEOUT']);
-const hex = (bytes) => Array.from(bytes, (byte) => byte.toString(16).padStart(2, '0')).join('');
-const unhex = (text) => Uint8Array.from(text.match(/../g) ?? [], (pair) => Number.parseInt(pair, 16));
-const joined = (a, b) => {
-    const out = new Uint8Array(a.length + b.length);
-    out.set(a);
-    out.set(b, a.length);
-    return out;
-};
-export class WebCarry {
-    #doors = new Map();
-    #lines = new Map();
-    #path;
-    #addresses;
-    #origins;
-    #allowPrivate;
-    #wait;
-    /**
-     * `path` is where it listens under the ground's listener, `/quo` where
-     * omitted. `addresses` are written into invitations, or read each time
-     * where the listener's port is known only once it listens. `origins` are
-     * the pages of other origins it answers, by the CORS protocol.
-     */
-    constructor({ path = '/quo', addresses = [], origins = [], allowPrivate = false, wait = 30_000, } = {}) {
-        this.#path = path;
-        this.#addresses = addresses;
-        this.#origins = new Set(origins);
-        this.#allowPrivate = allowPrivate;
-        this.#wait = wait;
-    }
-    /** A ward's door, answered on the post and on held lines alike. */
-    listen({ ward, door }) {
-        this.#doors.set(ward, door);
-    }
-    /** A ward this handler answers no more. */
-    unlisten({ ward }) {
-        this.#doors.delete(ward);
-    }
-    at(_options = {}) {
-        return typeof this.#addresses === 'function' ? this.#addresses() : this.#addresses;
-    }
-    /** The hosts of its `https` and `wss` addresses that vouch for the ward, each read over TLS. */
-    vouched({ ward, at }) {
-        return vouchesOf({ fetcher: (url, init) => fetch(url, init), ward, at, schemes: ['https', 'wss'], allowPrivate: this.#allowPrivate, wait: this.#wait });
-    }
-    // ---- the listener ----
-    #cors(request) {
-        const origin = request.headers.get('origin');
-        return origin !== null && (this.#origins.has(origin) || this.#origins.has('*')) ? { 'access-control-allow-origin': origin, vary: 'origin' } : {};
-    }
-    // A page reaches the door from its own host, or from an origin the carry
-    // names. A request that names no origin is no page's, and is let in.
-    #admits(request) {
-        const origin = request.headers.get('origin');
-        if (origin === null || this.#origins.has(origin) || this.#origins.has('*'))
-            return true;
-        try {
-            return new URL(origin).host === new URL(request.url).host;
-        }
-        catch {
-            return false;
-        }
-    }
-    async fetch(request) {
-        if (new URL(request.url).pathname !== this.#path)
-            return null;
-        const cors = this.#cors(request);
-        if (request.method === 'OPTIONS' && 'access-control-allow-origin' in cors) {
-            return new Response(null, { status: 204, headers: { ...cors, 'access-control-allow-methods': 'POST', 'access-control-allow-headers': 'content-type' } });
-        }
-        if (request.method !== 'POST')
-            return new Response(null, { status: 405, headers: cors });
-        if (!this.#admits(request))
-            return new Response(null, { status: 403 });
-        const bytes = new Uint8Array(await request.arrayBuffer());
-        if (bytes.length <= PK || bytes.length > LONGEST_POST)
-            return new Response(null, { status: 400, headers: cors });
-        const door = this.#doors.get(hex(bytes.subarray(0, PK)));
-        if (door === undefined)
-            return new Response(null, { status: 404, headers: cors });
-        const reply = await door(bytes.slice(PK)).catch(() => null);
-        if (reply === null)
-            return new Response(null, { status: 204, headers: cors });
-        return new Response(new Uint8Array(reply), { status: 200, headers: { ...cors, 'content-type': 'application/octet-stream' } });
-    }
-    upgrade(request) {
-        if (new URL(request.url).pathname !== this.#path)
-            return null;
-        const offered = (request.headers.get('sec-websocket-protocol') ?? '').split(',').map((protocol) => protocol.trim());
-        if (!offered.includes(PROTOCOL) || !this.#admits(request))
-            return null;
-        return {
-            protocol: PROTOCOL,
-            open: (socket) => ({
-                message: (data) => {
-                    const frame = typeof data === 'string' ? null : read(data);
-                    if (frame === null)
-                        return socket.close();
-                    // A reply or a nothing frame is not a listener's to read.
-                    if (frame.kind !== ASK)
-                        return;
-                    const door = this.#doors.get(hex(frame.rest.subarray(0, PK)));
-                    return (door === undefined ? Promise.resolve(null) : door(frame.rest.slice(PK)).catch(() => null)).then((reply) => {
-                        try {
-                            socket.send(reply === null ? body(NOTHING, frame.id, new Uint8Array()) : body(REPLY, frame.id, reply));
-                        }
-                        catch {
-                            // The line went while the door answered.
-                        }
-                    });
-                },
-                close: () => undefined,
-            }),
-        };
-    }
-    // ---- the dialer ----
-    async send({ ward, at, box, wait = this.#wait }) {
-        // A ward this carry listens for is on this ground: its door takes the box by pointer.
-        const door = this.#doors.get(ward);
-        if (door !== undefined) {
-            const reply = await door(box).catch(() => null);
-            if (reply !== null)
-                return { reply };
-        }
-        for (const address of at) {
-            let url;
-            try {
-                url = new URL(address);
-            }
-            catch {
-                continue;
-            }
-            if (!this.#allowPrivate && privateHost(url.hostname))
-                continue;
-            const scheme = url.protocol.slice(0, -1);
-            const answer = scheme === 'http' || scheme === 'https' ? await this.#post(address, ward, box, wait) : scheme === 'ws' || scheme === 'wss' ? await this.#held(address, ward, box, wait) : 'unheard';
-            // A reply ends it; an ask that may have been heard is not carried again.
-            if (answer === 'heard')
-                return { reply: null, heard: true };
-            if (answer !== 'unheard')
-                return { reply: answer, via: address };
-        }
-        return { reply: null, heard: false };
-    }
-    async #post(address, ward, box, wait) {
-        const abort = new AbortController();
-        const timer = setTimeout(() => abort.abort(), wait);
-        try {
-            // A redirect is never followed, so no answer leads the box to an address its check never read.
-            const response = await fetch(address, { method: 'POST', body: joined(unhex(ward), box), signal: abort.signal, redirect: 'error' });
-            if (response.status !== 200) {
-                await response.body?.cancel();
-                return 'unheard';
-            }
-            const reply = new Uint8Array(await response.arrayBuffer());
-            return reply.length > 0 ? reply : 'unheard';
-        }
-        catch (error) {
-            // A connection never made, or a port the fetch standard blocks, sent nothing.
-            const cause = error.cause;
-            const unsent = (typeof cause?.code === 'string' && UNREACHED.has(cause.code)) || cause?.message === 'bad port';
-            return !abort.signal.aborted && unsent ? 'unheard' : 'heard';
-        }
-        finally {
-            clearTimeout(timer);
-        }
-    }
-    async #held(address, ward, box, wait) {
-        let line;
-        try {
-            line = await this.#line(address);
-        }
-        catch {
-            return 'unheard';
-        }
-        const id = line.next;
-        line.next = (line.next + 1) >>> 0;
-        const answered = new Promise((resolve) => line.pending.set(id, resolve));
-        try {
-            line.socket.send(body(ASK, id, joined(unhex(ward), box)));
-        }
-        catch {
-            line.pending.delete(id);
-            return 'unheard';
-        }
-        let timer;
-        const late = new Promise((resolve) => (timer = setTimeout(() => resolve(null), wait)));
-        const frame = await Promise.race([answered, late]);
-        clearTimeout(timer);
-        line.pending.delete(id);
-        if (frame === null)
-            return 'heard';
-        return frame.kind === REPLY ? frame.rest : 'unheard';
-    }
-    #line(address) {
-        let held = this.#lines.get(address);
-        if (held === undefined) {
-            held = new Promise((resolve, reject) => {
-                const socket = new WebSocket(address, [PROTOCOL]);
-                socket.binaryType = 'arraybuffer';
-                const line = { socket, pending: new Map(), next: 1 };
-                let open = false;
-                socket.onopen = () => {
-                    if (socket.protocol !== PROTOCOL)
-                        return socket.close();
-                    open = true;
-                    resolve(line);
-                };
-                socket.onmessage = (event) => {
-                    const frame = typeof event.data === 'string' ? null : read(new Uint8Array(event.data));
-                    if (frame === null)
-                        return socket.close();
-                    // An ask is not a dialer's to read: nothing is said to it, and the line stands.
-                    if (frame.kind === ASK)
-                        return;
-                    line.pending.get(frame.id)?.(frame);
-                };
-                socket.onclose = () => {
-                    this.#lines.delete(address);
-                    for (const settle of line.pending.values())
-                        settle(null);
-                    line.pending.clear();
-                    if (!open)
-                        reject(new Error(`no held line to ${address}`));
-                };
-                socket.onerror = () => undefined;
-            });
-            this.#lines.set(address, held);
-            held.catch(() => this.#lines.delete(address));
-        }
-        return held;
-    }
-    /** Closes every held line it dialled. */
-    async close() {
-        for (const line of this.#lines.values())
-            void line.then((held) => held.socket.close(), () => undefined);
-        this.#lines.clear();
-    }
-}

package/dist/bodies/web-clock.d.ts

@@ -1,12 +0,0 @@
-import type { Clock } from '../foundation.ts';
-export declare class WebClock implements Clock {
-    #private;
-    now(): number;
-    wait({ id, ms }: {
-        id: string;
-        ms: number;
-    }): Promise<boolean>;
-    cancel({ id }: {
-        id: string;
-    }): void;
-}

package/dist/bodies/web-clock.js

@@ -1,33 +0,0 @@
-// A timer holds at most this long; a longer wait is a chain of them.
-const LONGEST = 2 ** 31 - 1;
-export class WebClock {
-    #waits = new Map();
-    now() {
-        return Date.now();
-    }
-    wait({ id, ms }) {
-        this.cancel({ id });
-        const at = Date.now() + Math.max(0, ms);
-        return new Promise((resolve) => {
-            const arm = () => {
-                const left = at - Date.now();
-                const timer = setTimeout(() => {
-                    if (at > Date.now())
-                        return arm();
-                    this.#waits.delete(id);
-                    resolve(true);
-                }, Math.min(Math.max(0, left), LONGEST));
-                this.#waits.set(id, { timer, resolve });
-            };
-            arm();
-        });
-    }
-    cancel({ id }) {
-        const held = this.#waits.get(id);
-        if (held === undefined)
-            return;
-        clearTimeout(held.timer);
-        this.#waits.delete(id);
-        held.resolve(false);
-    }
-}

package/dist/browser/browser-ground.d.ts

@@ -1,76 +0,0 @@
-import type { Json } from '../being/being.ts';
-import type { Memory } from '../foundation.ts';
-import { Ground, type Registry, type Unlock } from '../ground/ground.ts';
-import type { Answer } from '../house/rows-shape.ts';
-import { type Load } from './origin-classes.ts';
-/** What the ground takes of its engine. Each is the page's own where omitted. */
-export interface BrowserPlatform {
-    readonly locks: Pick<LockManager, 'request'>;
-    readonly channel: (name: string) => Pick<BroadcastChannel, 'postMessage' | 'close'> & {
-        onmessage: ((event: MessageEvent) => void) | null;
-    };
-    /** Where its code stands; its classes load from under it alone. */
-    readonly origin: string;
-    /** Asks the browser to keep its storage, and answers whether it will. */
-    readonly persist: () => Promise<boolean>;
-    /** Loads a module of classes by URL: `import()`, or in a service worker a map of the worker's own imports. */
-    readonly load: Load;
-}
-/**
- * Where its key and its memory rest: the terrain's own, never the
- * drawer's, since the drawer is read with them. A BrowserGround's are the
- * origin's IndexedDB; an AppGround's are the shell's. No entry exports
- * this.
- */
-export interface Stores {
-    readonly unlock: (name: string) => Promise<Unlock>;
-    readonly memory: (name: string) => Promise<Memory>;
-}
-/** The origin's ground on stores of the terrain's own: an AppGround's, or a proof's in memory. No entry exports it. */
-export declare const openOn: (options: BrowserGroundOptions, stores: Stores) => Promise<BrowserGround>;
-export interface BrowserGroundOptions {
-    /** The ground's name on its origin, which names its lock, its channel and its storage. `nervur` where omitted. */
-    readonly name?: string;
-    /** The page's own registry, which joins the terrain's as the ladder's first rung. */
-    readonly registry?: Registry;
-    readonly platform?: Partial<BrowserPlatform>;
-    /** The ground's bound on every ask, in milliseconds. */
-    readonly wait?: number;
-    /** Whether it dials private and loopback addresses, as a page on localhost does. */
-    readonly allowPrivate?: boolean;
-}
-/** One request of the hand, as every terrain serves it: `describe`, or an ask of a being in the house it names, or of the dock's steward where it names none. */
-export interface BrowserHandRequest {
-    readonly describe?: true;
-    readonly house?: string;
-    readonly id?: string;
-    readonly method?: string;
-    readonly args?: Json;
-    readonly after?: Answer;
-    readonly cells?: true;
-    readonly call?: string;
-}
-export declare class BrowserGround {
-    #private;
-    private constructor();
-    /**
-     * The origin's ground, joined: this page runs it where it takes the lock,
-     * and reaches the page that runs it where another holds the lock.
-     */
-    static open(options?: BrowserGroundOptions): Promise<BrowserGround>;
-    /** Whether this page runs the ground now. */
-    get leading(): boolean;
-    /** The ground, where this page runs it. */
-    get ground(): Ground | undefined;
-    /** Resolves once this page runs the ground, and rejects where its boot failed. */
-    led(): Promise<void>;
-    /**
-     * The hand: `describe`, or an ask of a being in a named house or of the
-     * dock's steward, answered by whichever page runs the ground.
-     */
-    hand(request: BrowserHandRequest): Promise<Answer | {
-        readonly describe: Json;
-    }>;
-    /** This page leaves: its ground closes where it ran one, and the lock passes to the next page. */
-    close(): Promise<void>;
-}

package/dist/browser/browser-ground.js

@@ -1,294 +0,0 @@
-var __rewriteRelativeImportExtension = (this && this.__rewriteRelativeImportExtension) || function (path, preserveJsx) {
-    if (typeof path === "string" && /^\.\.?\//.test(path)) {
-        return path.replace(/\.(tsx)$|((?:\.d)?)((?:\.[^./]+?)?)\.([cm]?)ts$/i, function (m, tsx, d, ext, cm) {
-            return tsx ? preserveJsx ? ".jsx" : ".js" : d && (!ext || !cm) ? m : (d + ext + "." + cm.toLowerCase() + "js");
-        });
-    }
-    return path;
-};
-import { s } from '../being/schema.js';
-import { WebCarry } from '../bodies/web-carry.js';
-import { Ground, joinedRegistry } from '../ground/ground.js';
-import { IndexedDbMemory } from './indexeddb-memory.js';
-import { LockedUnlock } from './locked-unlock.js';
-import { OriginClasses } from './origin-classes.js';
-const originStores = {
-    unlock: (unlock) => LockedUnlock.open(unlock),
-    memory: (memory) => IndexedDbMemory.open(memory),
-};
-let joinOn;
-/** The origin's ground on stores of the terrain's own: an AppGround's, or a proof's in memory. No entry exports it. */
-export const openOn = (options, stores) => joinOn(options, stores);
-const NAME = /^[a-z0-9][a-z0-9._-]{0,63}$/;
-const NONE = { args: s.object({}) };
-const random = () => Array.from(crypto.getRandomValues(new Uint8Array(8)), (byte) => byte.toString(16).padStart(2, '0')).join('');
-const defaults = (name) => ({
-    locks: navigator.locks,
-    channel: (channel) => new BroadcastChannel(channel),
-    origin: globalThis.location?.origin ?? `nervur:${name}`,
-    persist: async () => (await navigator.storage?.persist?.()) ?? false,
-    load: (href) => import(__rewriteRelativeImportExtension(href)),
-});
-export class BrowserGround {
-    #name;
-    #platform;
-    #stores;
-    #options;
-    #self = random();
-    #channel;
-    #abort = new AbortController();
-    // Asks sent to another page's ground, by id, with the page they went to.
-    #pending = new Map();
-    #ground;
-    #persisted = false;
-    #leader;
-    #waiting = [];
-    #release;
-    #leading;
-    #led;
-    #failed;
-    #closed = false;
-    constructor(name, platform, stores, options) {
-        this.#name = name;
-        this.#platform = platform;
-        this.#stores = stores;
-        this.#options = options;
-        this.#channel = platform.channel(`${name}-hand`);
-        this.#leading = new Promise((resolve, reject) => {
-            this.#led = resolve;
-            this.#failed = reject;
-        });
-        this.#leading.catch(() => undefined);
-    }
-    /**
-     * The origin's ground, joined: this page runs it where it takes the lock,
-     * and reaches the page that runs it where another holds the lock.
-     */
-    static open(options = {}) {
-        return BrowserGround.#join(options, originStores);
-    }
-    static async #join(options, stores) {
-        const name = options.name ?? 'nervur';
-        if (!NAME.test(name))
-            throw new TypeError(`no ground is named ${name}`);
-        const platform = { ...defaults(name), ...options.platform };
-        const joining = new BrowserGround(name, platform, stores, options);
-        joining.#listen();
-        joining.#queue();
-        joining.#say({ kind: 'who' });
-        return joining;
-    }
-    static {
-        joinOn = (options, stores) => BrowserGround.#join(options, stores);
-    }
-    /** Whether this page runs the ground now. */
-    get leading() {
-        return this.#ground !== undefined;
-    }
-    /** The ground, where this page runs it. */
-    get ground() {
-        return this.#ground;
-    }
-    /** Resolves once this page runs the ground, and rejects where its boot failed. */
-    led() {
-        return this.#leading;
-    }
-    /**
-     * The hand: `describe`, or an ask of a being in a named house or of the
-     * dock's steward, answered by whichever page runs the ground.
-     */
-    async hand(request) {
-        if (this.#closed)
-            return { error: { message: 'the ground is closed here' } };
-        if (this.#ground !== undefined)
-            return this.#local(request);
-        if (this.#leader === undefined)
-            await new Promise((resolve) => this.#waiting.push(resolve));
-        if (this.#ground !== undefined)
-            return this.#local(request);
-        const id = random();
-        const to = this.#leader;
-        return new Promise((settle) => {
-            this.#pending.set(id, { to, settle });
-            this.#say({ kind: 'ask', id, to, request });
-        });
-    }
-    async #local(request) {
-        const answer = await this.#ground.hand(request);
-        if (request.describe === true && 'result' in answer)
-            return { result: { ...answer.result, persisted: this.#persisted } };
-        return answer;
-    }
-    #say(said) {
-        this.#channel.postMessage(said);
-    }
-    #listen() {
-        this.#channel.onmessage = (event) => {
-            const said = event.data;
-            if (said.kind === 'who' && this.#ground !== undefined)
-                this.#say({ kind: 'up', leader: this.#self });
-            else if (said.kind === 'up')
-                this.#heard(said.leader);
-            else if (said.kind === 'answer') {
-                const pending = this.#pending.get(said.id);
-                this.#pending.delete(said.id);
-                pending?.settle(said.answer);
-            }
-        };
-    }
-    // A new page runs the ground: asks sent to the one before may never be answered, so they fail, and whoever waited goes on.
-    #heard(leader) {
-        if (leader !== this.#leader)
-            this.#orphan((to) => to !== leader);
-        this.#leader = leader;
-        const waiting = this.#waiting;
-        this.#waiting = [];
-        for (const resolve of waiting)
-            resolve();
-    }
-    #orphan(lost) {
-        for (const [id, pending] of this.#pending) {
-            if (!lost(pending.to))
-                continue;
-            this.#pending.delete(id);
-            pending.settle({ error: { message: 'the page that ran the ground closed; ask again' } });
-        }
-    }
-    // The lock, asked once and held until this page closes.
-    #queue() {
-        this.#platform.locks
-            .request(`${this.#name}-ground`, { signal: this.#abort.signal }, async () => {
-            let booted;
-            try {
-                booted = await this.#boot();
-            }
-            catch (error) {
-                this.#failed(error);
-                return;
-            }
-            // A page that closed while its boot ran lets the ground go at once, and the lock with it.
-            if (this.#closed) {
-                await booted.close();
-                return;
-            }
-            this.#ground = booted;
-            this.#heard(this.#self);
-            this.#say({ kind: 'up', leader: this.#self });
-            this.#led();
-            await new Promise((resolve) => {
-                this.#release = resolve;
-            });
-        })
-            .catch(() => undefined);
-    }
-    // The boot: its own unlock and memory, then the ground on them, its ladder and its drawer's houses.
-    async #boot() {
-        const name = this.#name;
-        const platform = this.#platform;
-        const stores = this.#stores;
-        this.#persisted = await platform.persist().catch(() => false);
-        // Each store it opens is let go when its body goes down, so the next ground in this page opens on none of its.
-        const closing = (opened) => () => opened.close?.();
-        const own = {
-            faculties: {
-                'store-unlock': {
-                    takes: NONE,
-                    up: async () => {
-                        const unlock = await stores.unlock(`${name}-unlock`);
-                        return { serves: 'unlock', object: unlock, down: closing(unlock) };
-                    },
-                },
-                'store-memory': {
-                    takes: NONE,
-                    up: async () => {
-                        const memory = await stores.memory(`${name}-ground`);
-                        return { serves: 'memory', object: memory, down: closing(memory) };
-                    },
-                },
-                // The hand, for every other page of the origin: the asks sent to this page on the channel, each answered there.
-                'channel-hand': {
-                    takes: { args: s.object({ channel: s.string(), self: s.string(), persisted: s.boolean() }) },
-                    up: ({ args, faculties }) => {
-                        const ground = faculties.ground;
-                        const channel = platform.channel(args.channel);
-                        let open = true;
-                        channel.onmessage = (event) => {
-                            const said = event.data;
-                            if (said.kind !== 'ask' || said.to !== args.self)
-                                return;
-                            // An ask this hand's close ended is answered by no one here: the page that runs the ground next is asked again.
-                            void ground.hand(said.request).then((answer) => {
-                                if (!open)
-                                    return;
-                                channel.postMessage({
-                                    kind: 'answer',
-                                    id: said.id,
-                                    answer: said.request.describe === true && 'result' in answer ? { result: { ...answer.result, persisted: args.persisted === true } } : answer,
-                                });
-                            });
-                        };
-                        return {
-                            serves: 'hand',
-                            down: () => {
-                                open = false;
-                                channel.close();
-                            },
-                        };
-                    },
-                },
-                // It only dials, so it writes no address into an invitation.
-                web: {
-                    takes: { args: s.object({ allowPrivate: s.optional(s.boolean()) }) },
-                    up: ({ args }) => {
-                        const web = new WebCarry({ allowPrivate: args.allowPrivate === true });
-                        return { serves: 'carry', schemes: ['https', 'http', 'wss', 'ws'], object: web };
-                    },
-                },
-                origin: {
-                    takes: NONE,
-                    up: () => ({
-                        serves: 'classes',
-                        house: ({ args }) => {
-                            if (typeof args.at !== 'string')
-                                throw new Error('the origin faculty names a house’s module in at');
-                            return OriginClasses.open(args.at, platform.origin, platform.load);
-                        },
-                    }),
-                },
-            },
-        };
-        const wait = this.#options.wait;
-        return Ground.open({
-            registry: joinedRegistry(own, this.#options.registry ?? {}),
-            primordial: {
-                unlock: { make: 'store-unlock' },
-                memory: { make: 'store-memory' },
-                crypto: { make: 'noble' },
-                tools: { make: 'strict' },
-                clock: { make: 'clock' },
-                hand: { make: 'channel-hand', args: { channel: `${name}-hand`, self: this.#self, persisted: this.#persisted }, faculties: ['ground'] },
-            },
-            entries: {
-                origin: { make: 'origin' },
-                web: { make: 'web', args: this.#options.allowPrivate === true ? { allowPrivate: true } : {} },
-            },
-            ...(wait === undefined ? {} : { wait }),
-        });
-    }
-    /** This page leaves: its ground closes where it ran one, and the lock passes to the next page. */
-    async close() {
-        if (this.#closed)
-            return;
-        this.#closed = true;
-        this.#abort.abort();
-        const ground = this.#ground;
-        this.#ground = undefined;
-        await ground?.close();
-        this.#release?.();
-        this.#orphan(() => true);
-        for (const resolve of this.#waiting)
-            resolve();
-        this.#waiting = [];
-        this.#channel.close();
-    }
-}

package/dist/browser/index.d.ts

@@ -1,4 +0,0 @@
-export { BrowserGround } from './browser-ground.ts';
-export { IndexedDbMemory } from './indexeddb-memory.ts';
-export { IndexedDbShelf, LockedUnlock, type Shelf } from './locked-unlock.ts';
-export { OriginClasses } from './origin-classes.ts';

package/dist/browser/index.js

@@ -1,7 +0,0 @@
-// SPDX-License-Identifier: Apache-2.0
-// `nervur/browser`: the ground of a page and its service worker, and the
-// bodies it passes, for whoever writes a ground of their own.
-export { BrowserGround } from './browser-ground.js';
-export { IndexedDbMemory } from './indexeddb-memory.js';
-export { IndexedDbShelf, LockedUnlock } from './locked-unlock.js';
-export { OriginClasses } from './origin-classes.js';