@microsoft/rayfin-client 1.35.0-alpha.1412 → 1.35.0-beta.0

package/dist/client.d.ts

@@ -8,6 +8,7 @@ import { type EntitySchema, createDataApi } from '@microsoft/rayfin-data';
 import { createFunctionsApi, type FunctionsSchema } from '@microsoft/rayfin-functions';
 import { SdkError, NetworkError } from '@microsoft/rayfin-lib';
 import { ApiClient, ApiClientConfig } from '@microsoft/rayfin-lib';
+import { type RayfinRuntimeConfig } from './config.js';
 /**
  * Auth error specific to the Rayfin SDK.
  */
@@ -36,6 +37,8 @@ export interface RayfinClientConfig extends ApiClientConfig {
     autoRefreshToken?: boolean;
     /** When false, StorageEvent listener is not registered. Default: auto-detected (true in browser with localStorage). */
     multiTabSync?: boolean;
+    /** Values passed through to `resolveRayfinConfig()`'s `runtimeConfig` result when constructed via that helper (e.g. build-time `VITE_*` vars as defaults); exposed as `client.runtimeConfig`. */
+    runtimeConfig?: RayfinRuntimeConfig;
 }
 /**
  * Configuration for the server/worker-oriented {@link RayfinServerClient}.
@@ -45,13 +48,17 @@ export interface RayfinClientConfig extends ApiClientConfig {
 export interface RayfinServerClientConfig extends Omit<ApiClientConfig, 'getAccessToken'> {
     /** Access token (string or function) for Authorization: Bearer <token>. Use the function form to rotate per request. */
     accessToken?: string | (() => string | null);
