@trezor/connect 9.7.3 → 10.0.0-alpha.1

package/libESM/data/firmwareInfo.mjs

@@ -0,0 +1,411 @@
+import { DeviceModelInternal, FirmwareType, getBootloaderVersionArray, getFirmwareOrBootloaderVersionArray, getFirmwareVersionArray } from "@trezor/device-utils";
+import { getIntegerInRangeFromString, removeTrailingSlashes, versionUtils } from "@trezor/utils";
+import * as firmwareReleaseStore from "./firmwareReleaseStore.mjs";
+import * as localFirmwareStore from "./localFirmwareStore.mjs";
+import * as settingsStore from "./settingsStore.mjs";
+import { getReleaseAsset, getReleasesAssetByDeviceModelAndFirmwareType } from "../utils/assetUtils.mjs";
+import { httpRequest } from "../utils/assets.mjs";
+import { getOnlineFirmwareBaseUrl } from "../utils/firmwareReleaseConfigUtils.mjs";
+import { buildIntermediaryFirmwareFileName, buildLocalFirmwareFileName, buildLocalReleaseName, findBestCompatibleRelease, isFirmwareCacheUsedForSelectedSource, isStrictFeatures } from "../utils/firmwareUtils.mjs";
+const getBundledFirmwareVersion = (deviceModel, firmwareType) => {
+  const localFirmwareReleaseConfig = firmwareReleaseStore.getLocal();
+  const modelReleases = localFirmwareReleaseConfig.releases[deviceModel];
+  const bundledRelease = modelReleases?.[firmwareType];
+  if (!bundledRelease) {
+    return;
+  }
+  const bundledVersion = bundledRelease.releasePath.match(/(\d+\.\d+\.\d+)/);
+  if (!bundledVersion) {
+    throw new Error('Fimrware bundled version was not found.');
+  }
+  return bundledVersion[0];
+};
+export const getBundledRelease = (deviceModel, firmwareType) => {
+  const version = getBundledFirmwareVersion(deviceModel, firmwareType);
+  if (!version) {
+    return;
+  }
+  const versionArray = versionUtils.tryParse(version);
+  if (!versionArray) {
+    throw new Error('There was error parsing bundled release.');
+  }
+  return getReleaseAsset(deviceModel, versionArray, firmwareType);
+};
+const getOnlineReleaseByPath = async releasePath => {
+  const onlineFirmwareBaseUrl = getOnlineFirmwareBaseUrl(settingsStore.get('firmwareChannel'));
+  const url = `${onlineFirmwareBaseUrl.BASE_URL}/${releasePath}`;
+  const response = await httpRequest(url, 'json', {
+    signal: AbortSignal.timeout(10000),
+    skipLocalForceDownload: true
+  });
+  return response;
+};
+const getOnlineReleasePath = (deviceModel, firmwareVersion, firmwareType) => {
+  const onlineFirmwareBaseUrl = getOnlineFirmwareBaseUrl(settingsStore.get('firmwareChannel'));
+  const firmwareTypeFileString = firmwareType === FirmwareType.BitcoinOnly ? 'bitcoinonly' : 'universal';
+  const relaseJsonFilename = `${deviceModel.toLowerCase()}-${firmwareVersion.join('.')}-${firmwareTypeFileString}.json`;
+  const origin = `${onlineFirmwareBaseUrl.MIDDLE_PATH}/${deviceModel.toLowerCase()}/${firmwareTypeFileString}`;
+  const releasePath = `${origin}/${relaseJsonFilename}`;
+  return releasePath;
+};
+export const getOnlineReleaseByVersion = async (deviceModel, firmwareVersion, firmwareType) => {
+  const releasePath = getOnlineReleasePath(deviceModel, firmwareVersion, firmwareType);
+  const onlineRelease = await getOnlineReleaseByPath(releasePath);
+  if (!onlineRelease || !versionUtils.isEqual(onlineRelease.version, firmwareVersion)) {
+    return;
+  }
+  return onlineRelease;
+};
+export const getReleaseConfig = (features, firmwareType) => {
+  const {
+    internal_model
+  } = features;
+  if (internal_model === DeviceModelInternal.UNKNOWN) {
+    return undefined;
+  }
+  const firmwareReleaseConfig = firmwareReleaseStore.getReleases();
+  if (!firmwareReleaseConfig) {
+    throw new Error('Firmware release config not loaded.');
+  }
+  const deviceMessageRelease = firmwareReleaseConfig[internal_model];
+  if (!deviceMessageRelease) {
+    return;
+  }
+  return deviceMessageRelease[firmwareType];
+};
+export const getReleaseByVersion = async (features, firmwareVersion, firmwareType) => {
+  const deviceModel = features.internal_model;
+  const tryGetRelease = async getter => {
+    try {
+      return await getter();
+    } catch {
+      return;
+    }
+  };
+  const releaseFromConfig = getReleaseConfig(features, firmwareType)?.release;
+  if (releaseFromConfig && versionUtils.isEqual(firmwareVersion, releaseFromConfig.version)) {
+    return releaseFromConfig;
+  }
+  const releaseName = buildLocalReleaseName(firmwareType, deviceModel, firmwareVersion);
+  const {
+    firmwareDir,
+    firmwareList
+  } = localFirmwareStore.get();
+  if (isFirmwareCacheUsedForSelectedSource(settingsStore.get('firmwareChannel')) && firmwareList.includes(releaseName)) {
+    const localReleasePath = `${firmwareDir}${releaseName}`;
+    const localReleaseBuffer = await httpRequest(localReleasePath, 'json');
+    return JSON.parse(localReleaseBuffer.toString());
+  }
+  const release = (await tryGetRelease(() => getReleaseAsset(deviceModel, firmwareVersion, firmwareType))) || (await tryGetRelease(() => getOnlineReleaseByVersion(deviceModel, firmwareVersion, firmwareType)));
+  if (release && versionUtils.isEqual(release.version, firmwareVersion)) {
+    return release;
+  }
+  return;
+};
+export const createLocalFirmwareConfig = baseConfig => {
+  const releaseEntries = Object.entries(baseConfig.releases).map(([deviceModel, modelReleases]) => {
+    const modelKey = deviceModel;
+    if (modelKey === DeviceModelInternal.UNKNOWN) return null;
+    const {
+      'bitcoin-only': bitcoinOnlyConfig,
+      universal: universalConfig
+    } = modelReleases ?? {};
+    if (!bitcoinOnlyConfig?.releasePath || !universalConfig?.releasePath) return null;
+    const btcOnlyRelease = getBundledRelease(modelKey, FirmwareType.BitcoinOnly);
+    const universalRelease = getBundledRelease(modelKey, FirmwareType.Universal);
+    if (!btcOnlyRelease || !universalRelease) return null;
+    const releases = {
+      [FirmwareType.BitcoinOnly]: {
+        ...bitcoinOnlyConfig,
+        release: btcOnlyRelease
+      },
+      [FirmwareType.Universal]: {
+        ...universalConfig,
+        release: universalRelease
+      }
+    };
+    return [modelKey, releases];
+  }).filter(entry => entry !== null);
+  return Object.fromEntries(releaseEntries);
+};
+export const createRemoteFirmwareConfig = async config => {
+  const releaseEntryPromises = Object.entries(config.releases).map(async ([deviceModel, modelReleases]) => {
+    const modelKey = deviceModel;
+    if (modelKey === DeviceModelInternal.UNKNOWN) return null;
+    const {
+      'bitcoin-only': bitcoinOnlyConfig,
+      universal: universalConfig
+    } = modelReleases ?? {};
+    if (!bitcoinOnlyConfig?.releasePath || !universalConfig?.releasePath) return null;
+    const [bitcoinOnlyRelease, universalRelease] = await Promise.all([getOnlineReleaseByPath(bitcoinOnlyConfig.releasePath), getOnlineReleaseByPath(universalConfig.releasePath)]);
+    if (!universalRelease || !bitcoinOnlyRelease) return null;
+    const releases = {
+      [FirmwareType.BitcoinOnly]: {
+        ...bitcoinOnlyConfig,
+        release: bitcoinOnlyRelease
+      },
+      [FirmwareType.Universal]: {
+        ...universalConfig,
+        release: universalRelease
+      }
+    };
+    return [modelKey, releases];
+  });
+  const validEntries = (await Promise.all(releaseEntryPromises)).filter(entry => entry !== null);
+  return Object.fromEntries(validEntries);
+};
+export const initializeFirmwareConfig = async (config, isRemote) => {
+  if (isRemote) {
+    try {
+      const remoteReleases = await createRemoteFirmwareConfig(config);
+      return {
+        releases: remoteReleases,
+        intermediaries: config.intermediaries
+      };
+    } catch {}
+  }
+  const localFirmwareReleaseConfig = firmwareReleaseStore.getLocal();
+  const localReleases = createLocalFirmwareConfig(localFirmwareReleaseConfig);
+  return {
+    releases: localReleases,
+    intermediaries: localFirmwareReleaseConfig.intermediaries
+  };
+};
+export const getLanguage = languageBinPath => {
+  const baseUrl = getOnlineFirmwareBaseUrl(settingsStore.get('firmwareChannel'));
+  const url = `${baseUrl.BASE_URL}/${languageBinPath}`;
+  return httpRequest(url, 'binary');
+};
+const getCurrentVersion = features => {
+  if (!isStrictFeatures(features)) {
+    throw new Error('Features of unexpected shape provided.');
+  }
+  const bootloaderVersion = getBootloaderVersionArray({
+    features
+  });
+  const firmwareVersion = getFirmwareVersionArray({
+    features
+  });
+  return {
+    bootloaderVersion,
+    firmwareVersion
+  };
+};
+const getIntermediaryMessageRelease = features => {
+  const config = firmwareReleaseStore.getIntermediary();
+  if (!config) {
+    throw new Error('Firmware release config not loaded.');
+  }
+  const deviceIntermediaryReleases = config[features.internal_model];
+  if (!deviceIntermediaryReleases || deviceIntermediaryReleases.length === 0) {
+    return;
+  }
+  const {
+    bootloaderVersion,
+    firmwareVersion
+  } = getCurrentVersion(features);
+  const currentVersion = features.bootloader_mode ? bootloaderVersion : firmwareVersion;
+  const minVersionKey = features.bootloader_mode ? 'min_bootloader_version' : 'min_firmware_version';
+  if (!currentVersion) {
+    return undefined;
+  }
+  return deviceIntermediaryReleases.find(release => versionUtils.isNewer(release[minVersionKey], currentVersion));
+};
+const getIsBitcoinOnlyAvailable = features => {
+  const {
+    internal_model
+  } = features;
+  if (internal_model === DeviceModelInternal.UNKNOWN) {
+    return false;
+  }
+  const firmwareReleaseConfig = firmwareReleaseStore.getReleases();
+  if (!firmwareReleaseConfig) {
+    throw new Error('Firmware release config not loaded.');
+  }
+  const deviceMessageRelease = firmwareReleaseConfig[internal_model];
+  return !!deviceMessageRelease && !!deviceMessageRelease[FirmwareType.BitcoinOnly];
+};
+const isValidConditionalRelease = release => !!(release.version && release.min_firmware_version && release.min_bootloader_version);
+const calculateShouldOfferRelease = (rolloutProbability, deviceId) => {
+  if (rolloutProbability < 0 || rolloutProbability > 100) {
+    throw new Error('Probability must be between 0 and 100.');
+  }
+  if (deviceId === null) {
+    return rolloutProbability > 0;
+  } else {
+    const deterministicValueToCompare = getIntegerInRangeFromString(deviceId, 101);
+    return deterministicValueToCompare < rolloutProbability;
+  }
+};
+const getChangelog = (releases, features) => {
+  if (features.bootloader_mode) {
+    if (features.firmware_present && features.major_version === 1) {
+      return null;
+    }
+    if (features.firmware_present && features.major_version === 2) {
+      return releases.filter(r => versionUtils.isNewer(r.version, [features.fw_major, features.fw_minor, features.fw_patch]));
+    }
+    return releases;
+  }
+  return releases.filter(r => versionUtils.isNewer(r.version, getFirmwareOrBootloaderVersionArray(features)));
+};
+const isRequired = changelog => {
+  if (!changelog || !changelog.length) return null;
+  return changelog.some(item => item.required);
+};
+export const getReleaseInfo = ({
+  features,
+  release,
+  conditions,
+  intermediary,
+  firmwareType,
+  isBitcoinOnlyAvailable,
+  releasesOfDevice
+}) => {
+  if (!isStrictFeatures(features)) {
+    throw new Error('Features of unexpected shape provided.');
+  }
+  if (!isValidConditionalRelease(release)) {
+    throw new Error(`Release object in unexpected shape.`);
+  }
+  const {
+    min_firmware_version,
+    min_bootloader_version
+  } = release;
+  const changelog = getChangelog(releasesOfDevice, features);
+  let isNewer = false;
+  let requiresIntermediary = false;
+  if (features.bootloader_mode && release.bootloader_version) {
+    const {
+      bootloaderVersion,
+      firmwareVersion
+    } = getCurrentVersion(features);
+    if (versionUtils.isVersionArray(firmwareVersion)) {
+      isNewer = versionUtils.isNewer(release.version, firmwareVersion);
+      requiresIntermediary = versionUtils.isNewer(min_firmware_version, firmwareVersion);
+    } else if (versionUtils.isVersionArray(bootloaderVersion)) {
+      isNewer = versionUtils.isNewer(release.bootloader_version, bootloaderVersion);
+      requiresIntermediary = versionUtils.isNewer(min_bootloader_version, bootloaderVersion);
+    } else {
+      throw new Error('Version is not version array.');
+    }
+  } else {
+    const {
+      firmwareVersion
+    } = getCurrentVersion(features);
+    if (!versionUtils.isVersionArray(firmwareVersion)) {
+      throw new Error('Firmware version is not version array.');
+    }
+    isNewer = versionUtils.isNewer(release.version, firmwareVersion);
+    requiresIntermediary = versionUtils.isNewer(min_firmware_version, firmwareVersion);
+  }
+  const {
+    rollout_probability
+  } = conditions;
+  const shouldBeOffered = calculateShouldOfferRelease(rollout_probability, features.device_id);
+  if (requiresIntermediary && intermediary) {
+    isNewer = true;
+  }
+  return {
+    firmwareType,
+    isBitcoinOnlyAvailable,
+    releaseConditions: {
+      ...conditions,
+      shouldBeOffered
+    },
+    release,
+    intermediary: requiresIntermediary ? intermediary : undefined,
+    isRequired: isRequired(changelog),
+    isNewer,
+    translations: release.translations
+  };
+};
+export const getFirmwareReleaseConfigInfo = (features, firmwareType) => {
+  const deviceMessageRelease = getReleaseConfig(features, firmwareType);
+  if (!deviceMessageRelease?.release) {
+    return;
+  }
+  const {
+    release,
+    conditions,
+    firmware_type
+  } = deviceMessageRelease;
+  const currentVersion = getCurrentVersion(features);
+  const inBootloaderMode = features.bootloader_mode && !!currentVersion.bootloaderVersion;
+  const versionContext = inBootloaderMode ? {
+    version: currentVersion.bootloaderVersion,
+    minVersionKey: 'min_bootloader_version'
+  } : {
+    version: currentVersion.firmwareVersion,
+    minVersionKey: 'min_firmware_version'
+  };
+  const isCompatible = versionContext.version && versionUtils.isNewerOrEqual(versionContext.version, release[versionContext.minVersionKey]);
+  const releasesOfDevice = getReleasesAssetByDeviceModelAndFirmwareType(features.internal_model, firmwareType);
+  let suitableRelease = release;
+  if (!isCompatible) {
+    const alternativeRelease = findBestCompatibleRelease(releasesOfDevice, currentVersion, versionContext.minVersionKey);
+    if (alternativeRelease) {
+      suitableRelease = alternativeRelease;
+    }
+  }
+  const intermediary = getIntermediaryMessageRelease(features);
+  const finalTargetRelease = intermediary ? release : suitableRelease;
+  return getReleaseInfo({
+    isBitcoinOnlyAvailable: getIsBitcoinOnlyAvailable(features),
+    features,
+    release: finalTargetRelease,
+    conditions,
+    intermediary,
+    firmwareType: firmware_type,
+    releasesOfDevice
+  });
+};
+export const getFirmwareStatus = (features, firmwareType) => {
+  if (features.firmware_present === false) {
+    return 'none';
+  }
+  if (features.major_version === 1 && features.bootloader_mode) {
+    return 'unknown';
+  }
+  const releaseInfo = getFirmwareReleaseConfigInfo(features, firmwareType);
+  if (!releaseInfo) return 'custom';
+  if (releaseInfo.isRequired) return 'required';
+  if (releaseInfo.isNewer) return 'outdated';
+  return 'valid';
+};
+export const getFirmwareLocation = ({
+  firmwareVersion,
+  remotePath,
+  deviceModel,
+  firmwareType,
+  intermediaryVersion
+}) => {
+  const firmwareName = intermediaryVersion ? buildIntermediaryFirmwareFileName(deviceModel, intermediaryVersion) : buildLocalFirmwareFileName(firmwareType, deviceModel, firmwareVersion);
+  const versionString = firmwareVersion.join('.');
+  const bundledBaseUrl = removeTrailingSlashes(settingsStore.get('binFilesBaseUrl'));
+  const isRealBundled = !bundledBaseUrl.includes('data.trezor.io');
+  const bundledVersion = getBundledFirmwareVersion(deviceModel, firmwareType);
+  const isIntermediary = bundledBaseUrl && intermediaryVersion;
+  const isMatchingBundledVersion = bundledBaseUrl && isRealBundled && bundledVersion === versionString;
+  if (isIntermediary || isMatchingBundledVersion) {
+    return {
+      baseUrl: bundledBaseUrl,
+      path: `firmware/${deviceModel.toLowerCase()}/${firmwareName}`
+    };
+  }
+  const {
+    firmwareDir,
+    firmwareList
+  } = localFirmwareStore.get();
+  if (isFirmwareCacheUsedForSelectedSource(settingsStore.get('firmwareChannel')) && firmwareList.includes(firmwareName)) {
+    return {
+      baseUrl: firmwareDir,
+      path: firmwareName
+    };
+  }
+  const onlineBaseUrl = getOnlineFirmwareBaseUrl(settingsStore.get('firmwareChannel'));
+  return {
+    baseUrl: onlineBaseUrl.BASE_URL,
+    path: remotePath
+  };
+};

