nervur 0.23.0 → 0.24.0

package/dist/node/websocket.d.ts

@@ -1,12 +0,0 @@
-import type { Socket } from 'node:net';
-import type { Held, HeldSocket } from '../bodies/web-carry.ts';
-/** The `Sec-WebSocket-Accept` for a client's key. */
-export declare const acceptOf: (key: string) => string;
-/**
- * A socket past its handshake, held as frames. Every `ping` milliseconds it
- * pings, so a router between keeps the line, and a line silent across two
- * pings is closed, so its dialer dials again rather than wait on the dead.
- */
-export declare const hold: (socket: Socket, open: (held: HeldSocket) => Held, longest: number, { ping }?: {
-    ping?: number;
-}) => void;

package/dist/node/websocket.js

@@ -1,134 +0,0 @@
-// SPDX-License-Identifier: Apache-2.0
-// The server's side of a WebSocket, as RFC 6455 writes it: the handshake's
-// answer, and messages framed on the socket. A client masks every frame;
-// the server masks none. A message past `longest` closes the connection.
-import { createHash } from 'node:crypto';
-const GUID = '258EAFA5-E914-47DA-95CA-C5AB0DC85B11';
-const TEXT = 1;
-const BINARY = 2;
-const CLOSE = 8;
-const PING = 9;
-const PONG = 10;
-/** The `Sec-WebSocket-Accept` for a client's key. */
-export const acceptOf = (key) => createHash('sha1').update(`${key}${GUID}`).digest('base64');
-const header = (opcode, length) => {
-    if (length < 126)
-        return Buffer.from([0x80 | opcode, length]);
-    if (length < 65_536) {
-        const out = Buffer.alloc(4);
-        out[0] = 0x80 | opcode;
-        out[1] = 126;
-        out.writeUInt16BE(length, 2);
-        return out;
-    }
-    const out = Buffer.alloc(10);
-    out[0] = 0x80 | opcode;
-    out[1] = 127;
-    out.writeBigUInt64BE(BigInt(length), 2);
-    return out;
-};
-/**
- * A socket past its handshake, held as frames. Every `ping` milliseconds it
- * pings, so a router between keeps the line, and a line silent across two
- * pings is closed, so its dialer dials again rather than wait on the dead.
- */
-export const hold = (socket, open, longest, { ping = 25_000 } = {}) => {
-    let closed = false;
-    let quiet = 0;
-    const write = (opcode, payload) => {
-        if (closed)
-            return;
-        socket.write(Buffer.concat([header(opcode, payload.length), payload]));
-    };
-    const beat = setInterval(() => {
-        if (++quiet > 2)
-            return end();
-        write(PING, new Uint8Array());
-    }, ping);
-    beat.unref();
-    const end = () => {
-        clearInterval(beat);
-        if (closed)
-            return;
-        write(CLOSE, new Uint8Array());
-        closed = true;
-        socket.end();
-    };
-    const held = open({ send: (data) => write(BINARY, data), close: end });
-    let buffered = Buffer.alloc(0);
-    let parts = [];
-    let partsKind = 0;
-    let partsLength = 0;
-    socket.on('data', (chunk) => {
-        // Anything heard, a pong among it, says the line stands.
-        quiet = 0;
-        buffered = Buffer.concat([buffered, chunk]);
-        while (buffered.length >= 2) {
-            const fin = (buffered[0] & 0x80) !== 0;
-            const opcode = buffered[0] & 0x0f;
-            const masked = (buffered[1] & 0x80) !== 0;
-            let length = buffered[1] & 0x7f;
-            let at = 2;
-            if (length === 126) {
-                if (buffered.length < 4)
-                    return;
-                length = buffered.readUInt16BE(2);
-                at = 4;
-            }
-            else if (length === 127) {
-                if (buffered.length < 10)
-                    return;
-                const long = buffered.readBigUInt64BE(2);
-                if (long > BigInt(longest))
-                    return end();
-                length = Number(long);
-                at = 10;
-            }
-            // Every frame from a client is masked, and a message past the longest is none of ours.
-            if (!masked || length > longest)
-                return end();
-            if (buffered.length < at + 4 + length)
-                return;
-            const mask = buffered.subarray(at, at + 4);
-            const payload = Buffer.from(buffered.subarray(at + 4, at + 4 + length));
-            for (let index = 0; index < payload.length; index++)
-                payload[index] ^= mask[index % 4];
-            buffered = buffered.subarray(at + 4 + length);
-            if (opcode === CLOSE)
-                return end();
-            if (opcode === PING) {
-                write(PONG, payload);
-                continue;
-            }
-            if (opcode === PONG)
-                continue;
-            if (opcode !== 0) {
-                partsKind = opcode;
-                parts = [];
-                partsLength = 0;
-            }
-            parts.push(payload);
-            partsLength += payload.length;
-            if (partsLength > longest)
-                return end();
-            if (!fin)
-                continue;
-            const message = Buffer.concat(parts);
-            parts = [];
-            partsLength = 0;
-            // An always-on ground holds no wake, so what a message asks is answered in its own time.
-            if (partsKind === TEXT)
-                void held.message(message.toString('utf8'));
-            else if (partsKind === BINARY)
-                void held.message(new Uint8Array(message));
-            else
-                return end();
-        }
-    });
-    socket.on('close', () => {
-        clearInterval(beat);
-        closed = true;
-        held.close();
-    });
-    socket.on('error', () => socket.destroy());
-};

