mindwire 0.1.33 → 0.1.36

package/dist/computer/connection-change.d.ts

@@ -0,0 +1,13 @@
+import { type ComputerConfig } from "./lifecycle.js";
+export interface ComputerConnectionChange {
+    id: string;
+    patch: Pick<Partial<ComputerConfig>, "relay" | "host">;
+    status: "queued" | "connecting" | "complete" | "failed";
+    message?: string;
+}
+/** The controller verifies a replacement before committing it. Parallel CLI
+ * invocations join the same settings change, or run one after the other. */
+export declare function changeComputerConnection(directory: string, patch: ComputerConnectionChange["patch"], options?: {
+    signal?: AbortSignal;
+    onProgress?: (message: string) => void;
+}): Promise<void>;

package/dist/computer/connection-flow.d.ts

@@ -4,12 +4,12 @@ export declare function connectionAction(value: string | undefined): ConnectionA
 /** Safe to copy into either a Unix shell or PowerShell, even when an ID starts
  * with a dash. Validate old daemons too; these values originated on a phone. */
 export declare function approvalCommand(pairingId: string, requestId: string): string;
-/** Saved approvals do not prove that the phone still has its key or address.
- * Every disconnected phone uses the same QR; the signed handshake chooses resume
- * or fresh approval. The old commands remain aliases, not separate UX paths. */
+/** Stable endpoints need no new invitation after network loss or restart.
+ * An approval means ready to reconnect, never proof of current connectivity. */
 export declare function chooseConnectionAction(options: {
     requested?: ConnectionAction;
     devices: ComputerDevice[];
+    persistent?: boolean;
 }): Promise<ConnectionAction>;
 /** A fresh key is never merged by name. Replacement requires the owner's explicit
  * choice of the exact approvals shown here; a different same-name phone can be added. */

package/dist/computer/directory-http.d.ts

@@ -0,0 +1,8 @@
+export declare class DirectoryRequestError extends Error {
+    readonly status: number;
+    readonly code: string;
+    readonly retryAfter: number;
+    constructor(status: number, code: string, retryAfter?: number);
+}
+/** Bounded, same-origin requests. No redirects, cookie jar or retained credentials. */
+export declare function directoryRequest<T>(url: string, path: string, body: unknown): Promise<T>;

package/dist/computer/discovery.d.ts

@@ -0,0 +1,13 @@
+import type { Mindwire } from "../client.js";
+import type { ComputerDiscoveryStatus } from "../computer.js";
+import type { SetupPrompt } from "./setup-prompt.js";
+export declare const DIRECTORY_API_PATH = "/api/computer-directory/v1";
+export declare const DIRECTORY_URL = "https://console.mindwire.sh/api/computer-directory/v1";
+export declare function directoryURL(value: string): string;
+export declare function enableAddressDiscovery(options: {
+    directory: string;
+    computer: Mindwire;
+    prompt: SetupPrompt;
+    url?: string;
+}): Promise<ComputerDiscoveryStatus>;
+export declare function discoveryDescription(status: ComputerDiscoveryStatus | undefined): string;

package/dist/computer/lifecycle.d.ts

@@ -12,7 +12,7 @@ export interface ComputerConfig {
     websocketPort: number;
     relay: RelayOptions;
 }
