@react-native-harness/bridge 1.5.0 → 1.6.0

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

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

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../src/link/index.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,KAAK,EAAE,aAAa,EAAE,MAAM,EAAE,yBAAyB,EAAE,MAAM,YAAY,CAAC;AAC1F,OAAO,EAA+C,KAAK,WAAW,EAAE,MAAM,cAAc,CAAC;AAc7F,OAAO,EAAE,gBAAgB,EAAE,MAAM,cAAc,CAAC;AAChD,YAAY,EAAE,WAAW,EAAE,sBAAsB,EAAE,MAAM,cAAc,CAAC;AACxE,OAAO,EAAE,WAAW,EAAE,MAAM,YAAY,CAAC;AACzC,YAAY,EACV,KAAK,EACL,aAAa,EACb,MAAM,EACN,WAAW,EACX,yBAAyB,GAC1B,MAAM,YAAY,CAAC;AACpB,OAAO,EACL,wBAAwB,EACxB,2BAA2B,EAC3B,KAAK,iBAAiB,EACtB,KAAK,4BAA4B,EACjC,KAAK,wBAAwB,GAC9B,MAAM,yBAAyB,CAAC;AAEjC,MAAM,WAAW,cAAe,SAAQ,aAAa;IACnD,WAAW,CAAC,OAAO,EAAE;QAAE,QAAQ,CAAC,MAAM,EAAE,WAAW,CAAA;KAAE,GAAG,OAAO,CAAC,WAAW,CAAC,CAAC;IAC7E,aAAa,CAAC,EAAE,EAAE,MAAM,GAAG,WAAW,CAAC;CACxC;AAED,MAAM,WAAW,WAAW;IAC1B,QAAQ,CAAC,GAAG,EAAE,QAAQ,GAAG,SAAS,CAAC;IACnC,QAAQ,CAAC,KAAK,EAAE,KAAK,CAAC;IACtB,QAAQ,CAAC,MAAM,EAAE,MAAM,CAAC;IACxB,QAAQ,CAAC,kBAAkB,CAAC,EAAE,MAAM,CAAC;IACrC,QAAQ,CAAC,UAAU,CAAC,EAAE,MAAM,MAAM,CAAC;CACpC;AA+QD,wBAAgB,UAAU,CACxB,SAAS,EAAE,yBAAyB,EACpC,OAAO,EAAE,WAAW,GACnB,cAAc,CAEhB"}

package/dist/link/index.js