package/libESM/data/firmwareReleaseStore.d.mts

@@ -0,0 +1,10 @@
+import type { FirmwareChannel } from '@trezor/connect-common/libESM/types/firmware';
+import type { ConditionalRelease, DeviceModelInternal, FirmwareReleaseConfig, FirmwareType, IntermediaryReleaseConfig, ReleasesConfig } from '@trezor/device-utils';
+export type InitializeFirmwareConfig = (config: FirmwareReleaseConfig, isRemote: boolean) => Promise<{
+    releases: ReleasesConfig;
+    intermediaries: Record<DeviceModelInternal, IntermediaryReleaseConfig[]>;
+}>;
+export declare const init: (firmwareChannel: FirmwareChannel | undefined, onlyLocal: boolean, initializeFirmwareConfig: InitializeFirmwareConfig) => Promise<void>;
+export declare const getLocal: () => FirmwareReleaseConfig;
+export declare const getReleases: () => Partial<Record<"T1B1" | "T2T1" | "T3T1" | "T2B1" | "T3B1" | "T3W1" | "UNKNOWN", Record<FirmwareType, ConditionalRelease>>> | undefined;
+export declare const getIntermediary: () => Record<"T1B1" | "T2T1" | "T3T1" | "T2B1" | "T3B1" | "T3W1" | "UNKNOWN", IntermediaryReleaseConfig[]> | undefined;

