@react-native-harness/bridge 1.4.1 → 1.6.0

package/dist/binary.d.ts

@@ -0,0 +1,16 @@
+import type { LinkConnection } from './link/index.js';
+export type OutgoingBinary = {
+    channelId: string;
+    /** Settles once every byte is handed to the link, or rejects if the channel fails. */
+    written: Promise<void>;
+    abort: (reason?: string) => void;
+};
+/**
+ * Opens a link channel and starts writing `data` into it. The channel id travels in an
+ * RPC message; the peer reads the bytes with `receiveBinary`. The link sends the channel's
+ * OPEN before any later message, so the peer always knows the id by the time it asks.
+ */
+export declare const sendBinary: (link: LinkConnection, data: Uint8Array) => Promise<OutgoingBinary>;
+/** Accepts the channel the peer opened with `sendBinary` and reads it to the end. */
+export declare const receiveBinary: (link: LinkConnection, channelId: string) => Promise<Uint8Array>;
+//# sourceMappingURL=binary.d.ts.map

package/dist/binary.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"binary.d.ts","sourceRoot":"","sources":["../src/binary.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAe,cAAc,EAAE,MAAM,iBAAiB,CAAC;AAEnE,MAAM,MAAM,cAAc,GAAG;IAC3B,SAAS,EAAE,MAAM,CAAC;IAClB,sFAAsF;IACtF,OAAO,EAAE,OAAO,CAAC,IAAI,CAAC,CAAC;IACvB,KAAK,EAAE,CAAC,MAAM,CAAC,EAAE,MAAM,KAAK,IAAI,CAAC;CAClC,CAAC;AAEF;;;;GAIG;AACH,eAAO,MAAM,UAAU,GACrB,MAAM,cAAc,EACpB,MAAM,UAAU,KACf,OAAO,CAAC,cAAc,CAgBxB,CAAC;AA6BF,qFAAqF;AACrF,eAAO,MAAM,aAAa,GACxB,MAAM,cAAc,EACpB,WAAW,MAAM,KAChB,OAAO,CAAC,UAAU,CAOpB,CAAC"}

package/dist/binary.js

@@ -0,0 +1,47 @@
+/**
+ * Opens a link channel and starts writing `data` into it. The channel id travels in an
+ * RPC message; the peer reads the bytes with `receiveBinary`. The link sends the channel's
+ * OPEN before any later message, so the peer always knows the id by the time it asks.
+ */
+export const sendBinary = async (link, data) => {
+    const channel = await link.openChannel({
+        signal: new AbortController().signal,
+    });
+    const written = (async () => {
+        const writer = channel.writable.getWriter();
+        await writer.write(data);
+        await writer.close();
+    })();
+    return {
+        channelId: channel.id,
+        written,
+        abort: (reason) => channel.abort(reason),
+    };
+};
+const readAll = async (channel) => {
+    const reader = channel.readable.getReader();
+    const chunks = [];
+    let size = 0;
+    for (;;) {
+        const { done, value } = await reader.read();
+        if (done) {
+            break;
+        }
+        chunks.push(value);
+        size += value.length;
+    }
+    const bytes = new Uint8Array(size);
+    let offset = 0;
+    for (const chunk of chunks) {
+        bytes.set(chunk, offset);
+        offset += chunk.length;
+    }
+    return bytes;
+};
+/** Accepts the channel the peer opened with `sendBinary` and reads it to the end. */
+export const receiveBinary = async (link, channelId) => {
+    const channel = link.acceptChannel(channelId);
+    // Nothing flows back to the sender; ending this direction lets the channel free its slot.
+    void channel.writable.close().catch(() => undefined);
+    return readAll(channel);
+};

package/dist/link/channel.d.ts

