vim-web 0.3.40 → 0.3.42

package/dist/types/core-viewers/ultra/index.d.ts

@@ -6,3 +6,4 @@ export * from './utils/math3d';
 export * from './viewer/color';
 export type { ILoadRequest, VimRequestErrorType } from './viewer/loadRequest';
 export type { ClientState } from './viewer/socketClient';
+export type { VimSource } from './viewer/rpcSafeClient';

package/dist/types/core-viewers/ultra/viewer/logger.d.ts

@@ -1,5 +1,5 @@
 export interface ILogger {
-    log(message: string): void;
+    log(message: string, obj?: any): void;
     error: (message: string, e: unknown) => void;
 }
 export declare const defaultLogger: ILogger;

package/dist/types/core-viewers/ultra/viewer/renderer.d.ts

@@ -1,4 +1,5 @@
 import { RGBA } from "../utils/math3d";
+import { ILogger } from "./logger";
 import { RpcSafeClient, SceneSettings } from "./rpcSafeClient";
 import { ClientStreamError } from "./socketClient";
 /**
@@ -32,6 +33,7 @@ export interface IRenderer {
  */
 export declare class Renderer implements IRenderer {
     private _rpc;
+    private _logger;
     private _settings;
     private _animationFrame;
     private _updateLighting;
@@ -42,7 +44,7 @@ export declare class Renderer implements IRenderer {
      * @param rpc - RPC client for communication with the rendering backend
      * @param settings - Optional partial render settings to override defaults
      */
-    constructor(rpc: RpcSafeClient, settings?: Partial<RenderSettings>);
+    constructor(rpc: RpcSafeClient, logger: ILogger, settings?: Partial<RenderSettings>);
     /**
      * Validates the connection to the server by attempting to start a scene.
      * @returns A promise that resolves to a ClientStreamError if the connection fails, or undefined if successful.

package/dist/types/core-viewers/ultra/viewer/rpcClient.d.ts

@@ -18,6 +18,7 @@ export declare const materialHandles: MaterialHandle[];
 export declare class RpcClient {
     private readonly _messenger;
     get url(): string;
+    get connected(): boolean;
     constructor(_messenger: SocketClient);
     readonly API_VERSION = "5.0.0";
     RPCAddNodeFlags(componentHandle: number, nodes: number[], flags: number): void;

package/dist/types/core-viewers/ultra/viewer/rpcSafeClient.d.ts

@@ -1,6 +1,10 @@
 import { Box3, RGBA, RGBA32, Segment, Vector2, Vector3 } from "../utils/math3d";
 import { HitCheckResult } from "./marshal";
 import { MaterialHandle, RpcClient } from "./rpcClient";
+export type VimSource = {
+    url: string;
+    authToken?: string;
+};
 export type VimLoadingState = {
     status: VimLoadingStatus;
     progress: number;
@@ -34,6 +38,7 @@ export declare class RpcSafeClient {
     private readonly rpc;
     private readonly batchSize;
     get url(): string;
+    get connected(): boolean;
     constructor(rpc: RpcClient, batchSize?: number);
     /*******************************************************************************
      * SCENE MANAGEMENT METHODS
@@ -213,18 +218,18 @@ export declare class RpcSafeClient {
      ******************************************************************************/
     /**
      * Loads a VIM file from the local filesystem.
-     * @param fileName - The path to the VIM file (supports file:// protocol)
+     * @param source - The path to the VIM file (supports file:// protocol)
      * @returns Promise resolving to the handle of the loaded VIM component
      * @throws {Error} If the filename is invalid or empty
      */
-    RPCLoadVim(fileName: string): Promise<number>;
+    RPCLoadVim(source: VimSource): Promise<number>;
     /**
      * Loads a VIM file from a remote URL.
      * @param url - The URL of the VIM file to load
      * @returns Promise resolving to the handle of the loaded VIM component
      * @throws {Error} If the URL is invalid
      */
-    RPCLoadVimURL(url: string): Promise<number>;
+    RPCLoadVimURL(source: VimSource): Promise<number>;
     /**
      * Retrieves the current loading state and progress of a VIM component.
      * @param componentHandle - The handle of the VIM component

package/dist/types/core-viewers/ultra/viewer/viewer.d.ts

@@ -7,7 +7,7 @@ import { ILogger } from './logger';
 import { IViewport } from './viewport';
 import { ColorManager } from './colorManager';
 import { ICamera } from './camera';
-import { RpcSafeClient } from './rpcSafeClient';
+import { RpcSafeClient, VimSource } from './rpcSafeClient';
 import { ISimpleEvent } from 'ste-simple-events';
 import { IReadonlyVimCollection } from './vimCollection';
 import { IRenderer } from './renderer';
@@ -104,10 +104,10 @@ export declare class Viewer {
     disconnect(): void;
     /**
      * Requests the server to load the given URL or file path.
-     * @param path - The path or URL to the VIM file.
+     * @param source - The path or URL to the VIM file.
      * @returns A load request object that can be used to wait for the load to complete.
      */
-    loadVim(path: string): ILoadRequest;
+    loadVim(source: VimSource): ILoadRequest;
     /**
      * Unloads the given VIM from the viewer.
      * @param vim - The VIM instance to unload.

package/dist/types/core-viewers/ultra/viewer/viewport.d.ts

@@ -1,3 +1,4 @@
+import { ILogger } from "./logger";
 import { RpcSafeClient } from "./rpcSafeClient";
 /**
  * Interface defining viewport functionality
@@ -15,6 +16,7 @@ export declare class Viewport {
     /** The HTML canvas element used for rendering */
     canvas: HTMLCanvasElement;
     private _rpc;
+    private _logger;
     private _observer;
     private _clearTimeout;
     /**
@@ -22,7 +24,7 @@ export declare class Viewport {
      * @param canvas - The HTML canvas element to observe and manage
      * @param rpc - RPC client for viewport communication
      */
-    constructor(canvas: HTMLCanvasElement, rpc: RpcSafeClient);
+    constructor(canvas: HTMLCanvasElement, rpc: RpcSafeClient, logger: ILogger);
     /**
      * Handles resize events for the canvas
      * @private

package/dist/types/core-viewers/ultra/viewer/vim.d.ts

@@ -1,12 +1,12 @@
 import { ColorHandle } from './color';
 import { ColorManager } from './colorManager';
 import { LoadRequest } from './loadRequest';
-import { RpcSafeClient } from './rpcSafeClient';
+import { RpcSafeClient, VimSource } from './rpcSafeClient';
 import { ILogger } from './logger';
 import { Box3 } from '../utils/math3d';
 type NodeState = 'visible' | 'hidden' | 'ghosted' | 'highlighted';
 export declare class Vim {
-    readonly source: string;
+    readonly source: VimSource;
     private _handle;
     private _request;
     private readonly _rpc;
@@ -24,7 +24,7 @@ export declare class Vim {
      * @param source - The source URL or file path of the Vim.
      * @param logger - The logger for logging messages.
      */
-    constructor(rpc: RpcSafeClient, color: ColorManager, source: string, logger: ILogger);
+    constructor(rpc: RpcSafeClient, color: ColorManager, source: VimSource, logger: ILogger);
     get handle(): number;
     /**
      * Indicates whether the Vim is connected.
@@ -44,7 +44,7 @@ export declare class Vim {
     disconnect(): void;
     /**
      * Requests for the server to load the given URL or file path.
-     * @param url - The URL or file path to load.
+     * @param source - The URL or file path to load.
      * @param result - The load request object to update.
      * @returns The updated load request.
      */

package/dist/types/core-viewers/webgl/viewer/gizmos/sectionBox/sectionBoxInputs.d.ts

@@ -26,6 +26,7 @@ export declare class BoxInputs {
     constructor(viewer: Viewer, cube: THREE.Object3D, box: THREE.Box3);
     private reg;
     register(): void;
+    onPointerLeave(event: PointerEvent): void;
     capturePointer(pointerId: number): void;
     releasePointer(): void;
     unregister(): void;

package/dist/types/react-viewers/ultra/errors/serverFileDownloadingError.d.ts

@@ -1,2 +1,2 @@
 import { MessageBoxProps } from '../../panels/messageBox';
-export declare function serverFileDownloadingError(url: string, server?: string): MessageBoxProps;
+export declare function serverFileDownloadingError(url: string, authToken?: string, server?: string): MessageBoxProps;

package/dist/types/react-viewers/ultra/errors/ultraErrors.d.ts

@@ -1,3 +1,3 @@
 import * as Ultra from '../../../core-viewers/ultra';
 export declare function getErrorMessage(state: Ultra.ClientState): import("../..").MessageBoxProps;
-export declare function getRequestErrorMessage(url: string, error: Ultra.VimRequestErrorType): import("../..").MessageBoxProps;
+export declare function getRequestErrorMessage(source: Ultra.VimSource, error: Ultra.VimRequestErrorType): import("../..").MessageBoxProps;

package/dist/types/react-viewers/ultra/ultraComponent.d.ts

@@ -5,7 +5,7 @@ export type UltraComponentRef = {
     viewer: Ultra.Viewer;
     modal: ModalRef;
     dispose: () => void;
-    load(url: string): Ultra.ILoadRequest;
+    load(url: Ultra.VimSource): Ultra.ILoadRequest;
 };
 /**
  * Creates a UI container along with a VIM.Viewer and its associated React component.

package/dist/vim-web.iife.js

@@ -50168,10 +50168,10 @@ data:image/png;base64,iVBORw0KGgoAAAANSUhEUgAAAZAAAAGQCAYAAACAvzbMAAAAAXNSR0IArs
     background: { color: new Color(12698310) },
     skybox: {
       enable: true,
-      skyColor: new Color(15135994),
-      // Light sky blue pastel
-      groundColor: new Color(14671841),
-      // Light earthy brown pastel
+      skyColor: new Color(16777215),
+      // white
+      groundColor: new Color(16185078),
+      // less white
       sharpness: 2
     },
     groundPlane: {
@@ -55236,6 +55236,15 @@ data:image/png;base64,iVBORw0KGgoAAAANSUhEUgAAAZAAAAGQCAYAAACAvzbMAAAAAXNSR0IArs
       this.reg(canvas, "pointerdown", this.onMouseDown.bind(this));
       this.reg(canvas, "pointermove", this.onMouseMove.bind(this));
       this.reg(canvas, "pointerup", this.onMouseUp.bind(this));
+      this.reg(canvas, "pointerleave", this.onPointerLeave.bind(this));
+    }
+    onPointerLeave(event) {
+      var _a2;
+      if (this.capturedId !== void 0) {
+        return;
+      }
+      this.faceNormal.set(0, 0, 0);
+      (_a2 = this.onFaceEnter) == null ? void 0 : _a2.call(this, this.faceNormal);
     }
     capturePointer(pointerId) {
       this.releasePointer();
@@ -58127,6 +58136,9 @@ data:image/png;base64,iVBORw0KGgoAAAANSUhEUgAAAZAAAAGQCAYAAACAvzbMAAAAAXNSR0IArs
     get url() {
       return this._messenger.url;
     }
+    get connected() {
+      return this._messenger.state.status === "connected";
+    }
     RPCAddNodeFlags(componentHandle, nodes, flags) {
       const marshal = new Marshal();
       marshal.writeString("RPCAddNodeFlags");
@@ -58823,6 +58835,9 @@ data:image/png;base64,iVBORw0KGgoAAAANSUhEUgAAAZAAAAGQCAYAAACAvzbMAAAAAXNSR0IArs
     get url() {
       return this.rpc.url;
     }
+    get connected() {
+      return this.rpc.connected;
+    }
     /*******************************************************************************
      * SCENE MANAGEMENT METHODS
      * Methods for managing the overall scene, including initialization, lighting,
@@ -59159,15 +59174,15 @@ data:image/png;base64,iVBORw0KGgoAAAANSUhEUgAAAZAAAAGQCAYAAACAvzbMAAAAAXNSR0IArs
      ******************************************************************************/
     /**
      * Loads a VIM file from the local filesystem.
-     * @param fileName - The path to the VIM file (supports file:// protocol)
+     * @param source - The path to the VIM file (supports file:// protocol)
      * @returns Promise resolving to the handle of the loaded VIM component
      * @throws {Error} If the filename is invalid or empty
      */
-    async RPCLoadVim(fileName) {
-      if (!Validation.isNonEmptyString(fileName)) return INVALID_HANDLE;
-      fileName = fileName.replace("file:///", "file://");
+    async RPCLoadVim(source) {
+      if (!Validation.isNonEmptyString(source.url)) return INVALID_HANDLE;
+      const url = source.url.replace("file:///", "file://");
       return await this.safeCall(
-        () => this.rpc.RPCLoadVim(fileName),
+        () => this.rpc.RPCLoadVim(url),
         INVALID_HANDLE
       );
     }
@@ -59177,10 +59192,10 @@ data:image/png;base64,iVBORw0KGgoAAAANSUhEUgAAAZAAAAGQCAYAAACAvzbMAAAAAXNSR0IArs
      * @returns Promise resolving to the handle of the loaded VIM component
      * @throws {Error} If the URL is invalid
      */
-    async RPCLoadVimURL(url) {
-      if (!Validation.isURL(url)) return INVALID_HANDLE;
+    async RPCLoadVimURL(source) {
+      if (!Validation.isURL(source.url)) return INVALID_HANDLE;
       return await this.safeCall(
-        () => this.rpc.RPCLoadVimURL(url, ""),
+        () => this.rpc.RPCLoadVimURL(source.url, source.authToken ?? ""),
         INVALID_HANDLE
       );
     }
@@ -59564,9 +59579,9 @@ data:image/png;base64,iVBORw0KGgoAAAANSUhEUgAAAZAAAAGQCAYAAACAvzbMAAAAAXNSR0IArs
       this._inputsMouse = new InputMouse(this._canvas, this._rpc, selection, camera2);
       this._inputsTouch = new InputTouch(this._canvas, this._rpc);
       this._keyboard = new InputKeyboard(this._rpc, selection, camera2, this);
-      this.register();
     }
     onConnect() {
+      this.register();
       this._rpc.RPCSetMoveSpeed(this._moveSpeed);
     }
     register() {
@@ -59812,7 +59827,7 @@ Averrage Date/Second ${avgDataRatePS} kb
      * Disconnects from the current WebSocket server.
      */
     disconnect(error) {
-      this._logger.log("Disconnecting from " + this._connectingUrl);
+      this._logger.log("Disconnecting from: ", this._connectingUrl);
       this._connectingUrl = void 0;
       this._disconnect(error);
     }
@@ -59898,7 +59913,7 @@ Averrage Date/Second ${avgDataRatePS} kb
         this._disconnect(issues);
         return;
       }
-      this._logger.log("Connected to " + ((_a2 = this._socket) == null ? void 0 : _a2.url));
+      this._logger.log("Connected to: ", (_a2 = this._socket) == null ? void 0 : _a2.url);
       this.updateState({ status: "connected" });
       this._streamLogger.startLoggging();
       this._connectPromise.resolve();
@@ -60211,7 +60226,10 @@ Averrage Date/Second ${avgDataRatePS} kb
           this._logger.error("Error decoding video chunk: ", e);
         }
       }
-      this._firstDecoded = true;
+      if (!this._firstDecoded) {
+        this._firstDecoded = true;
+        this._logger.log("First frame decoded");
+      }
     }
     /**
      * Clears the decoder state and renderer buffer.
@@ -60421,16 +60439,16 @@ Averrage Date/Second ${avgDataRatePS} kb
       if (this._request) {
         return this._request;
       }
-      this._logger.log("Loading " + this.source);
+      this._logger.log("Loading: ", this.source);
       this._request = new LoadRequest$1();
       this._load(this.source, this._request).then(async (request2) => {
         const result = await request2.getResult();
         if (result.isSuccess) {
-          this._logger.log(`Successfully loaded vim: ${this.source}`);
+          this._logger.log("Successfully loaded vim: ", this.source);
           this.reapplyNodes();
           this.reapplyColors();
         } else {
-          this._logger.log(`Failed to load vim:  ${this.source}`);
+          this._logger.log("Failed to load vim: ", this.source);
         }
       });
       return this._request;
@@ -60463,18 +60481,19 @@ Averrage Date/Second ${avgDataRatePS} kb
     }
     /**
      * Requests for the server to load the given URL or file path.
-     * @param url - The URL or file path to load.
+     * @param source - The URL or file path to load.
      * @param result - The load request object to update.
      * @returns The updated load request.
      */
-    async _load(url, result) {
-      const handle = await this._getHandle(url, result);
+    async _load(source, result) {
+      const handle = await this._getHandle(source, result);
       if (result.isCompleted || handle === INVALID_HANDLE) {
         return result;
       }
       while (true) {
         try {
           const state = await this._rpc.RPCGetVimLoadingState(handle);
+          this._logger.log("state :", state);
           result.onProgress(state.progress);
           switch (state.status) {
             // Keep waiting for the loading to complete
@@ -60511,16 +60530,16 @@ Averrage Date/Second ${avgDataRatePS} kb
           return "unknown";
       }
     }
-    async _getHandle(url, result) {
+    async _getHandle(source, result) {
       let handle = void 0;
       try {
-        if (isURL(url)) {
-          handle = await this._rpc.RPCLoadVimURL(url);
-        } else if (isFileURI(url)) {
-          handle = await this._rpc.RPCLoadVim(url);
+        if (isURL(source.url)) {
+          handle = await this._rpc.RPCLoadVimURL(source);
+        } else if (isFileURI(source.url)) {
+          handle = await this._rpc.RPCLoadVim(source);
         } else {
           console.log("Defaulting to file path");
-          handle = await this._rpc.RPCLoadVim(url);
+          handle = await this._rpc.RPCLoadVim(source);
         }
       } catch (e) {
         result.error("downloadingError", e.message);
@@ -60530,6 +60549,7 @@ Averrage Date/Second ${avgDataRatePS} kb
         result.error("downloadingError");
         return INVALID_HANDLE;
       }
+      console.log("handle :", handle);
       return handle;
     }
     /**
@@ -60735,13 +60755,27 @@ Averrage Date/Second ${avgDataRatePS} kb
     return new Promise((resolve) => setTimeout(resolve, ms));
   }
   const defaultLogger = {
-    log: (message) => {
-      console.log("VIM Ultra: " + message);
+    log: (message, obj) => {
+      const caller = getCaller();
+      const msg = `VIM Ultra : ${message}`;
+      if (obj) {
+        console.log(msg, obj, { caller });
+      } else {
+        console.log(msg, { caller });
+      }
     },
     error: (message, e) => {
-      console.error("VIM Ultra: " + message, e);
+      console.error("VIM Ultra " + message, e);
     }
   };
+  function getCaller() {
+    const stack = new Error().stack;
+    if (!stack) return "";
+    const files = stack.split("/");
+    const file = files[files.length - 1];
+    const clean = file.replace(/\?[^:]+/, "");
+    return clean;
+  }
   function debounce(func, delay) {
     let timeoutId;
     return [function(...args) {
@@ -60759,14 +60793,16 @@ Averrage Date/Second ${avgDataRatePS} kb
      * @param canvas - The HTML canvas element to observe and manage
      * @param rpc - RPC client for viewport communication
      */
-    constructor(canvas, rpc) {
+    constructor(canvas, rpc, logger) {
       /** The HTML canvas element used for rendering */
       __publicField(this, "canvas");
       __publicField(this, "_rpc");
+      __publicField(this, "_logger");
       __publicField(this, "_observer");
       __publicField(this, "_clearTimeout");
       this.canvas = canvas;
       this._rpc = rpc;
+      this._logger = logger;
       const [debounced, clear] = debounce(() => this.onResize(), 250);
       this._observer = new ResizeObserver(debounced);
       this._observer.observe(canvas);
@@ -60777,14 +60813,16 @@ Averrage Date/Second ${avgDataRatePS} kb
      * @private
      */
     onResize() {
-      console.log("Canvas resized to", this.canvas.offsetWidth, "x", this.canvas.offsetHeight);
+      this._logger.log("Canvas resized to :", { x: this.canvas.offsetWidth, y: this.canvas.offsetHeight });
       this.update();
     }
     /**
      * Updates the aspect ratio of the viewport on the server
      */
     update() {
-      this._rpc.RPCSetAspectRatio(this.canvas.offsetWidth, this.canvas.offsetHeight);
+      if (this._rpc.connected) {
+        this._rpc.RPCSetAspectRatio(this.canvas.offsetWidth, this.canvas.offsetHeight);
+      }
     }
     /**
      * Cleans up resources by removing resize observer and clearing timeouts
@@ -61330,14 +61368,16 @@ Averrage Date/Second ${avgDataRatePS} kb
      * @param rpc - RPC client for communication with the rendering backend
      * @param settings - Optional partial render settings to override defaults
      */
-    constructor(rpc, settings2 = {}) {
+    constructor(rpc, logger, settings2 = {}) {
       __publicField(this, "_rpc");
+      __publicField(this, "_logger");
       __publicField(this, "_settings");
       __publicField(this, "_animationFrame");
       __publicField(this, "_updateLighting", false);
       __publicField(this, "_updateGhostColor", false);
       __publicField(this, "_updateIblRotation", false);
       this._rpc = rpc;
+      this._logger = logger;
       this._settings = { ...defaultRenderSettings, ...settings2 };
     }
     /**
@@ -61346,8 +61386,12 @@ Averrage Date/Second ${avgDataRatePS} kb
      */
     async validateConnection() {
       const success = await this._rpc.RPCStartScene(this._settings);
-      if (success) return void 0;
+      if (success) {
+        this._logger.log("Scene stream started successfully");
+        return void 0;
+      }
       const error = await this._rpc.RPCGetLastError();
+      this._logger.error("Failed to start scene stream", error);
       return {
         status: "error",
         error: "stream",
@@ -61572,10 +61616,10 @@ Averrage Date/Second ${avgDataRatePS} kb
       this.rpc = new RpcSafeClient(new RpcClient(this._socketClient));
       this._canvas = canvas;
       this._vims = new VimCollection();
-      this._viewport = new Viewport(canvas, this.rpc);
+      this._viewport = new Viewport(canvas, this.rpc, this._logger);
       this._decoder = new Decoder(canvas, this._logger);
       this._selection = new ViewerSelection(this.rpc, this._vims);
-      this._renderer = new Renderer(this.rpc);
+      this._renderer = new Renderer(this.rpc, this._logger);
       this.colors = new ColorManager(this.rpc);
       this._camera = new Camera(this.rpc);
       this._input = new Inputs(canvas, this.rpc, this._selection, this._camera, this._renderer);
@@ -61684,6 +61728,7 @@ Averrage Date/Second ${avgDataRatePS} kb
       const remoteVersion = parseVersion(version2);
       const localParsedVersion = parseVersion(localVersion);
       if (localParsedVersion.major !== remoteVersion.major) {
+        this._logger.error("Major version mismatch", { local: localParsedVersion, remote: remoteVersion });
         return {
           status: "error",
           error: "compatibility",
@@ -61692,6 +61737,7 @@ Averrage Date/Second ${avgDataRatePS} kb
           serverVersion: version2
         };
       }
+      this._logger.log("API version check passed", { local: localParsedVersion, remote: remoteVersion });
       return void 0;
     }
     /**
@@ -61721,16 +61767,16 @@ Averrage Date/Second ${avgDataRatePS} kb
     }
     /**
      * Requests the server to load the given URL or file path.
-     * @param path - The path or URL to the VIM file.
+     * @param source - The path or URL to the VIM file.
      * @returns A load request object that can be used to wait for the load to complete.
      */
-    loadVim(path) {
-      if (typeof path !== "string" || path.trim() === "") {
+    loadVim(source) {
+      if (typeof source.url !== "string" || source.url.trim() === "") {
         const request22 = new LoadRequest$1();
         request22.error("loadingError", "Invalid path");
         return request22;
       }
-      const vim = new Vim(this.rpc, this.colors, path, this._logger);
+      const vim = new Vim(this.rpc, this.colors, source, this._logger);
       this._vims.add(vim);
       const request2 = vim.connect();
       request2.getResult().then((result) => {
@@ -74215,6 +74261,8 @@ Averrage Date/Second ${avgDataRatePS} kb
       relay("pointerdown", (s, e) => new PointerEvent(s, e), false);
       relay("pointermove", (s, e) => new PointerEvent(s, e), false);
       relay("pointerup", (s, e) => new PointerEvent(s, e), false);
+      relay("pointerenter", (s, e) => new PointerEvent(s, e));
+      relay("pointerleave", (s, e) => new PointerEvent(s, e));
       relay("touchstart", (s, e) => new TouchEvent(s, e), false);
       relay("touchend", (s, e) => new TouchEvent(s, e), false);
       relay("touchmove", (s, e) => new TouchEvent(s, e), false);
@@ -75658,18 +75706,18 @@ Averrage Date/Second ${avgDataRatePS} kb
     }
     return true;
   }
-  function serverFileDownloadingError(url, server) {
+  function serverFileDownloadingError(url, authToken, server) {
     if (isFilePathOrUri(url)) {
       return fileOpeningError(url);
     }
     return {
       title: "File Downloading Error",
-      body: body$4(server, url),
+      body: body$4(server, authToken, server),
       footer: footer(support),
       canClose: false
     };
   }
-  function body$4(server, url) {
+  function body$4(url, server, authToken) {
     return /* @__PURE__ */ jsxRuntimeExports.jsxs("div", { className: vcRoboto, children: [
       mainText(/* @__PURE__ */ jsxRuntimeExports.jsxs(jsxRuntimeExports.Fragment, { children: [
         "Oops, it appears that there’s an ",
@@ -75679,7 +75727,8 @@ Averrage Date/Second ${avgDataRatePS} kb
       subTitle("Error details:"),
       dotList([
         server ? bullet("VIM ULTRA Server:", server) : null,
-        bullet("File URL:", url)
+        bullet("File URL:", url),
+        authToken ? bullet("Auth Token:", authToken) : null
       ]),
       subTitle("Troubleshooting tips:"),
       numList([
@@ -75815,17 +75864,17 @@ Averrage Date/Second ${avgDataRatePS} kb
         return serverStreamError(state.serverUrl);
     }
   }
-  function getRequestErrorMessage(url, error) {
+  function getRequestErrorMessage(source, error) {
     console.log(error);
     switch (error) {
       case "loadingError":
-        return serverFileLoadingError(url);
+        return serverFileLoadingError(source.url);
       case "downloadingError":
       case "unknown":
       case "cancelled":
-        return serverFileDownloadingError(url);
+        return serverFileDownloadingError(source.url);
       case "serverDisconnected":
-        return serverConnectionError(url);
+        return serverConnectionError(source.url);
     }
   }
   function createUltraComponent(container) {
@@ -75880,13 +75929,13 @@ Averrage Date/Second ${avgDataRatePS} kb
     }
   }
   function ToRef(viewer, modal) {
-    function load(url) {
-      const request2 = viewer.loadVim(url);
+    function load(source) {
+      const request2 = viewer.loadVim(source);
       void updateProgress(request2, modal);
       void request2.getResult().then(
         (result) => {
           if (result.isError) {
-            modal.message(getRequestErrorMessage(url, result.error));
+            modal.message(getRequestErrorMessage(source, result.error));
             return;
           }
           if (result.isSuccess) {