+    /** Values passed through to `resolveRayfinConfig()`'s `runtimeConfig` result when constructed via that helper (e.g. build-time env vars as defaults); exposed as `client.runtimeConfig`. */
+    runtimeConfig?: RayfinRuntimeConfig;
 }
 /** Shared base for Rayfin clients: owns the typed data API and the underlying HTTP client. */
 export declare abstract class RayfinClientBase<TSchema extends EntitySchema = Record<string, any>> {
     /** Typed data API for querying and mutating your entities. */
     readonly data: ReturnType<typeof createDataApi<TSchema>>;
     protected apiClient: ApiClient;
-    protected constructor(config: ApiClientConfig);
+    protected constructor(config: ApiClientConfig & {
+        runtimeConfig?: RayfinRuntimeConfig;
+    });
     /** SDK error classes, exposed for convenient `instanceof` checks. */
     static readonly errors: {
         SdkError: typeof SdkError;
@@ -84,12 +91,22 @@ export declare abstract class RayfinClientBase<TSchema extends EntitySchema = Re
  *   .where({ isActive: true })
  *   .execute();
  * ```
+ *
+ * @example ALM-aware deployments — resolve runtime config, then construct
+ * ```typescript
+ * import { RayfinClient, resolveRayfinConfig } from '@microsoft/rayfin-client';
+ *
+ * const resolved = await resolveRayfinConfig({ baseUrl, publishableKey });
+ * const client = new RayfinClient({ ...resolved, authStorage: true });
+ * ```
  */
 export declare class RayfinClient<TSchema extends EntitySchema = Record<string, any>, TFunctionsSchema extends FunctionsSchema = FunctionsSchema> extends RayfinClientBase<TSchema> {
     /** Authentication operations (sign up, sign in, sign out, session state). */
     readonly auth: Auth;
     /** Typed, schema-aware accessors for invoking your backend functions. */
     readonly functions: ReturnType<typeof createFunctionsApi<TFunctionsSchema>>;
+    /** All resolved `rayfin.config.json` values, for apps that need more than just `baseUrl`/`publishableKey` (e.g. Fabric embed auth coordinates). */
+    readonly runtimeConfig?: RayfinRuntimeConfig;
     /**
      * Creates a browser Rayfin client and wires up authentication.
      *
@@ -111,6 +128,19 @@ export declare class RayfinClient<TSchema extends EntitySchema = Record<string,
  *
  * const todos = await client.data.Todo.select(['id', 'title']).execute();
  * ```
+ *
+ * @example ALM-aware deployments — resolve runtime config, then construct
+ * ```typescript
+ * import { RayfinServerClient, resolveRayfinConfig } from '@microsoft/rayfin-client';
+ *
+ * // Node.js/workers have no implicit document origin, so pass an absolute
+ * // configUrl to enable remote config loading.
+ * const resolved = await resolveRayfinConfig(
+ *   { baseUrl, publishableKey },
+ *   { configUrl: `${process.env.RAYFIN_API_URL}/rayfin.config.json` }
+ * );
+ * const client = new RayfinServerClient({ ...resolved, accessToken });
+ * ```
  */
 export declare class RayfinServerClient<TSchema extends EntitySchema = Record<string, any>> extends RayfinClientBase<TSchema> {
     /**
@@ -119,6 +149,8 @@ export declare class RayfinServerClient<TSchema extends EntitySchema = Record<st
      * @param config - Client configuration, including the access token (string or
      * function form for per-request rotation).
      */
+    /** All resolved `rayfin.config.json` values, for callers that need more than just `baseUrl`/`publishableKey`. */
+    readonly runtimeConfig?: RayfinRuntimeConfig;
     constructor(config: RayfinServerClientConfig);
 }
 export default RayfinClient;

package/dist/client.js

@@ -49,6 +49,7 @@ export class RayfinClientBase {
             functionsBaseUrl: config.functionsBaseUrl,
             useProxy: config.useProxy,
             headers: config.headers,
+            moniker: config.runtimeConfig?.itemId,
             timeout: config.timeout,
             getAccessToken: config.getAccessToken,
         });
@@ -87,12 +88,22 @@ export class RayfinClientBase {
  *   .where({ isActive: true })
  *   .execute();
  * ```
+ *
+ * @example ALM-aware deployments — resolve runtime config, then construct
+ * ```typescript
+ * import { RayfinClient, resolveRayfinConfig } from '@microsoft/rayfin-client';
+ *
+ * const resolved = await resolveRayfinConfig({ baseUrl, publishableKey });
+ * const client = new RayfinClient({ ...resolved, authStorage: true });
+ * ```
  */
 export class RayfinClient extends RayfinClientBase {
     /** Authentication operations (sign up, sign in, sign out, session state). */
     auth;
     /** Typed, schema-aware accessors for invoking your backend functions. */
     functions;
+    /** All resolved `rayfin.config.json` values, for apps that need more than just `baseUrl`/`publishableKey` (e.g. Fabric embed auth coordinates). */
+    runtimeConfig;
     /**
      * Creates a browser Rayfin client and wires up authentication.
      *
@@ -108,6 +119,7 @@ export class RayfinClient extends RayfinClientBase {
         });
         this.auth.attachToClient(this.apiClient);
         this.functions = createFunctionsApi(this.apiClient);
+        this.runtimeConfig = config.runtimeConfig;
     }
 }
 /**
@@ -124,6 +136,19 @@ export class RayfinClient extends RayfinClientBase {
  *
  * const todos = await client.data.Todo.select(['id', 'title']).execute();
  * ```
+ *
+ * @example ALM-aware deployments — resolve runtime config, then construct
+ * ```typescript
+ * import { RayfinServerClient, resolveRayfinConfig } from '@microsoft/rayfin-client';
+ *
+ * // Node.js/workers have no implicit document origin, so pass an absolute
+ * // configUrl to enable remote config loading.
+ * const resolved = await resolveRayfinConfig(
+ *   { baseUrl, publishableKey },
+ *   { configUrl: `${process.env.RAYFIN_API_URL}/rayfin.config.json` }
+ * );
+ * const client = new RayfinServerClient({ ...resolved, accessToken });
+ * ```
  */
 export class RayfinServerClient extends RayfinClientBase {
     /**
@@ -132,6 +157,8 @@ export class RayfinServerClient extends RayfinClientBase {
      * @param config - Client configuration, including the access token (string or
      * function form for per-request rotation).
      */
+    /** All resolved `rayfin.config.json` values, for callers that need more than just `baseUrl`/`publishableKey`. */
+    runtimeConfig;
     constructor(config) {
         super(config);
         if (config.accessToken !== undefined) {
@@ -140,6 +167,7 @@ export class RayfinServerClient extends RayfinClientBase {
                 : () => config.accessToken;
             this.apiClient.setAccessTokenCallback(tokenFn);
         }
+        this.runtimeConfig = config.runtimeConfig;
     }
 }
 // Default export remains the browser client for backward compatibility.

package/dist/config.d.ts

@@ -0,0 +1,128 @@
+/**
+ * Runtime configuration loading for Rayfin SPAs.
+ *
+ * Instead of baking environment-specific values into the bundle at build time
+ * (via `import.meta.env.VITE_*`), the SPA fetches a `rayfin.config.json` file
+ * at startup. This allows the same compiled bundle to work across all
+ * environments — only the config file changes per stage.
+ *
+ * The file is a deploy-time artifact: `rayfin up` emits it into the static
+ * build so it is bundled and served alongside the app, then removes it from the
+ * working tree afterward. In local development the file is intentionally absent
+ * — `rayfin dev` relies on build-time `VITE_*` values instead — so
+ * `loadRayfinConfig` returns `null` and the SPA falls back to those values.
+ */
+/**
+ * Error thrown when runtime configuration loading fails.
+ */
+export declare class RayfinConfigError extends Error {
+    readonly code: string;
+    constructor(message: string, code: string);
+}
+/**
+ * Runtime configuration shape for a Rayfin SPA.
+ * Loaded from `rayfin.config.json` at startup — contains only
+ * deployment-specific values that change per environment.
+ * Service mode (mock / rayfin / fabric) is controlled separately
+ * via `VITE_SERVICE_MODE` and is not part of this config.
+ */
+export interface RayfinConfig {
+    /** Base URL of the Rayfin backend API. */
+    apiUrl: string;
+    /** Publishable key for service-level authentication. */
+    publishableKey?: string;
+    /** Fabric workspace ID (present in Fabric deployments). */
+    workspaceId?: string;
+    /** Fabric item ID (present in Fabric deployments). */
+    itemId?: string;
+    /** Fabric portal URL (present in Fabric deployments). */
+    portalUrl?: string;
+    /** Fabric tenant ID (present in Fabric deployments). */
+    tenantId?: string;
+}
+/**
+ * Loads the Rayfin runtime configuration from the well-known config file.
+ *
+ * @param path - Override the config file URL (defaults to `/rayfin.config.json`).
+ * @returns The validated runtime configuration, or `null` if the config is
+ *   genuinely absent (HTTP 404, an HTML SPA fallback body, or — in a
+ *   non-browser runtime with no explicit `configUrl` — a relative path with
+ *   no origin to resolve against). Throws {@link RayfinConfigError} if the
+ *   file could not be loaded for any other reason (`CONFIG_LOAD_FAILED`,
+ *   e.g. a 5xx or 401/403 response, or a fetch-level failure such as a
+ *   network error — these are real failures, not absence, and are not
+ *   silently swallowed), or if the file is present but malformed or
+ *   incomplete (`CONFIG_PARSE_FAILED`, `CONFIG_INVALID`, `CONFIG_INCOMPLETE`).
+ *
+ * Not part of the public API — {@link resolveRayfinConfig} calls this
+ * internally. Prefer that over calling this directly.
+ */
+export declare function loadRayfinConfig(path?: string): Promise<RayfinConfig | null>;
+/**
+ * Options controlling how {@link resolveRayfinConfig} fetches remote runtime
+ * configuration. To skip remote loading entirely, don't call it — construct
+ * the client directly from your own values instead.
+ */
+export interface ResolveRayfinConfigOptions {
+    /**
+     * Absolute URL to fetch the runtime config from, overriding the default
+     * relative `/rayfin.config.json`.
+     *
+     * The default relative path only resolves in a browser, where `fetch`
+     * implicitly uses the page's document origin. Non-browser runtimes (e.g.
+     * `RayfinServerClient` in Node.js) have no such origin, so omitting
+     * `configUrl` there skips the fetch entirely and falls back to
+     * caller-supplied values, rather than attempting a relative fetch that
+     * would always reject. Pass an absolute `configUrl` (e.g.
+     * `${process.env.RAYFIN_API_URL}/rayfin.config.json`) to enable remote
+     * config loading outside the browser — once set (or in the browser, where
+     * a fetch is always attempted), a fetch failure (unreachable host,
+     * DNS/TLS error, offline, etc.) throws {@link RayfinConfigError}
+     * (`CONFIG_LOAD_FAILED`) rather than silently falling back, since it's a
+     * real failure, not evidence of absence.
+     */
+    configUrl?: string;
+}
+/**
+ * All `rayfin.config.json` values as a single optional-field bag — every
+ * field is optional because neither the remote config nor a caller-supplied
+ * set of defaults is guaranteed to provide it. Used both as the defaults
+ * shape (typically build-time `VITE_*` values) and as the resolved shape
+ * returned by {@link resolveRayfinConfig}.
+ */
+export interface RayfinRuntimeConfig {
+    /** Base URL of the Rayfin backend API. */
+    apiUrl?: string;
+    /** Publishable key for service-level authentication. */
+    publishableKey?: string;
+    /** Fabric workspace ID (present in Fabric deployments). */
+    workspaceId?: string;
+    /** Fabric item ID (present in Fabric deployments). */
+    itemId?: string;
+    /** Fabric portal URL (present in Fabric deployments). */
+    portalUrl?: string;
+    /** Fabric tenant ID (present in Fabric deployments). */
+    tenantId?: string;
+}
+/**
+ * Resolves the config a `RayfinClient` / `RayfinServerClient` should be
+ * constructed with: loads the remote `rayfin.config.json` (unless the caller
+ * skips calling this function entirely), overlays it over the supplied
+ * `defaults` per-field, and returns the merged `baseUrl` / `publishableKey` /
+ * `runtimeConfig`. Construction itself is a plain, synchronous
+ * `new RayfinClient(...)` call — this function only resolves values.
+ *
+ * @example
+ * ```typescript
+ * import { RayfinClient, resolveRayfinConfig } from '@microsoft/rayfin-client';
+ *
+ * const resolved = await resolveRayfinConfig({ baseUrl, publishableKey });
+ * const client = new RayfinClient({ ...resolved, authStorage: true });
+ * ```
+ */
+export declare function resolveRayfinConfig(defaults: Pick<RayfinRuntimeConfig, 'apiUrl' | 'publishableKey'> & Partial<RayfinRuntimeConfig>, options?: ResolveRayfinConfigOptions): Promise<{
+    baseUrl?: string;
+    publishableKey?: string;
+    runtimeConfig: RayfinRuntimeConfig;
+}>;
+//# sourceMappingURL=config.d.ts.map

package/dist/config.js

@@ -0,0 +1,189 @@
+/**
+ * Runtime configuration loading for Rayfin SPAs.
+ *
+ * Instead of baking environment-specific values into the bundle at build time
+ * (via `import.meta.env.VITE_*`), the SPA fetches a `rayfin.config.json` file
+ * at startup. This allows the same compiled bundle to work across all
+ * environments — only the config file changes per stage.
+ *
+ * The file is a deploy-time artifact: `rayfin up` emits it into the static
+ * build so it is bundled and served alongside the app, then removes it from the
+ * working tree afterward. In local development the file is intentionally absent
+ * — `rayfin dev` relies on build-time `VITE_*` values instead — so
+ * `loadRayfinConfig` returns `null` and the SPA falls back to those values.
+ */
+/**
+ * Error thrown when runtime configuration loading fails.
+ */
+export class RayfinConfigError extends Error {
+    code;
+    constructor(message, code) {
+        super(message);
+        this.name = 'RayfinConfigError';
+        this.code = code;
+    }
+}
+/** Default path for the runtime config file (served from `public/`). */
+const DEFAULT_CONFIG_PATH = '/rayfin.config.json';
+/**
+ * Loads the Rayfin runtime configuration from the well-known config file.
+ *
+ * @param path - Override the config file URL (defaults to `/rayfin.config.json`).
+ * @returns The validated runtime configuration, or `null` if the config is
+ *   genuinely absent (HTTP 404, an HTML SPA fallback body, or — in a
+ *   non-browser runtime with no explicit `configUrl` — a relative path with
+ *   no origin to resolve against). Throws {@link RayfinConfigError} if the
+ *   file could not be loaded for any other reason (`CONFIG_LOAD_FAILED`,
+ *   e.g. a 5xx or 401/403 response, or a fetch-level failure such as a
+ *   network error — these are real failures, not absence, and are not
+ *   silently swallowed), or if the file is present but malformed or
+ *   incomplete (`CONFIG_PARSE_FAILED`, `CONFIG_INVALID`, `CONFIG_INCOMPLETE`).
+ *
+ * Not part of the public API — {@link resolveRayfinConfig} calls this
+ * internally. Prefer that over calling this directly.
+ */
+export async function loadRayfinConfig(path = DEFAULT_CONFIG_PATH) {
+    if (typeof window === 'undefined' && path === DEFAULT_CONFIG_PATH) {
+        // Non-browser runtime with no explicit configUrl: a relative fetch has
+        // no origin to resolve against and would always reject. Skip it rather
+        // than triggering (and swallowing) that rejection — callers that want
+        // remote config outside the browser must pass an absolute configUrl.
+        return null;
+    }
+    let response;
+    try {
+        response = await fetch(path);
+    }
+    catch (err) {
+        // A fetch-level failure (offline, DNS, CORS, a transient network error)
+        // is a real failure, not absence — local-dev absence is identified below
+        // via 404 / the SPA HTML fallback, once a response is actually received.
+        // Swallowing this would let a promoted Prod bundle silently keep using
+        // its compiled Dev endpoint and key.
+        throw new RayfinConfigError(`Failed to load Rayfin config from "${path}": ` +
+            `${err instanceof Error ? err.message : String(err)}.`, 'CONFIG_LOAD_FAILED');
+    }
+    if (!response.ok) {
+        if (response.status === 404) {
+            // Genuinely absent (e.g. local dev, where no config was emitted).
+            return null;
+        }
+        // Any other non-2xx (5xx, 401/403, etc.) is a real load failure, not
+        // absence. Treating it as "absent" would silently fall back to the
+        // build-time source-stage values, which in a deployed stage can mean
+        // sending users to the wrong backend. Fail closed instead.
+        throw new RayfinConfigError(`Failed to load Rayfin config from "${path}": ` +
+            `${response.status} ${response.statusText}.`, 'CONFIG_LOAD_FAILED');
+    }
+    const contentType = response.headers.get('content-type')?.toLowerCase() ?? '';
+    const text = await response.text();
+    const trimmed = text.trimStart();
+    // A missing /rayfin.config.json is not always a 404: Vite's dev server and
+    // SPA static hosts serve index.html (200) for unknown paths. An HTML response
+    // therefore means "no config file" (e.g. local dev, where `rayfin dev` relies
+    // on build-time VITE_* values) — treat it as absent rather than a malformed
+    // config. Check the declared content type first, then fall back to sniffing
+    // the body for hosts that mislabel the fallback.
+    if (contentType.includes('html') || trimmed.startsWith('<')) {
+        return null;
+    }
+    let json;
+    try {
+        json = JSON.parse(trimmed);
+    }
+    catch {
+        throw new RayfinConfigError(`Rayfin config at "${path}" is not valid JSON.`, 'CONFIG_PARSE_FAILED');
+    }
+    return validateConfig(json, path);
+}
+function validateConfig(json, path) {
+    if (typeof json !== 'object' || json === null || Array.isArray(json)) {
+        throw new RayfinConfigError(`Rayfin config at "${path}" must be a JSON object.`, 'CONFIG_INVALID');
+    }
+    const obj = json;
+    const missing = [];
+    if (!obj.apiUrl || typeof obj.apiUrl !== 'string') {
+        missing.push('apiUrl');
+    }
+    if (missing.length > 0) {
+        throw new RayfinConfigError(`Rayfin config at "${path}" is incomplete. ` +
+            `Missing required fields: ${missing.join(', ')}.`, 'CONFIG_INCOMPLETE');
+    }
+    const rawApiUrl = obj.apiUrl;
+    const publishableKey = readOptionalStringField(obj, 'publishableKey', path);
+    const workspaceId = readOptionalStringField(obj, 'workspaceId', path);
+    const portalUrl = readOptionalStringField(obj, 'portalUrl', path);
+    const itemId = readOptionalStringField(obj, 'itemId', path);
+    const tenantId = readOptionalStringField(obj, 'tenantId', path);
+    const config = {
+        apiUrl: rawApiUrl.endsWith('/') ? rawApiUrl : `${rawApiUrl}/`,
+        ...(publishableKey ? { publishableKey } : {}),
+    };
+    if (workspaceId) {
+        config.workspaceId = workspaceId;
+    }
+    if (portalUrl) {
+        config.portalUrl = portalUrl;
+    }
+    if (itemId) {
+        config.itemId = itemId;
+    }
+    if (tenantId) {
+        config.tenantId = tenantId;
+    }
+    return config;
+}
+/**
+ * Reads an optional string field from a parsed config object.
+ *
+ * A missing, `null`, or empty-string value is treated as absent
+ * (`undefined`). A present value of any other type is a malformed config —
+ * rather than silently dropping it via an unchecked cast, this throws so the
+ * caller finds out immediately instead of the SDK crashing later with an
+ * untyped error (e.g. a numeric `publishableKey` reaching `.trim()`).
+ */
+function readOptionalStringField(obj, field, path) {
+    const value = obj[field];
+    if (value === undefined || value === null || value === '') {
+        return undefined;
+    }
+    if (typeof value !== 'string') {
+        throw new RayfinConfigError(`Rayfin config at "${path}" has an invalid "${field}" field: ` +
+            `expected a string.`, 'CONFIG_INVALID');
+    }
+    return value;
+}
+/**
+ * Resolves the config a `RayfinClient` / `RayfinServerClient` should be
+ * constructed with: loads the remote `rayfin.config.json` (unless the caller
+ * skips calling this function entirely), overlays it over the supplied
+ * `defaults` per-field, and returns the merged `baseUrl` / `publishableKey` /
+ * `runtimeConfig`. Construction itself is a plain, synchronous
+ * `new RayfinClient(...)` call — this function only resolves values.
+ *
+ * @example
+ * ```typescript
+ * import { RayfinClient, resolveRayfinConfig } from '@microsoft/rayfin-client';
+ *
+ * const resolved = await resolveRayfinConfig({ baseUrl, publishableKey });
+ * const client = new RayfinClient({ ...resolved, authStorage: true });
+ * ```
+ */
+export async function resolveRayfinConfig(defaults, options = {}) {
+    const remote = await loadRayfinConfig(options.configUrl);
+    const baseUrl = remote?.apiUrl ?? defaults.apiUrl;
+    const publishableKey = remote?.publishableKey ?? defaults.publishableKey;
+    return {
+        baseUrl,
+        publishableKey,
+        runtimeConfig: {
+            apiUrl: baseUrl,
+            publishableKey,
+            workspaceId: remote?.workspaceId ?? defaults.workspaceId,
+            itemId: remote?.itemId ?? defaults.itemId,
+            portalUrl: remote?.portalUrl ?? defaults.portalUrl,
+            tenantId: remote?.tenantId ?? defaults.tenantId,
+        },
+    };
+}
+//# sourceMappingURL=config.js.map

package/dist/index.d.ts

@@ -1,5 +1,7 @@
 export * from './client.js';
 export { default } from './client.js';
+export { RayfinConfigError, resolveRayfinConfig } from './config.js';
+export type { RayfinRuntimeConfig, ResolveRayfinConfigOptions } from './config.js';
 export type { TypedDataClients, EntitySchema } from '@microsoft/rayfin-data';
 export type { FunctionsSchema } from '@microsoft/rayfin-functions';
 export type { ApiClientConfig } from '@microsoft/rayfin-lib';

package/dist/index.js

@@ -1,6 +1,8 @@
 // Export all from client.ts
 export * from './client.js';
 export { default } from './client.js';
+// Runtime configuration loading
+export { RayfinConfigError, resolveRayfinConfig } from './config.js';
 // Re-export deprecation silencing controls from rayfin-lib so consumers have a
 // stable public import path here; emitter helpers stay internal to the SDK.
 export { setDeprecationsSilenced, isDeprecationSilenced, } from '@microsoft/rayfin-lib';

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@microsoft/rayfin-client",
-  "version": "1.35.0-alpha.1412",
+  "version": "1.35.0-beta.0",
   "description": "Main client SDK for Rayfin services",
   "type": "module",
   "exports": {
@@ -9,6 +9,7 @@
       "default": "./dist/index.js"
     },
     "./experimental": {
+      "typedoc": null,
       "types": "./dist/experimental/index.d.ts",
       "default": "./dist/experimental/index.js"
     }
@@ -21,11 +22,11 @@
     "assets/docs"
   ],
   "dependencies": {
-    "@microsoft/rayfin-auth": "1.35.0-alpha.1412",
-    "@microsoft/rayfin-connectors": "1.35.0-alpha.1412",
-    "@microsoft/rayfin-lib": "1.35.0-alpha.1412",
-    "@microsoft/rayfin-data": "1.35.0-alpha.1412",
-    "@microsoft/rayfin-functions": "1.35.0-alpha.1412"
+    "@microsoft/rayfin-auth": "1.35.0-beta.0",
+    "@microsoft/rayfin-connectors": "1.35.0-beta.0",
+    "@microsoft/rayfin-data": "1.35.0-beta.0",
+    "@microsoft/rayfin-lib": "1.35.0-beta.0",
+    "@microsoft/rayfin-functions": "1.35.0-beta.0"
   },
   "devDependencies": {
     "typescript": "^5.8.3",