@@ -0,0 +1,45 @@
+import type { Clock, Logger } from "./ports.js";
+import { type ResetReason } from "./envelope.js";
+import type { BulkMessage, BulkSource, Scheduler } from "./scheduler.js";
+export type LinkChannelErrorReason = "aborted" | "invalid" | "not-accepted" | "stalled" | "closed" | "stopped";
+export declare class LinkChannelError extends Error {
+    readonly reason: LinkChannelErrorReason;
+    constructor(reason: LinkChannelErrorReason, message?: string);
+}
+export interface LinkChannel {
+    readonly id: string;
+    readonly readable: ReadableStream<Uint8Array>;
+    readonly writable: WritableStream<Uint8Array>;
+    abort(reason?: string): void;
+    readonly credit: number;
+    whenCredit(): Promise<void>;
+}
+export interface ChannelHost {
+    readonly clock: Clock;
+    readonly logger: Logger;
+    readonly scheduler: Scheduler;
+    unsentBytes(): number;
+    channelDone(channel: Channel): void;
+}
+export declare class Channel implements BulkSource {
+    #private;
+    readonly number: number;
+    readonly id: string;
+    readonly ownedByUs: boolean;
+    accepted: boolean;
+    readonly view: LinkChannel;
+    constructor(host: ChannelHost, number: number, id: string, ownedByUs: boolean);
+    get hasNext(): boolean;
+    get credit(): number;
+    markAccepted(): void;
+    takeNext(): BulkMessage | undefined;
+    transportMoved(): void;
+    onData(payload: Uint8Array): void;
+    onEnd(): void;
+    onStop(): void;
+    onCredit(amount: number | undefined): void;
+    onReset(reason: ResetReason | undefined): void;
+    closeWith(error: LinkChannelError): void;
+    abort(reason?: string): void;
+}
+//# sourceMappingURL=channel.d.ts.map

package/dist/link/channel.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"channel.d.ts","sourceRoot":"","sources":["../../src/link/channel.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,KAAK,EAAE,MAAM,EAAe,MAAM,YAAY,CAAC;AAC7D,OAAO,EASL,KAAK,WAAW,EACjB,MAAM,eAAe,CAAC;AACvB,OAAO,KAAK,EAAE,WAAW,EAAE,UAAU,EAAE,SAAS,EAAE,MAAM,gBAAgB,CAAC;AAOzE,MAAM,MAAM,sBAAsB,GAC9B,SAAS,GACT,SAAS,GACT,cAAc,GACd,SAAS,GACT,QAAQ,GACR,SAAS,CAAC;AAEd,qBAAa,gBAAiB,SAAQ,KAAK;IAEvC,QAAQ,CAAC,MAAM,EAAE,sBAAsB;gBAA9B,MAAM,EAAE,sBAAsB,EACvC,OAAO,CAAC,EAAE,MAAM;CAKnB;AAED,MAAM,WAAW,WAAW;IAC1B,QAAQ,CAAC,EAAE,EAAE,MAAM,CAAC;IACpB,QAAQ,CAAC,QAAQ,EAAE,cAAc,CAAC,UAAU,CAAC,CAAC;IAC9C,QAAQ,CAAC,QAAQ,EAAE,cAAc,CAAC,UAAU,CAAC,CAAC;IAC9C,KAAK,CAAC,MAAM,CAAC,EAAE,MAAM,GAAG,IAAI,CAAC;IAC7B,QAAQ,CAAC,MAAM,EAAE,MAAM,CAAC;IACxB,UAAU,IAAI,OAAO,CAAC,IAAI,CAAC,CAAC;CAC7B;AAED,MAAM,WAAW,WAAW;IAC1B,QAAQ,CAAC,KAAK,EAAE,KAAK,CAAC;IACtB,QAAQ,CAAC,MAAM,EAAE,MAAM,CAAC;IACxB,QAAQ,CAAC,SAAS,EAAE,SAAS,CAAC;IAC9B,WAAW,IAAI,MAAM,CAAC;IACtB,WAAW,CAAC,OAAO,EAAE,OAAO,GAAG,IAAI,CAAC;CACrC;AAaD,qBAAa,OAAQ,YAAW,UAAU;;IACxC,QAAQ,CAAC,MAAM,EAAE,MAAM,CAAC;IACxB,QAAQ,CAAC,EAAE,EAAE,MAAM,CAAC;IACpB,QAAQ,CAAC,SAAS,EAAE,OAAO,CAAC;IAC5B,QAAQ,EAAE,OAAO,CAAC;IAClB,QAAQ,CAAC,IAAI,EAAE,WAAW,CAAC;gBAkCf,IAAI,EAAE,WAAW,EAAE,MAAM,EAAE,MAAM,EAAE,EAAE,EAAE,MAAM,EAAE,SAAS,EAAE,OAAO;IAwB7E,IAAI,OAAO,IAAI,OAAO,CAErB;IAED,IAAI,MAAM,IAAI,MAAM,CAGnB;IAED,YAAY,IAAI,IAAI;IAQpB,QAAQ,IAAI,WAAW,GAAG,SAAS;IAwBnC,cAAc,IAAI,IAAI;IAItB,MAAM,CAAC,OAAO,EAAE,UAAU,GAAG,IAAI;IAcjC,KAAK,IAAI,IAAI;IAab,MAAM,IAAI,IAAI;IAUd,QAAQ,CAAC,MAAM,EAAE,MAAM,GAAG,SAAS,GAAG,IAAI;IAW1C,OAAO,CAAC,MAAM,EAAE,WAAW,GAAG,SAAS,GAAG,IAAI;IAW9C,SAAS,CAAC,KAAK,EAAE,gBAAgB,GAAG,IAAI;IAMxC,KAAK,CAAC,MAAM,CAAC,EAAE,MAAM,GAAG,IAAI;CA0O7B"}

