@react-native-harness/bridge 1.5.0 → 1.7.0

package/dist/js-block-budget-policy.d.ts

@@ -0,0 +1,31 @@
+import type { JsBlockBudget } from './js-watchdog.js';
+import type { BridgeEvents } from './shared.js';
+export type JsBlockBudgetPolicyOptions = {
+    /** Budget outside any test, hook or file load. */
+    idleMs: number;
+    /** Budget while a setup file or test file loads (module code and `describe` bodies). */
+    fileLoadMs: number;
+    /** Added to a test's or hook's own timeout. */
+    graceMs: number;
+};
+export declare const IDLE_BUDGET_LABEL = "between test phases";
+export declare const getIdleBudget: (options: JsBlockBudgetPolicyOptions) => JsBlockBudget;
+export type JsBlockBudgetPolicy = {
+    /**
+     * Returns the block budget that applies from this event on, or `null` for
+     * events that do not change it.
+     */
+    getBudgetForEvent: (event: BridgeEvents) => JsBlockBudget | null;
+};
+/**
+ * Maps runner events to block budgets. Budgets come from timeouts the user
+ * already configures, so long work within them never fails a run:
+ *
+ * - loading a setup file or test file: `fileLoadMs`
+ * - a test, including its `beforeEach`/`afterEach` hooks: its timeout + grace
+ * - a suite's `beforeAll`/`afterAll` hooks: the hook timeout + grace, from
+ *   `suite-started` until `suite-finished`, outside the suite's tests
+ * - anything else: `idleMs`
+ */
+export declare const createJsBlockBudgetPolicy: (options: JsBlockBudgetPolicyOptions) => JsBlockBudgetPolicy;
+//# sourceMappingURL=js-block-budget-policy.d.ts.map

package/dist/js-block-budget-policy.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"js-block-budget-policy.d.ts","sourceRoot":"","sources":["../src/js-block-budget-policy.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,aAAa,EAAE,MAAM,kBAAkB,CAAC;AACtD,OAAO,KAAK,EAAE,YAAY,EAAE,MAAM,aAAa,CAAC;AAEhD,MAAM,MAAM,0BAA0B,GAAG;IACvC,kDAAkD;IAClD,MAAM,EAAE,MAAM,CAAC;IACf,wFAAwF;IACxF,UAAU,EAAE,MAAM,CAAC;IACnB,+CAA+C;IAC/C,OAAO,EAAE,MAAM,CAAC;CACjB,CAAC;AAEF,eAAO,MAAM,iBAAiB,wBAAwB,CAAC;AAEvD,eAAO,MAAM,aAAa,GACxB,SAAS,0BAA0B,KAClC,aAAmE,CAAC;AAEvE,MAAM,MAAM,mBAAmB,GAAG;IAChC;;;OAGG;IACH,iBAAiB,EAAE,CAAC,KAAK,EAAE,YAAY,KAAK,aAAa,GAAG,IAAI,CAAC;CAClE,CAAC;AAEF;;;;;;;;;GASG;AACH,eAAO,MAAM,yBAAyB,GACpC,SAAS,0BAA0B,KAClC,mBAmDF,CAAC"}

package/dist/js-block-budget-policy.js

@@ -0,0 +1,60 @@
+export const IDLE_BUDGET_LABEL = 'between test phases';
+export const getIdleBudget = (options) => ({ ms: options.idleMs, label: IDLE_BUDGET_LABEL });
+/**
+ * Maps runner events to block budgets. Budgets come from timeouts the user
+ * already configures, so long work within them never fails a run:
+ *
+ * - loading a setup file or test file: `fileLoadMs`
+ * - a test, including its `beforeEach`/`afterEach` hooks: its timeout + grace
+ * - a suite's `beforeAll`/`afterAll` hooks: the hook timeout + grace, from
+ *   `suite-started` until `suite-finished`, outside the suite's tests
+ * - anything else: `idleMs`
+ */
+export const createJsBlockBudgetPolicy = (options) => {
+    const idle = getIdleBudget(options);
+    // Hook budgets of the suites currently running, innermost last.
+    const suites = [];
+    const outsideTests = () => suites[suites.length - 1] ?? idle;
+    return {
+        getBudgetForEvent: (event) => {
+            switch (event.type) {
+                case 'setup-file-bundling-finished':
+                    return {
+                        ms: options.fileLoadMs,
+                        label: `loading setup file ${event.file}`,
+                    };
+                case 'collection-started':
+                    return { ms: options.fileLoadMs, label: `loading ${event.file}` };
+                case 'setup-file-bundling-failed':
+                case 'collection-finished':
+                case 'file-started':
+                case 'file-finished':
+                    suites.length = 0;
+                    return idle;
+                case 'suite-started':
+                    suites.push(event.timeout === undefined
+                        ? outsideTests()
+                        : {
+                            ms: event.timeout + options.graceMs,
+                            label: `beforeAll/afterAll hooks of suite "${event.name}" (${event.timeout}ms timeout + ${options.graceMs}ms grace)`,
+                        });
+                    return outsideTests();
+                case 'suite-finished':
+                    suites.pop();
+                    return outsideTests();
+                case 'test-started':
+                    if (event.timeout === undefined) {
+                        return null;
+                    }
+                    return {
+                        ms: event.timeout + options.graceMs,
+                        label: `test "${event.fullName}" (${event.timeout}ms timeout + ${options.graceMs}ms grace)`,
+                    };
+                case 'test-finished':
+                    return outsideTests();
+                default:
+                    return null;
+            }
+        },
+    };
+};

