nervur 0.20.0 → 0.20.2

package/dist/http/websocket.js

@@ -0,0 +1,133 @@
+// SPDX-License-Identifier: Apache-2.0
+// The server side of RFC 6455, as far as a held line needs it: the accept
+// key, frames written plain, and a reader of masked frames that joins
+// fragments into messages and stops at the first byte that breaks the RFC
+// or a message longer than it takes.
+import { createHash } from 'node:crypto';
+const GUID = '258EAFA5-E914-47DA-95CA-C5AB0DC85B11';
+export const OP = { continuation: 0x0, text: 0x1, binary: 0x2, close: 0x8, ping: 0x9, pong: 0xa };
+export const acceptKey = (key) => createHash('sha1')
+    .update(key + GUID)
+    .digest('base64');
+export const isClientKey = (key) => typeof key === 'string' && /^[A-Za-z0-9+/]{22}==$/.test(key);
+// One frame as a server writes it: final, unmasked.
+export const frameOf = (opcode, payload = new Uint8Array(0)) => {
+    const length = payload.length;
+    const extended = length < 126 ? 0 : length < 65_536 ? 2 : 8;
+    const out = new Uint8Array(2 + extended + length);
+    const view = new DataView(out.buffer);
+    out[0] = 0x80 | opcode;
+    out[1] = extended === 0 ? length : extended === 2 ? 126 : 127;
+    if (extended === 2)
+        view.setUint16(2, length);
+    if (extended === 8)
+        view.setBigUint64(2, BigInt(length));
+    out.set(payload, 2 + extended);
+    return out;
+};
+// Frames a client wrote, masked, read as they come.
+export class WsReader {
+    #max;
+    #buffer = new Uint8Array(0);
+    #parts = null;
+    #partsLength = 0;
+    #partsText = false;
+    #done = false;
+    constructor(max) {
+        this.#max = max;
+    }
+    push(chunk) {
+        if (this.#done)
+            return [];
+        const joined = new Uint8Array(this.#buffer.length + chunk.length);
+        joined.set(this.#buffer);
+        joined.set(chunk, this.#buffer.length);
+        this.#buffer = joined;
+        const out = [];
+        while (this.#buffer.length >= 2) {
+            const b0 = this.#buffer[0];
+            const b1 = this.#buffer[1];
+            const fin = (b0 & 0x80) !== 0;
+            const opcode = b0 & 0x0f;
+            const masked = (b1 & 0x80) !== 0;
+            if ((b0 & 0x70) !== 0 || !masked)
+                return this.#bad(out);
+            let length = b1 & 0x7f;
+            let at = 2;
+            const view = new DataView(this.#buffer.buffer, this.#buffer.byteOffset, this.#buffer.length);
+            if (length === 126) {
+                if (this.#buffer.length < 4)
+                    break;
+                length = view.getUint16(2);
+                at = 4;
+            }
+            else if (length === 127) {
+                if (this.#buffer.length < 10)
+                    break;
+                const long = view.getBigUint64(2);
+                if (long > BigInt(this.#max))
+                    return this.#bad(out);
+                length = Number(long);
+                at = 10;
+            }
+            const control = opcode >= 0x8;
+            if (control && (length > 125 || !fin))
+                return this.#bad(out);
+            if (!control && this.#partsLength + length > this.#max)
+                return this.#bad(out);
+            if (this.#buffer.length < at + 4 + length)
+                break;
+            const mask = this.#buffer.subarray(at, at + 4);
+            const payload = this.#buffer.slice(at + 4, at + 4 + length);
+            for (let i = 0; i < payload.length; i += 1)
+                payload[i] ^= mask[i & 3];
+            this.#buffer = this.#buffer.slice(at + 4 + length);
+            if (opcode === OP.close) {
+                this.#done = true;
+                out.push({ type: 'close' });
+                return out;
+            }
+            if (opcode === OP.ping)
+                out.push({ type: 'ping', data: payload });
+            else if (opcode === OP.pong)
+                continue;
+            else if (opcode === OP.text || opcode === OP.binary) {
+                if (this.#parts !== null)
+                    return this.#bad(out);
+                if (fin)
+                    out.push(opcode === OP.text ? { type: 'text' } : { type: 'binary', data: payload });
+                else {
+                    this.#parts = [payload];
+                    this.#partsLength = payload.length;
+                    this.#partsText = opcode === OP.text;
+                }
+            }
+            else if (opcode === OP.continuation) {
+                if (this.#parts === null)
+                    return this.#bad(out);
+                this.#parts.push(payload);
+                this.#partsLength += payload.length;
+                if (fin) {
+                    const whole = new Uint8Array(this.#partsLength);
+                    let o = 0;
+                    for (const part of this.#parts) {
+                        whole.set(part, o);
+                        o += part.length;
+                    }
+                    out.push(this.#partsText ? { type: 'text' } : { type: 'binary', data: whole });
+                    this.#parts = null;
+                    this.#partsLength = 0;
+                }
+            }
+            else
+                return this.#bad(out);
+        }
+        return out;
+    }
+    #bad(out) {
+        this.#done = true;
+        this.#buffer = new Uint8Array(0);
+        out.push({ type: 'bad' });
+        return out;
+    }
+}

package/dist/index.d.ts

@@ -1,7 +1,8 @@
 export { Being, canonical, digest, Faculty, isSilence, isWord, OWNER, silence, told, WARD, word } from './being/index.ts';
 export type { Answer, Ask, Asker, AskSpec, BeingClass, BeingLike, Blueprint, Invitation, Json, JsonObject, Occupants, Reply, Schema, Silence, Stance, Standing, Standings, Wanted, Word, WordName } from './being/index.ts';
 export { readInvitation } from './quo/index.ts';
-export { Carrier, Clock, Custody, Entropy, Memory, type Rows } from './contract/index.ts';
-export { CEILING, DEFAULT, DEPTH, ownerAsk, pilots, WardBeing, type Steward, type WardBeingStance } from './ward/index.ts';
-export { BOX, Dock, Harbor, Registry, Terrain } from './harbor/index.ts';
-export { CryptoEntropy, HeldCustody, NoCarrier, PointerCarrier, PointerTerrain, SystemClock, VolatileMemory, World, type PointerParts } from './pointer/index.ts';
+export { Carrier, Clock, Custody, Entropy, Loader, Memory, type Loaded, type Module, type Rows } from './contract/index.ts';
+export { CEILING, DEFAULT, DEPTH, ownerAsk, Pilot, pilots, WardBeing, type Steward, type WardBeingStance } from './ward/index.ts';
+export { BOX, CarrierFaculty, Catalogue, copyPackage, Dock, Harbor, addGround, grounds, readRootRequest, Registry, Push, PUSH, RELAY, RELAY_CLIENT, rootLine, Terrain, UNDIALED, type Dialed, type Failures, type Ground, type GroundFaculty, type GroundProbe, type Opening, type Probing, type RootRequest, } from './harbor/index.ts';
+export { CryptoEntropy, HeldCustody, HeldLoader, NoCarrier, PointerCarrier, PointerTerrain, SystemClock, VolatileMemory, World, type PointerParts } from './pointer/index.ts';
+export { NEUTRAL, WEB, WEB_OPENING, WEB_PUSH, WebDialer, webFaculty, webPush, type WebListen, type WebListener, type WebServe } from './line/index.ts';

package/dist/index.js

@@ -1,14 +1,20 @@
 // SPDX-License-Identifier: Apache-2.0
 // `nervur`: what a stranger writes a world with. It imports no platform, so
-// it runs wherever JavaScript runs. A disk is `nervur/folder`.
+// it runs wherever JavaScript runs. A disk is `nervur/folder`. Node reads
+// `node.ts` under this name instead, which adds the Node ground.
+import { addGround } from './harbor/index.js';
+import { neutralGround } from './line/index.js';
 // Beings, faculties, and what they are told.
 export { Being, canonical, digest, Faculty, isSilence, isWord, OWNER, silence, told, WARD, word } from './being/index.js';
 export { readInvitation } from './quo/index.js';
 // What a terrain gives a harbor.
-export { Carrier, Clock, Custody, Entropy, Memory } from './contract/index.js';
+export { Carrier, Clock, Custody, Entropy, Loader, Memory } from './contract/index.js';
 // Wards and the ward-being.
-export { CEILING, DEFAULT, DEPTH, ownerAsk, pilots, WardBeing } from './ward/index.js';
-// The onion.
-export { BOX, Dock, Harbor, Registry, Terrain } from './harbor/index.js';
+export { CEILING, DEFAULT, DEPTH, ownerAsk, Pilot, pilots, WardBeing } from './ward/index.js';
+// The onion, and the one line its root's asks cross from any front.
+export { BOX, CarrierFaculty, Catalogue, copyPackage, Dock, Harbor, addGround, grounds, readRootRequest, Registry, Push, PUSH, RELAY, RELAY_CLIENT, rootLine, Terrain, UNDIALED, } from './harbor/index.js';
 // The pointer dock: a whole world in one process.
-export { CryptoEntropy, HeldCustody, NoCarrier, PointerCarrier, PointerTerrain, SystemClock, VolatileMemory, World } from './pointer/index.js';
+export { CryptoEntropy, HeldCustody, HeldLoader, NoCarrier, PointerCarrier, PointerTerrain, SystemClock, VolatileMemory, World } from './pointer/index.js';
+export { NEUTRAL, WEB, WEB_OPENING, WEB_PUSH, WebDialer, webFaculty, webPush } from './line/index.js';
+// The ground that fits everywhere, tried after any a platform entry adds.
+addGround(neutralGround);

package/dist/line/answer.d.ts

@@ -0,0 +1,8 @@
+import type { Ground } from '../harbor/index.ts';
+import { type WebListen } from './web.ts';
+export declare const answerPost: (ground: Ground, listen: WebListen, request: Request) => Promise<Response>;
+export type HeldSide = {
+    send(body: Uint8Array): void;
+    close(): void;
+};
+export declare const answerHeld: (ground: Ground, side: HeldSide, message: Uint8Array | string) => void;

package/dist/line/answer.js

@@ -0,0 +1,60 @@
+// SPDX-License-Identifier: Apache-2.0
+// The web carrier's inbound side on the standard Request and Response,
+// for a ground whose engine hands its code a request: a post answered, and
+// a held line's messages, whatever socket the engine gives.
+//
+// A post is one ask: 200 with the reply's box, or 204 for nothing. A post
+// to another path is 404, another method 405, a body that is no ask 400.
+// A page of an origin the listen names, or of any under `*`, is answered
+// as the CORS protocol says, its preflight included.
+import { hex } from '../crypto/index.js';
+import { nothingBody, readBody, replyBody } from './frame.js';
+import { MAX_POST, readPost } from './web.js';
+const allowedOrigin = (origins, origin) => {
+    if (origin === null)
+        return null;
+    if (origins.includes('*'))
+        return '*';
+    return origins.includes(origin) ? origin : null;
+};
+export const answerPost = async (ground, listen, request) => {
+    const headers = new Headers();
+    const allowed = allowedOrigin(listen.origins, request.headers.get('origin'));
+    if (allowed !== null)
+        headers.set('access-control-allow-origin', allowed);
+    if (new URL(request.url).pathname !== listen.path)
+        return new Response(null, { status: 404, headers });
+    if (request.method === 'OPTIONS') {
+        if (allowed !== null) {
+            headers.set('access-control-allow-methods', 'POST');
+            headers.set('access-control-allow-headers', 'content-type');
+        }
+        return new Response(null, { status: 204, headers });
+    }
+    if (request.method !== 'POST') {
+        headers.set('allow', 'POST, OPTIONS');
+        return new Response(null, { status: 405, headers });
+    }
+    const body = new Uint8Array(await request.arrayBuffer());
+    const ask = body.length > MAX_POST ? null : readPost(body);
+    if (ask === null)
+        return new Response(null, { status: 400, headers });
+    const reply = await ground.arrive(ask.pk, ask.box).catch(() => null);
+    if (reply === null || reply.length === 0)
+        return new Response(null, { status: 204, headers });
+    headers.set('content-type', 'application/octet-stream');
+    return new Response(new Uint8Array(reply), { status: 200, headers });
+};
+// One message on a held line: an ask answered on the same line, a text
+// message or a body that is no frame closing it, and anything else let be.
+export const answerHeld = (ground, side, message) => {
+    const frame = typeof message === 'string' ? null : readBody(message);
+    if (frame === null)
+        return side.close();
+    if (frame.kind !== 'ask')
+        return;
+    void ground
+        .arrive(hex(frame.pk), frame.box)
+        .catch(() => null)
+        .then((reply) => side.send(reply === null ? nothingBody(frame.id) : replyBody(frame.id, reply)));
+};

package/dist/line/frame.d.ts

@@ -0,0 +1,34 @@
+export declare const TCP = "org.nervur.tcp";
+export declare const TCP_OPENING: {
+    readonly key: 'tcp';
+    readonly kind: "org.nervur.tcp";
+};
+export declare const ASK = 0;
+export declare const REPLY = 1;
+export declare const NOTHING = 2;
+export declare const MAX_BODY = 1048645;
+export type Frame = {
+    kind: 'ask';
+    id: number;
+    pk: Uint8Array;
+    box: Uint8Array;
+} | {
+    kind: 'reply';
+    id: number;
+    box: Uint8Array;
+} | {
+    kind: 'nothing';
+    id: number;
+};
+export declare const askBody: (id: number, pk: Uint8Array, box: Uint8Array) => Uint8Array;
+export declare const replyBody: (id: number, box: Uint8Array) => Uint8Array;
+export declare const nothingBody: (id: number) => Uint8Array;
+export declare const askFrame: (id: number, pk: Uint8Array, box: Uint8Array) => Uint8Array;
+export declare const replyFrame: (id: number, box: Uint8Array) => Uint8Array;
+export declare const nothingFrame: (id: number) => Uint8Array;
+export declare const readBody: (b: Uint8Array) => Frame | null;
+export declare class FrameReader {
+    #private;
+    get bad(): boolean;
+    push(chunk: Uint8Array): Frame[];
+}

package/dist/line/frame.js

@@ -0,0 +1,81 @@
+// SPDX-License-Identifier: Apache-2.0
+// The frames of `quo/CARRIER-TCP.md`, which the held line of
+// `quo/CARRIER-WEB.md` carries too, one body to a message:
+//
+//   frame = length (4, big-endian) || body
+//   body  = kind (1) || id (4, big-endian) || rest
+//   00 ask      rest = ward pk (64) || box
+//   01 reply    rest = box
+//   02 nothing  rest = empty
+//
+// A reader says bytes are not a frame as soon as they say so, and reads
+// nothing after them.
+import { concat } from '../crypto/index.js';
+// The kind of a TCP carrier faculty, whichever ground's body it is, and
+// the faculty a ground that speaks TCP opens at genesis under `tcp`.
+export const TCP = 'org.nervur.tcp';
+export const TCP_OPENING = { key: 'tcp', kind: TCP };
+export const ASK = 0;
+export const REPLY = 1;
+export const NOTHING = 2;
+export const MAX_BODY = 1_048_645;
+const PK = 64;
+const body = (kind, id, ...rest) => {
+    const head = new Uint8Array(5);
+    head[0] = kind;
+    new DataView(head.buffer).setUint32(1, id >>> 0);
+    return concat(head, ...rest);
+};
+const framed = (b) => {
+    const length = new Uint8Array(4);
+    new DataView(length.buffer).setUint32(0, b.length);
+    return concat(length, b);
+};
+export const askBody = (id, pk, box) => body(ASK, id, pk, box);
+export const replyBody = (id, box) => body(REPLY, id, box);
+export const nothingBody = (id) => body(NOTHING, id);
+export const askFrame = (id, pk, box) => framed(askBody(id, pk, box));
+export const replyFrame = (id, box) => framed(replyBody(id, box));
+export const nothingFrame = (id) => framed(nothingBody(id));
+// Whether a body of this length, and this first byte when known, is no frame.
+const notAFrame = (length, kind) => length > MAX_BODY || length < 5 || (kind !== undefined && (kind > NOTHING || (kind === ASK && length < 5 + PK) || (kind === NOTHING && length !== 5)));
+// One whole body, read, or null for bytes that are no frame.
+export const readBody = (b) => {
+    if (notAFrame(b.length, b[0]))
+        return null;
+    const id = new DataView(b.buffer, b.byteOffset).getUint32(1);
+    if (b[0] === ASK)
+        return { kind: 'ask', id, pk: b.slice(5, 5 + PK), box: b.slice(5 + PK) };
+    if (b[0] === REPLY)
+        return { kind: 'reply', id, box: b.slice(5) };
+    return { kind: 'nothing', id };
+};
+// Frames out of a stream, each with its length in front.
+export class FrameReader {
+    #buffer = new Uint8Array(0);
+    #bad = false;
+    // True once bytes that are not a frame arrived; nothing is read after.
+    get bad() {
+        return this.#bad;
+    }
+    push(chunk) {
+        if (this.#bad)
+            return [];
+        this.#buffer = this.#buffer.length === 0 ? chunk.slice() : concat(this.#buffer, chunk);
+        const out = [];
+        while (this.#buffer.length >= 4) {
+            const length = new DataView(this.#buffer.buffer, this.#buffer.byteOffset).getUint32(0);
+            if (notAFrame(length, this.#buffer.length > 4 ? this.#buffer[4] : undefined)) {
+                this.#bad = true;
+                this.#buffer = new Uint8Array(0);
+                return out;
+            }
+            if (this.#buffer.length < 4 + length)
+                break;
+            const frame = readBody(this.#buffer.subarray(4, 4 + length));
+            this.#buffer = this.#buffer.slice(4 + length);
+            out.push(frame);
+        }
+        return out;
+    }
+}

package/dist/line/ground.d.ts

@@ -0,0 +1,3 @@
+import type { GroundProbe } from '../harbor/index.ts';
+export declare const NEUTRAL = "neutral";
+export declare const neutralGround: GroundProbe;

package/dist/line/ground.js

@@ -0,0 +1,9 @@
+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

@@ -0,0 +1,5 @@
+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

@@ -0,0 +1,9 @@
+// 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

@@ -0,0 +1,7 @@
+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

@@ -0,0 +1,92 @@
+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;
+    }
+};

package/dist/line/web.d.ts

@@ -0,0 +1,30 @@
+import { type Dialed, type Ground, type GroundFaculty } from '../harbor/index.ts';
+export declare const MIN_POST = 65;
+export declare const MAX_POST: number;
+export declare class WebDialer {
+    #private;
+    dial(at: string, pk: string, bytes: Uint8Array): Promise<Dialed>;
+    close(): Promise<void>;
+}
+export type WebListen = {
+    host: string;
+    port: number;
+    path: string;
+    origins: string[];
+};
+export interface WebListener {
+    readonly at: string[];
+    readonly port: number;
+    close(): Promise<void>;
+}
+export type WebServe = (ground: Ground, listen: WebListen) => Promise<WebListener>;
+export declare const WEB = "org.nervur.web";
+export declare const WEB_OPENING: {
+    readonly key: 'web';
+    readonly kind: "org.nervur.web";
+};
+export declare const webFaculty: (serve?: WebServe) => GroundFaculty;
+export declare const readPost: (body: Uint8Array) => {
+    pk: string;
+    box: Uint8Array;
+} | null;