package/dist/link/channel.js

@@ -0,0 +1,414 @@
+import { CHANNEL_WINDOW, ENVELOPE, KIB, MAX_DATA_BYTES, encodeCredit, encodeEnvelope, encodeAscii, encodeReset, } from "./envelope.js";
+import { LinkByteLengthQueuingStrategy, LinkReadableStream, LinkWritableStream, } from "./streams.js";
+export class LinkChannelError extends Error {
+    reason;
+    constructor(reason, message) {
+        super(message ?? reason);
+        this.reason = reason;
+        this.name = "LinkChannelError";
+    }
+}
+const ACCEPT_WAIT_MS = 30_000;
+const STALL_WAIT_MS = 60_000;
+const WRITER_BUFFER = 64 * KIB;
+export class Channel {
+    number;
+    id;
+    ownedByUs;
+    accepted;
+    view;
+    #host;
+    #failure;
+    #done = false;
+    #openHanded;
+    #queue = [];
+    #queuedBytes = 0;
+    #allowance = CHANNEL_WINDOW;
+    #handed = 0;
+    #inFlight = 0;
+    #endQueued = false;
+    #endHanded = false;
+    #stoppedByPeer = false;
+    #pendingWrite;
+    #creditWaiters = [];
+    #stallTimer;
+    #acceptTimer;
+    #received = 0;
+    #granted = 0;
+    #readTotal = 0;
+    #inQueue = [];
+    #inEnded = false;
+    #stopSent = false;
+    #wantRead = false;
+    #readableController;
+    #writableController;
+    #resetQueued = false;
+    #resetHanded = false;
+    #resetReceived = false;
+    constructor(host, number, id, ownedByUs) {
+        this.#host = host;
+        this.number = number;
+        this.id = id;
+        this.ownedByUs = ownedByUs;
+        this.accepted = ownedByUs;
+        this.#openHanded = !ownedByUs;
+        this.view = this.#buildView();
+        if (ownedByUs) {
+            host.scheduler.binary(encodeEnvelope(ENVELOPE.OPEN, number, encodeAscii(id)), () => {
+                this.#openHanded = true;
+                if (this.hasNext)
+                    host.scheduler.addBulk(this);
+            });
+        }
+        else {
+            this.#acceptTimer = host.clock.setTimer(ACCEPT_WAIT_MS, () => {
+                this.#acceptTimer = undefined;
+                this.#fail(new LinkChannelError("not-accepted"), "not-accepted");
+            });
+        }
+    }
+    get hasNext() {
+        return this.#queue.length > 0;
+    }
+    get credit() {
+        if (this.#failure !== undefined || this.#endQueued || this.#stoppedByPeer)
+            return 0;
+        return Math.max(0, this.#allowance - this.#handed - this.#queuedBytes);
+    }
+    markAccepted() {
+        this.accepted = true;
+        if (this.#acceptTimer !== undefined) {
+            this.#host.clock.cancel(this.#acceptTimer);
+            this.#acceptTimer = undefined;
+        }
+    }
+    takeNext() {
+        const item = this.#queue.shift();
+        if (item === undefined)
+            return undefined;
+        return {
+            bytes: item.bytes,
+            onHanded: () => {
+                if (item.end) {
+                    this.#endHanded = true;
+                    this.#checkDone();
+                    return;
+                }
+                this.#queuedBytes -= item.payload;
+                this.#handed += item.payload;
+                this.#inFlight += 1;
+                this.#updateStall();
+            },
+            onWritten: () => {
+                if (item.end)
+                    return;
+                this.#inFlight -= 1;
+                this.#updateStall();
+            },
+        };
+    }
+    transportMoved() {
+        this.#updateStall();
+    }
+    onData(payload) {
+        if (this.#failure !== undefined)
+            return;
+        if (this.#inEnded)
+            return this.#invalid("DATA after the direction ended");
+        if (this.#stopSent)
+            return;
+        if (payload.length > MAX_DATA_BYTES)
+            return this.#invalid("DATA over 64 KiB");
+        if (this.#received + payload.length > CHANNEL_WINDOW + this.#granted) {
+            return this.#invalid("DATA past the allowed bytes");
+        }
+        if (payload.length === 0)
+            return;
+        this.#received += payload.length;
+        this.#inQueue.push(payload);
+        this.#deliver();
+    }
+    onEnd() {
+        if (this.#failure !== undefined) {
+            // why: the peer's END still ends its direction after this side failed; the slot frees once both are done.
+            this.#inEnded = true;
+            this.#checkDone();
+            return;
+        }
+        if (this.#inEnded)
+            return this.#invalid("END after the direction ended");
+        this.#inEnded = true;
+        this.#deliver();
+        this.#checkDone();
+    }
+    onStop() {
+        if (this.#failure !== undefined)
+            return;
+        if (this.#stoppedByPeer)
+            return this.#invalid("a second STOP for one direction");
+        this.#dropQueuedData();
+        if (this.#endQueued)
+            return;
+        this.#stoppedByPeer = true;
+        this.#queueEnd();
+        this.#failOutgoing(new LinkChannelError("stopped"));
+    }
+    onCredit(amount) {
+        if (this.#failure !== undefined)
+            return;
+        if (amount === undefined || amount < 1)
+            return this.#invalid("a CREDIT of 0");
+        const taken = this.#handed + this.#queuedBytes;
+        if (this.#allowance + amount > taken + CHANNEL_WINDOW) {
+            return this.#invalid("credit beyond 4 MiB outstanding");
+        }
+        this.#allowance += amount;
+        this.#wakeWriters();
+    }
+    onReset(reason) {
+        this.#resetReceived = true;
+        if (this.#failure === undefined) {
+            this.#fail(new LinkChannelError(reason ?? "aborted"), this.#resetQueued ? undefined : "aborted");
+        }
+        this.#checkDone();
+    }
+    closeWith(error) {
+        this.#resetQueued = true;
+        this.#done = true;
+        this.#fail(error, undefined);
+    }
+    abort(reason) {
+        if (this.#failure !== undefined)
+            return;
+        this.#fail(new LinkChannelError("aborted", reason), "aborted");
+    }
+    #invalid(rule) {
+        this.#host.logger.warn(`link: channel ${this.id} broke a rule: ${rule}`);
+        this.#fail(new LinkChannelError("invalid", rule), "invalid");
+    }
+    #fail(error, send) {
+        if (this.#failure !== undefined)
+            return;
+        this.#failure = error;
+        this.#clearTimers();
+        this.#host.scheduler.removeBulk(this);
+        this.#queue = [];
+        this.#queuedBytes = 0;
+        this.#inQueue = [];
+        this.#wantRead = false;
+        this.#failOutgoing(error);
+        try {
+            this.#readableController?.error(error);
+        }
+        catch {
+            // why: the readable may already be closed or cancelled, and a stream cannot be errored twice.
+        }
+        if (send !== undefined && !this.#resetQueued) {
+            this.#resetQueued = true;
+            this.#host.scheduler.binary(encodeReset(this.number, send), () => {
+                this.#resetHanded = true;
+                this.#checkDone();
+            });
+        }
+        this.#checkDone();
+    }
+    #failOutgoing(error) {
+        this.#clearStall();
+        const pending = this.#pendingWrite;
+        this.#pendingWrite = undefined;
+        pending?.reject(error);
+        for (const waiter of this.#creditWaiters.splice(0))
+            waiter.reject(error);
+        try {
+            this.#writableController?.error(error);
+        }
+        catch {
+            // why: the writable may already be closed or errored.
+        }
+    }
+    #checkDone() {
+        if (this.#done)
+            return;
+        const ours = this.#resetHanded || this.#endHanded;
+        const theirs = this.#resetReceived || this.#inEnded;
+        if (!ours || !theirs)
+            return;
+        this.#done = true;
+        this.#clearTimers();
+        this.#host.scheduler.removeBulk(this);
+        this.#host.channelDone(this);
+    }
+    #clearTimers() {
+        this.#clearStall();
+        if (this.#acceptTimer !== undefined) {
+            this.#host.clock.cancel(this.#acceptTimer);
+            this.#acceptTimer = undefined;
+        }
+    }
+    #dropQueuedData() {
+        this.#queue = this.#queue.filter((item) => item.end);
+        this.#queuedBytes = 0;
+        if (this.#queue.length === 0)
+            this.#host.scheduler.removeBulk(this);
+    }
+    #queueEnd() {
+        this.#endQueued = true;
+        this.#queue.push({ bytes: encodeEnvelope(ENVELOPE.END, this.number), end: true, payload: 0 });
+        if (this.#openHanded)
+            this.#host.scheduler.addBulk(this);
+    }
+    #take(chunk) {
+        for (let offset = 0; offset < chunk.length; offset += MAX_DATA_BYTES) {
+            const piece = chunk.subarray(offset, Math.min(chunk.length, offset + MAX_DATA_BYTES));
+            this.#queue.push({
+                bytes: encodeEnvelope(ENVELOPE.DATA, this.number, piece),
+                end: false,
+                payload: piece.length,
+            });
+            this.#queuedBytes += piece.length;
+        }
+        if (this.#openHanded)
+            this.#host.scheduler.addBulk(this);
+    }
+    #wakeWriters() {
+        const pending = this.#pendingWrite;
+        this.#pendingWrite = undefined;
+        pending?.resolve();
+        for (const waiter of this.#creditWaiters.splice(0))
+            waiter.resolve();
+        this.#updateStall();
+    }
+    #updateStall() {
+        const waiting = this.#pendingWrite !== undefined || this.#creditWaiters.length > 0;
+        const peerHoldsEverything = this.#queuedBytes === 0 && (this.#host.unsentBytes() === 0 || this.#inFlight === 0);
+        if (!waiting || !peerHoldsEverything || this.#failure !== undefined) {
+            this.#clearStall();
+            return;
+        }
+        if (this.#stallTimer !== undefined)
+            return;
+        this.#stallTimer = this.#host.clock.setTimer(STALL_WAIT_MS, () => {
+            this.#stallTimer = undefined;
+            this.#fail(new LinkChannelError("stalled"), "stalled");
+        });
+    }
+    #clearStall() {
+        if (this.#stallTimer === undefined)
+            return;
+        this.#host.clock.cancel(this.#stallTimer);
+        this.#stallTimer = undefined;
+    }
+    #deliver() {
+        const controller = this.#readableController;
+        if (controller === undefined || !this.#wantRead || this.#stopSent)
+            return;
+        const chunk = this.#inQueue.shift();
+        if (chunk !== undefined) {
+            this.#wantRead = false;
+            this.#readTotal += chunk.length;
+            controller.enqueue(chunk);
+            this.#grant();
+            return;
+        }
+        if (this.#inEnded) {
+            this.#wantRead = false;
+            controller.close();
+        }
+    }
+    #grant() {
+        const unread = this.#readTotal - this.#granted;
+        if (unread <= 0 || this.#inEnded)
+            return;
+        if (unread < 64 * KIB && this.#inQueue.length > 0)
+            return;
+        this.#granted += unread;
+        this.#host.scheduler.binary(encodeCredit(this.number, unread));
+    }
+    #cancelReadable() {
+        if (this.#stopSent || this.#failure !== undefined)
+            return;
+        this.#inQueue = [];
+        this.#wantRead = false;
+        if (this.#inEnded)
+            return;
+        this.#stopSent = true;
+        this.#host.scheduler.binary(encodeEnvelope(ENVELOPE.STOP, this.number));
+    }
+    #buildView() {
+        const readable = new LinkReadableStream({
+            start: (controller) => {
+                this.#readableController = controller;
+            },
+            pull: () => {
+                this.#wantRead = true;
+                this.#deliver();
+            },
+            cancel: () => this.#cancelReadable(),
+        }, { highWaterMark: 0 });
+        const writable = new LinkWritableStream({
+            start: (controller) => {
+                this.#writableController = controller;
+            },
+            write: (chunk) => this.#write(chunk),
+            close: () => {
+                if (this.#failure !== undefined)
+                    throw this.#failure;
+                if (this.#endQueued)
+                    return;
+                this.#queueEnd();
+                const error = new LinkChannelError("closed", "the channel's sending direction ended");
+                for (const waiter of this.#creditWaiters.splice(0))
+                    waiter.reject(error);
+                this.#updateStall();
+            },
+            abort: (reason) => {
+                this.abort(reason === undefined ? undefined : String(reason));
+            },
+        }, new LinkByteLengthQueuingStrategy({ highWaterMark: WRITER_BUFFER }));
+        const currentCredit = () => this.credit;
+        return {
+            abort: (reason) => this.abort(reason),
+            get credit() {
+                return currentCredit();
+            },
+            id: this.id,
+            readable,
+            whenCredit: () => this.#whenCredit(),
+            writable,
+        };
+    }
+    async #write(chunk) {
+        let offset = 0;
+        while (offset < chunk.length) {
+            if (this.#failure !== undefined)
+                throw this.#failure;
+            if (this.#stoppedByPeer)
+                throw new LinkChannelError("stopped");
+            const n = Math.min(this.credit, chunk.length - offset);
+            if (n > 0) {
+                this.#take(chunk.subarray(offset, offset + n));
+                offset += n;
+                continue;
+            }
+            await new Promise((resolve, reject) => {
+                this.#pendingWrite = { reject, resolve };
+                this.#updateStall();
+            });
+        }
+    }
+    #whenCredit() {
+        if (this.#failure !== undefined)
+            return Promise.reject(this.#failure);
+        if (this.#stoppedByPeer)
+            return Promise.reject(new LinkChannelError("stopped"));
+        if (this.#endQueued) {
+            return Promise.reject(new LinkChannelError("closed", "the channel's sending direction ended"));
+        }
+        if (this.credit > 0)
+            return Promise.resolve();
+        return new Promise((resolve, reject) => {
+            this.#creditWaiters.push({ reject, resolve });
+            this.#updateStall();
+        });
+    }
+}

package/dist/link/envelope.d.ts

@@ -0,0 +1,38 @@
+export declare const KIB = 1024;
+export declare const MAX_DATA_BYTES: number;
+export declare const CHANNEL_WINDOW: number;
+export declare const MAX_CHANNEL_NUMBER = 4294967295;
+export declare const ENVELOPE: {
+    readonly OPEN: 1;
+    readonly DATA: 2;
+    readonly END: 3;
+    readonly STOP: 4;
+    readonly CREDIT: 5;
+    readonly RESET: 6;
+};
+export type EnvelopeType = (typeof ENVELOPE)[keyof typeof ENVELOPE];
+declare const RESET_CODES: {
+    readonly aborted: 1;
+    readonly stalled: 2;
+    readonly "not-accepted": 3;
+    readonly invalid: 4;
+};
+export type ResetReason = keyof typeof RESET_CODES;
+export interface ParsedEnvelope {
+    readonly type: number;
+    readonly number: number;
+    readonly payload: Uint8Array;
+}
+export declare function encodeEnvelope(type: EnvelopeType, number: number, payload?: Uint8Array): Uint8Array;
+export declare function encodeCredit(number: number, amount: number): Uint8Array;
+export declare function encodeReset(number: number, reason: ResetReason): Uint8Array;
+export declare function parseEnvelope(bytes: Uint8Array): ParsedEnvelope | undefined;
+export declare function isEnvelopeType(type: number): type is EnvelopeType;
+export declare function parseCredit(payload: Uint8Array): number | undefined;
+export declare function parseResetReason(payload: Uint8Array): ResetReason | undefined;
+export declare function utf8Length(text: string): number;
+export declare function isChannelId(id: string): boolean;
+export declare function parseChannelId(payload: Uint8Array): string | undefined;
+export declare function encodeAscii(text: string): Uint8Array;
+export {};
+//# sourceMappingURL=envelope.d.ts.map

package/dist/link/envelope.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"envelope.d.ts","sourceRoot":"","sources":["../../src/link/envelope.ts"],"names":[],"mappings":"AAAA,eAAO,MAAM,GAAG,OAAO,CAAC;AACxB,eAAO,MAAM,cAAc,QAAW,CAAC;AACvC,eAAO,MAAM,cAAc,QAAgB,CAAC;AAC5C,eAAO,MAAM,kBAAkB,aAAa,CAAC;AAE7C,eAAO,MAAM,QAAQ;;;;;;;CAAsE,CAAC;AAC5F,MAAM,MAAM,YAAY,GAAG,CAAC,OAAO,QAAQ,CAAC,CAAC,MAAM,OAAO,QAAQ,CAAC,CAAC;AAEpE,QAAA,MAAM,WAAW;;;;;CAAqE,CAAC;AACvF,MAAM,MAAM,WAAW,GAAG,MAAM,OAAO,WAAW,CAAC;AAKnD,MAAM,WAAW,cAAc;IAC7B,QAAQ,CAAC,IAAI,EAAE,MAAM,CAAC;IACtB,QAAQ,CAAC,MAAM,EAAE,MAAM,CAAC;IACxB,QAAQ,CAAC,OAAO,EAAE,UAAU,CAAC;CAC9B;AAED,wBAAgB,cAAc,CAC5B,IAAI,EAAE,YAAY,EAClB,MAAM,EAAE,MAAM,EACd,OAAO,GAAE,UAA8B,GACtC,UAAU,CAMZ;AAED,wBAAgB,YAAY,CAAC,MAAM,EAAE,MAAM,EAAE,MAAM,EAAE,MAAM,GAAG,UAAU,CAIvE;AAED,wBAAgB,WAAW,CAAC,MAAM,EAAE,MAAM,EAAE,MAAM,EAAE,WAAW,GAAG,UAAU,CAE3E;AAED,wBAAgB,aAAa,CAAC,KAAK,EAAE,UAAU,GAAG,cAAc,GAAG,SAAS,CAI3E;AAED,wBAAgB,cAAc,CAAC,IAAI,EAAE,MAAM,GAAG,IAAI,IAAI,YAAY,CAEjE;AAED,wBAAgB,WAAW,CAAC,OAAO,EAAE,UAAU,GAAG,MAAM,GAAG,SAAS,CAGnE;AAED,wBAAgB,gBAAgB,CAAC,OAAO,EAAE,UAAU,GAAG,WAAW,GAAG,SAAS,CAM7E;AAGD,wBAAgB,UAAU,CAAC,IAAI,EAAE,MAAM,GAAG,MAAM,CAgB/C;AAMD,wBAAgB,WAAW,CAAC,EAAE,EAAE,MAAM,GAAG,OAAO,CAE/C;AAED,wBAAgB,cAAc,CAAC,OAAO,EAAE,UAAU,GAAG,MAAM,GAAG,SAAS,CAGtE;AAID,wBAAgB,WAAW,CAAC,IAAI,EAAE,MAAM,GAAG,UAAU,CAIpD"}

package/dist/link/envelope.js

@@ -0,0 +1,90 @@
+export const KIB = 1024;
+export const MAX_DATA_BYTES = 64 * KIB;
+export const CHANNEL_WINDOW = 4 * KIB * KIB;
+export const MAX_CHANNEL_NUMBER = 0xffffffff;
+export const ENVELOPE = { OPEN: 1, DATA: 2, END: 3, STOP: 4, CREDIT: 5, RESET: 6 };
+const RESET_CODES = { aborted: 1, stalled: 2, "not-accepted": 3, invalid: 4 };
+const HEADER_BYTES = 5;
+const CHANNEL_ID = /^[A-Za-z0-9-]{1,32}$/;
+export function encodeEnvelope(type, number, payload = new Uint8Array(0)) {
+    const bytes = new Uint8Array(HEADER_BYTES + payload.length);
+    bytes[0] = type;
+    new DataView(bytes.buffer).setUint32(1, number);
+    bytes.set(payload, HEADER_BYTES);
+    return bytes;
+}
+export function encodeCredit(number, amount) {
+    const payload = new Uint8Array(4);
+    new DataView(payload.buffer).setUint32(0, amount);
+    return encodeEnvelope(ENVELOPE.CREDIT, number, payload);
+}
+export function encodeReset(number, reason) {
+    return encodeEnvelope(ENVELOPE.RESET, number, new Uint8Array([RESET_CODES[reason]]));
+}
+export function parseEnvelope(bytes) {
+    if (bytes.length < HEADER_BYTES)
+        return undefined;
+    const view = new DataView(bytes.buffer, bytes.byteOffset, bytes.byteLength);
+    return { number: view.getUint32(1), payload: bytes.slice(HEADER_BYTES), type: bytes[0] ?? 0 };
+}
+export function isEnvelopeType(type) {
+    return type >= ENVELOPE.OPEN && type <= ENVELOPE.RESET;
+}
+export function parseCredit(payload) {
+    if (payload.length !== 4)
+        return undefined;
+    return new DataView(payload.buffer, payload.byteOffset, payload.byteLength).getUint32(0);
+}
+export function parseResetReason(payload) {
+    const code = payload[0];
+    for (const [reason, value] of Object.entries(RESET_CODES)) {
+        if (value === code)
+            return reason;
+    }
+    return undefined;
+}
+// why: counted the way Buffer.byteLength counts, so the link needs no Buffer (a browser has none).
+export function utf8Length(text) {
+    let bytes = 0;
+    for (let at = 0; at < text.length; at += 1) {
+        const code = text.charCodeAt(at);
+        if (code < 0x80) {
+            bytes += 1;
+        }
+        else if (code < 0x800) {
+            bytes += 2;
+        }
+        else if (code >= 0xd800 && code <= 0xdbff && isLowSurrogate(text.charCodeAt(at + 1))) {
+            bytes += 4;
+            at += 1;
+        }
+        else {
+            bytes += 3;
+        }
+    }
+    return bytes;
+}
+function isLowSurrogate(code) {
+    return code >= 0xdc00 && code <= 0xdfff;
+}
+export function isChannelId(id) {
+    return CHANNEL_ID.test(id);
+}
+export function parseChannelId(payload) {
+    const id = decodeAscii(payload);
+    return isChannelId(id) ? id : undefined;
+}
+// harness: channel ids are ASCII, so the link needs no TextEncoder or TextDecoder (not every
+// Hermes has TextDecoder). A byte over 0x7f decodes to a character the id pattern refuses.
+export function encodeAscii(text) {
+    const bytes = new Uint8Array(text.length);
+    for (let at = 0; at < text.length; at += 1)
+        bytes[at] = text.charCodeAt(at) & 0xff;
+    return bytes;
+}
+function decodeAscii(bytes) {
+    let text = "";
+    for (let at = 0; at < bytes.length; at += 1)
+        text += String.fromCharCode(bytes[at] ?? 0);
+    return text;
+}

package/dist/link/index.d.ts

@@ -0,0 +1,22 @@
+import type { Clock, IpcConnection, Logger, UplinkTransportConnection } from "./ports.js";
+import { type LinkChannel } from "./channel.js";
+export { LinkChannelError } from "./channel.js";
+export type { LinkChannel, LinkChannelErrorReason } from "./channel.js";
+export { globalClock } from "./ports.js";
+export type { Clock, IpcConnection, Logger, TimerHandle, UplinkTransportConnection, } from "./ports.js";
+export { connectStandardWebSocket, StandardWebSocketConnection, type StandardWebSocket, type StandardWebSocketDialOptions, type StandardWebSocketOptions, } from "./standard-websocket.js";
+export interface LinkConnection extends IpcConnection {
+    openChannel(options: {
+        readonly signal: AbortSignal;
+    }): Promise<LinkChannel>;
+    acceptChannel(id: string): LinkChannel;
+}
+export interface LinkOptions {
+    readonly end: "worker" | "gateway";
+    readonly clock: Clock;
+    readonly logger: Logger;
+    readonly firstChannelNumber?: number;
+    readonly generateId?: () => string;
+}
+export declare function createLink(transport: UplinkTransportConnection, options: LinkOptions): LinkConnection;
+//# sourceMappingURL=index.d.ts.map