package/dist/quo/frame.d.ts

@@ -1,33 +0,0 @@
-export declare const ASK = 0;
-export declare const REPLY = 1;
-export declare const NOTHING = 2;
-/** The longest frame body. */
-export declare const LARGEST = 1048645;
-/** A ward pk, in bytes. */
-export declare const PK = 64;
-export interface Frame {
-    readonly kind: number;
-    readonly id: number;
-    readonly rest: Uint8Array;
-}
-/** A frame's body. */
-export declare const body: (kind: number, id: number, rest: Uint8Array) => Uint8Array<ArrayBuffer>;
-/** A frame read from its body, or `null` where the body is no frame and its connection closes. */
-export declare const read: (bytes: Uint8Array) => Frame | null;
-/** A frame as a stream carries it: its body's length in four bytes, then the body. */
-export declare const framed: (kind: number, id: number, rest: Uint8Array) => Uint8Array<ArrayBuffer>;
-/** Frames read off a stream, as its chunks arrive. */
-export declare class Frames {
-    #private;
-    /** Each whole frame in order; `false` where the stream sent something that is no frame, and closes. */
-    take(chunk: Uint8Array, each: (frame: Frame) => void): boolean;
-}
-/** A `tcp://host:port` address read, or `null` where it is none of the TCP carrier's. */
-export declare const parseAddress: (address: string) => {
-    host: string;
-    port: number;
-} | null;
-/** Whether an IP address is loopback, private, shared, link-local or unspecified. */
-export declare const privateAddress: (ip: string) => boolean;
-/** Whether a host, as a URL writes it, is one a carry dials only where its ground allows. */
-export declare const privateHost: (host: string) => boolean;

package/dist/quo/frame.js

