@miosa/sdk 2.0.6 → 2.0.7

package/dist/index.d.ts

@@ -7401,6 +7401,16 @@ declare class Sandbox {
         timeout?: number;
         stream?: boolean;
     }): Promise<boolean>;
+    /**
+     * Readiness answers from the server; `assertRunning` reads the local
+     * snapshot. Leaving that snapshot behind meant a caller could await
+     * `waitUntilReady()`, receive `true`, and have the very next call refused
+     * for being "provisioning" — the sandbox was running the whole time, only
+     * this object had not been told. Nothing here can fail the wait: readiness
+     * has already answered, so a refresh that does not land is not the caller's
+     * problem.
+     */
+    private adoptReadyState;
     /**
      * Returns `true` / `false` for terminal SSE events, or `null` if the
      * stream endpoint is unavailable (404 or transport error) so callers

package/dist/index.js

@@ -168,7 +168,7 @@ var TokenRefreshFailedError = class extends MiosaError {
 };
 
 // src/version.ts
-var SDK_VERSION = "2.0.6";
+var SDK_VERSION = "2.0.7";
 var SDK_USER_AGENT = `@miosa/sdk/${SDK_VERSION}`;
 
 // src/http.ts
@@ -9398,19 +9398,40 @@ var Sandbox = class _Sandbox {
     const stream = options.stream ?? true;
     if (stream) {
       const sseResult = await this.tryReadinessStream(timeout);
-      if (sseResult !== null) return sseResult;
+      if (sseResult !== null) {
+        if (sseResult) await this.adoptReadyState();
+        return sseResult;
+      }
     }
     const deadlineMs = Date.now() + timeout * 1e3;
     while (Date.now() < deadlineMs) {
       try {
         const data = await this.readiness();
-        if (data.ready === true || data.status === "ready") return true;
+        if (data.ready === true || data.status === "ready") {
+          await this.adoptReadyState();
+          return true;
+        }
       } catch {
       }
       await new Promise((resolve) => setTimeout(resolve, 10));
     }
     return false;
   }
+  /**
+   * Readiness answers from the server; `assertRunning` reads the local
+   * snapshot. Leaving that snapshot behind meant a caller could await
+   * `waitUntilReady()`, receive `true`, and have the very next call refused
+   * for being "provisioning" — the sandbox was running the whole time, only
+   * this object had not been told. Nothing here can fail the wait: readiness
+   * has already answered, so a refresh that does not land is not the caller's
+   * problem.
+   */
+  async adoptReadyState() {
+    try {
+      await this.refresh();
+    } catch {
+    }
+  }
   /**
    * Returns `true` / `false` for terminal SSE events, or `null` if the
    * stream endpoint is unavailable (404 or transport error) so callers