package/dist/js-watchdog.d.ts

@@ -0,0 +1,31 @@
+/**
+ * The longest the app's JS thread may go without answering a `js-probe`, and
+ * a label naming what it is busy with, used in the failure message.
+ */
+export type JsBlockBudget = {
+    ms: number;
+    label: string;
+};
+export type JsWatchdog = {
+    notifyProbeAck: (id: number) => void;
+    /**
+     * Replaces the current budget. The new budget covers silence from the
+     * later of the last acknowledged probe and the change itself: a block that
+     * fitted the previous budget is never judged against a smaller one.
+     */
+    setBlockBudget: (budget: JsBlockBudget) => void;
+    dispose: () => void;
+};
+export declare const DEFAULT_JS_PROBE_INTERVAL_MS = 1000;
+/**
+ * Checks that the app's JS thread keeps getting a turn to run. The server
+ * sends `js-probe` messages, which only JS can answer, and fails once the
+ * thread has been silent for longer than the current block budget.
+ */
+export declare const createJsWatchdog: (options: {
+    sendProbe: (id: number) => void;
+    onUnresponsive: (budget: JsBlockBudget) => void;
+    initialBudget: JsBlockBudget;
+    probeIntervalMs?: number;
+}) => JsWatchdog;
+//# sourceMappingURL=js-watchdog.d.ts.map

package/dist/js-watchdog.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"js-watchdog.d.ts","sourceRoot":"","sources":["../src/js-watchdog.ts"],"names":[],"mappings":"AAAA;;;GAGG;AACH,MAAM,MAAM,aAAa,GAAG;IAC1B,EAAE,EAAE,MAAM,CAAC;IACX,KAAK,EAAE,MAAM,CAAC;CACf,CAAC;AAEF,MAAM,MAAM,UAAU,GAAG;IACvB,cAAc,EAAE,CAAC,EAAE,EAAE,MAAM,KAAK,IAAI,CAAC;IACrC;;;;OAIG;IACH,cAAc,EAAE,CAAC,MAAM,EAAE,aAAa,KAAK,IAAI,CAAC;IAChD,OAAO,EAAE,MAAM,IAAI,CAAC;CACrB,CAAC;AAEF,eAAO,MAAM,4BAA4B,OAAQ,CAAC;AAElD;;;;GAIG;AACH,eAAO,MAAM,gBAAgB,GAAI,SAAS;IACxC,SAAS,EAAE,CAAC,EAAE,EAAE,MAAM,KAAK,IAAI,CAAC;IAChC,cAAc,EAAE,CAAC,MAAM,EAAE,aAAa,KAAK,IAAI,CAAC;IAChD,aAAa,EAAE,aAAa,CAAC;IAC7B,eAAe,CAAC,EAAE,MAAM,CAAC;CAC1B,KAAG,UA6CH,CAAC"}

package/dist/js-watchdog.js

@@ -0,0 +1,46 @@
+export const DEFAULT_JS_PROBE_INTERVAL_MS = 1_000;
+/**
+ * Checks that the app's JS thread keeps getting a turn to run. The server
+ * sends `js-probe` messages, which only JS can answer, and fails once the
+ * thread has been silent for longer than the current block budget.
+ */
+export const createJsWatchdog = (options) => {
+    let budget = options.initialBudget;
+    let lastAckAt = Date.now();
+    let budgetSetAt = lastAckAt;
+    let nextProbeId = 1;
+    let pendingProbeId = null;
+    let disposed = false;
+    const dispose = () => {
+        if (disposed) {
+            return;
+        }
+        disposed = true;
+        clearInterval(interval);
+    };
+    const interval = setInterval(() => {
+        if (Date.now() - Math.max(lastAckAt, budgetSetAt) > budget.ms) {
+            dispose();
+            options.onUnresponsive(budget);
+            return;
+        }
+        if (pendingProbeId === null) {
+            pendingProbeId = nextProbeId++;
+            options.sendProbe(pendingProbeId);
+        }
+    }, options.probeIntervalMs ?? DEFAULT_JS_PROBE_INTERVAL_MS);
+    return {
+        notifyProbeAck: (id) => {
+            if (id !== pendingProbeId) {
+                return;
+            }
+            pendingProbeId = null;
+            lastAckAt = Date.now();
+        },
+        setBlockBudget: (next) => {
+            budget = next;
+            budgetSetAt = Date.now();
+        },
+        dispose,
+    };
+};

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"}