@@ -1,92 +0,0 @@
-// SPDX-License-Identifier: Apache-2.0
-// A frame's body, as quo/CARRIER-TCP.md writes it: kind, id and rest. Over
-// TCP a length goes in front; on a held line the message is the body.
-// And which hosts a carry refuses to dial unless its ground allows it.
-export const ASK = 0;
-export const REPLY = 1;
-export const NOTHING = 2;
-/** The longest frame body. */
-export const LARGEST = 1_048_645;
-/** A ward pk, in bytes. */
-export const PK = 64;
-/** A frame's body. */
-export const body = (kind, id, rest) => {
-    const out = new Uint8Array(5 + rest.length);
-    out[0] = kind;
-    new DataView(out.buffer).setUint32(1, id >>> 0);
-    out.set(rest, 5);
-    return out;
-};
-/** A frame read from its body, or `null` where the body is no frame and its connection closes. */
-export const read = (bytes) => {
-    if (bytes.length < 5 || bytes.length > LARGEST)
-        return null;
-    const kind = bytes[0];
-    const rest = bytes.slice(5);
-    if (kind > NOTHING || (kind === ASK && rest.length < PK) || (kind === NOTHING && rest.length > 0))
-        return null;
-    return { kind, id: new DataView(bytes.buffer, bytes.byteOffset, bytes.byteLength).getUint32(1), rest };
-};
-/** A frame as a stream carries it: its body's length in four bytes, then the body. */
-export const framed = (kind, id, rest) => {
-    const inner = body(kind, id, rest);
-    const out = new Uint8Array(4 + inner.length);
-    new DataView(out.buffer).setUint32(0, inner.length);
-    out.set(inner, 4);
-    return out;
-};
-/** Frames read off a stream, as its chunks arrive. */
-export class Frames {
-    #held = new Uint8Array(0);
-    /** Each whole frame in order; `false` where the stream sent something that is no frame, and closes. */
-    take(chunk, each) {
-        const joined = new Uint8Array(this.#held.length + chunk.length);
-        joined.set(this.#held);
-        joined.set(chunk, this.#held.length);
-        let at = 0;
-        while (joined.length - at >= 4) {
-            const length = new DataView(joined.buffer, at, 4).getUint32(0);
-            if (length < 5 || length > LARGEST)
-                return false;
-            if (joined.length - at < 4 + length)
-                break;
-            const frame = read(joined.subarray(at + 4, at + 4 + length));
-            if (frame === null)
-                return false;
-            at += 4 + length;
-            each(frame);
-        }
-        this.#held = joined.slice(at);
-        return true;
-    }
-}
-/** A `tcp://host:port` address read, or `null` where it is none of the TCP carrier's. */
-export const parseAddress = (address) => {
-    const found = /^tcp:\/\/(\[[0-9a-fA-F:.]+\]|[^/?#@:[\]]+):([0-9]{1,5})$/i.exec(address);
-    if (found === null)
-        return null;
-    const port = Number(found[2]);
-    if (port < 1 || port > 65_535)
-        return null;
-    const host = found[1].startsWith('[') ? found[1].slice(1, -1) : found[1];
-    return { host, port };
-};
-const IPV4 = /^(\d{1,3})\.(\d{1,3})\.(\d{1,3})\.(\d{1,3})$/;
-/** Whether an IP address is loopback, private, shared, link-local or unspecified. */
-export const privateAddress = (ip) => {
-    const four = IPV4.exec(ip);
-    if (four !== null) {
-        const [a, b] = [Number(four[1]), Number(four[2])];
-        return a === 0 || a === 10 || a === 127 || (a === 169 && b === 254) || (a === 172 && b >= 16 && b <= 31) || (a === 192 && b === 168) || (a === 100 && b >= 64 && b <= 127);
-    }
-    const lower = ip.toLowerCase();
-    if (lower.startsWith('::ffff:'))
-        return privateAddress(lower.slice(7));
-    return lower === '::' || lower === '::1' || /^f[cd]/.test(lower) || /^fe[89ab]/.test(lower);
-};
-/** Whether a host, as a URL writes it, is one a carry dials only where its ground allows. */
-export const privateHost = (host) => {
-    const bare = host.startsWith('[') ? host.slice(1, -1) : host;
-    const lower = bare.toLowerCase();
-    return lower === 'localhost' || lower.endsWith('.localhost') || privateAddress(lower);
-};

package/dist/quo/index.d.ts

@@ -1 +0,0 @@
-export { Room, type Admitted, type Choice, type Occupant, type Standing } from './room.ts';

package/dist/quo/index.js

@@ -1,5 +0,0 @@
-// SPDX-License-Identifier: Apache-2.0
-// The room's one index: the ward's code, reached by the house through here
-// alone. The framing the carriers share stands beside it, and is no part
-// of the room.
-export { Room } from './room.js';

package/dist/quo/room.d.ts

@@ -1,154 +0,0 @@
-import type { Crypto, Keys, Tools } from '../foundation.ts';
-/** The invitation of the spec, read. */
-export interface Invitation {
-    readonly ward: string;
-    readonly heir: string;
-    readonly secret: string;
-    readonly lock: string;
-    readonly at?: readonly string[];
-}
-/** The door's end of a relation, by its heir. */
-export interface Occupant {
-    readonly heir: string;
-    /** A door has made a choice on it. */
-    readonly spent: boolean;
-    /** The door stopped holding it while it was spent, and keeps its keys. */
-    readonly removed: boolean;
-    readonly held: string | null;
-    readonly vouched: string | null;
-    readonly open: string | null;
-    readonly offered: string | null;
-    /** The highest number honoured; the door honours none below it. */
-    readonly highest: number;
-}
-/** The standing's end of a relation. */
-export interface Standing {
-    readonly invitation: Invitation;
-    /** The secret it signs with. */
-    readonly key: string;
-    /** The edge key it sends under; `null` before its knock. */
-    readonly edge: string | null;
-    /** Its knock, kept to send again until the door is known to have bound it. */
-    readonly knock: string | null;
-    readonly bound: boolean;
-    /** Whether its knock may have reached the door. Until it may have, the knock alone is sent again. */
-    readonly heard: boolean;
-    /** Whether the last box it sealed was its knock again. */
-    readonly knockedLast: boolean;
-    readonly sent: number;
-    readonly moved: number;
-}
-/** One ask in flight, kept by its sender until its reply is read. */
-export interface Pending {
-    readonly seq: number;
-    readonly lid: string;
-    readonly announced: string | null;
-    readonly under: string;
-    readonly knock: boolean;
-}
-/** What a standing read. */
-export type Read = {
-    readonly object: unknown;
-    readonly text: string;
-    readonly seen: string | null;
-    readonly at?: readonly string[];
-} | {
-    readonly silence: true;
-} | {
-    readonly quo: 'removed' | 'unannounced' | 'repeated';
-} | {
-    readonly nothing: true;
-};
-/** What the door chooses. `object` is JSON text, written into the reply as it stands, and `at` where the ward is reached now. */
-export type Choice = {
-    readonly object: string;
-    readonly seen: string | null;
-    readonly at?: readonly string[];
-} | {
-    readonly silence: true;
-};
-/** An ask the door admitted, waiting for its choice. */
-export interface Admitted {
-    readonly refused: false;
-    /** `null` for the zero head. */
-    readonly heir: string | null;
-    readonly by: string;
-    readonly seq: number;
-    readonly method: string | undefined;
-    /** The text of `args` as it arrived, `{}` where absent. */
-    readonly args: string;
-    /** Two keys of one name somewhere inside `args`. */
-    readonly strange: boolean;
-    /** The call id beside the method, a field Quo gives no meaning. */
-    readonly call: string | undefined;
-    /** The milliseconds its chain still has, a field Quo gives no meaning. */
-    readonly within: number | undefined;
-    /** The digest of the answer a watch holds, a field Quo gives no meaning. */
-    readonly after: string | undefined;
-    /** The ask's signature as hex, which names a box on the zero head. */
-    readonly signature: string;
-    /** The reply to the choice, and the occupant moved; `null` on the zero head. */
-    choose(choice: Choice): Promise<{
-        readonly reply: Uint8Array;
-        readonly occupant: Occupant | null;
-    }>;
-}
-/** A refusal: the reply, and nothing moves. `why` is the case, for the kit's own eyes. */
-export interface Refusal {
-    readonly refused: true;
-    readonly reply: Uint8Array;
-    readonly why: number;
-}
-export type Arrival = Admitted | Refusal;
-/** How the door finds an occupant, and whether anything answers the zero head. */
-export interface Lookup {
-    occupant(heir: string): Promise<Occupant | undefined> | Occupant | undefined;
-    readonly zero: boolean;
-}
-export declare class Room {
-    #private;
-    constructor(keys: Keys, crypto: Crypto, tools: Tools);
-    /** The ward's name: its signing pk, then its padlock, as 128 hex. */
-    ward(): Promise<string>;
-    /** A new heir: the invitation to give away, and the occupant to keep. */
-    invite(at?: readonly string[]): Promise<{
-        invitation: Invitation;
-        occupant: Occupant;
-    }>;
-    /** The occupant after the door stops holding it: gone while fresh, its keys kept while spent. */
-    release(occupant: Occupant): Occupant | null;
-    /** A value read as an invitation, or `null` where it is none. */
-    invitation(value: unknown): Promise<Invitation | null>;
-    /** A standing on an invitation, before its knock. */
-    standing(invitation: Invitation): Standing;
-    /** A box at the door: refused with its reply, or admitted and waiting for a choice. */
-    arrive(box: Uint8Array, lookup: Lookup): Promise<Arrival>;
-    /** The next box on a relation: its knock, its knock again, or an ask. */
-    seal(standing: Standing, ask: {
-        method?: string;
-        args?: string;
-        call?: string;
-        within?: number;
-        after?: string;
-    }): Promise<{
-        box: Uint8Array;
-        pending: Pending;
-        standing: Standing;
-    }>;
-    /** A reply read, and the standing moved where an object came back above every ask it moved on. */
-    /** `heard` says whether a box that brought nothing may have reached the door; a reply was heard. */
-    read(given: Standing, pending: Pending, reply: Uint8Array | null, heard?: boolean): Promise<{
-        read: Read;
-        standing: Standing;
-    }>;
-    /** An ask on the zero head of a ward, signed by `secret`, which the door keeps nothing of. */
-    stranger(ward: string, secret: string, ask: {
-        method?: string;
-        args?: string;
-    }): Promise<{
-        box: Uint8Array;
-        lid: string;
-    }>;
-    /** A stranger's reply read. */
-    strangerRead(ward: string, lid: string, reply: Uint8Array | null): Promise<Read>;
-}