@volley/vwr-loader 1.0.4 → 1.0.5

package/src/getDeviceId.test.ts

@@ -6,9 +6,8 @@ describe("getDeviceId", () => {
     beforeEach(() => {
         vi.clearAllMocks()
         // Clean up window properties
-        delete (window as any).Capacitor
-        delete (window as any).iosAppContext
-        delete (window as any).androidAppContext
+        delete (window as any).DeviceInfo
+        delete (window as any).NativeBridge
         delete (window as any).webapis
         delete (window as any).webOSDev
         delete (window as any).webOS
@@ -16,26 +15,21 @@ describe("getDeviceId", () => {
 
     afterEach(() => {
         vi.restoreAllMocks()
-        delete (window as any).Capacitor
-        delete (window as any).iosAppContext
-        delete (window as any).androidAppContext
+        delete (window as any).DeviceInfo
+        delete (window as any).NativeBridge
         delete (window as any).webapis
         delete (window as any).webOSDev
         delete (window as any).webOS
     })
 
     describe("FIRE_TV platform", () => {
-        it("returns device ID from Capacitor DeviceInfo.getAndroidId when available", async () => {
+        it("returns device ID from DeviceInfo.getAndroidId when available", async () => {
             const mockAndroidId = "firetv-android-id-123"
-            Object.defineProperty(window, "Capacitor", {
+            Object.defineProperty(window, "DeviceInfo", {
                 value: {
-                    Plugins: {
-                        DeviceInfo: {
-                            getAndroidId: vi.fn().mockResolvedValue({
-                                androidId: mockAndroidId,
-                            }),
-                        },
-                    },
+                    getAndroidId: vi
+                        .fn()
+                        .mockResolvedValue({ androidId: mockAndroidId }),
                 },
                 writable: true,
                 configurable: true,
@@ -46,17 +40,11 @@ describe("getDeviceId", () => {
         })
 
         it("returns null when DeviceInfo throws error", async () => {
-            Object.defineProperty(window, "Capacitor", {
+            Object.defineProperty(window, "DeviceInfo", {
                 value: {
-                    Plugins: {
-                        DeviceInfo: {
-                            getAndroidId: vi
-                                .fn()
-                                .mockRejectedValue(
-                                    new Error("DeviceInfo error")
-                                ),
-                        },
-                    },
+                    getAndroidId: vi
+                        .fn()
+                        .mockRejectedValue(new Error("DeviceInfo error")),
                 },
                 writable: true,
                 configurable: true,
@@ -67,15 +55,9 @@ describe("getDeviceId", () => {
         })
 
         it("returns null when DeviceInfo returns empty", async () => {
-            Object.defineProperty(window, "Capacitor", {
+            Object.defineProperty(window, "DeviceInfo", {
                 value: {
-                    Plugins: {
-                        DeviceInfo: {
-                            getAndroidId: vi
-                                .fn()
-                                .mockResolvedValue({ androidId: "" }),
-                        },
-                    },
+                    getAndroidId: vi.fn().mockResolvedValue({ androidId: "" }),
                 },
                 writable: true,
                 configurable: true,
@@ -166,25 +148,11 @@ describe("getDeviceId", () => {
     })
 
     describe("MOBILE platform", () => {
-        it("returns device ID from iosAppContext when available", async () => {
-            const mockDeviceId = "ios-device-123"
-            Object.defineProperty(window, "iosAppContext", {
-                value: {
-                    phoneDeviceId: mockDeviceId,
-                },
-                writable: true,
-                configurable: true,
-            })
-
-            const result = await getDeviceId("MOBILE")
-            expect(result).toBe(mockDeviceId)
-        })
-
-        it("returns device ID from androidAppContext when available", async () => {
-            const mockDeviceId = "android-device-123"
-            Object.defineProperty(window, "androidAppContext", {
+        it("returns device ID from NativeBridge when available", async () => {
+            const mockDeviceId = "native-device-123"
+            Object.defineProperty(window, "NativeBridge", {
                 value: {
-                    phoneDeviceId: mockDeviceId,
+                    getDeviceId: vi.fn().mockResolvedValue(mockDeviceId),
                 },
                 writable: true,
                 configurable: true,
@@ -194,35 +162,12 @@ describe("getDeviceId", () => {
             expect(result).toBe(mockDeviceId)
         })
 
-        it("prefers iosAppContext over androidAppContext", async () => {
-            Object.defineProperty(window, "iosAppContext", {
-                value: {
-                    phoneDeviceId: "ios-id",
-                },
-                writable: true,
-                configurable: true,
-            })
-            Object.defineProperty(window, "androidAppContext", {
-                value: {
-                    phoneDeviceId: "android-id",
-                },
-                writable: true,
-                configurable: true,
-            })
-
-            const result = await getDeviceId("MOBILE")
-            expect(result).toBe("ios-id")
-        })
-
-        it("returns null when no app context is available", async () => {
-            const result = await getDeviceId("MOBILE")
-            expect(result).toBeNull()
-        })
-
-        it("returns null when phoneDeviceId is empty", async () => {
-            Object.defineProperty(window, "iosAppContext", {
+        it("returns null when NativeBridge throws error", async () => {
+            Object.defineProperty(window, "NativeBridge", {
                 value: {
-                    phoneDeviceId: "",
+                    getDeviceId: vi
+                        .fn()
+                        .mockRejectedValue(new Error("Native error")),
                 },
                 writable: true,
                 configurable: true,

package/src/getDeviceId.ts

@@ -7,12 +7,12 @@ import { defaultLogger, type Logger } from "./logger"
  *
  * Platform handling:
  * - FireTV: DeviceInfo (Capacitor plugin)
- * - Android/iOS: window.iosAppContext / window.androidAppContext (phoneDeviceId)
+ * - Android/iOS: NativeBridge
  * - Samsung TV: webapis
  * - LG TV: webOS Luna service
  * - Web: localStorage (with generated UUID fallback)
  *
- * @param platform - Platform identifier ('FIRE_TV', 'SAMSUNG_TV', 'LG_TV', 'ANDROID_MOBILE', 'IOS_MOBILE', 'WEB')
+ * @param platform - Platform identifier ('FIRE_TV', 'SAMSUNG_TV', 'LG_TV', 'MOBILE', 'WEB')
  * @param logger - Optional logger for error reporting. Defaults to defaultLogger.
  * @returns A promise that resolves to a unique device identifier string, or null if retrieval fails
  *
@@ -36,9 +36,7 @@ export async function getDeviceId(
             return await getSamsungDeviceId(logger)
         case "LG_TV":
             return await getLGDeviceId(logger)
-        case "ANDROID_MOBILE":
-        case "IOS_MOBILE":
-        case "MOBILE": // Legacy/Generic
+        case "MOBILE": // iOS and Android
             return await getMobileDeviceId(logger)
         case "WEB":
             return getLocalStorageDeviceId()
@@ -66,62 +64,44 @@ function getLocalStorageDeviceId(): string {
  */
 async function getFireTVDeviceId(logger: Logger): Promise<string | null> {
     try {
-        // Access via Capacitor.Plugins (standard Capacitor plugin access)
-        const Capacitor = (window as any).Capacitor
-        const DeviceInfo = Capacitor?.Plugins?.DeviceInfo
-
-        if (!DeviceInfo?.getAndroidId) {
+        if (!window.Capacitor?.Plugins?.DeviceInfo?.getAndroidId) {
             return null
         }
 
-        const result = await DeviceInfo.getAndroidId()
+        const result = await window.Capacitor.Plugins.DeviceInfo.getAndroidId()
         if (result?.androidId && result.androidId.trim()) {
             return result.androidId
         } else {
-            logger.error("DeviceInfo.getAndroidId returned empty")
+            logger.error(
+                "Capacitor.Plugins.DeviceInfo.getAndroidId returned empty"
+            )
         }
     } catch (error) {
-        const message = "DeviceInfo.getAndroidId failed:"
+        const message = "Capacitor.Plugins.DeviceInfo.getAndroidId failed:"
         logger.error(message, { error })
     }
     return null
 }
 
 /**
- * Attempt to get device ID from mobile app context (Android/iOS)
- *
- * iOS exposes phoneDeviceId via window.iosAppContext
- * Android exposes phoneDeviceId via window.androidAppContext (also check window.top for iframes)
+ * Attempt to get device ID from Native Bridge (Android/iOS)
  */
-function getMobileDeviceId(logger: Logger): string | null {
-    // Try iOS first
-    const iosId = (window as ExtendedWindow).iosAppContext?.phoneDeviceId
-    if (iosId && iosId.trim()) {
-        return iosId
-    }
-
-    // Try Android (check both window and window.top for iframe scenarios)
-    const androidContext = (window as ExtendedWindow).androidAppContext
+async function getMobileDeviceId(logger: Logger): Promise<string | null> {
     try {
-        const androidId =
-            androidContext?.phoneDeviceId ??
-            (window.top as ExtendedWindow | null)?.androidAppContext
-                ?.phoneDeviceId
-        if (androidId && androidId.trim()) {
-            return androidId
+        if (!window.NativeBridge?.getDeviceId) {
+            return null
         }
-    } catch {
-        // window.top access can throw if cross-origin
-        const androidId = androidContext?.phoneDeviceId
-        if (androidId && androidId.trim()) {
-            return androidId
+
+        const id = await window.NativeBridge.getDeviceId()
+        if (id && id.trim()) {
+            return id
+        } else {
+            logger.error("NativeBridge.getDeviceId returned empty")
         }
+    } catch (error) {
+        const message = "NativeBridge.getDeviceId failed:"
+        logger.error(message, { error })
     }
-
-    logger.error("[VWR:MobileDeviceId] phoneDeviceId not found", {
-        iosAppContext: !!(window as ExtendedWindow).iosAppContext,
-        androidAppContext: !!androidContext,
-    })
     return null
 }
 
@@ -229,23 +209,18 @@ interface LGDeviceIdResponse {
     }>
 }
 
-/**
- * Extended window interface for mobile app context
- * Matches the types from @volley/sdk ExtendedWindow.ts
- */
-interface ExtendedWindow extends Window {
-    iosAppContext?: {
-        phoneDeviceId: string
-    }
-    androidAppContext?: {
-        phoneDeviceId: string
-    }
-}
-
 // Type augmentation for platform-specific APIs
-// Note: Capacitor types are declared in getShellVersion.ts with flexible index signatures
+// Note: Capacitor types are declared in getShellVersion.ts with index signatures
+// to allow extensibility. Additional methods used here are accessed via
+// the index signatures [key: string]: any
 declare global {
     interface Window {
+        DeviceInfo?: {
+            getAndroidId: () => Promise<{ androidId: string }>
+        }
+        NativeBridge?: {
+            getDeviceId: () => Promise<string>
+        }
         webapis?: {
             productinfo?: {
                 getDuid: () => string

package/src/getEnvironment.ts

@@ -0,0 +1,137 @@
+import { defaultLogger, type Logger } from "./logger"
+
+export type Environment = "local" | "dev" | "staging" | "prod"
+export type EnvironmentSource = "native" | "build-time" | "default"
+
+export interface EnvironmentResult {
+    environment: Environment
+    source: EnvironmentSource
+}
+
+/**
+ * Get the environment for the current platform.
+ *
+ * Precedence:
+ * 1. Native shell (Fire TV only) - reads from BuildConfig.ENVIRONMENT
+ * 2. Build-time injection (VITE_ENVIRONMENT) - CLI override
+ * 3. Default fallback ("dev")
+ *
+ * This ensures production APKs cannot accidentally run dev VWR,
+ * since the native Android build variant determines the environment.
+ *
+ * @param platform - Platform identifier ('FIRE_TV', 'SAMSUNG_TV', 'LG_TV', 'MOBILE', 'WEB')
+ * @param buildTimeEnv - Optional build-time injected environment (from CLI)
+ * @param logger - Optional logger for reporting
+ * @returns Environment result with source information for logging
+ */
+export async function getEnvironment(
+    platform: string,
+    buildTimeEnv: string | undefined,
+    logger: Logger = defaultLogger
+): Promise<EnvironmentResult> {
+    const normalizedPlatform = platform.toUpperCase()
+
+    // For Fire TV, try to read from native first (safest - prevents env mismatch)
+    if (normalizedPlatform === "FIRE_TV") {
+        const nativeEnv = await getFireTVEnvironment(logger)
+        if (nativeEnv) {
+            const mapped = mapNativeEnvironment(nativeEnv)
+            logger.info(
+                `[Shell] Environment: "${mapped}" (source: native BuildConfig.ENVIRONMENT="${nativeEnv}")`
+            )
+            return { environment: mapped, source: "native" }
+        }
+        // Fall through to build-time if native fails
+        logger.warn(
+            "[Shell] Failed to read environment from native, falling back to build-time"
+        )
+    }
+
+    // Build-time injection (CLI --env flag)
+    if (buildTimeEnv && isValidEnvironment(buildTimeEnv)) {
+        logger.info(
+            `[Shell] Environment: "${buildTimeEnv}" (source: build-time CLI injection)`
+        )
+        return {
+            environment: buildTimeEnv as Environment,
+            source: "build-time",
+        }
+    }
+
+    // Default fallback
+    const defaultEnv: Environment = "dev"
+    logger.warn(
+        `[Shell] Environment: "${defaultEnv}" (source: default fallback - no native or build-time env found)`
+    )
+    return { environment: defaultEnv, source: "default" }
+}
+
+/**
+ * Read environment from Fire TV native shell via Capacitor plugin.
+ */
+async function getFireTVEnvironment(logger: Logger): Promise<string | null> {
+    try {
+        if (
+            !window.Capacitor?.Plugins?.DeviceInfo?.getNativeShellAppEnvironment
+        ) {
+            logger.warn(
+                "[Shell] DeviceInfo.getNativeShellAppEnvironment not available"
+            )
+            return null
+        }
+
+        const result =
+            await window.Capacitor.Plugins.DeviceInfo.getNativeShellAppEnvironment()
+        if (result?.environment && result.environment.trim()) {
+            return result.environment
+        } else {
+            logger.error(
+                "[Shell] DeviceInfo.getNativeShellAppEnvironment returned empty"
+            )
+        }
+    } catch (error) {
+        logger.error(
+            "[Shell] DeviceInfo.getNativeShellAppEnvironment failed:",
+            { error }
+        )
+    }
+    return null
+}
+
+/**
+ * Map native Android BuildConfig.ENVIRONMENT values to vwr-loader environment names.
+ *
+ * Android BuildConfig values:
+ * - "development" (debug build)
+ * - "staging" (staging build)
+ * - "production" (release build)
+ *
+ * VWR environment names:
+ * - "dev"
+ * - "staging"
+ * - "prod"
+ */
+function mapNativeEnvironment(nativeEnv: string): Environment {
+    const normalized = nativeEnv.toLowerCase()
+    switch (normalized) {
+        case "development":
+            return "dev"
+        case "staging":
+            return "staging"
+        case "production":
+            return "prod"
+        default:
+            // If it's already in vwr format, use it
+            if (isValidEnvironment(normalized)) {
+                return normalized as Environment
+            }
+            return "dev"
+    }
+}
+
+function isValidEnvironment(env: string): boolean {
+    return ["local", "dev", "staging", "prod"].includes(env)
+}
+
+// Note: Window.Capacitor type is declared in getDeviceId.ts
+// We just need to add the getNativeShellAppEnvironment method type there

package/src/getShellVersion.test.ts

@@ -268,7 +268,7 @@ describe("getShellVersion", () => {
             expect(version).toBe("unknown")
             expect(consoleWarnSpy).toHaveBeenCalledWith(
                 "[Shell] Failed to get shell version:",
-                { error: expect.any(Error) }
+                expect.any(Error)
             )
 
             consoleWarnSpy.mockRestore()

package/src/getShellVersion.ts

@@ -7,10 +7,10 @@ import { defaultLogger, type Logger } from "./logger"
  * - SAMSUNG_TV: Tizen Application API `tizen.application.getAppInfo().version`
  * - LG_TV: webOS Application API `webOS.fetchAppInfo()`
  * - FIRE_TV: Native bridge via Capacitor DeviceInfo plugin
- * - ANDROID_MOBILE/IOS_MOBILE: Native bridge (future implementation)
+ * - MOBILE: Native bridge (future implementation)
  * - WEB/Unknown: Returns 'unknown'
  *
- * @param platform - Platform identifier (SAMSUNG_TV, LG_TV, FIRE_TV, ANDROID_MOBILE, IOS_MOBILE, WEB)
+ * @param platform - Platform identifier (SAMSUNG_TV, LG_TV, FIRE_TV, MOBILE, WEB)
  * @param logger - Optional logger for warning reporting. Defaults to defaultLogger.
  * @returns Shell version string or 'unknown' if not available
  */
@@ -66,11 +66,7 @@ export async function getShellVersion(
         }
 
         // Mobile: Future implementation via native bridge
-        if (
-            normalizedPlatform === "ANDROID_MOBILE" ||
-            normalizedPlatform === "IOS_MOBILE" ||
-            normalizedPlatform === "MOBILE"
-        ) {
+        if (normalizedPlatform === "MOBILE") {
             // TODO: Implement native bridge version retrieval when available
             return "unknown"
         }

package/src/loadVwr.ts

@@ -1,15 +1,17 @@
-import type * as VWR from "@volley/vwr"
-
 import { fetchAmplitudeFlags } from "./amplitudeFlagFetcher"
 import { ENV_DEFAULTS } from "./envDefaults"
 import { getDeviceId } from "./getDeviceId"
+import { getEnvironment } from "./getEnvironment"
 import { getShellVersion } from "./getShellVersion"
 import { defaultLogger, type Logger } from "./logger"
 import type { VWRConfig, VWRConfigRequest } from "./vwrConfig"
 import { getVWRConfig, validateConfig } from "./vwrConfig"
 
 // Vite injects these at build time
-const ENVIRONMENT = import.meta.env.VITE_ENVIRONMENT
+// VITE_ENVIRONMENT is optional for platforms that support native env reading (Fire TV)
+const BUILD_TIME_ENVIRONMENT = import.meta.env.VITE_ENVIRONMENT as
+    | string
+    | undefined
 const PLATFORM = import.meta.env.VITE_PLATFORM
 const CONFIG_URL = import.meta.env.VITE_CONFIG_URL
 const CONFIG_FILE = import.meta.env.VITE_CONFIG_FILE
@@ -28,15 +30,20 @@ export type { Logger }
  * this reduces startup latency from ~2-4s to ~500ms by skipping config fetches.
  *
  * Flow:
- * 1. Get deviceId, shellVersion (fast, local)
+ * 1. Get deviceId, shellVersion, environment (fast, local/native)
  * 2. Check vwr-enabled flag (single request, ~500ms)
  * 3. If OFF → throw immediately (no config fetches)
  * 4. If ON → fetch config, load VWR module, initialize
  *
+ * Environment resolution:
+ * - Fire TV: reads from native BuildConfig.ENVIRONMENT (prevents env mismatch)
+ * - Other platforms: uses build-time injected VITE_ENVIRONMENT
+ * - Fallback: "dev"
+ *
  * @param logger - Optional logger, defaults to console
  */
 export const loadVwr = async (logger: Logger = defaultLogger) => {
-    if (!ENVIRONMENT || !PLATFORM || !CONFIG_URL || !CONFIG_FILE) {
+    if (!PLATFORM || !CONFIG_URL || !CONFIG_FILE) {
         throw new Error("[Shell] Build config not injected properly")
     }
 
@@ -48,6 +55,14 @@ export const loadVwr = async (logger: Logger = defaultLogger) => {
     }
     const shellVersion = await getShellVersion(PLATFORM, logger)
 
+    // Get environment from native (Fire TV) or build-time injection
+    // This ensures prod APKs cannot accidentally run dev VWR
+    const { environment: ENVIRONMENT } = await getEnvironment(
+        PLATFORM,
+        BUILD_TIME_ENVIRONMENT,
+        logger
+    )
+
     // Get amplitude key: injected at build time OR from envDefaults
     // Precedence: build-time injection > envDefaults
     let amplitudeKey = AMPLITUDE_KEY
@@ -100,10 +115,7 @@ export const loadVwr = async (logger: Logger = defaultLogger) => {
         vwrUrl: vwrConfig.vwrUrl,
     })
     try {
-        const vwr = (await import(
-            /* @vite-ignore */ vwrConfig.vwrUrl
-        )) as typeof VWR
-
+        const vwr = await import(/* @vite-ignore */ vwrConfig.vwrUrl)
         logger.info("[Shell] VWR module loaded successfully")
 
         if (typeof vwr.init !== "function") {
@@ -112,12 +124,11 @@ export const loadVwr = async (logger: Logger = defaultLogger) => {
 
         await vwr.init({
             hubUrl: vwrConfig.hubUrl,
+            launchUrl: vwrConfig.launchUrl,
             platform: PLATFORM,
-            stage: ENVIRONMENT,
-            appVersion: shellVersion,
-            platformApiUrl: vwrConfig.platformApiUrl,
-            platformAuthApiUrl: vwrConfig.platformAuthApiUrl,
-            trustedOrigins: new Set(vwrConfig.trustedDomains),
+            deviceId,
+            environment: ENVIRONMENT,
+            trustedDomains: vwrConfig.trustedDomains,
             nativeShellVersion: shellVersion,
         })
         logger.info("[Shell] VWR initialized successfully")

package/src/main.ts

@@ -18,9 +18,7 @@ async function init() {
             }
         } finally {
             //Fallback, can't trust config exists
-            const fallbackUrl = new URL(HUB_URL)
-            fallbackUrl.searchParams.set("volley_platform", PLATFORM)
-            window.location.href = fallbackUrl.toString()
+            window.location.href = HUB_URL
         }
     }
 }

package/src/vite-env.d.ts

@@ -8,9 +8,6 @@ interface ImportMetaEnv {
     readonly VITE_SHELL_VERSION: string
     readonly VITE_CONFIG_URL: string
     readonly VITE_CONFIG_FILE: string
-    readonly VITE_PLATFORM_API_URL: string
-    readonly VITE_PLATFORM_AUTH_API_URL: string
-    readonly VITE_TRUSTED_ORIGINS: string
 }
 
 interface ImportMeta {

package/src/vwrConfig.ts

@@ -5,8 +5,6 @@ export type VWRConfig = {
     hubUrl: string
     vwrUrl: string
     launchUrl: string | undefined
-    platformApiUrl: string
-    platformAuthApiUrl: string
     trustedDomains: Array<string>
 }
 
@@ -234,14 +232,6 @@ const tryGetVWRConfig = async (
 const parseConfig = (config: VWRConfig): VWRConfig => {
     const defaultConfig = getDefaultConfig()
 
-    if (!config.platformApiUrl) {
-        config.platformApiUrl = defaultConfig.platformApiUrl
-    }
-
-    if (!config.platformAuthApiUrl) {
-        config.platformAuthApiUrl = defaultConfig.platformAuthApiUrl
-    }
-
     if (
         !Array.isArray(config.trustedDomains) ||
         config.trustedDomains.length === 0
@@ -251,26 +241,21 @@ const parseConfig = (config: VWRConfig): VWRConfig => {
 
     if (!config.vwrUrl) {
         config.vwrUrl = defaultConfig.vwrUrl
-        const vwrUrlOrigin = new URL(defaultConfig.vwrUrl).origin
-        if (!config.trustedDomains.includes(vwrUrlOrigin)) {
-            config.trustedDomains.push(vwrUrlOrigin)
+        if (!config.trustedDomains.includes(defaultConfig.vwrUrl)) {
+            config.trustedDomains.push(defaultConfig.vwrUrl)
         }
     }
 
     if (!config.hubUrl) {
         config.hubUrl = defaultConfig.hubUrl
-        const hubUrlOrigin = new URL(defaultConfig.hubUrl).origin
-        if (!config.trustedDomains.includes(hubUrlOrigin)) {
-            config.trustedDomains.push(hubUrlOrigin)
+        if (!config.trustedDomains.includes(defaultConfig.hubUrl)) {
+            config.trustedDomains.push(defaultConfig.hubUrl)
         }
     }
 
     // launchUrl is optional - only add to trustedDomains if explicitly set
-    if (config.launchUrl) {
-        const launchUrlOrigin = new URL(config.launchUrl).origin
-        if (!config.trustedDomains.includes(launchUrlOrigin)) {
-            config.trustedDomains.push(launchUrlOrigin)
-        }
+    if (config.launchUrl && !config.trustedDomains.includes(config.launchUrl)) {
+        config.trustedDomains.push(config.launchUrl)
     }
 
     return config
@@ -303,12 +288,6 @@ const getDefaultConfig = (): VWRConfig => {
         hubUrl: defaults.hubUrl,
         vwrUrl: defaults.vwrUrl,
         launchUrl: undefined,
-        platformApiUrl: defaults.platformApiUrl,
-        platformAuthApiUrl: defaults.platformAuthApiUrl,
-        trustedDomains: [
-            new URL(defaults.hubUrl).origin,
-            new URL(defaults.vwrUrl).origin,
-            ...(defaults.trustedOrigins ?? []),
-        ],
+        trustedDomains: [defaults.hubUrl, defaults.vwrUrl],
     }
 }

package/tsconfig.eslint.json

@@ -0,0 +1,16 @@
+{
+    "extends": "./tsconfig.json",
+    "include": [
+        "src/**/*",
+        "scripts/**/*",
+        "vite.config.ts",
+        "vitest.config.ts",
+        "**/*.test.ts"
+    ],
+    "exclude": ["node_modules", "dist"],
+    "compilerOptions": {
+        "noEmit": true,
+        "types": ["node", "vite/client", "vitest/globals"]
+    }
+}
+