@bytescale/sdk 1.5.0 → 3.0.0-alpha.10

package/dist/types/private/AuthSessionState.d.ts

@@ -1,13 +1,30 @@
 import { AuthSession } from "./model/AuthSession";
+import { Mutex } from "./Mutex";
+/**
+ * Maintains a global session state, even across package versions.
+ *
+ * This is to allow users to start auth sessions via the Bytescale JavaScript SDK, where due to versioning or other
+ * bundling issues, the Bytescale Upload Widget has been bundled with a different Bytescale JavaScript SDK. In this
+ * scenario, the user wouldn't be able to start an auth session with the Bytescale Upload Widget. Therefore, we use
+ * global state (i.e. on the window) to ensure the session state can be shared between the user's instance of the
+ * Bytescale JavaScript SDK and the Upload Widget's version of the Bytescale JavaScript SDK.
+ *
+ * Users also frequently have problems caused by them not keeping track of *Api and *Manager instances correctly, so
+ * making this global prevents a lot of common mistakes.
+ */
 export declare class AuthSessionState {
+    private static readonly stateKey;
+    private static readonly mutexKey;
     /**
-     * Intentionally global:
-     *
-     * Users frequently have problems caused by them not keeping track of *Api and *Manager instances correctly, so we
-     * make this global as in 99.9% of cases, this is what users want, and it prevents lots of common mistakes.
-     *
-     * We only set this in the browser.
-     * Never in Node.js.
+     * Called in the browser only.
      */
-    static session: AuthSession | undefined;
+    static getMutex(): Mutex;
+    /**
+     * Called in the browser only.
+     */
+    static setSession(session: AuthSession | undefined): void;
+    /**
+     * Called in the browser and in Node.js (so we check the env before calling env-specific code).
+     */
+    static getSession(): AuthSession | undefined;
 }

package/dist/types/public/browser/AuthManagerBrowser.d.ts

@@ -7,6 +7,7 @@ export declare class AuthManager extends BaseAPI implements AuthManagerInterface
     private readonly contentTypeJson;
     private readonly contentTypeText;
     private readonly minJwtTtlSeconds;
+    private readonly maxJwtTtlSeconds;
     private readonly retryAuthAfterErrorSeconds;
     private readonly refreshBeforeExpirySeconds;
     constructor(config: BytescaleApiClientConfig);

package/dist/types/public/shared/UrlBuilder.d.ts

