agent-yes 1.300.3 → 1.300.4

package/ts/webrtcRemote.ts

@@ -22,6 +22,14 @@ import {
   FLAG_CONFIRM,
 } from "../lab/ui/e2e.js";
 import { SIGNAL_SUBPROTOCOL as SUB, parseWebrtcLink, type WebrtcLink } from "./webrtcLink.ts";
+import {
+  closeError,
+  describeConnectFailure,
+  reduceSignal,
+  socketError,
+  timeoutError,
+  type SignalState,
+} from "./webrtcSignal.ts";
 
 export { isWebrtcSpec, parseWebrtcLink } from "./webrtcLink.ts";
 export type { WebrtcLink } from "./webrtcLink.ts";
@@ -49,6 +57,11 @@ class WebRtcConn {
   private confirmedIn = false;
   private confirmedOut = false;
   private confirmed = false;
+  // Join progress, so a failure names the phase it happened in (webrtcSignal.ts).
+  private readonly sig: SignalState = { opened: false, offered: false, confirmed: false };
+  // Host candidates that trickled in before the offer; applied once the peer exists.
+  private earlyCandidates: any[] = [];
+  private warnedDuplicateHost = false;
   private sendChain: Promise<void> = Promise.resolve();
   private recvChain: Promise<void> = Promise.resolve();
   private idCounter = 0;
@@ -64,7 +77,7 @@ class WebRtcConn {
       this.rejectReady = rej;
     });
     const timer = setTimeout(
-      () => this.rejectReady(new Error(`WebRTC connect timeout after ${CONNECT_TIMEOUT_MS}ms`)),
+      () => this.rejectReady(timeoutError(this.sig, CONNECT_TIMEOUT_MS)),
       CONNECT_TIMEOUT_MS,
     );
     this.ready.then(
@@ -78,13 +91,16 @@ class WebRtcConn {
     const { room, host } = this.link;
     const ws = new WebSocket(`wss://${host}/${room}`, [SUB]);
     ws.onopen = async () => {
+      this.sig.opened = true;
       const authToken = await deriveAuthToken(this.link.s, room, host);
       ws.send(JSON.stringify({ type: "hello", role: "client", v: 2, token: authToken }));
     };
-    ws.onerror = (e: any) =>
-      this.rejectReady(new Error(`signaling error: ${String(e?.message ?? e)}`));
-    ws.onclose = () => {
-      if (!this.confirmed) this.rejectReady(new Error("signaling closed before connect"));
+    ws.onerror = (e: any) => this.rejectReady(socketError(this.sig, String(e?.message ?? e)));
+    ws.onclose = (ev: any) => {
+      // The close code and reason are the server's own diagnosis (1008 "forbidden",
+      // "room not open"); dropping them left only "closed before connect".
+      if (!this.confirmed)
+        this.rejectReady(closeError(this.sig, Number(ev?.code ?? 0), String(ev?.reason ?? "")));
     };
     ws.onmessage = (ev: any) => void this.onSignal(ev);
     return ws;
@@ -92,9 +108,32 @@ class WebRtcConn {
 
   private async onSignal(ev: any): Promise<void> {
     const m = JSON.parse(typeof ev.data === "string" ? ev.data : await ev.data.text());
-    if (m.type === "offer") {
-      this.hostPeer = m.from;
-      const pc = new RTCPeerConnection({ iceServers: m.iceServers || [] });
+    const action = reduceSignal(this.sig, m);
+    if (action.kind === "fail") {
+      this.rejectReady(action.error);
+      return;
+    }
+    if (action.kind === "duplicate-offer") {
+      // Two hosts in one room: our answer would go to both and neither
+      // handshake completes. Stay with the first; say so once.
+      if (!this.warnedDuplicateHost) {
+        this.warnedDuplicateHost = true;
+        process.stderr.write(
+          `[webrtc] a second host offered in room ${this.link.room} — two hosts serve this room; ` +
+            `on the host, stop the stray one (\`ay serve status\`)\n`,
+        );
+      }
+      return;
+    }
+    if (action.kind === "candidate") {
+      if (action.queue) this.earlyCandidates.push(action.candidate);
+      else if (this.pc) await this.pc.addIceCandidate(action.candidate).catch(() => {});
+      return;
+    }
+    if (action.kind === "offer") {
+      this.sig.offered = true;
+      this.hostPeer = action.from ?? null;
+      const pc = new RTCPeerConnection({ iceServers: action.iceServers || [] });
       this.pc = pc;
       pc.onicecandidate = (e: any) => {
         if (e.candidate)
@@ -111,18 +150,22 @@ class WebRtcConn {
           this.recvChain = this.recvChain.then(() => this.onFrame(ev2.data)).catch(() => {});
         };
       };
-      await pc.setRemoteDescription({ type: "offer", sdp: m.sdp });
+      await pc.setRemoteDescription({ type: "offer", sdp: action.sdp });
+      // Candidates the host trickled before its offer (the Rust host does) are
+      // only valid once the remote description is set — flush them now, or the
+      // host's LAN routes are lost and the handshake limps to a timeout.
+      const early = this.earlyCandidates;
+      this.earlyCandidates = [];
+      for (const c of early) await pc.addIceCandidate(c).catch(() => {});
       const answer = await pc.createAnswer();
       await pc.setLocalDescription(answer);
-      this.th = await computeTranscriptHash(m.sdp, pc.localDescription.sdp);
+      this.th = await computeTranscriptHash(action.sdp, pc.localDescription.sdp);
       const keys = await deriveDirKeys(this.link.s, this.th);
       this.keyC2H = keys.keyC2H;
       this.keyH2C = keys.keyH2C;
       this.ws.send(
         JSON.stringify({ type: "answer", to: this.hostPeer, sdp: pc.localDescription.sdp }),
       );
-    } else if (m.type === "candidate" && this.pc) {
-      await this.pc.addIceCandidate(m.candidate).catch(() => {});
     }
   }
 
@@ -159,6 +202,7 @@ class WebRtcConn {
       if (env.echo && env.echo === this.myNonce) this.confirmedIn = true;
       if (this.confirmedIn && this.confirmedOut) {
         this.confirmed = true;
+        this.sig.confirmed = true;
         this.resolveReady();
       }
       return;
@@ -258,14 +302,16 @@ export async function startWebrtcBridge(link: string): Promise<WebrtcBridge> {
     await conn.ready;
   } catch (e) {
     // Every remote command routes through here, so this is the one place a
-    // signaling failure has to become actionable. The raw error names the URL
-    // and says "failed to connect" — all true, none of it pointing at the cause
-    // when the cause is the local environment rather than the network. Probe
-    // and say which; see ts/signalingHint.ts for why it is derived rather than
-    // guessed.
-    const cause = String((e as Error)?.message ?? e);
-    const probe = await probeSignalingHost(parsed.host);
-    throw new Error(signalingFailureHint(cause, probe, parsed.host));
+    // signaling failure has to become actionable. The failure names its phase
+    // (webrtcSignal.ts); only a socket that never opened gets the HTTPS-probe
+    // sandbox/proxy hint (signalingHint.ts) — every later phase proves the
+    // WebSocket upgrade worked, so that hint would be a misdiagnosis there.
+    const err = e instanceof Error ? e : new Error(String(e));
+    throw new Error(
+      await describeConnectFailure(err, parsed.host, async (cause) =>
+        signalingFailureHint(cause, await probeSignalingHost(parsed.host), parsed.host),
+      ),
+    );
   }
 
   const server = Bun.serve({

package/ts/webrtcSignal.bun.spec.ts

@@ -0,0 +1,120 @@
+import { describe, expect, it } from "bun:test";
+import {
+  ConnectError,
+  closeError,
+  describeConnectFailure,
+  reduceSignal,
+  socketError,
+  timeoutError,
+  type SignalState,
+} from "./webrtcSignal.ts";
+
+const fresh = (): SignalState => ({ opened: false, offered: false, confirmed: false });
+const opened = (): SignalState => ({ opened: true, offered: false, confirmed: false });
+const offered = (): SignalState => ({ opened: true, offered: true, confirmed: false });
+
+// Every one of these used to be a 25 s "connect timeout" followed by a hint
+// that blamed a sandbox. The server says which it is; the viewer must listen.
+describe("reduceSignal", () => {
+  it("fails fast when the server says no host is attached", () => {
+    const a = reduceSignal(opened(), { type: "welcome", hostPresent: false });
+    expect(a.kind).toBe("fail");
+    if (a.kind === "fail") expect(a.error.phase).toBe("no-host");
+    expect(reduceSignal(opened(), { type: "welcome", hostPresent: true })).toEqual({
+      kind: "ignore",
+    });
+    expect(reduceSignal(opened(), { type: "welcome" })).toEqual({ kind: "ignore" });
+  });
+
+  it("accepts the first offer and refuses a second one (two hosts in a room)", () => {
+    expect(
+      reduceSignal(opened(), { type: "offer", sdp: "v=0", iceServers: [{ urls: "stun:x" }] }),
+    ).toEqual({
+      kind: "offer",
+      sdp: "v=0",
+      iceServers: [{ urls: "stun:x" }],
+      from: undefined,
+    });
+    expect(reduceSignal(offered(), { type: "offer", sdp: "v=0" })).toEqual({
+      kind: "duplicate-offer",
+    });
+  });
+
+  it("queues a candidate that arrives before the offer, applies one after", () => {
+    expect(reduceSignal(opened(), { type: "candidate", candidate: { c: 1 } })).toEqual({
+      kind: "candidate",
+      candidate: { c: 1 },
+      queue: true,
+    });
+    expect(reduceSignal(offered(), { type: "candidate", candidate: { c: 2 } })).toEqual({
+      kind: "candidate",
+      candidate: { c: 2 },
+      queue: false,
+    });
+  });
+
+  it("ignores anything else, including garbage", () => {
+    expect(reduceSignal(opened(), { type: "peer-join" })).toEqual({ kind: "ignore" });
+    expect(reduceSignal(opened(), null)).toEqual({ kind: "ignore" });
+    expect(reduceSignal(opened(), "nope")).toEqual({ kind: "ignore" });
+  });
+});
+
+describe("closeError / timeoutError / socketError", () => {
+  it("keeps the server's close code and reason, and names the phase", () => {
+    expect(closeError(fresh(), 1006, "")).toMatchObject({ phase: "ws-not-open" });
+    expect(closeError(opened(), 1008, "forbidden")).toMatchObject({
+      phase: "rejected",
+      message: expect.stringContaining("1008: forbidden"),
+    });
+    expect(closeError(opened(), 1000, "room not open")).toMatchObject({ phase: "rejected" });
+    expect(closeError(opened(), 1006, "")).toMatchObject({ phase: "no-host" });
+    expect(closeError(offered(), 1006, "")).toMatchObject({ phase: "ice-timeout" });
+  });
+
+  it("times out into the phase the join had reached", () => {
+    expect(timeoutError(fresh(), 25_000)).toMatchObject({ phase: "ws-not-open" });
+    expect(timeoutError(opened(), 25_000)).toMatchObject({
+      phase: "no-host",
+      message: expect.stringContaining("25s"),
+    });
+    expect(timeoutError(offered(), 25_000)).toMatchObject({ phase: "ice-timeout" });
+  });
+
+  it("treats a socket error before open as the socket not opening", () => {
+    expect(socketError(fresh(), "ECONNRESET")).toMatchObject({ phase: "ws-not-open" });
+    expect(socketError(opened(), "ECONNRESET")).toMatchObject({ phase: "rejected" });
+  });
+});
+
+describe("describeConnectFailure", () => {
+  const host = "s.example";
+  const sandbox = async (cause: string) => `SANDBOX-HINT(${cause})`;
+
+  it("consults the sandbox hint only for a socket that never opened", async () => {
+    expect(await describeConnectFailure(new ConnectError("ws-not-open", "x"), host, sandbox)).toBe(
+      "SANDBOX-HINT(x)",
+    );
+    // A plain Error (no phase) is treated the same way — nothing is known.
+    expect(await describeConnectFailure(new Error("y"), host, sandbox)).toBe("SANDBOX-HINT(y)");
+    for (const phase of ["no-host", "rejected", "ice-timeout"] as const) {
+      const text = await describeConnectFailure(new ConnectError(phase, "cause"), host, sandbox);
+      expect(text).not.toContain("SANDBOX");
+      expect(text).not.toMatch(/sandbox.*permission/i);
+      expect(text).toContain("cause");
+      expect(text).toContain(host);
+    }
+  });
+
+  it("tells the operator what to do on the host for each phase", async () => {
+    expect(await describeConnectFailure(new ConnectError("no-host", "c"), host, sandbox)).toContain(
+      "ay share status",
+    );
+    expect(
+      await describeConnectFailure(new ConnectError("rejected", "c"), host, sandbox),
+    ).toContain("re-add the remote");
+    expect(
+      await describeConnectFailure(new ConnectError("ice-timeout", "c"), host, sandbox),
+    ).toContain("not a sandbox");
+  });
+});

package/ts/webrtcSignal.spec.ts

@@ -0,0 +1,120 @@
+import { describe, expect, it } from "vitest";
+import {
+  ConnectError,
+  closeError,
+  describeConnectFailure,
+  reduceSignal,
+  socketError,
+  timeoutError,
+  type SignalState,
+} from "./webrtcSignal.ts";
+
+const fresh = (): SignalState => ({ opened: false, offered: false, confirmed: false });
+const opened = (): SignalState => ({ opened: true, offered: false, confirmed: false });
+const offered = (): SignalState => ({ opened: true, offered: true, confirmed: false });
+
+// Every one of these used to be a 25 s "connect timeout" followed by a hint
+// that blamed a sandbox. The server says which it is; the viewer must listen.
+describe("reduceSignal", () => {
+  it("fails fast when the server says no host is attached", () => {
+    const a = reduceSignal(opened(), { type: "welcome", hostPresent: false });
+    expect(a.kind).toBe("fail");
+    if (a.kind === "fail") expect(a.error.phase).toBe("no-host");
+    expect(reduceSignal(opened(), { type: "welcome", hostPresent: true })).toEqual({
+      kind: "ignore",
+    });
+    expect(reduceSignal(opened(), { type: "welcome" })).toEqual({ kind: "ignore" });
+  });
+
+  it("accepts the first offer and refuses a second one (two hosts in a room)", () => {
+    expect(
+      reduceSignal(opened(), { type: "offer", sdp: "v=0", iceServers: [{ urls: "stun:x" }] }),
+    ).toEqual({
+      kind: "offer",
+      sdp: "v=0",
+      iceServers: [{ urls: "stun:x" }],
+      from: undefined,
+    });
+    expect(reduceSignal(offered(), { type: "offer", sdp: "v=0" })).toEqual({
+      kind: "duplicate-offer",
+    });
+  });
+
+  it("queues a candidate that arrives before the offer, applies one after", () => {
+    expect(reduceSignal(opened(), { type: "candidate", candidate: { c: 1 } })).toEqual({
+      kind: "candidate",
+      candidate: { c: 1 },
+      queue: true,
+    });
+    expect(reduceSignal(offered(), { type: "candidate", candidate: { c: 2 } })).toEqual({
+      kind: "candidate",
+      candidate: { c: 2 },
+      queue: false,
+    });
+  });
+
+  it("ignores anything else, including garbage", () => {
+    expect(reduceSignal(opened(), { type: "peer-join" })).toEqual({ kind: "ignore" });
+    expect(reduceSignal(opened(), null)).toEqual({ kind: "ignore" });
+    expect(reduceSignal(opened(), "nope")).toEqual({ kind: "ignore" });
+  });
+});
+
+describe("closeError / timeoutError / socketError", () => {
+  it("keeps the server's close code and reason, and names the phase", () => {
+    expect(closeError(fresh(), 1006, "")).toMatchObject({ phase: "ws-not-open" });
+    expect(closeError(opened(), 1008, "forbidden")).toMatchObject({
+      phase: "rejected",
+      message: expect.stringContaining("1008: forbidden"),
+    });
+    expect(closeError(opened(), 1000, "room not open")).toMatchObject({ phase: "rejected" });
+    expect(closeError(opened(), 1006, "")).toMatchObject({ phase: "no-host" });
+    expect(closeError(offered(), 1006, "")).toMatchObject({ phase: "ice-timeout" });
+  });
+
+  it("times out into the phase the join had reached", () => {
+    expect(timeoutError(fresh(), 25_000)).toMatchObject({ phase: "ws-not-open" });
+    expect(timeoutError(opened(), 25_000)).toMatchObject({
+      phase: "no-host",
+      message: expect.stringContaining("25s"),
+    });
+    expect(timeoutError(offered(), 25_000)).toMatchObject({ phase: "ice-timeout" });
+  });
+
+  it("treats a socket error before open as the socket not opening", () => {
+    expect(socketError(fresh(), "ECONNRESET")).toMatchObject({ phase: "ws-not-open" });
+    expect(socketError(opened(), "ECONNRESET")).toMatchObject({ phase: "rejected" });
+  });
+});
+
+describe("describeConnectFailure", () => {
+  const host = "s.example";
+  const sandbox = async (cause: string) => `SANDBOX-HINT(${cause})`;
+
+  it("consults the sandbox hint only for a socket that never opened", async () => {
+    expect(await describeConnectFailure(new ConnectError("ws-not-open", "x"), host, sandbox)).toBe(
+      "SANDBOX-HINT(x)",
+    );
+    // A plain Error (no phase) is treated the same way — nothing is known.
+    expect(await describeConnectFailure(new Error("y"), host, sandbox)).toBe("SANDBOX-HINT(y)");
+    for (const phase of ["no-host", "rejected", "ice-timeout"] as const) {
+      const text = await describeConnectFailure(new ConnectError(phase, "cause"), host, sandbox);
+      expect(text).not.toContain("SANDBOX");
+      expect(text).not.toMatch(/sandbox.*permission/i);
+      expect(text).toContain("cause");
+      expect(text).toContain(host);
+    }
+  });
+
+  it("tells the operator what to do on the host for each phase", async () => {
+    expect(await describeConnectFailure(new ConnectError("no-host", "c"), host, sandbox)).toContain(
+      "ay share status",
+    );
+    expect(
+      await describeConnectFailure(new ConnectError("rejected", "c"), host, sandbox),
+    ).toContain("re-add the remote");
+    expect(
+      await describeConnectFailure(new ConnectError("ice-timeout", "c"), host, sandbox),
+    ).toContain("not a sandbox");
+  });
+});

package/ts/webrtcSignal.ts

@@ -0,0 +1,143 @@
+/**
+ * The CLI viewer's signaling decisions, as pure functions.
+ *
+ * Every way a WebRTC join can fail used to surface as one thing: a 25 s
+ * "connect timeout", followed by a hint that blamed a sandbox. The server
+ * actually tells the viewer which it is — `welcome.hostPresent:false` when no
+ * host is attached, a 1008 close with a reason when the join is rejected — and
+ * the handshake itself has observable phases (socket open, offer received,
+ * channel confirmed). Keeping that bookkeeping here, away from the socket and
+ * peer-connection plumbing in webrtcRemote.ts, makes each branch testable
+ * without a network, and keeps the sandbox hint for the one case it is true.
+ */
+
+/** Where the join was when it failed; drives the operator-facing explanation. */
+export type ConnectPhase =
+  /** The signaling WebSocket never opened. The only phase a sandbox explains. */
+  | "ws-not-open"
+  /** The socket opened but no host is attached to the room / none offered. */
+  | "no-host"
+  /** The signaling server rejected the join (wrong secret, room not open…). */
+  | "rejected"
+  /** Signaling worked and the host offered, but no data channel came up. */
+  | "ice-timeout";
+
+export class ConnectError extends Error {
+  constructor(
+    readonly phase: ConnectPhase,
+    message: string,
+  ) {
+    super(message);
+    this.name = "ConnectError";
+  }
+}
+
+/** The viewer's progress through the join, updated by the caller. */
+export interface SignalState {
+  opened: boolean;
+  offered: boolean;
+  confirmed: boolean;
+}
+
+export type SignalAction =
+  | { kind: "ignore" }
+  | { kind: "fail"; error: ConnectError }
+  /** The first offer: build the peer connection and answer it. */
+  | { kind: "offer"; sdp: string; iceServers: any[]; from?: string }
+  /** A second offer — two hosts in one room. Answering both breaks the handshake. */
+  | { kind: "duplicate-offer" }
+  /** A host candidate: `queue` when it arrived before the offer (the Rust host
+   *  may trickle candidates first), else apply it. */
+  | { kind: "candidate"; candidate: any; queue: boolean };
+
+/** Classify one signaling frame against the current state. */
+export function reduceSignal(state: SignalState, m: any): SignalAction {
+  if (!m || typeof m !== "object") return { kind: "ignore" };
+  switch (m.type) {
+    case "welcome":
+      // The browser console fails fast on this; the CLI used to wait out the
+      // whole timeout and then blame the network.
+      if (m.hostPresent === false)
+        return {
+          kind: "fail",
+          error: new ConnectError("no-host", "the room is open but no host is attached to it"),
+        };
+      return { kind: "ignore" };
+    case "offer":
+      if (state.offered) return { kind: "duplicate-offer" };
+      return { kind: "offer", sdp: m.sdp, iceServers: m.iceServers || [], from: m.from };
+    case "candidate":
+      return { kind: "candidate", candidate: m.candidate, queue: !state.offered };
+    default:
+      return { kind: "ignore" };
+  }
+}
+
+/** The error for a socket that closed before the channel was confirmed. */
+export function closeError(state: SignalState, code: number, reason: string): ConnectError {
+  const why = `signaling closed (code ${code}${reason ? `: ${reason}` : ""})`;
+  if (!state.opened) return new ConnectError("ws-not-open", `${why} before the socket opened`);
+  // 1008 is the server's policy-violation close: bad secret, room not open.
+  // Any close that carries a reason is the server explaining itself.
+  if (code === 1008 || reason) return new ConnectError("rejected", why);
+  if (!state.offered) return new ConnectError("no-host", `${why} before the host offered`);
+  return new ConnectError("ice-timeout", `${why} during the WebRTC handshake`);
+}
+
+/** The error for the connect deadline expiring. */
+export function timeoutError(state: SignalState, timeoutMs: number): ConnectError {
+  const s = `${Math.round(timeoutMs / 1000)}s`;
+  if (!state.opened) return new ConnectError("ws-not-open", `signaling did not open within ${s}`);
+  if (!state.offered) return new ConnectError("no-host", `no host answered the join within ${s}`);
+  return new ConnectError("ice-timeout", `no WebRTC data channel came up within ${s}`);
+}
+
+/** The error for a WebSocket `error` event. */
+export function socketError(state: SignalState, detail: string): ConnectError {
+  return state.opened
+    ? new ConnectError("rejected", `signaling error after connect: ${detail}`)
+    : new ConnectError("ws-not-open", `signaling error: ${detail}`);
+}
+
+/**
+ * The operator-facing explanation. `sandboxHint` is the HTTPS-probe-derived
+ * note from signalingHint.ts and is consulted ONLY for a socket that never
+ * opened: every later phase proves the WebSocket upgrade worked, so blaming a
+ * sandbox or proxy there would be wrong — and sent one reader down exactly
+ * that path.
+ */
+export function describeConnectFailure(
+  err: Error,
+  host: string,
+  sandboxHint: (cause: string) => Promise<string>,
+): Promise<string> {
+  const phase = err instanceof ConnectError ? err.phase : "ws-not-open";
+  const cause = err.message;
+  switch (phase) {
+    case "no-host":
+      return Promise.resolve(
+        `no host in the room at ${host}: ${cause}\n` +
+          `  The signaling server is reachable and accepted the join — the daemon on the\n` +
+          `  other machine is not attached to this room. There, run \`ay share status\`:\n` +
+          `  if it prints a different link, the room rotated (or the daemon was\n` +
+          `  reinstalled) and this saved remote is stale — re-add it with the new link.`,
+      );
+    case "rejected":
+      return Promise.resolve(
+        `join rejected by the signaling host ${host}: ${cause}\n` +
+          `  The room id or secret in this saved remote no longer matches what the host\n` +
+          `  serves (it rotated, or the link was copied from a different machine).\n` +
+          `  On the host run \`ay share status\` and re-add the remote with that link.`,
+      );
+    case "ice-timeout":
+      return Promise.resolve(
+        `WebRTC handshake with the host behind ${host} failed: ${cause}\n` +
+          `  Signaling worked and the host answered, so this is not a sandbox or proxy\n` +
+          `  problem — the two machines could not open a data channel. Usual causes: a\n` +
+          `  second host answering in the same room (on the host: \`ay serve status\`,\n` +
+          `  and kill any stray \`ayrs serve\`), or ICE blocked between the networks.`,
+      );
+    default:
+      return sandboxHint(cause);
+  }
+}

package/dist/rustBinary-BNmAJEBb.js

@@ -1,4 +0,0 @@
-import "./versionChecker-CCGSbjio.js";
-import { a as findSpawnHiddenLauncher, c as getBinDir, d as getRustBinary, f as hasValidMacSignature, i as findRustBinary, l as getBinaryName, n as downloadBinary, o as findTrayLauncher, r as findAyrsBinary, s as gcOldBinaryDirs, t as devBuildInfo, u as getDownloadUrl } from "./rustBinary-gI_r3g9K.js";
-
-export { findAyrsBinary, gcOldBinaryDirs };

package/dist/share-Bmnd_qT0.js

@@ -1,4 +0,0 @@
-import "./e2e-z1xpwSAg.js";
-import { a as shareLinkFromRoomUrl, i as loadOrCreateShareRoom, n as getIceServers, o as startShare, r as importRTC, t as formatRoomLink } from "./share-C9oGvjXT.js";
-
-export { getIceServers, importRTC, loadOrCreateShareRoom, shareLinkFromRoomUrl, startShare };

package/dist/trayApp-BDIb8fOj.js

@@ -1,5 +0,0 @@
-import "./versionChecker-CCGSbjio.js";
-import "./rustBinary-gI_r3g9K.js";
-import { a as trayHiddenMarker, i as launchTray, n as hasDesktop, r as isTrayHidden, t as cmdTray } from "./trayApp-PJrwfyDs.js";
-
-export { cmdTray };