package/libESM/data/firmwareReleaseStore.mjs

@@ -0,0 +1,16 @@
+import { getFirmwareReleaseConfig, getOnlyLocalFirmwareReleaseConfig } from "../utils/firmwareReleaseConfigUtils.mjs";
+const local = getOnlyLocalFirmwareReleaseConfig().config;
+let releases;
+let intermediary;
+export const init = async (firmwareChannel, onlyLocal, initializeFirmwareConfig) => {
+  const firmwareReleaseConfig = onlyLocal ? {
+    config: local,
+    isRemote: false
+  } : await getFirmwareReleaseConfig(firmwareChannel);
+  const result = await initializeFirmwareConfig(firmwareReleaseConfig.config, firmwareReleaseConfig.isRemote);
+  releases = result.releases;
+  intermediary = result.intermediaries;
+};
+export const getLocal = () => local;
+export const getReleases = () => releases;
+export const getIntermediary = () => intermediary;

package/libESM/data/localFirmwareStore.d.mts

@@ -0,0 +1,3 @@
+import type { LocalFirmwares } from '@trezor/connect-common';
+export declare const set: (next: LocalFirmwares) => void;
+export declare const get: () => LocalFirmwares;

package/libESM/data/localFirmwareStore.mjs

@@ -0,0 +1,8 @@
+let firmwares = {
+  firmwareDir: '',
+  firmwareList: []
+};
+export const set = next => {
+  firmwares = next;
+};
+export const get = () => firmwares;