@@ -0,0 +1,271 @@
+import { Channel, LinkChannelError } from "./channel.js";
+import { ENVELOPE, MAX_CHANNEL_NUMBER, isChannelId, isEnvelopeType, parseChannelId, parseCredit, parseEnvelope, parseResetReason, } from "./envelope.js";
+import { Scheduler } from "./scheduler.js";
+export { LinkChannelError } from "./channel.js";
+export { globalClock } from "./ports.js";
+export { connectStandardWebSocket, StandardWebSocketConnection, } from "./standard-websocket.js";
+const OPEN_LIMIT = 64;
+class Link {
+    clock;
+    logger;
+    scheduler;
+    #transport;
+    #ownParity;
+    #generateId;
+    #channels = new Map();
+    #unaccepted = new Map();
+    #waiters = [];
+    #dataListeners = new Set();
+    #closeListeners = new Set();
+    #errorListeners = new Set();
+    #pendingText = [];
+    #nextOwn;
+    #highestPeer = 0;
+    #ownOpen = 0;
+    #peerOpen = 0;
+    #closed = false;
+    constructor(transport, options) {
+        this.clock = options.clock;
+        this.logger = options.logger;
+        this.#transport = transport;
+        this.#ownParity = options.end === "worker" ? 1 : 0;
+        this.#generateId = options.generateId ?? randomId;
+        this.#nextOwn = options.firstChannelNumber ?? (options.end === "worker" ? 1 : 2);
+        this.scheduler = new Scheduler(transport);
+        transport.onData((chunk) => this.#onText(chunk));
+        transport.onBinary((bytes) => this.#onBinary(bytes));
+        transport.onError((error) => {
+            for (const listener of this.#errorListeners)
+                listener(error);
+        });
+        transport.onSent(() => {
+            for (const channel of this.#channels.values())
+                channel.transportMoved();
+        });
+        transport.onClose(() => this.#onTransportClosed());
+    }
+    get closed() {
+        return this.#closed || this.#transport.closed;
+    }
+    unsentBytes() {
+        return this.#transport.unsentBytes;
+    }
+    onData(listener) {
+        this.#dataListeners.add(listener);
+        if (this.#pendingText.length > 0) {
+            for (const chunk of this.#pendingText.splice(0))
+                listener(chunk);
+        }
+        return () => {
+            this.#dataListeners.delete(listener);
+        };
+    }
+    onClose(listener) {
+        if (this.#closed) {
+            listener();
+            return () => undefined;
+        }
+        this.#closeListeners.add(listener);
+        return () => {
+            this.#closeListeners.delete(listener);
+        };
+    }
+    onError(listener) {
+        this.#errorListeners.add(listener);
+        return () => {
+            this.#errorListeners.delete(listener);
+        };
+    }
+    write(contents) {
+        return this.scheduler.text(contents);
+    }
+    async close() {
+        await this.#transport.close();
+        this.#onTransportClosed();
+    }
+    openChannel(options) {
+        const { signal } = options;
+        if (this.#closed)
+            return Promise.reject(new LinkChannelError("closed"));
+        if (signal.aborted)
+            return Promise.reject(signal.reason);
+        if (this.#ownOpen < OPEN_LIMIT && this.#waiters.length === 0) {
+            try {
+                return Promise.resolve(this.#open().view);
+            }
+            catch (error) {
+                return Promise.reject(error);
+            }
+        }
+        return new Promise((resolve, reject) => {
+            const onAbort = () => {
+                const at = this.#waiters.findIndex((waiter) => waiter.onAbort === onAbort);
+                if (at >= 0)
+                    this.#waiters.splice(at, 1);
+                reject(signal.reason);
+            };
+            signal.addEventListener("abort", onAbort, { once: true });
+            this.#waiters.push({ onAbort, reject, resolve, signal });
+        });
+    }
+    acceptChannel(id) {
+        const channel = this.#unaccepted.get(id);
+        if (channel === undefined) {
+            throw new Error(`channel ${id} was not opened by the peer, or was already accepted or ended`);
+        }
+        this.#unaccepted.delete(id);
+        channel.markAccepted();
+        return channel.view;
+    }
+    channelDone(channel) {
+        if (this.#channels.get(channel.number) !== channel)
+            return;
+        this.#forget(channel);
+        this.#drainWaiters();
+    }
+    #forget(channel) {
+        this.#channels.delete(channel.number);
+        if (this.#unaccepted.get(channel.id) === channel)
+            this.#unaccepted.delete(channel.id);
+        if (channel.ownedByUs)
+            this.#ownOpen -= 1;
+        else
+            this.#peerOpen -= 1;
+    }
+    #open() {
+        if (this.#nextOwn > MAX_CHANNEL_NUMBER) {
+            this.logger.warn("link: this side has used every channel number on the connection");
+            throw new Error("the link has no channel numbers left on this connection");
+        }
+        let id = this.#newId();
+        while (this.#channels.size > 0 && [...this.#channels.values()].some((c) => c.id === id)) {
+            id = this.#newId();
+        }
+        const number = this.#nextOwn;
+        this.#nextOwn += 2;
+        const channel = new Channel(this, number, id, true);
+        this.#channels.set(number, channel);
+        this.#ownOpen += 1;
+        return channel;
+    }
+    #newId() {
+        const id = this.#generateId();
+        if (!isChannelId(id)) {
+            throw new Error("link: `generateId` must make ids of 1 to 32 characters from [A-Za-z0-9-]");
+        }
+        return id;
+    }
+    #drainWaiters() {
+        while (this.#waiters.length > 0 && this.#ownOpen < OPEN_LIMIT && !this.#closed) {
+            const waiter = this.#waiters.shift();
+            if (waiter === undefined)
+                break;
+            waiter.signal.removeEventListener("abort", waiter.onAbort);
+            try {
+                waiter.resolve(this.#open().view);
+            }
+            catch (error) {
+                waiter.reject(error);
+            }
+        }
+    }
+    #onText(chunk) {
+        if (this.#dataListeners.size === 0) {
+            this.#pendingText.push(chunk);
+            return;
+        }
+        for (const listener of this.#dataListeners)
+            listener(chunk);
+    }
+    #onTransportClosed() {
+        if (this.#closed)
+            return;
+        this.#closed = true;
+        this.scheduler.close();
+        for (const waiter of this.#waiters.splice(0)) {
+            waiter.signal.removeEventListener("abort", waiter.onAbort);
+            waiter.reject(new LinkChannelError("closed"));
+        }
+        const error = new LinkChannelError("closed");
+        for (const channel of this.#channels.values())
+            channel.closeWith(error);
+        this.#channels.clear();
+        this.#unaccepted.clear();
+        for (const listener of this.#closeListeners)
+            listener();
+    }
+    #warn(rule) {
+        this.logger.warn(`link: dropped a message from the peer: ${rule}`);
+    }
+    #onBinary(bytes) {
+        const envelope = parseEnvelope(bytes);
+        if (envelope === undefined)
+            return this.#warn("a message too short to read");
+        if (!isEnvelopeType(envelope.type))
+            return this.#warn("an unknown envelope type");
+        if (envelope.type === ENVELOPE.OPEN)
+            return this.#onOpen(envelope.number, envelope.payload);
+        const channel = this.#channels.get(envelope.number);
+        if (channel === undefined) {
+            if (!this.#isLate(envelope.number))
+                this.#warn("a channel number the peer never opened");
+            return;
+        }
+        this.#dispatch(channel, envelope);
+    }
+    #dispatch(channel, envelope) {
+        switch (envelope.type) {
+            case ENVELOPE.DATA:
+                return channel.onData(envelope.payload);
+            case ENVELOPE.END:
+                return channel.onEnd();
+            case ENVELOPE.STOP:
+                return channel.onStop();
+            case ENVELOPE.CREDIT:
+                return channel.onCredit(parseCredit(envelope.payload));
+            case ENVELOPE.RESET:
+                return channel.onReset(parseResetReason(envelope.payload));
+        }
+    }
+    #isLate(number) {
+        if (number < 1)
+            return false;
+        if (number % 2 === this.#ownParity)
+            return number < this.#nextOwn;
+        return number <= this.#highestPeer;
+    }
+    #onOpen(number, payload) {
+        if (number % 2 === this.#ownParity || number < 1)
+            return this.#warn("an OPEN with the wrong parity");
+        if (number <= this.#highestPeer) {
+            return this.#warn(this.#channels.has(number)
+                ? "an OPEN reusing a live number"
+                : "an OPEN reusing an ended number");
+        }
+        if (this.#peerOpen >= OPEN_LIMIT)
+            return this.#warn("a 65th OPEN from the peer");
+        const id = parseChannelId(payload);
+        if (id === undefined)
+            return this.#warn("an OPEN with an id outside [A-Za-z0-9-]{1,32}");
+        if (this.#unaccepted.has(id))
+            return this.#warn("an OPEN reusing an id not yet accepted");
+        this.#highestPeer = number;
+        const channel = new Channel(this, number, id, false);
+        this.#channels.set(number, channel);
+        this.#unaccepted.set(id, channel);
+        this.#peerOpen += 1;
+    }
+}
+function randomId() {
+    const source = globalThis.crypto;
+    if (typeof source?.randomUUID === "function")
+        return source.randomUUID().replace(/-/g, "");
+    if (typeof source?.getRandomValues === "function") {
+        const bytes = source.getRandomValues(new Uint8Array(16));
+        return Array.from(bytes, (byte) => byte.toString(16).padStart(2, "0")).join("");
+    }
+    throw new Error("link: this runtime has no crypto to make channel ids; pass `generateId`");
+}
+export function createLink(transport, options) {
+    return new Link(transport, options);
+}

package/dist/link/ports.d.ts

@@ -0,0 +1,31 @@
+export interface TimerHandle {
+    readonly _timerHandle?: never;
+}
+export interface Clock {
+    now(): number;
+    setTimer(delayMs: number, callback: () => void): TimerHandle;
+    cancel(handle: TimerHandle): void;
+}
+export declare const globalClock: Clock;
+export interface Logger {
+    debug(message: string, fields?: Record<string, unknown>): void;
+    info(message: string, fields?: Record<string, unknown>): void;
+    warn(message: string, fields?: Record<string, unknown>): void;
+    error(message: string, fields?: Record<string, unknown>): void;
+    child(module: string): Logger;
+}
+export interface IpcConnection {
+    readonly closed: boolean;
+    onData(listener: (chunk: string) => void): () => void;
+    onClose(listener: () => void): () => void;
+    onError(listener: (error: Error) => void): () => void;
+    write(contents: string): Promise<void>;
+    close(): Promise<void>;
+}
+export interface UplinkTransportConnection extends IpcConnection {
+    writeBinary(bytes: Uint8Array): Promise<void>;
+    onBinary(listener: (bytes: Uint8Array) => void): () => void;
+    readonly unsentBytes: number;
+    onSent(listener: () => void): () => void;
+}
+//# sourceMappingURL=ports.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"ports.d.ts","sourceRoot":"","sources":["../../src/link/ports.ts"],"names":[],"mappings":"AAGA,MAAM,WAAW,WAAW;IAC1B,QAAQ,CAAC,YAAY,CAAC,EAAE,KAAK,CAAC;CAC/B;AAED,MAAM,WAAW,KAAK;IACpB,GAAG,IAAI,MAAM,CAAC;IACd,QAAQ,CAAC,OAAO,EAAE,MAAM,EAAE,QAAQ,EAAE,MAAM,IAAI,GAAG,WAAW,CAAC;IAC7D,MAAM,CAAC,MAAM,EAAE,WAAW,GAAG,IAAI,CAAC;CACnC;AAED,eAAO,MAAM,WAAW,EAAE,KAIzB,CAAC;AAEF,MAAM,WAAW,MAAM;IACrB,KAAK,CAAC,OAAO,EAAE,MAAM,EAAE,MAAM,CAAC,EAAE,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,GAAG,IAAI,CAAC;IAC/D,IAAI,CAAC,OAAO,EAAE,MAAM,EAAE,MAAM,CAAC,EAAE,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,GAAG,IAAI,CAAC;IAC9D,IAAI,CAAC,OAAO,EAAE,MAAM,EAAE,MAAM,CAAC,EAAE,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,GAAG,IAAI,CAAC;IAC9D,KAAK,CAAC,OAAO,EAAE,MAAM,EAAE,MAAM,CAAC,EAAE,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,GAAG,IAAI,CAAC;IAC/D,KAAK,CAAC,MAAM,EAAE,MAAM,GAAG,MAAM,CAAC;CAC/B;AAED,MAAM,WAAW,aAAa;IAC5B,QAAQ,CAAC,MAAM,EAAE,OAAO,CAAC;IACzB,MAAM,CAAC,QAAQ,EAAE,CAAC,KAAK,EAAE,MAAM,KAAK,IAAI,GAAG,MAAM,IAAI,CAAC;IACtD,OAAO,CAAC,QAAQ,EAAE,MAAM,IAAI,GAAG,MAAM,IAAI,CAAC;IAC1C,OAAO,CAAC,QAAQ,EAAE,CAAC,KAAK,EAAE,KAAK,KAAK,IAAI,GAAG,MAAM,IAAI,CAAC;IACtD,KAAK,CAAC,QAAQ,EAAE,MAAM,GAAG,OAAO,CAAC,IAAI,CAAC,CAAC;IACvC,KAAK,IAAI,OAAO,CAAC,IAAI,CAAC,CAAC;CACxB;AAED,MAAM,WAAW,yBAA0B,SAAQ,aAAa;IAC9D,WAAW,CAAC,KAAK,EAAE,UAAU,GAAG,OAAO,CAAC,IAAI,CAAC,CAAC;IAC9C,QAAQ,CAAC,QAAQ,EAAE,CAAC,KAAK,EAAE,UAAU,KAAK,IAAI,GAAG,MAAM,IAAI,CAAC;IAC5D,QAAQ,CAAC,WAAW,EAAE,MAAM,CAAC;IAC7B,MAAM,CAAC,QAAQ,EAAE,MAAM,IAAI,GAAG,MAAM,IAAI,CAAC;CAC1C"}

package/dist/link/ports.js

@@ -0,0 +1,7 @@
+// The parts of simlock's `src/ports` the link uses. Types only, plus `globalClock`,
+// so the link runs unchanged in Node, a browser, and React Native.
+export const globalClock = {
+    cancel: (handle) => clearTimeout(handle),
+    now: () => Date.now(),
+    setTimer: (delayMs, callback) => setTimeout(callback, delayMs),
+};

package/dist/link/scheduler.d.ts

@@ -0,0 +1,21 @@
+import type { UplinkTransportConnection } from "./ports.js";
+export interface BulkMessage {
+    readonly bytes: Uint8Array;
+    onHanded(): void;
+    onWritten(): void;
+}
+export interface BulkSource {
+    takeNext(): BulkMessage | undefined;
+    readonly hasNext: boolean;
+}
+export declare class Scheduler {
+    #private;
+    constructor(transport: UplinkTransportConnection);
+    text(text: string): Promise<void>;
+    binary(bytes: Uint8Array, onHanded?: () => void): void;
+    addBulk(source: BulkSource): void;
+    removeBulk(source: BulkSource): void;
+    wake(): void;
+    close(): void;
+}
+//# sourceMappingURL=scheduler.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"scheduler.d.ts","sourceRoot":"","sources":["../../src/link/scheduler.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,yBAAyB,EAAE,MAAM,YAAY,CAAC;AAM5D,MAAM,WAAW,WAAW;IAC1B,QAAQ,CAAC,KAAK,EAAE,UAAU,CAAC;IAC3B,QAAQ,IAAI,IAAI,CAAC;IACjB,SAAS,IAAI,IAAI,CAAC;CACnB;AAED,MAAM,WAAW,UAAU;IACzB,QAAQ,IAAI,WAAW,GAAG,SAAS,CAAC;IACpC,QAAQ,CAAC,OAAO,EAAE,OAAO,CAAC;CAC3B;AAMD,qBAAa,SAAS;;gBAUR,SAAS,EAAE,yBAAyB;IAKhD,IAAI,CAAC,IAAI,EAAE,MAAM,GAAG,OAAO,CAAC,IAAI,CAAC;IAQjC,MAAM,CAAC,KAAK,EAAE,UAAU,EAAE,QAAQ,CAAC,EAAE,MAAM,IAAI,GAAG,IAAI;IAQtD,OAAO,CAAC,MAAM,EAAE,UAAU,GAAG,IAAI;IAOjC,UAAU,CAAC,MAAM,EAAE,UAAU,GAAG,IAAI;IAKpC,IAAI,IAAI,IAAI;IASZ,KAAK,IAAI,IAAI;CA0Dd"}

package/dist/link/scheduler.js

@@ -0,0 +1,116 @@
+import { KIB, utf8Length } from "./envelope.js";
+const UNSENT_MARK = 256 * KIB;
+const PRIORITY_SHARE = 64 * KIB;
+export class Scheduler {
+    #transport;
+    #priority = [];
+    #ring = [];
+    #inRing = new Set();
+    #prioritySinceBulk = 0;
+    #pumping = false;
+    #scheduled = false;
+    #closed = false;
+    constructor(transport) {
+        this.#transport = transport;
+        transport.onSent(() => this.wake());
+    }
+    text(text) {
+        if (this.#closed)
+            return Promise.resolve();
+        return new Promise((resolve) => {
+            this.#priority.push({ kind: "text", resolve, text });
+            this.wake();
+        });
+    }
+    binary(bytes, onHanded) {
+        if (this.#closed)
+            return;
+        this.#priority.push(onHanded === undefined ? { bytes, kind: "binary" } : { bytes, kind: "binary", onHanded });
+        this.wake();
+    }
+    addBulk(source) {
+        if (this.#inRing.has(source))
+            return;
+        this.#inRing.add(source);
+        this.#ring.push(source);
+        this.wake();
+    }
+    removeBulk(source) {
+        if (!this.#inRing.delete(source))
+            return;
+        this.#ring.splice(this.#ring.indexOf(source), 1);
+    }
+    wake() {
+        if (this.#scheduled || this.#closed)
+            return;
+        this.#scheduled = true;
+        queueMicrotask(() => {
+            this.#scheduled = false;
+            this.#pump();
+        });
+    }
+    close() {
+        this.#closed = true;
+        for (const message of this.#priority.splice(0)) {
+            if (message.kind === "text")
+                message.resolve();
+        }
+        this.#ring.length = 0;
+        this.#inRing.clear();
+    }
+    #pump() {
+        if (this.#pumping)
+            return;
+        this.#pumping = true;
+        try {
+            while (!this.#closed) {
+                const canBulk = this.#ring.length > 0 && this.#transport.unsentBytes < UNSENT_MARK;
+                const bulkDue = canBulk && this.#prioritySinceBulk >= PRIORITY_SHARE;
+                if (this.#priority.length > 0 && !bulkDue) {
+                    this.#sendPriority();
+                }
+                else if (canBulk) {
+                    this.#sendBulk();
+                }
+                else {
+                    break;
+                }
+            }
+        }
+        finally {
+            this.#pumping = false;
+        }
+    }
+    #sendPriority() {
+        const message = this.#priority.shift();
+        if (message === undefined)
+            return;
+        if (message.kind === "text") {
+            this.#prioritySinceBulk += utf8Length(message.text);
+            const done = () => message.resolve();
+            this.#transport.write(message.text).then(done, done);
+            return;
+        }
+        this.#prioritySinceBulk += message.bytes.length;
+        message.onHanded?.();
+        this.#transport.writeBinary(message.bytes).catch(() => undefined);
+    }
+    #sendBulk() {
+        const source = this.#ring.shift();
+        if (source === undefined)
+            return;
+        const message = source.takeNext();
+        if (source.hasNext) {
+            this.#ring.push(source);
+        }
+        else {
+            this.#inRing.delete(source);
+        }
+        if (message === undefined)
+            return;
+        this.#prioritySinceBulk = 0;
+        message.onHanded();
+        const written = () => message.onWritten();
+        this.#transport.writeBinary(message.bytes).then(written, written);
+    }
+}

package/dist/link/standard-websocket.d.ts

@@ -0,0 +1,36 @@
+import { type Clock, type UplinkTransportConnection } from "./ports.js";
+export { globalClock } from "./ports.js";
+export interface StandardWebSocket {
+    binaryType: string;
+    readonly bufferedAmount: number | undefined;
+    readonly readyState: number;
+    send(data: string | ArrayBufferView): void;
+    close(code?: number, reason?: string): void;
+    addEventListener(type: "open" | "close" | "error" | "message", listener: never): void;
+    removeEventListener(type: "open" | "close" | "error" | "message", listener: never): void;
+}
+export interface StandardWebSocketOptions {
+    readonly clock?: Clock;
+    readonly pollMs?: number;
+}
+export declare class StandardWebSocketConnection implements UplinkTransportConnection {
+    #private;
+    constructor(socket: StandardWebSocket, options?: StandardWebSocketOptions);
+    get closed(): boolean;
+    get unsentBytes(): number;
+    onData(listener: (chunk: string) => void): () => void;
+    onBinary(listener: (bytes: Uint8Array) => void): () => void;
+    onClose(listener: () => void): () => void;
+    onError(listener: (error: Error) => void): () => void;
+    onSent(listener: () => void): () => void;
+    write(contents: string): Promise<void>;
+    writeBinary(bytes: Uint8Array): Promise<void>;
+    close(): Promise<void>;
+}
+export interface StandardWebSocketDialOptions extends StandardWebSocketOptions {
+    readonly url: string;
+    readonly protocols?: string | string[];
+    readonly createSocket?: (url: string, protocols?: string | string[]) => StandardWebSocket;
+}
+export declare function connectStandardWebSocket(options: StandardWebSocketDialOptions): Promise<UplinkTransportConnection>;
+//# sourceMappingURL=standard-websocket.d.ts.map

package/dist/link/standard-websocket.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"standard-websocket.d.ts","sourceRoot":"","sources":["../../src/link/standard-websocket.ts"],"names":[],"mappings":"AAAA,OAAO,EAAe,KAAK,KAAK,EAAoB,KAAK,yBAAyB,EAAE,MAAM,YAAY,CAAC;AAEvG,OAAO,EAAE,WAAW,EAAE,MAAM,YAAY,CAAC;AAEzC,MAAM,WAAW,iBAAiB;IAChC,UAAU,EAAE,MAAM,CAAC;IAEnB,QAAQ,CAAC,cAAc,EAAE,MAAM,GAAG,SAAS,CAAC;IAC5C,QAAQ,CAAC,UAAU,EAAE,MAAM,CAAC;IAC5B,IAAI,CAAC,IAAI,EAAE,MAAM,GAAG,eAAe,GAAG,IAAI,CAAC;IAC3C,KAAK,CAAC,IAAI,CAAC,EAAE,MAAM,EAAE,MAAM,CAAC,EAAE,MAAM,GAAG,IAAI,CAAC;IAC5C,gBAAgB,CAAC,IAAI,EAAE,MAAM,GAAG,OAAO,GAAG,OAAO,GAAG,SAAS,EAAE,QAAQ,EAAE,KAAK,GAAG,IAAI,CAAC;IACtF,mBAAmB,CAAC,IAAI,EAAE,MAAM,GAAG,OAAO,GAAG,OAAO,GAAG,SAAS,EAAE,QAAQ,EAAE,KAAK,GAAG,IAAI,CAAC;CAC1F;AAID,MAAM,WAAW,wBAAwB;IACvC,QAAQ,CAAC,KAAK,CAAC,EAAE,KAAK,CAAC;IACvB,QAAQ,CAAC,MAAM,CAAC,EAAE,MAAM,CAAC;CAC1B;AAaD,qBAAa,2BAA4B,YAAW,yBAAyB;;gBAiB/D,MAAM,EAAE,iBAAiB,EAAE,OAAO,GAAE,wBAA6B;IAoB7E,IAAI,MAAM,IAAI,OAAO,CAEpB;IAMD,IAAI,WAAW,IAAI,MAAM,CAExB;IAED,MAAM,CAAC,QAAQ,EAAE,CAAC,KAAK,EAAE,MAAM,KAAK,IAAI,GAAG,MAAM,IAAI;IAUrD,QAAQ,CAAC,QAAQ,EAAE,CAAC,KAAK,EAAE,UAAU,KAAK,IAAI,GAAG,MAAM,IAAI;IAO3D,OAAO,CAAC,QAAQ,EAAE,MAAM,IAAI,GAAG,MAAM,IAAI;IAWzC,OAAO,CAAC,QAAQ,EAAE,CAAC,KAAK,EAAE,KAAK,KAAK,IAAI,GAAG,MAAM,IAAI;IAOrD,MAAM,CAAC,QAAQ,EAAE,MAAM,IAAI,GAAG,MAAM,IAAI;IAOxC,KAAK,CAAC,QAAQ,EAAE,MAAM,GAAG,OAAO,CAAC,IAAI,CAAC;IAItC,WAAW,CAAC,KAAK,EAAE,UAAU,GAAG,OAAO,CAAC,IAAI,CAAC;IAIvC,KAAK,IAAI,OAAO,CAAC,IAAI,CAAC;CAiF7B;AAED,MAAM,WAAW,4BAA6B,SAAQ,wBAAwB;IAC5E,QAAQ,CAAC,GAAG,EAAE,MAAM,CAAC;IACrB,QAAQ,CAAC,SAAS,CAAC,EAAE,MAAM,GAAG,MAAM,EAAE,CAAC;IACvC,QAAQ,CAAC,YAAY,CAAC,EAAE,CAAC,GAAG,EAAE,MAAM,EAAE,SAAS,CAAC,EAAE,MAAM,GAAG,MAAM,EAAE,KAAK,iBAAiB,CAAC;CAC3F;AAED,wBAAsB,wBAAwB,CAC5C,OAAO,EAAE,4BAA4B,GACpC,OAAO,CAAC,yBAAyB,CAAC,CA2BpC"}