-export declare const CONTROLLER_PROTOCOL = 2;
+export declare const CONTROLLER_PROTOCOL = 3;
 export interface ControllerState extends ProcessState {
     protocol?: number;
     cliVersion?: string;
@@ -23,6 +23,8 @@ export interface ControllerState extends ProcessState {
     recovering?: boolean;
     routes?: ComputerRoute[];
     checkedAt?: number;
+    relayFailureSince?: number;
+    relayFailures?: number;
 }
 export declare const defaultStateDirectory: () => string;
 export declare const defaultComputerConfig: () => ComputerConfig;
@@ -34,6 +36,8 @@ export declare function directRoutes(config: ComputerConfig, port: number): Comp
 export declare function ensureComputer(directory: string, cliPath: string, patch?: Partial<ComputerConfig>, onProgress?: (message: string) => void, options?: {
     resume?: boolean;
     signal?: AbortSignal;
+    timeoutMs?: number;
+    waitForRoutes?: boolean;
 }): Promise<Mindwire>;
 export declare function superviseComputer(directory: string): Promise<void>;
 export declare function stopComputer(directory: string, force?: boolean): Promise<void>;

package/dist/computer/managed-relay.d.ts

@@ -0,0 +1,27 @@
+import type { Oblien } from "oblien";
+import { type RelayOptions } from "./relay.js";
+export interface RelayWorkerConfig {
+    options: RelayOptions;
+    port: number;
+}
+interface TunnelToken {
+    token: string;
+    connect_url: string;
+    expires_at: string;
+}
+/** Cache only the short-lived broker token. Renew early without disconnecting a
+ * healthy carrier; a later reconnect uses the newest token for the same tunnel. */
+export declare class OblienTunnelLease {
+    private readonly tunnelId;
+    private readonly client;
+    private readonly now;
+    private value?;
+    private pending?;
+    constructor(tunnelId: number, client: () => Promise<Oblien>, now?: () => number);
+    get(force?: boolean): Promise<TunnelToken>;
+}
+export declare function relayFailureMessage(error: unknown, provider: string): string;
+/** A separate owned process survives controller updates just like cloudflared.
+ * It does not own the daemon, terminals, identity, or phone authorization. */
+export declare function runManagedRelay(file: string): Promise<void>;
+export {};

package/dist/computer/oblien-auth.d.ts

@@ -0,0 +1,25 @@
+import { Oblien } from "oblien";
+import type { SetupPrompt } from "./setup-prompt.js";
+export interface OblienCredentials {
+    token?: string;
+    clientId?: string;
+    clientSecret?: string;
+    baseUrl?: string;
+}
+export declare class ProviderSignInRequired extends Error {
+    readonly code = "provider_sign_in";
+    constructor(provider?: string);
+}
+export declare function tokenExpiry(token: string): number | undefined;
+export declare function oblienClient(credentials: OblienCredentials): Oblien;
+/** The SDK's resource methods share this transport but do not yet accept a
+ * timeout. Bound every request, including tunnel creation and token renewal,
+ * without bypassing the official resource API or retrying mutations. */
+export declare function boundedOblienClient(client: Oblien, timeoutMs?: number): Oblien;
+/** Auth is not yet a public SDK resource. Use the SDK's authenticated transport
+ * for the documented browser-session endpoints; all tunnel calls use edgeTunnel. */
+export declare function authenticatedOblien(file: string, options?: {
+    now?: () => number;
+    client?: typeof oblienClient;
+}): Promise<Oblien>;
+export declare function signInOblien(file: string, prompt: SetupPrompt): Promise<Oblien>;

package/dist/computer/provider-errors.d.ts

@@ -0,0 +1,9 @@
+export type ProviderErrorCode = "provider_sign_in" | "provider_limit" | "provider_missing" | "provider_certificate" | "provider_configuration" | "provider_connection";
+export declare class ProviderConnectionError extends Error {
+    readonly code: ProviderErrorCode;
+    constructor(code: ProviderErrorCode, message: string);
+}
+export declare function providerNeedsAction(code: string | undefined): boolean;
+/** Inspect transport causes, but never forward their raw text or headers. */
+export declare function hasCertificateError(error: unknown): boolean;
+export declare function providerFailure(error: unknown, provider: string): ProviderConnectionError;

package/dist/computer/provider-info.d.ts

@@ -0,0 +1,7 @@
+import type { ComputerConnectionInfo } from "../computer.js";
+import type { RelayOptions } from "./relay.js";
+/** Credential renewal does not change the address already saved by the phone. */
+export declare function connectionAddress(relay: RelayOptions, host?: string): string;
+/** Public, non-secret metadata. Route/SSH identity is independent of provider credentials. */
+export declare function connectionInfo(relay: RelayOptions, host?: string): ComputerConnectionInfo;
+export declare function connectionDescription(info: ComputerConnectionInfo): string;

package/dist/computer/provider-setup.d.ts

@@ -0,0 +1,20 @@
+import type { Oblien } from "oblien";
+import { type ComputerConfig } from "./lifecycle.js";
+import type { SetupPrompt } from "./setup-prompt.js";
+export type ConnectionProvider = "oblien" | "cloudflare" | "ngrok" | "vpn" | "custom" | "temporary" | "automatic";
+export declare function chooseProvider(prompt: SetupPrompt): Promise<ConnectionProvider>;
+export declare function connectionProvider(value: string): ConnectionProvider;
+export declare function providerHostname(value: string): string;
+/** No port-based account-wide reuse: two computers commonly use the same port. */
+export declare function prepareOblienTunnel(client: Oblien, stateFile: string, port: number): Promise<{
+    id: number;
+    url: string;
+}>;
+/** Setup is explicit and serialized. Background startup only consumes the saved
+ * result: it never opens a browser, changes provider, or creates another tunnel. */
+export declare function setupProvider(options: {
+    directory: string;
+    provider: ConnectionProvider;
+    prompt: SetupPrompt;
+    config?: ComputerConfig;
+}): Promise<Partial<ComputerConfig>>;

package/dist/computer/relay-health.d.ts

@@ -1,14 +1,29 @@
-import type { LookupFunction } from "node:net";
+import { type LookupFunction } from "node:net";
 import type { ComputerRoute } from "../computer.js";
 import type { RelayOptions } from "./relay.js";
 export declare class RelayCheckError extends Error {
-    readonly code: "dns" | "timeout" | "proxy" | "connection" | "response";
-    constructor(code: "dns" | "timeout" | "proxy" | "connection" | "response", message: string, cause?: Error);
+    readonly code: "dns" | "timeout" | "proxy" | "connection" | "response" | "provider_certificate";
+    readonly addressMissing: boolean;
+    constructor(code: "dns" | "timeout" | "proxy" | "connection" | "response" | "provider_certificate", message: string, cause?: Error, addressMissing?: boolean);
 }
-/** A resolver's negative cache says nothing about the helper's connection.
- * Rotating a live tunnel for NXDOMAIN creates another hostname to cache and
- * strands phones with the previous address. Process exits are handled separately. */
+/** Local NXDOMAIN can be a stale cache. A missing address confirmed by the
+ * provider is different: its helper may stay alive after the quick tunnel expires.
+ * Keep a grace period for newly allocated records and ordinary internet outages. */
 export declare function relayNeedsRestart(error: unknown, failures: number, failedForMs: number): boolean;
+type RelayDNSResult = {
+    addresses: {
+        address: string;
+        family: number;
+    }[];
+    missing: boolean;
+};
+/** Use the tunnel provider's HTTPS resolver only after local DNS fails. This
+ * bypasses router negative caches without another service or a persisted IP.
+ * A DNS answer never replaces TLS hostname validation or the phone's SSH pin. */
+export declare function resolveCloudflareAddress(hostname: string, family?: number, options?: {
+    fetch?: typeof fetch;
+    timeoutMs?: number;
+}): Promise<RelayDNSResult>;
 /** Check the actual WebSocket byte path, not just the helper's PID or its logs.
  * The phone still authenticates and pins the SSH host before sending secrets. */
 export declare function checkRelay(route: ComputerRoute, options?: {
@@ -19,3 +34,4 @@ export declare function checkRelay(route: ComputerRoute, options?: {
 /** Don't rotate a quick-tunnel address during an ordinary internet outage.
  * Let the provider reconnect with the same address until it is reachable again. */
 export declare function relayProviderReachable(options: RelayOptions, signal?: AbortSignal): Promise<boolean>;
+export {};

package/dist/computer/relay.d.ts

@@ -2,25 +2,33 @@ import { type ChildProcess } from "node:child_process";
 import type { ComputerRoute } from "../computer.js";
 import { type OwnedProcess } from "./process.js";
 export interface RelayOptions {
-    kind: "none" | "cloudflare" | "ngrok" | "custom";
+    kind: "none" | "oblien" | "cloudflare" | "ngrok" | "custom";
     /** A stable, already configured hostname; custom relays must forward WebSocket upgrades. */
     url?: string;
     cloudflareTokenFile?: string;
+    cloudflareTunnelId?: string;
+    cloudflareCredentialsFile?: string;
+    ngrokTokenFile?: string;
+    oblienTunnelId?: number;
+    oblienCredentialsFile?: string;
 }
 export interface RelayHandle {
     route?: ComputerRoute;
     process?: ChildProcess;
     owner?: OwnedProcess;
     outputFile?: string;
+    configFile?: string;
     close(): void | Promise<void>;
 }
-export declare function adoptRelay(owner: OwnedProcess, route: ComputerRoute | undefined, directory: string, outputFile?: string): Promise<RelayHandle>;
+export declare function adoptRelay(owner: OwnedProcess, route: ComputerRoute | undefined, directory: string, outputFile?: string, configFile?: string): Promise<RelayHandle>;
 export declare function websocketURL(value: string): string;
+export declare function validateRelayOptions(options: RelayOptions): void;
 /** Both providers forward encrypted SSH bytes to one loopback WebSocket bridge. */
 export declare function startRelay(options: RelayOptions, port: number, runtime?: {
     cacheDir?: string;
     outputDirectory?: string;
+    cliPath?: string;
     onProgress?: (message: string) => void | Promise<void>;
     signal?: AbortSignal;
-    onSpawn?: (owner: OwnedProcess, outputFile: string) => Promise<void>;
+    onSpawn?: (owner: OwnedProcess, outputFile: string, configFile?: string) => Promise<void>;
 }): Promise<RelayHandle>;

package/dist/computer/setup-prompt.d.ts

@@ -0,0 +1,9 @@
+export interface SetupPrompt {
+    question(text: string): Promise<string>;
+    secret(text: string): Promise<string>;
+    print(text: string): void;
+    open(url: string): void;
+}
+/** No shell interpolation, even for a URL returned by a provider. */
+export declare function openSetupURL(value: string): void;
+export declare const terminalSetupPrompt: SetupPrompt;

package/dist/computer.d.ts

@@ -7,6 +7,10 @@ export type ComputerRoute = {
     kind: "websocket";
     url: string;
 };
+export interface ComputerConnectionInfo {
+    provider: "oblien" | "cloudflare" | "ngrok" | "custom" | "direct";
+    address: "persistent" | "temporary" | "network";
+}
 export interface ComputerInvitation {
     version: 1;
     computerId: string;
@@ -37,6 +41,23 @@ export interface ComputerDevice {
     createdAt: string;
     revoked: boolean;
     connected?: boolean;
+    /** This phone acknowledged securely saving its address-discovery key. */
+    addressRecovery?: boolean;
+}
+export interface ComputerDiscoveryStatus {
+    version: 1;
+    enabled: boolean;
+    directoryId: string;
+    url?: string;
+    sequence?: number;
+    publishedSequence?: number;
+    publishedAt?: number;
+    error?: string;
+}
+export interface ComputerDirectoryEnvelope {
+    publicKey: string;
+    payload: string;
+    signature: string;
 }
 /** Signature is a base64 Ed25519 proof over
  * `mindwire-computer-pairing-v1\n${pairingId}\n${id}\n${name}\n${publicKey}`.
@@ -79,6 +100,8 @@ export interface ComputerInfo {
     /** 2 supports signed reconnection and atomic replacement of lost device keys.
      * 3 requires signed pairing acknowledgements and expires/revokes pairing transports. */
     pairingVersion?: number;
+    connection?: ComputerConnectionInfo;
+    discovery?: ComputerDiscoveryStatus;
 }
 export interface ComputerForwardRequest {
     id: string;
@@ -93,7 +116,10 @@ export declare class ComputerApi {
     private readonly client;
     constructor(client: Mindwire);
     info(): Promise<ComputerInfo>;
-    setRoutes(routes: ComputerRoute[]): Promise<ComputerInfo>;
+    discovery(): Promise<ComputerDiscoveryStatus>;
+    configureDiscovery(enabled: boolean, url?: string): Promise<ComputerDiscoveryStatus>;
+    directoryEnrollment(url: string, challenge: string): Promise<ComputerDirectoryEnvelope>;
+    setRoutes(routes: ComputerRoute[], connection?: ComputerConnectionInfo): Promise<ComputerInfo>;
     updateStatus(): Promise<ComputerUpdate>;
     /** Automatic requests wait for idle. With serviceUpdateVersion >= 2, force
      * promotes the same active request to an explicit restart without re-downloading. */

package/dist/connection-change-IBNL42BL.js

@@ -0,0 +1,41 @@
+import { acquireProcessLock, readJSON, writeJSON } from './chunk-RTGZDLSG.js';
+import './chunk-PFYKJ6LX.js';
+import { randomUUID } from 'crypto';
+import * as path from 'path';
+import { setTimeout } from 'timers/promises';
+
+async function changeComputerConnection(directory, patch, options = {}) {
+  const lock = await acquireProcessLock(path.join(directory, "connection-change.lock"), { signal: options.signal });
+  const file = path.join(directory, "computer-connection-change.json");
+  try {
+    const saved = await readJSON(path.join(directory, "computer-config.json"));
+    if (Object.entries(patch).every(([key, value]) => JSON.stringify(saved?.[key]) === JSON.stringify(value))) return;
+    const previous = await readJSON(file);
+    if (previous && ["queued", "connecting"].includes(previous.status) && JSON.stringify(previous.patch) !== JSON.stringify(patch)) {
+      throw new Error("Another connection change is still running. Run mindwire status, then retry.");
+    }
+    const request = previous && ["queued", "connecting"].includes(previous.status) ? previous : { id: randomUUID(), patch, status: "queued" };
+    await writeJSON(file, request);
+    let message;
+    const deadline = Date.now() + 13e4;
+    while (Date.now() < deadline) {
+      options.signal?.throwIfAborted();
+      const current = await readJSON(file);
+      if (current?.id !== request.id) throw new Error("The connection change was replaced. Run mindwire status.");
+      if (current.status === "complete") return;
+      if (current.status === "failed") throw new Error(current.message ?? "Connection setup failed. The previous connection is unchanged.");
+      if (current.message && message !== current.message) {
+        message = current.message;
+        options.onProgress?.(message);
+      }
+      await setTimeout(250, void 0, { signal: options.signal });
+    }
+    throw new Error("Connection setup is still running in the background. Run mindwire status for its result.");
+  } finally {
+    await lock?.close();
+  }
+}
+
+export { changeComputerConnection };
+//# sourceMappingURL=connection-change-IBNL42BL.js.map
+//# sourceMappingURL=connection-change-IBNL42BL.js.map

package/dist/connection-change-IBNL42BL.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../src/computer/connection-change.ts"],"names":["delay"],"mappings":";;;;;;AAeA,eAAsB,wBAAA,CAAyB,SAAA,EAAmB,KAAA,EAA0C,OAAA,GAExG,EAAC,EAAkB;AACrB,EAAA,MAAM,IAAA,GAAO,MAAM,kBAAA,CAAwB,IAAA,CAAA,IAAA,CAAK,SAAA,EAAW,wBAAwB,CAAA,EAAG,EAAE,MAAA,EAAQ,OAAA,CAAQ,MAAA,EAAQ,CAAA;AAChH,EAAA,MAAM,IAAA,GAAY,IAAA,CAAA,IAAA,CAAK,SAAA,EAAW,iCAAiC,CAAA;AACnE,EAAA,IAAI;AACF,IAAA,MAAM,QAAQ,MAAM,QAAA,CAA8B,IAAA,CAAA,IAAA,CAAK,SAAA,EAAW,sBAAsB,CAAC,CAAA;AACzF,IAAA,IAAI,MAAA,CAAO,QAAQ,KAAK,CAAA,CAAE,MAAM,CAAC,CAAC,KAAK,KAAK,CAAA,KAAM,KAAK,SAAA,CAAU,KAAA,GAAQ,GAA2B,CAAC,CAAA,KAAM,KAAK,SAAA,CAAU,KAAK,CAAC,CAAA,EAAG;AACnI,IAAA,MAAM,QAAA,GAAW,MAAM,QAAA,CAAmC,IAAI,CAAA;AAC9D,IAAA,IAAI,YAAY,CAAC,QAAA,EAAU,YAAY,CAAA,CAAE,SAAS,QAAA,CAAS,MAAM,CAAA,IAAK,IAAA,CAAK,UAAU,QAAA,CAAS,KAAK,MAAM,IAAA,CAAK,SAAA,CAAU,KAAK,CAAA,EAAG;AAC9H,MAAA,MAAM,IAAI,MAAM,8EAA8E,CAAA;AAAA,IAChG;AACA,IAAA,MAAM,UAAU,QAAA,IAAY,CAAC,QAAA,EAAU,YAAY,EAAE,QAAA,CAAS,QAAA,CAAS,MAAM,CAAA,GAAI,WAC7E,EAAE,EAAA,EAAI,YAAW,EAAG,KAAA,EAAO,QAAQ,QAAA,EAAkB;AACzD,IAAA,MAAM,SAAA,CAAU,MAAM,OAAO,CAAA;AAC7B,IAAA,IAAI,OAAA;AACJ,IAAA,MAAM,QAAA,GAAW,IAAA,CAAK,GAAA,EAAI,GAAI,IAAA;AAC9B,IAAA,OAAO,IAAA,CAAK,GAAA,EAAI,GAAI,QAAA,EAAU;AAC5B,MAAA,OAAA,CAAQ,QAAQ,cAAA,EAAe;AAC/B,MAAA,MAAM,OAAA,GAAU,MAAM,QAAA,CAAmC,IAAI,CAAA;AAC7D,MAAA,IAAI,SAAS,EAAA,KAAO,OAAA,CAAQ,IAAI,MAAM,IAAI,MAAM,0DAA0D,CAAA;AAC1G,MAAA,IAAI,OAAA,CAAQ,WAAW,UAAA,EAAY;AACnC,MAAA,IAAI,OAAA,CAAQ,WAAW,QAAA,EAAU,MAAM,IAAI,KAAA,CAAM,OAAA,CAAQ,WAAW,gEAAgE,CAAA;AACpI,MAAA,IAAI,OAAA,CAAQ,OAAA,IAAW,OAAA,KAAY,OAAA,CAAQ,OAAA,EAAS;AAAE,QAAA,OAAA,GAAU,OAAA,CAAQ,OAAA;AAAS,QAAA,OAAA,CAAQ,aAAa,OAAO,CAAA;AAAA,MAAG;AAChH,MAAA,MAAMA,WAAM,GAAA,EAAK,KAAA,CAAA,EAAW,EAAE,MAAA,EAAQ,OAAA,CAAQ,QAAQ,CAAA;AAAA,IACxD;AACA,IAAA,MAAM,IAAI,MAAM,0FAA0F,CAAA;AAAA,EAC5G,CAAA,SAAE;AAAU,IAAA,MAAM,MAAM,KAAA,EAAM;AAAA,EAAG;AACnC","file":"connection-change-IBNL42BL.js","sourcesContent":["import { randomUUID } from \"node:crypto\";\nimport * as path from \"node:path\";\nimport { setTimeout as delay } from \"node:timers/promises\";\nimport { acquireProcessLock } from \"./lock.js\";\nimport { readJSON, writeJSON, type ComputerConfig } from \"./lifecycle.js\";\n\nexport interface ComputerConnectionChange {\n  id: string;\n  patch: Pick<Partial<ComputerConfig>, \"relay\" | \"host\">;\n  status: \"queued\" | \"connecting\" | \"complete\" | \"failed\";\n  message?: string;\n}\n\n/** The controller verifies a replacement before committing it. Parallel CLI\n * invocations join the same settings change, or run one after the other. */\nexport async function changeComputerConnection(directory: string, patch: ComputerConnectionChange[\"patch\"], options: {\n  signal?: AbortSignal; onProgress?: (message: string) => void;\n} = {}): Promise<void> {\n  const lock = await acquireProcessLock(path.join(directory, \"connection-change.lock\"), { signal: options.signal });\n  const file = path.join(directory, \"computer-connection-change.json\");\n  try {\n    const saved = await readJSON<ComputerConfig>(path.join(directory, \"computer-config.json\"));\n    if (Object.entries(patch).every(([key, value]) => JSON.stringify(saved?.[key as keyof ComputerConfig]) === JSON.stringify(value))) return;\n    const previous = await readJSON<ComputerConnectionChange>(file);\n    if (previous && [\"queued\", \"connecting\"].includes(previous.status) && JSON.stringify(previous.patch) !== JSON.stringify(patch)) {\n      throw new Error(\"Another connection change is still running. Run mindwire status, then retry.\");\n    }\n    const request = previous && [\"queued\", \"connecting\"].includes(previous.status) ? previous\n      : { id: randomUUID(), patch, status: \"queued\" as const };\n    await writeJSON(file, request);\n    let message: string | undefined;\n    const deadline = Date.now() + 130_000;\n    while (Date.now() < deadline) {\n      options.signal?.throwIfAborted();\n      const current = await readJSON<ComputerConnectionChange>(file);\n      if (current?.id !== request.id) throw new Error(\"The connection change was replaced. Run mindwire status.\");\n      if (current.status === \"complete\") return;\n      if (current.status === \"failed\") throw new Error(current.message ?? \"Connection setup failed. The previous connection is unchanged.\");\n      if (current.message && message !== current.message) { message = current.message; options.onProgress?.(message); }\n      await delay(250, undefined, { signal: options.signal });\n    }\n    throw new Error(\"Connection setup is still running in the background. Run mindwire status for its result.\");\n  } finally { await lock?.close(); }\n}\n"]}