package/libESM/data/protobufLoader.d.mts

@@ -0,0 +1 @@
+export declare const loadProtobufModules: () => Promise<void>;

package/libESM/data/protobufLoader.mjs

@@ -0,0 +1,29 @@
+import { protobufManager } from "@trezor/protobuf";
+import * as bitcoinProto from "@trezor/protobuf/libESM/definitions/messages-bitcoin_pb.mjs";
+import * as bleProto from "@trezor/protobuf/libESM/definitions/messages-ble_pb.mjs";
+import * as bootloaderProto from "@trezor/protobuf/libESM/definitions/messages-bootloader_pb.mjs";
+import * as cardanoProto from "@trezor/protobuf/libESM/definitions/messages-cardano_pb.mjs";
+import * as commonProto from "@trezor/protobuf/libESM/definitions/messages-common_pb.mjs";
+import * as cryptoProto from "@trezor/protobuf/libESM/definitions/messages-crypto_pb.mjs";
+import * as debugProto from "@trezor/protobuf/libESM/definitions/messages-debug_pb.mjs";
+import * as definitionsProto from "@trezor/protobuf/libESM/definitions/messages-definitions_pb.mjs";
+import * as eosProto from "@trezor/protobuf/libESM/definitions/messages-eos_pb.mjs";
+import * as ethereumEip712Proto from "@trezor/protobuf/libESM/definitions/messages-ethereum-eip712_pb.mjs";
+import * as ethereumProto from "@trezor/protobuf/libESM/definitions/messages-ethereum_pb.mjs";
+import * as evoluProto from "@trezor/protobuf/libESM/definitions/messages-evolu_pb.mjs";
+import * as managementProto from "@trezor/protobuf/libESM/definitions/messages-management_pb.mjs";
+import * as moneroProto from "@trezor/protobuf/libESM/definitions/messages-monero_pb.mjs";
+import * as rippleProto from "@trezor/protobuf/libESM/definitions/messages-ripple_pb.mjs";
+import * as solanaProto from "@trezor/protobuf/libESM/definitions/messages-solana_pb.mjs";
+import * as stellarProto from "@trezor/protobuf/libESM/definitions/messages-stellar_pb.mjs";
+import * as telemetryProto from "@trezor/protobuf/libESM/definitions/messages-telemetry_pb.mjs";
+import * as tezosProto from "@trezor/protobuf/libESM/definitions/messages-tezos_pb.mjs";
+import * as thpProto from "@trezor/protobuf/libESM/definitions/messages-thp_pb.mjs";
+import * as tronProto from "@trezor/protobuf/libESM/definitions/messages-tron_pb.mjs";
+import * as messagesProto from "@trezor/protobuf/libESM/definitions/messages_pb.mjs";
+import * as optionsProto from "@trezor/protobuf/libESM/definitions/options_pb.mjs";
+export const loadProtobufModules = () => {
+  const definitionModules = [bitcoinProto, bleProto, bootloaderProto, cardanoProto, commonProto, cryptoProto, debugProto, definitionsProto, eosProto, ethereumEip712Proto, ethereumProto, evoluProto, managementProto, moneroProto, rippleProto, solanaProto, stellarProto, telemetryProto, tezosProto, thpProto, tronProto, messagesProto, optionsProto];
+  protobufManager.load(definitionModules);
+  return Promise.resolve();
+};

package/libESM/data/settingsStore.d.mts

@@ -0,0 +1,6 @@
+import type { ConnectSettings } from '@trezor/connect-common';
+export declare const set: (next: ConnectSettings) => void;
+export declare const update: (partial: Partial<ConnectSettings>) => void;
+export declare const isLoaded: () => boolean;
+export declare function get(): ConnectSettings;
+export declare function get<T extends keyof ConnectSettings>(key: T): ConnectSettings[T];

package/libESM/data/settingsStore.mjs

@@ -0,0 +1,21 @@
+import { ERRORS } from "@trezor/connect-common/libESM/constants/index.mjs";
+let settings;
+export const set = next => {
+  settings = next;
+};
+export const update = partial => {
+  if (!settings) {
+    throw ERRORS.TypedError('Runtime', 'settingsStore.update called before set()');
+  }
+  settings = {
+    ...settings,
+    ...partial
+  };
+};
+export const isLoaded = () => settings != null;
+export function get(key) {
+  if (!settings) {
+    throw ERRORS.TypedError('Runtime', 'settingsStore.get called before set()');
+  }
+  return key === undefined ? settings : settings[key];
+}