@@ -25,6 +25,7 @@ export declare class UrlBuilder {
     private raw;
     private transformation;
     private getBaseUrl;
+    private getCommonTransformationQueryParams;
     private getCommonQueryParams;
     private makeQueryParams;
     private getTransformationParams;

package/dist/types/public/shared/UrlBuilderTypes.d.ts

@@ -26,7 +26,10 @@ export interface UrlBuilderParams {
      */
     options?: UrlBuilderOptions;
 }
-export interface UrlBuilderOptions {
+export declare type UrlBuilderOptions = UrlBuilderOptionsRaw | UrlBuilderTransformationOptions;
+export declare type UrlBuilderTransformationOptions = UrlBuilderTransformationApiOptions | UrlBuilderOptionsPreset;
+export declare type UrlBuilderTransformationApiOptions = UrlBuilderOptionsImage | UrlBuilderOptionsVideo | UrlBuilderOptionsAudio | UrlBuilderOptionsArchive;
+export interface UrlBuilderOptionsBase {
     /**
      * Set to 'true' to download a private file. Requires an active auth session. See AuthManager.beginAuthSession.
      *
@@ -57,7 +60,6 @@ export interface UrlBuilderOptions {
      * Default: false
      */
     forceDownloadPrompt?: boolean;
-    transformation?: UrlBuilderParamsTransformation;
     /**
      * Downloads the latest version of your file (if you have overwritten it) when added to the URL with a unique value.
      *
@@ -67,48 +69,55 @@ export interface UrlBuilderOptions {
      */
     version?: string;
 }
-export declare type UrlBuilderParamsTransformation = UrlBuilderParamsTransformationPreset | UrlBuilderParamsImageTransformation | UrlBuilderParamsVideoTransformation | UrlBuilderParamsAudioTransformation | UrlBuilderParamsArchiveTransformation;
-export interface UrlBuilderParamsTransformationOptions {
+export interface UrlBuilderOptionsRaw extends UrlBuilderOptionsBase {
+    transformation?: undefined;
+}
+export interface UrlBuilderOptionsImage extends UrlBuilderOptionsTransformationApi<ParameterGroup> {
     /**
-     * The transformation artifact to download.
-     *
-     * Some transformations produce multiple files. The 'artifact' parameter is used to select which file to download.
-     *
-     * Must begin with: "/"
+     * Set to "image" to use Bytescale's Image Processing API:
      *
-     * Default: "/"
+     * https://www.bytescale.com/docs/image-processing-api
      */
-    artifact?: string;
+    transformation: "image";
+}
+export interface UrlBuilderOptionsVideo extends UrlBuilderOptionsTransformationApi<ParameterGroup> {
     /**
-     * Specifies whether to permanently cache the transformed result in the Bytescale CDN.
-     *
-     * Permanently cached files can be deleted via a manual action in the Bytescale Dashboard.
-     *
-     * When cache=false this parameter is automatically set to false.
-     *
-     * When cachePermanently="auto" the permanent cache will only be used for files that take more than 1000ms to process.
-     *
-     * When the permanent cache is used, approximately 200ms of latency is added to the initial request. Thereafter, files will be served from the Bytescale CDN's edge cache or permanent cache, so will have minimal latency.
+     * Set to "video" to use Bytescale's Video Processing API:
      *
-     * Default: Please refer to your account's default cache settings in the Bytescale Dashboard.
+     * https://www.bytescale.com/docs/video-processing-api
      */
-    cachePermanently?: "auto" | boolean;
+    transformation: "video";
+}
+export interface UrlBuilderOptionsAudio extends UrlBuilderOptionsTransformationApi<ParameterGroup> {
     /**
-     * Set to true to return transformed files over 6MB in the initial HTTP response.
+     * Set to "audio" to use Bytescale's Audio Processing API:
      *
-     * By default, transformations that produce files larger than 6MB require a subsequent HTTP request to return the result: the initial HTTP request will process the file and return a JSON result instructing the requester the transformation has been performed. All subsequent requests will return the transformed file. Enable this flag to ensure the transformed file is always returned in the initial response.
+     * https://www.bytescale.com/docs/audio-processing-api
+     */
+    transformation: "audio";
+}
+export interface UrlBuilderOptionsArchive extends UrlBuilderOptionsTransformationApi<ParameterGroup> {
+    /**
+     * Set to "archive" to use Bytescale's Archive Processing API:
      *
-     * Recommendation: set large=true only if you require transformation results over 6MB. A small amount of latency is incurred on edge cache misses when this flag is enabled. In general, we recommend adjusting your transformation parameters to keep files below this size, instead of enabling this flag.
+     * https://www.bytescale.com/docs/archive-processing-api
+     */
+    transformation: "archive";
+}
+export interface UrlBuilderOptionsPreset extends UrlBuilderOptionsTransformation {
+    transformation: "preset";
+    /**
+     * The name of the transformation preset, as displayed in the Bytescale Dashboard.
      *
-     * Default: false
+     * To specify transformation parameters on-the-fly, set "transformation" to a File Processing API (e.g. "image", "video", "audio"), and then use the "transformationParams" field to pass parameters to the File Processing API.
      */
-    large?: boolean;
+    transformationPreset: string;
 }
-export interface UrlBuilderParamsTransformationApiBase<T> {
+export interface UrlBuilderOptionsTransformationApi<T> extends UrlBuilderOptionsTransformation {
     /**
-     * Use the "params" field to pass parameters to the File Processing API.
+     * Use the "transformationParams" field to pass parameters to the File Processing API.
      *
-     * Use the "type" field to specify which File Processing API to use:
+     * Use the "transformation" field to specify which File Processing API to use:
      *
      * - https://www.bytescale.com/docs/image-processing-api
      * - https://www.bytescale.com/docs/video-processing-api
@@ -122,52 +131,43 @@ export interface UrlBuilderParamsTransformationApiBase<T> {
      * Order is sensitive both within and across parameter groups for certain transformation operations, please consult
      * the documentation for the File Processing API you are using (see links above).
      */
-    params?: (T & UrlBuilderParamsTransformationOptions) | Array<T & UrlBuilderParamsTransformationOptions>;
+    transformationParams?: T | T[];
 }
-export interface UrlBuilderParamsTransformationPreset {
-    params?: UrlBuilderParamsTransformationOptions;
+export interface UrlBuilderOptionsTransformation extends UrlBuilderOptionsBase {
     /**
-     * The name of the transformation preset, as displayed in the Bytescale Dashboard.
+     * The transformation artifact to download.
      *
-     * To specify transformation parameters on-the-fly, set "type" to a File Processing API (e.g. "image", "video", "audio"), and then use the "params" field to pass parameters to the File Processing API.
-     */
-    preset: string;
-    /**
-     * Use a transformation preset that was created in the Bytescale Dashboard.
+     * Some transformations produce multiple files. The 'artifact' parameter is used to select which file to download.
      *
-     * To specify transformation parameters on-the-fly, set "type" to a File Processing API (e.g. "image", "video", "audio"), and then use the "params" field to pass parameters to the File Processing API.
-     */
-    type: "preset";
-}
-export interface UrlBuilderParamsImageTransformation extends UrlBuilderParamsTransformationApiBase<ParameterGroup> {
-    /**
-     * Set to "image" to use Bytescale's Image Processing API:
+     * Must begin with: "/"
      *
-     * https://www.bytescale.com/docs/image-processing-api
+     * Default: "/"
      */
-    type: "image";
-}
-export interface UrlBuilderParamsVideoTransformation extends UrlBuilderParamsTransformationApiBase<ParameterGroup> {
+    artifact?: string;
     /**
-     * Set to "video" to use Bytescale's Video Processing API:
+     * Specifies whether to permanently cache the transformed result in the Bytescale CDN.
      *
-     * https://www.bytescale.com/docs/video-processing-api
-     */
-    type: "video";
-}
-export interface UrlBuilderParamsAudioTransformation extends UrlBuilderParamsTransformationApiBase<ParameterGroup> {
-    /**
-     * Set to "audio" to use Bytescale's Audio Processing API:
+     * Permanently cached files can be deleted via a manual action in the Bytescale Dashboard.
      *
-     * https://www.bytescale.com/docs/audio-processing-api
+     * When cache=false this parameter is automatically set to false.
+     *
+     * When cachePermanently="auto" the permanent cache will only be used for files that take more than 1000ms to process.
+     *
+     * When the permanent cache is used, approximately 200ms of latency is added to the initial request. Thereafter, files will be served from the Bytescale CDN's edge cache or permanent cache, so will have minimal latency.
+     *
+     * Default: Please refer to your account's default cache settings in the Bytescale Dashboard.
      */
-    type: "audio";
-}
-export interface UrlBuilderParamsArchiveTransformation extends UrlBuilderParamsTransformationApiBase<ParameterGroup> {
+    cachePermanently?: "auto" | boolean;
     /**
-     * Set to "archive" to use Bytescale's Archive Processing API:
+     * Only set this parameter to `true` if you expect the HTTP response body for the transformation request to be over 6MB.
      *
-     * https://www.bytescale.com/docs/archive-processing-api
+     * We recommend leaving this parameter unset (so it defaults to `false`) and controlling the HTTP response body size via transformation parameters. E.g. for Image Processing API requests, you can shrink the HTTP response body by reducing the output image's dimensions and/or quality.
+     *
+     * Setting this parameter to `true` will route the request via an alternative CDN path, which allows responses over 6MB, but incurs a ~200ms latency on all CDN edge cache misses for the URL.
+     *
+     * Setting this parameter to `false` (default) results in faster routing. If a response over 6MB is returned, the initial response will be a JSON error indicating the response was too large to return. All subsequent requests to the same URL will successfully return the transformed file (forever).
+     *
+     * Default: false
      */
-    type: "archive";
+    large?: boolean;
 }

package/dist/types/public/shared/generated/apis/FileApi.d.ts

@@ -30,8 +30,25 @@ export interface DeleteFileBatchOperationParams {
 export interface DownloadFileParams {
     accountId: string;
     filePath: string;
+    /**
+     * Specifies whether to cache the raw file in the Bytescale CDN.
+     *
+     * Default: true
+     */
     cache?: boolean;
+    /**
+     * Specifies the maximum amount of time, in seconds, the file will be cached on the user's device and in the Bytescale CDN's edge cache.
+     *
+     * Default: Please refer to your account's default cache settings in the Bytescale Dashboard.
+     */
     cacheTtl?: number;
+    /**
+     * Downloads the latest version of your file (if you have overwritten it) when added to the URL with a unique value.
+     *
+     *   The value of the `version` parameter can be anything, e.g. an incremental number, a timestamp, etc.
+     *
+     *   You only need to provide and update this value if/when you overwrite your file.
+     */
     version?: string;
 }
 export interface GetFileDetailsParams {
@@ -41,29 +58,113 @@ export interface GetFileDetailsParams {
 export interface ProcessFileParams {
     accountId: string;
     filePath: string;
+    /**
+     * The name of the File Processing API (e.g. "image", "video", "audio") or transformation preset (created in the Bytescale Dashboard) to use when processing the file.
+     */
     transformation: string;
+    /**
+     * Some transformations output multiple files, called artifacts.
+     *
+     * You can download each individual transformation artifact by specifying its path with this parameter
+     */
     artifact?: string;
+    /**
+     * Specifies whether to cache the transformed result.
+     *
+     * If set to `false` the transformation will be executed on every request.
+     *
+     * *Recommendation:* instead of disabling the cache, a more performant solution is to use the `version` parameter and to increment it each time you require an updated result.
+     *
+     * Default: true
+     */
     cache?: boolean;
+    /**
+     * Specifies whether to cache the transformed result in the Bytescale CDN perma-cache.
+     *
+     * Perma-caching works by storing your file permanently, or until a manual cache purge is performed.
+     *
+     * When `cache=false` this parameter is automatically set to `false`.
+     *
+     * When `cache_perm=auto` the perma-cache will only be used for files that take more than 1000ms to process.
+     *
+     * When the perma-cache is used, approximately 200ms of latency is added to the initial request. Thereafter, files will be served from the Bytescale CDN's edge cache or perma-cache, so will have minimal latency.
+     *
+     * Default: Please refer to your account's default cache settings in the Bytescale Dashboard.
+     */
     cachePerm?: ProcessFileCachePermEnum;
+    /**
+     * Specifies the maximum amount of time, in seconds, the transformed result will be cached on the user's device and in the Bytescale CDN's edge cache.
+     *
+     * If the file is perma-cached, then the file will not be reprocessed on edge cache misses.
+     *
+     * If the file is not perma-cached, then the file will be reprocessed on edge cache misses.
+     *
+     * For more information on perma-caching, see: `cache_perm`
+     *
+     * Default: Please refer to your account's default cache settings in the Bytescale Dashboard.
+     */
     cacheTtl?: number;
+    /**
+     * Only set this parameter to `true` if you expect the HTTP response body for the transformation request to be over 6MB.
+     *
+     * We recommend leaving this parameter unset (so it defaults to `false`) and controlling the HTTP response body size via transformation parameters. E.g. for Image Processing API requests, you can shrink the HTTP response body by reducing the output image's dimensions and/or quality.
+     *
+     * Setting this parameter to `true` will route the request via an alternative CDN path, which allows responses over 6MB, but incurs a ~200ms latency on all CDN edge cache misses for the URL.
+     *
+     * Setting this parameter to `false` (default) results in faster routing. If a response over 6MB is returned, the initial response will be a JSON error indicating the response was too large to return. All subsequent requests to the same URL will successfully return the transformed file (forever).
+     *
+     * Default: `false`
+     */
     large?: boolean;
+    /**
+     * Parameters to submit to the File Processing API (e.g. the Image Processing API).
+     *
+     * Please see the documentation for each File Processing API to determine which values can appear here:
+     *
+     * - https://www.bytescale.com/docs/image-processing-api
+     * - https://www.bytescale.com/docs/video-processing-api
+     * - https://www.bytescale.com/docs/audio-processing-api
+     * - https://www.bytescale.com/docs/archive-processing-api
+     */
     transformationParams?: {
         [key: string]: ProcessFileTransformationParamsParameterValue;
     };
+    /**
+     * Add this parameter and increment its value to force the file to be reprocessed.
+     *
+     * The Bytescale CDN caches files based on the full URL (including the querystring), meaning this parameter is useful when dealing with changes made to transformation presets. By contrast, File Processing APIs (like the Image Processing API) shouldn't ever require this parameter, since the URL/querystring naturally changes each time you adjust a parameter, causing a cache miss and the file to be reprocessed with the new querystring parameters.
+     *
+     * The value of the `version` parameter can be anything, e.g. an incremental number, a timestamp, etc.
+     *
+     * You only need to provide and update this value if/when you make changes to a transformation preset's settings.
+     */
     version?: string;
 }
 export interface ProcessFileAndSaveOperationParams {
     accountId: string;
     filePath: string;
+    /**
+     * The name of the File Processing API (e.g. "image", "video", "audio") or transformation preset (created in the Bytescale Dashboard) to use when processing the file.
+     */
     transformation: string;
+    /**
+     *
+     */
     processFileAndSaveRequest: ProcessFileAndSaveRequest;
+    /**
+     * Parameters to submit to the File Processing API (e.g. the Image Processing API).
+     *
+     * Please see the documentation for each File Processing API to determine which values can appear here:
+     *
+     * - https://www.bytescale.com/docs/image-processing-api
+     * - https://www.bytescale.com/docs/video-processing-api
+     * - https://www.bytescale.com/docs/audio-processing-api
+     * - https://www.bytescale.com/docs/archive-processing-api
+     */
     transformationParams?: {
         [key: string]: ProcessFileTransformationParamsParameterValue;
     };
 }
-/**
- *
- */
 export declare class FileApi extends runtime.BaseAPI {
     /**
      * Copies a file synchronously.

package/dist/types/public/shared/generated/apis/FolderApi.d.ts

@@ -47,9 +47,6 @@ export interface PutFolderOperationParams {
     accountId: string;
     putFolderRequest: PutFolderRequest;
 }
-/**
- *
- */
 export declare class FolderApi extends runtime.BaseAPI {
     /**
      * Copies a folder asynchronously.  You can use ListFolder to preview the operation: set `dryRun=true` with ```recursive```, ```includeFiles```, ```includeOverriddenStorage``` and ```includeVirtualFolders``` set to match the values you\'re using here. Leave all other flags unset.

package/dist/types/public/shared/generated/apis/JobApi.d.ts

@@ -25,9 +25,6 @@ export interface ListRecentJobsParams {
     accountId: string;
     jobType: Array<AccountJobType>;
 }
-/**
- *
- */
 export declare class JobApi extends runtime.BaseAPI {
     /**
      * Cancels an in-progress background job.  Requires a `secret_*` API key.

package/dist/types/public/shared/generated/apis/UploadApi.d.ts

@@ -13,6 +13,9 @@ import * as runtime from "../runtime";
 import type { BasicUploadResponse, BeginMultipartUploadRequest, BeginMultipartUploadResponse, CompleteUploadPartRequest, UploadFromUrlRequest, UploadPart, UploadPartList } from "../models";
 export interface BeginMultipartUploadOperationParams {
     accountId: string;
+    /**
+     *
+     */
     beginMultipartUploadRequest: BeginMultipartUploadRequest;
 }
 export interface CompleteUploadPartOperationParams {
@@ -32,11 +35,11 @@ export interface ListUploadPartsParams {
 }
 export interface UploadFromUrlOperationParams {
     accountId: string;
+    /**
+     *
+     */
     uploadFromUrlRequest: UploadFromUrlRequest;
 }
-/**
- *
- */
 export declare class UploadApi extends runtime.BaseAPI {
     /**
      * Begins a new multipart file upload process.

package/dist/types/public/shared/generated/models/index.d.ts

@@ -1524,7 +1524,7 @@ export interface ProcessFileAndSaveRequest {
  */
 export declare type ProcessFileAndSaveResponse = ProcessFileAndSaveResponseAsync | ProcessFileAndSaveResponseSync;
 /**
- * Response body for ProcessFileAndSave operations where the File Processing API operation is an asynchronous operation (e.g. a video transcoding job).
+ * Response body for ProcessFileAndSave operations where the File Processing API operation is asynchronous (e.g. a video transcoding job).
  * @export
  * @interface ProcessFileAndSaveResponseAsync
  */
@@ -1617,7 +1617,7 @@ export declare type ProcessFileAndSaveResponseAsyncJobDocsEnum = "https://www.by
  */
 export declare type ProcessFileAndSaveResponseAsyncAsyncEnum = true;
 /**
- * Response body for ProcessFileAndSave operations where the File Processing API operation is a synchronous operation (e.g. an image processing job).
+ * Response body for ProcessFileAndSave operations where the File Processing API operation is synchronous (e.g. an image processing job).
  * @export
  * @interface ProcessFileAndSaveResponseSync
  */
@@ -1641,9 +1641,7 @@ export interface ProcessFileAndSaveResponseSync {
      */
     async: ProcessFileAndSaveResponseSyncAsyncEnum;
     /**
-     * The `filePath` of the transformed file.
-     *
-     * If the transformation outputs multiple artifacts, then each artifact's path will be a child of this path.
+     * Absolute path to a file. Begins with a `/`.
      * @type {string}
      * @memberof ProcessFileAndSaveResponseSync
      */
@@ -1655,9 +1653,9 @@ export interface ProcessFileAndSaveResponseSync {
      */
     fileUrl: string;
     /**
-     * JSON response returned by certain transformation APIs.
+     * JSON response returned by certain File Processing APIs.
      *
-     * Structure varies between transformation APIs (please consult the documentation of the individual transformation APIs).
+     * Structure varies between File Processing APIs (please see the documentation of each individual File Processing API).
      * @type {{ [key: string]: any; }}
      * @memberof ProcessFileAndSaveResponseSync
      */

package/dist/types/public/shared/generated/runtime.d.ts

@@ -12,13 +12,13 @@ import { ErrorResponse } from "./models";
  */
 export interface BytescaleApiClientConfig {
     /**
-     * Required for Node.js: you must provide an instance of requires("node-fetch")
+     * Only required for Node.js. Must be an instance of requires("node-fetch").
      *
      * Not required for the browser.
      */
     fetchApi?: FetchAPI;
     /**
-     * Required for all environments. Must begin with "public_" or "secret_".
+     * Must begin with "public_" or "secret_".
      *
      * Please note: if you require JWT-based auth, you must provide an API key to this field, and then call 'AuthManager.beginAuthSession' to start a JWT-based auth session. The JWT's permissions will be merged with the API key's permissions, with precedence given to the JWT.
      */
@@ -38,21 +38,23 @@ export interface BytescaleApiClientConfig {
      */
     headers?: () => Promise<HTTPHeaders>;
 }
-export declare class BytescaleApiClientConfigResolver {
+export declare class BytescaleApiClientConfigUtils {
     static defaultApiUrl: string;
     static defaultCdnUrl: string;
+    private static readonly specialApiKeys;
+    private static readonly specialApiKeyAccountId;
+    private static readonly accountIdLength;
     static getApiUrl(config: BytescaleApiClientConfig): string;
     static getCdnUrl(config: BytescaleApiClientConfig): string;
     static getFetchApi(config: BytescaleApiClientConfig): FetchAPI;
+    static getAccountId(config: BytescaleApiClientConfig): string;
+    static validate(config: BytescaleApiClientConfig): void;
 }
 /**
  * This is the base class for all generated API classes.
  */
 export declare class BaseAPI {
     protected readonly config: BytescaleApiClientConfig;
-    protected static readonly specialApiKeys: string[];
-    protected static readonly specialApiKeyAccountId = "W142hJk";
-    protected static readonly accountIdLength = 7;
     constructor(config: BytescaleApiClientConfig);
     protected request(context: RequestOpts, initOverrides: RequestInit | InitOverrideFunction | undefined, baseUrlOverride: string | undefined): Promise<Response>;
     /**

package/package.json

@@ -1,12 +1,11 @@
 {
   "name": "@bytescale/sdk",
-  "version": "1.5.0",
+  "version": "3.0.0-alpha.10",
   "description": "Bytescale JavaScript SDK",
   "author": "Bytescale <hello@bytescale.com> (https://www.bytescale.com)",
   "license": "MIT",
   "types": "dist/types/index.d.ts",
   "main": "dist/node/cjs/main.js",
-  "module": "dist/node/esm/main.mjs",
   "browser": "dist/browser/cjs/main.js",
   "exports": {
     ".": {
@@ -14,10 +13,7 @@
         "require": "./dist/node/cjs/main.js",
         "import": "./dist/node/esm/main.mjs"
       },
-      "browser": {
-        "require": "./dist/browser/cjs/main.js"
-      },
-      "default": "./dist/node/esm/main.mjs"
+      "default": "./dist/browser/cjs/main.js"
     }
   },
   "homepage": "https://www.bytescale.com/docs/sdks/javascript",