@kubesense/kubesense-browser-rum-core 1.8.0 → 2.0.0-beta.1

package/esm/domain/configuration/jsonPathParser.mjs

@@ -0,0 +1,145 @@
+//#region src/domain/configuration/jsonPathParser.ts
+/**
+* Extract selectors from a simple JSON path expression, return [] for an invalid path
+*
+* Supports:
+* - Dot notation: `foo.bar.baz`
+* - Bracket notation: `['foo']["bar"]`
+* - Array indices: `items[0]`, `data['users'][1]`
+*
+* Examples:
+* parseJsonPath("['foo'].bar[12]")
+* => ['foo', 'bar', '12']
+*
+* parseJsonPath("['foo")
+* => []
+*/
+function parseJsonPath(path) {
+	const selectors = [];
+	let previousToken = 0;
+	let currentToken;
+	const parsingContext = {
+		quote: void 0,
+		escapeSequence: void 0
+	};
+	let currentSelector = "";
+	for (const char of path) {
+		currentToken = ALLOWED_NEXT_TOKENS[previousToken].find((token) => TOKEN_PREDICATE[token](char, parsingContext));
+		if (!currentToken) return [];
+		if (parsingContext.escapeSequence !== void 0 && currentToken !== 12) {
+			if (!isValidEscapeSequence(parsingContext.escapeSequence)) return [];
+			currentSelector += resolveEscapeSequence(parsingContext.escapeSequence);
+			parsingContext.escapeSequence = void 0;
+		}
+		if (ALLOWED_SELECTOR_TOKENS.includes(currentToken)) currentSelector += char;
+		else if (ALLOWED_SELECTOR_DELIMITER_TOKENS.includes(currentToken) && currentSelector !== "") {
+			selectors.push(currentSelector);
+			currentSelector = "";
+		} else if (currentToken === 12) parsingContext.escapeSequence = parsingContext.escapeSequence ? `${parsingContext.escapeSequence}${char}` : char;
+		else if (currentToken === 8) parsingContext.quote = char;
+		else if (currentToken === 9) parsingContext.quote = void 0;
+		previousToken = currentToken;
+	}
+	if (!ALLOWED_NEXT_TOKENS[previousToken].includes(1)) return [];
+	if (currentSelector !== "") selectors.push(currentSelector);
+	return selectors;
+}
+const NAME_SHORTHAND_FIRST_CHAR_REGEX = /[a-zA-Z_$]/;
+const NAME_SHORTHAND_CHAR_REGEX = /[a-zA-Z0-9_$]/;
+const DIGIT_REGEX = /[0-9]/;
+const UNICODE_CHAR_REGEX = /[a-fA-F0-9]/;
+const QUOTE_CHARS = "'\"";
+const TOKEN_PREDICATE = {
+	[0]: () => false,
+	[1]: () => false,
+	[2]: (char) => NAME_SHORTHAND_FIRST_CHAR_REGEX.test(char),
+	[3]: (char) => NAME_SHORTHAND_CHAR_REGEX.test(char),
+	[4]: (char) => char === ".",
+	[5]: (char) => char === "[",
+	[6]: (char) => char === "]",
+	[7]: (char) => DIGIT_REGEX.test(char),
+	[8]: (char) => QUOTE_CHARS.includes(char),
+	[9]: (char, parsingContext) => char === parsingContext.quote,
+	[10]: () => true,
+	[11]: (char) => char === "\\",
+	[12]: (char, parsingContext) => {
+		if (parsingContext.escapeSequence === void 0) return `${parsingContext.quote}/\\bfnrtu`.includes(char);
+		else if (parsingContext.escapeSequence.startsWith("u") && parsingContext.escapeSequence.length < 5) return UNICODE_CHAR_REGEX.test(char);
+		return false;
+	}
+};
+const ALLOWED_NEXT_TOKENS = {
+	[0]: [2, 5],
+	[1]: [],
+	[2]: [
+		3,
+		4,
+		5,
+		1
+	],
+	[3]: [
+		3,
+		4,
+		5,
+		1
+	],
+	[4]: [2],
+	[5]: [8, 7],
+	[6]: [
+		4,
+		5,
+		1
+	],
+	[7]: [7, 6],
+	[8]: [
+		11,
+		9,
+		10
+	],
+	[9]: [6],
+	[10]: [
+		11,
+		9,
+		10
+	],
+	[11]: [12],
+	[12]: [
+		12,
+		11,
+		9,
+		10
+	]
+};
+const ALLOWED_SELECTOR_TOKENS = [
+	2,
+	3,
+	7,
+	10
+];
+const ALLOWED_SELECTOR_DELIMITER_TOKENS = [
+	4,
+	5,
+	6
+];
+function isValidEscapeSequence(escapeSequence) {
+	return "\"'/\\bfnrt".includes(escapeSequence) || escapeSequence.startsWith("u") && escapeSequence.length === 5;
+}
+const ESCAPED_CHARS = {
+	"\"": "\"",
+	"'": "'",
+	"/": "/",
+	"\\": "\\",
+	b: "\b",
+	f: "\f",
+	n: "\n",
+	r: "\r",
+	t: "	"
+};
+function resolveEscapeSequence(escapeSequence) {
+	if (escapeSequence.startsWith("u")) return String.fromCharCode(parseInt(escapeSequence.slice(1), 16));
+	return ESCAPED_CHARS[escapeSequence];
+}
+//#endregion
+export { parseJsonPath };
+
+//# sourceMappingURL=jsonPathParser.mjs.map

package/esm/domain/configuration/jsonPathParser.mjs.map

@@ -0,0 +1 @@
+{"version":3,"file":"jsonPathParser.mjs","names":[],"sources":["../../../src/domain/configuration/jsonPathParser.ts"],"sourcesContent":["/**\n * Terminology inspired from https://www.rfc-editor.org/rfc/rfc9535.html\n *\n * jsonpath-query      = segment*\n * segment             = .name-shorthand / bracketed-selection\n * bracketed-selection = ['name-selector'] / [\"name-selector\"] / [index-selector]\n *\n * Useful references:\n * - https://goessner.net/articles/JsonPath/\n * - https://jsonpath.com/\n * - https://github.com/jsonpath-standard\n */\n\ninterface ParsingContext {\n  quote: string | undefined\n  escapeSequence: string | undefined\n}\n\n/**\n * Extract selectors from a simple JSON path expression, return [] for an invalid path\n *\n * Supports:\n * - Dot notation: `foo.bar.baz`\n * - Bracket notation: `['foo'][\"bar\"]`\n * - Array indices: `items[0]`, `data['users'][1]`\n *\n * Examples:\n * parseJsonPath(\"['foo'].bar[12]\")\n * => ['foo', 'bar', '12']\n *\n * parseJsonPath(\"['foo\")\n * => []\n */\nexport function parseJsonPath(path: string): string[] {\n  const selectors: string[] = []\n  let previousToken = Token.START\n  let currentToken: Token | undefined\n  const parsingContext: ParsingContext = { quote: undefined, escapeSequence: undefined }\n  let currentSelector = ''\n  for (const char of path) {\n    // find which kind of token is this char\n    currentToken = ALLOWED_NEXT_TOKENS[previousToken].find((token) => TOKEN_PREDICATE[token](char, parsingContext))\n    if (!currentToken) {\n      return []\n    }\n    if (parsingContext.escapeSequence !== undefined && currentToken !== Token.ESCAPE_SEQUENCE_CHAR) {\n      if (!isValidEscapeSequence(parsingContext.escapeSequence)) {\n        return []\n      }\n      currentSelector += resolveEscapeSequence(parsingContext.escapeSequence)\n      parsingContext.escapeSequence = undefined\n    }\n    if (ALLOWED_SELECTOR_TOKENS.includes(currentToken)) {\n      // buffer the char if it belongs to the selector\n      // ex: foo['bar']\n      //      ^    ^\n      currentSelector += char\n    } else if (ALLOWED_SELECTOR_DELIMITER_TOKENS.includes(currentToken) && currentSelector !== '') {\n      // close the current path part if we have reach a path part delimiter\n      // ex: foo.bar['qux']\n      //        ^   ^     ^\n      selectors.push(currentSelector)\n      currentSelector = ''\n    } else if (currentToken === Token.ESCAPE_SEQUENCE_CHAR) {\n      parsingContext.escapeSequence = parsingContext.escapeSequence ? `${parsingContext.escapeSequence}${char}` : char\n    } else if (currentToken === Token.QUOTE_START) {\n      parsingContext.quote = char\n    } else if (currentToken === Token.QUOTE_END) {\n      parsingContext.quote = undefined\n    }\n    previousToken = currentToken\n  }\n  if (!ALLOWED_NEXT_TOKENS[previousToken].includes(Token.END)) {\n    return []\n  }\n  if (currentSelector !== '') {\n    selectors.push(currentSelector)\n  }\n  return selectors\n}\n\n/**\n * List of all tokens in the path\n *\n * @example                        foo.bar['qu\\'x'][0]\n *                                |   |   |        |  |\n * Token sequence:                |   |   |        |  |\n * 1. START (before first char) <-+   |   |        |  |\n * 2. NAME_SHORTHAND_FIRST_CHAR: f    |   |        |  |\n * 3. NAME_SHORTHAND_CHAR: oo         |   |        |  |\n * 4. DOT: . <------------------------+   |        |  |\n * 5. NAME_SHORTHAND_FIRST_CHAR: b        |        |  |\n * 6. NAME_SHORTHAND_CHAR: ar             |        |  |\n * 7. BRACKET_START: [ <------------------+        |  |\n * 8. QUOTE_START: '                               |  |\n * 9. NAME_SELECTOR_CHAR: qu                       |  |\n * 10. ESCAPE: \\                                   |  |\n * 11. ESCAPABLE_CHAR: '                           |  |\n * 12. NAME_SELECTOR_CHAR: x                       |  |\n * 13. QUOTE_END: '                                |  |\n * 14. BRACKET_END: ]                              |  |\n * 15. BRACKET_START: [ <--------------------------+  |\n * 16. DIGIT: 0                                       |\n * 17. BRACKET_END: ]                                 |\n * 18. END (after last char) <------------------------+\n */\nconst enum Token {\n  START,\n  END,\n\n  NAME_SHORTHAND_FIRST_CHAR,\n  NAME_SHORTHAND_CHAR,\n  DOT,\n\n  BRACKET_START,\n  BRACKET_END,\n  DIGIT,\n\n  QUOTE_START,\n  QUOTE_END,\n  NAME_SELECTOR_CHAR,\n  ESCAPE,\n  ESCAPE_SEQUENCE_CHAR,\n}\n\nconst NAME_SHORTHAND_FIRST_CHAR_REGEX = /[a-zA-Z_$]/\nconst NAME_SHORTHAND_CHAR_REGEX = /[a-zA-Z0-9_$]/\nconst DIGIT_REGEX = /[0-9]/\nconst UNICODE_CHAR_REGEX = /[a-fA-F0-9]/\nconst QUOTE_CHARS = '\\'\"'\n\nconst TOKEN_PREDICATE: { [token in Token]: (char: string, parsingContext: ParsingContext) => boolean } = {\n  // no char should match to START or END\n  [Token.START]: () => false,\n  [Token.END]: () => false,\n\n  [Token.NAME_SHORTHAND_FIRST_CHAR]: (char) => NAME_SHORTHAND_FIRST_CHAR_REGEX.test(char),\n  [Token.NAME_SHORTHAND_CHAR]: (char) => NAME_SHORTHAND_CHAR_REGEX.test(char),\n  [Token.DOT]: (char) => char === '.',\n\n  [Token.BRACKET_START]: (char) => char === '[',\n  [Token.BRACKET_END]: (char) => char === ']',\n  [Token.DIGIT]: (char) => DIGIT_REGEX.test(char),\n\n  [Token.QUOTE_START]: (char) => QUOTE_CHARS.includes(char),\n  [Token.QUOTE_END]: (char, parsingContext) => char === parsingContext.quote,\n  [Token.NAME_SELECTOR_CHAR]: () => true, // any char can be used in name selector\n  [Token.ESCAPE]: (char) => char === '\\\\',\n  [Token.ESCAPE_SEQUENCE_CHAR]: (char, parsingContext) => {\n    if (parsingContext.escapeSequence === undefined) {\n      // see https://www.rfc-editor.org/rfc/rfc9535.html#name-semantics-3\n      return `${parsingContext.quote}/\\\\bfnrtu`.includes(char)\n    } else if (parsingContext.escapeSequence.startsWith('u') && parsingContext.escapeSequence.length < 5) {\n      return UNICODE_CHAR_REGEX.test(char)\n    }\n    return false\n  },\n}\n\nconst ALLOWED_NEXT_TOKENS: { [token in Token]: Token[] } = {\n  [Token.START]: [Token.NAME_SHORTHAND_FIRST_CHAR, Token.BRACKET_START],\n  [Token.END]: [],\n\n  [Token.NAME_SHORTHAND_FIRST_CHAR]: [Token.NAME_SHORTHAND_CHAR, Token.DOT, Token.BRACKET_START, Token.END],\n  [Token.NAME_SHORTHAND_CHAR]: [Token.NAME_SHORTHAND_CHAR, Token.DOT, Token.BRACKET_START, Token.END],\n  [Token.DOT]: [Token.NAME_SHORTHAND_FIRST_CHAR],\n\n  [Token.BRACKET_START]: [Token.QUOTE_START, Token.DIGIT],\n  [Token.BRACKET_END]: [Token.DOT, Token.BRACKET_START, Token.END],\n  [Token.DIGIT]: [Token.DIGIT, Token.BRACKET_END],\n\n  [Token.QUOTE_START]: [Token.ESCAPE, Token.QUOTE_END, Token.NAME_SELECTOR_CHAR],\n  [Token.QUOTE_END]: [Token.BRACKET_END],\n  [Token.NAME_SELECTOR_CHAR]: [Token.ESCAPE, Token.QUOTE_END, Token.NAME_SELECTOR_CHAR],\n  [Token.ESCAPE]: [Token.ESCAPE_SEQUENCE_CHAR],\n  [Token.ESCAPE_SEQUENCE_CHAR]: [Token.ESCAPE_SEQUENCE_CHAR, Token.ESCAPE, Token.QUOTE_END, Token.NAME_SELECTOR_CHAR],\n}\n\n// foo['bar\\n'][12]\n// ^^    ^ ^^   ^\nconst ALLOWED_SELECTOR_TOKENS = [\n  Token.NAME_SHORTHAND_FIRST_CHAR,\n  Token.NAME_SHORTHAND_CHAR,\n  Token.DIGIT,\n  Token.NAME_SELECTOR_CHAR,\n]\n\n// foo.bar['qux']\n//    ^   ^     ^\nconst ALLOWED_SELECTOR_DELIMITER_TOKENS = [Token.DOT, Token.BRACKET_START, Token.BRACKET_END]\n\nfunction isValidEscapeSequence(escapeSequence: string): boolean {\n  return '\"\\'/\\\\bfnrt'.includes(escapeSequence) || (escapeSequence.startsWith('u') && escapeSequence.length === 5)\n}\n\nconst ESCAPED_CHARS: { [key: string]: string } = {\n  '\"': '\"',\n  \"'\": \"'\",\n  '/': '/',\n  '\\\\': '\\\\',\n  b: '\\b',\n  f: '\\f',\n  n: '\\n',\n  r: '\\r',\n  t: '\\t',\n}\n\nfunction resolveEscapeSequence(escapeSequence: string): string {\n  if (escapeSequence.startsWith('u')) {\n    // build Unicode char from code\n    return String.fromCharCode(parseInt(escapeSequence.slice(1), 16))\n  }\n  return ESCAPED_CHARS[escapeSequence]\n}\n"],"mappings":"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"}

package/esm/domain/configuration/remoteConfiguration.mjs

@@ -0,0 +1,279 @@
+import { extractRegexMatch } from "../extractRegexMatch.mjs";
+import { parseJsonPath } from "./jsonPathParser.mjs";
+import { CACHE_STATUS_TO_METRIC_MAP, createConfigurationCache } from "./remoteConfigurationCache.mjs";
+import { isIndexableObject } from "@kubesense/kubesense-js-core/util";
+import { TelemetryMetrics, addTelemetryMetrics, display, fetch, getCookie, mapValues } from "@kubesense/kubesense-browser-core";
+import { monitorError } from "@kubesense/kubesense-js-core/monitor";
+import { buildEndpointUrl } from "@kubesense/kubesense-js-core/transport";
+//#region src/domain/configuration/remoteConfiguration.ts
+const REMOTE_CONFIGURATION_VERSION = "v1";
+const SUPPORTED_RUM_FIELDS = [
+	"applicationId",
+	"service",
+	"env",
+	"version",
+	"sessionSampleRate",
+	"sessionReplaySampleRate",
+	"telemetrySampleRate",
+	"trackAnonymousUser",
+	"trackUserInteractions",
+	"trackResources",
+	"trackLongTasks",
+	"traceContextInjection",
+	"actionNameAttribute",
+	"defaultPrivacyLevel",
+	"enablePrivacyForActionName",
+	"traceSampleRate",
+	"trackSessionAcrossSubdomains",
+	"allowedTracingUrls",
+	"allowedTrackingOrigins"
+];
+async function fetchAndApplyRemoteConfiguration(initConfiguration, supportedContextManagers) {
+	let rumInitConfiguration;
+	const metrics = initMetrics();
+	const fetchResult = await fetchRemoteConfiguration(initConfiguration);
+	if (!fetchResult.ok) {
+		metrics.increment("fetch", "failure");
+		display.error(fetchResult.error);
+	} else {
+		metrics.increment("fetch", "success");
+		rumInitConfiguration = applyRemoteConfiguration(initConfiguration, fetchResult.value, supportedContextManagers, metrics);
+	}
+	addTelemetryMetrics(TelemetryMetrics.REMOTE_CONFIGURATION_METRIC_NAME, { metrics: metrics.get() });
+	return rumInitConfiguration;
+}
+function applyRemoteConfiguration(initConfiguration, remoteConfiguration, supportedContextManagers, metrics) {
+	const appliedConfiguration = { ...initConfiguration };
+	if (remoteConfiguration.rum) {
+		const rumRemoteConfiguration = remoteConfiguration.rum;
+		SUPPORTED_RUM_FIELDS.forEach((option) => {
+			if (option in rumRemoteConfiguration) appliedConfiguration[option] = resolveConfigurationProperty(rumRemoteConfiguration[option]);
+		});
+		Object.keys(supportedContextManagers).forEach((context) => {
+			if (rumRemoteConfiguration[context] !== void 0) resolveContextProperty(supportedContextManagers[context], rumRemoteConfiguration[context]);
+		});
+	}
+	if (remoteConfiguration.profiling?.sampleRate !== void 0) appliedConfiguration.profilingSampleRate = remoteConfiguration.profiling.sampleRate;
+	return appliedConfiguration;
+	function resolveConfigurationProperty(property) {
+		if (Array.isArray(property)) return property.map(resolveConfigurationProperty);
+		if (isIndexableObject(property)) {
+			if (isSerializedOption(property)) {
+				const type = property.rcSerializedType;
+				switch (type) {
+					case "string": return property.value;
+					case "regex": return resolveRegex(property.value);
+					case "dynamic": return resolveDynamicOption(property);
+					default:
+						display.error(`Unsupported remote configuration: "rcSerializedType": "${type}"`);
+						return;
+				}
+			}
+			return mapValues(property, resolveConfigurationProperty);
+		}
+		return property;
+	}
+	function resolveContextProperty(contextManager, contextItems) {
+		contextItems.forEach(({ key, value }) => {
+			contextManager.setContextProperty(key, resolveConfigurationProperty(value));
+		});
+	}
+	function resolveDynamicOption(property) {
+		const strategy = property.strategy;
+		let resolvedValue;
+		switch (strategy) {
+			case "cookie":
+				resolvedValue = resolveCookieValue(property);
+				break;
+			case "dom":
+				resolvedValue = resolveDomValue(property);
+				break;
+			case "js":
+				resolvedValue = resolveJsValue(property);
+				break;
+			case "localStorage":
+				resolvedValue = resolveLocalStorageValue(property);
+				break;
+			default:
+				display.error(`Unsupported remote configuration: "strategy": "${strategy}"`);
+				return;
+		}
+		const extractor = property.extractor;
+		if (extractor !== void 0 && typeof resolvedValue === "string") return extractValue(extractor, resolvedValue);
+		return resolvedValue;
+	}
+	function resolveCookieValue({ name }) {
+		const value = getCookie(name);
+		metrics.increment("cookie", value !== void 0 ? "success" : "missing");
+		return value;
+	}
+	function resolveLocalStorageValue({ key }) {
+		let value;
+		try {
+			value = localStorage.getItem(key);
+		} catch {
+			metrics.increment("localStorage", "failure");
+			return;
+		}
+		metrics.increment("localStorage", value !== null ? "success" : "missing");
+		return value ?? void 0;
+	}
+	function resolveDomValue({ selector, attribute }) {
+		let element;
+		try {
+			element = document.querySelector(selector);
+		} catch {
+			display.error(`Invalid selector in the remote configuration: '${selector}'`);
+			metrics.increment("dom", "failure");
+			return;
+		}
+		if (!element) {
+			metrics.increment("dom", "missing");
+			return;
+		}
+		if (isForbidden(element, attribute)) {
+			display.error(`Forbidden element selected by the remote configuration: '${selector}'`);
+			metrics.increment("dom", "failure");
+			return;
+		}
+		const domValue = attribute !== void 0 ? element.getAttribute(attribute) : element.textContent;
+		if (domValue === null) {
+			metrics.increment("dom", "missing");
+			return;
+		}
+		metrics.increment("dom", "success");
+		return domValue;
+	}
+	function isForbidden(element, attribute) {
+		return element.getAttribute("type") === "password" && attribute === "value";
+	}
+	function resolveJsValue({ path }) {
+		let current = window;
+		const pathParts = parseJsonPath(path);
+		if (pathParts.length === 0) {
+			display.error(`Invalid JSON path in the remote configuration: '${path}'`);
+			metrics.increment("js", "failure");
+			return;
+		}
+		for (const pathPart of pathParts) {
+			if (!(pathPart in current)) {
+				metrics.increment("js", "missing");
+				return;
+			}
+			try {
+				current = current[pathPart];
+			} catch (e) {
+				display.error(`Error accessing: '${path}'`, e);
+				metrics.increment("js", "failure");
+				return;
+			}
+		}
+		metrics.increment("js", "success");
+		return current;
+	}
+}
+function initMetrics() {
+	const metrics = { fetch: {} };
+	return {
+		get: () => metrics,
+		increment: (metricName, type) => {
+			if (!metrics[metricName]) metrics[metricName] = {};
+			if (!metrics[metricName][type]) metrics[metricName][type] = 0;
+			metrics[metricName][type] = metrics[metricName][type] + 1;
+		}
+	};
+}
+function isSerializedOption(value) {
+	return "rcSerializedType" in value;
+}
+function resolveRegex(pattern) {
+	try {
+		return new RegExp(pattern);
+	} catch {
+		display.error(`Invalid regex in the remote configuration: '${pattern}'`);
+	}
+}
+function extractValue(extractor, candidate) {
+	const resolvedExtractor = resolveRegex(extractor.value);
+	if (resolvedExtractor === void 0) return;
+	return extractRegexMatch(candidate, resolvedExtractor);
+}
+/**
+* Reads the CDN publish time. `Last-Modified` is a CORS-safelisted response header, so it is
+* readable cross-origin without the CDN having to expose it explicitly. It carries an HTTP-date,
+* so the value is only accurate to the second.
+*/
+function parseLastModified(response) {
+	const header = response.headers?.get("last-modified");
+	if (!header) return;
+	const timestamp = new Date(header).getTime();
+	return isNaN(timestamp) ? void 0 : timestamp;
+}
+async function fetchRemoteConfiguration(configuration) {
+	let response;
+	try {
+		response = await fetch(buildEndpoint(configuration));
+	} catch {
+		response = void 0;
+	}
+	if (!response?.ok) return {
+		ok: false,
+		error: /* @__PURE__ */ new Error("Error fetching the remote configuration.")
+	};
+	const remoteConfiguration = await response.json();
+	if (remoteConfiguration.rum || remoteConfiguration.profiling) return {
+		ok: true,
+		value: remoteConfiguration,
+		lastModified: parseLastModified(response)
+	};
+	return {
+		ok: false,
+		error: /* @__PURE__ */ new Error("No remote configuration for RUM.")
+	};
+}
+function getRemoteConfigurationId(configuration) {
+	return configuration.remoteConfiguration?.id ?? configuration.remoteConfigurationId;
+}
+function buildEndpoint(configuration) {
+	if (configuration.remoteConfigurationProxy) return configuration.remoteConfigurationProxy;
+	const id = getRemoteConfigurationId(configuration);
+	return buildEndpointUrl({
+		kubesenseRumEndpoint: configuration.kubesenseRumEndpoint,
+		path: `/${REMOTE_CONFIGURATION_VERSION}/${encodeURIComponent(id)}.json`,
+		subdomain: "sdk-configuration"
+	});
+}
+function doBackgroundCacheSync(initConfiguration, cache, metrics) {
+	fetchRemoteConfiguration(initConfiguration).then((fetchResult) => {
+		if (!fetchResult.ok) {
+			metrics.increment("fetch", "failure");
+			display.error(fetchResult.error);
+		} else {
+			metrics.increment("fetch", "success");
+			cache.write(fetchResult.value, fetchResult.lastModified);
+		}
+	}).catch(monitorError).finally(() => {
+		addTelemetryMetrics(TelemetryMetrics.REMOTE_CONFIGURATION_METRIC_NAME, { metrics: metrics.get() });
+	});
+}
+/**
+* Returns `undefined` when RUM must not start, which only happens with `required: true` and no
+* usable cache entry.
+*/
+function getRemoteConfiguration(initConfiguration, supportedContextManagers) {
+	const configurationCache = createConfigurationCache({ remoteConfigurationId: getRemoteConfigurationId(initConfiguration) });
+	const metrics = initMetrics();
+	const cacheResult = configurationCache.read();
+	metrics.increment("cache", CACHE_STATUS_TO_METRIC_MAP[cacheResult.status]);
+	doBackgroundCacheSync(initConfiguration, configurationCache, metrics);
+	if (cacheResult.status === "hit") return {
+		metadata: configurationCache.stampFirstApplied(cacheResult),
+		initConfiguration: applyRemoteConfiguration(initConfiguration, cacheResult.config, supportedContextManagers, metrics)
+	};
+	if (initConfiguration.remoteConfiguration?.required) return;
+	return { initConfiguration };
+}
+//#endregion
+export { applyRemoteConfiguration, buildEndpoint, fetchAndApplyRemoteConfiguration, fetchRemoteConfiguration, getRemoteConfiguration, getRemoteConfigurationId, initMetrics };
+
+//# sourceMappingURL=remoteConfiguration.mjs.map

package/esm/domain/configuration/remoteConfiguration.mjs.map

@@ -0,0 +1 @@
+{"version":3,"file":"remoteConfiguration.mjs","names":[],"sources":["../../../src/domain/configuration/remoteConfiguration.ts"],"sourcesContent":["import type { createContextManager, Context } from '@kubesense/kubesense-browser-core'\nimport {\n  display,\n  mapValues,\n  getCookie,\n  addTelemetryMetrics,\n  TelemetryMetrics,\n  fetch,\n} from '@kubesense/kubesense-browser-core'\nimport { monitorError } from '@kubesense/kubesense-js-core/monitor'\nimport { isIndexableObject } from '@kubesense/kubesense-js-core/util'\nimport { buildEndpointUrl } from '@kubesense/kubesense-js-core/transport'\nimport { extractRegexMatch } from '../extractRegexMatch'\nimport type { RumInitConfiguration } from './configuration'\nimport type { RumSdkConfig, DynamicOption, ContextItem } from './remoteConfiguration.types'\nimport { parseJsonPath } from './jsonPathParser'\nimport type { RemoteConfigurationMetadata } from './remoteConfigurationCache'\nimport { CACHE_STATUS_TO_METRIC_MAP, createConfigurationCache } from './remoteConfigurationCache'\n\nexport type RemoteConfiguration = RumSdkConfig\nexport type RumRemoteConfiguration = Exclude<RemoteConfiguration['rum'], undefined>\nconst REMOTE_CONFIGURATION_VERSION = 'v1'\nconst SUPPORTED_RUM_FIELDS: Array<keyof RumInitConfiguration> = [\n  'applicationId',\n  'service',\n  'env',\n  'version',\n  'sessionSampleRate',\n  'sessionReplaySampleRate',\n  'telemetrySampleRate',\n  'trackAnonymousUser',\n  'trackUserInteractions',\n  'trackResources',\n  'trackLongTasks',\n  'traceContextInjection',\n  'actionNameAttribute',\n  'defaultPrivacyLevel',\n  'enablePrivacyForActionName',\n  'traceSampleRate',\n  'trackSessionAcrossSubdomains',\n  'allowedTracingUrls',\n  'allowedTrackingOrigins',\n]\n\n// type needed for switch on union\n// eslint-disable-next-line @typescript-eslint/consistent-type-definitions\ntype SerializedRegex = { rcSerializedType: 'regex'; value: string }\ntype SerializedOption = { rcSerializedType: 'string'; value: string } | SerializedRegex | DynamicOption\n\ninterface SupportedContextManagers {\n  user: ReturnType<typeof createContextManager>\n  context: ReturnType<typeof createContextManager>\n}\n\nexport interface RemoteConfigurationMetrics extends Context {\n  fetch: RemoteConfigurationMetricCounters\n  cache?: RemoteConfigurationMetricCounters\n  cookie?: RemoteConfigurationMetricCounters\n  dom?: RemoteConfigurationMetricCounters\n  js?: RemoteConfigurationMetricCounters\n  localStorage?: RemoteConfigurationMetricCounters\n}\n\ninterface RemoteConfigurationMetricCounters {\n  success?: number\n  missing?: number\n  failure?: number\n  [key: string]: number | undefined\n}\n\nexport async function fetchAndApplyRemoteConfiguration(\n  initConfiguration: RumInitConfiguration,\n  supportedContextManagers: SupportedContextManagers\n) {\n  let rumInitConfiguration: RumInitConfiguration | undefined\n  const metrics = initMetrics()\n  const fetchResult = await fetchRemoteConfiguration(initConfiguration)\n  if (!fetchResult.ok) {\n    metrics.increment('fetch', 'failure')\n    display.error(fetchResult.error)\n  } else {\n    metrics.increment('fetch', 'success')\n    rumInitConfiguration = applyRemoteConfiguration(\n      initConfiguration,\n      fetchResult.value,\n      supportedContextManagers,\n      metrics\n    )\n  }\n  // monitor-until: forever\n  addTelemetryMetrics(TelemetryMetrics.REMOTE_CONFIGURATION_METRIC_NAME, { metrics: metrics.get() })\n  return rumInitConfiguration\n}\n\nexport function applyRemoteConfiguration(\n  initConfiguration: RumInitConfiguration,\n  remoteConfiguration: RemoteConfiguration,\n  supportedContextManagers: SupportedContextManagers,\n  metrics: ReturnType<typeof initMetrics>\n): RumInitConfiguration {\n  // intents:\n  // - explicitly set each supported field to limit risk in case an attacker can create configurations\n  // - check the existence in the remote config to avoid clearing a provided init field\n  const appliedConfiguration = { ...initConfiguration } as RumInitConfiguration & { [key: string]: unknown }\n  if (remoteConfiguration.rum) {\n    const rumRemoteConfiguration = remoteConfiguration.rum as RumRemoteConfiguration & { [key: string]: unknown }\n    SUPPORTED_RUM_FIELDS.forEach((option: string) => {\n      if (option in rumRemoteConfiguration) {\n        appliedConfiguration[option] = resolveConfigurationProperty(rumRemoteConfiguration[option])\n      }\n    })\n    ;(Object.keys(supportedContextManagers) as Array<keyof SupportedContextManagers>).forEach((context) => {\n      if (rumRemoteConfiguration[context] !== undefined) {\n        resolveContextProperty(supportedContextManagers[context], rumRemoteConfiguration[context])\n      }\n    })\n  }\n  if (remoteConfiguration.profiling?.sampleRate !== undefined) {\n    appliedConfiguration.profilingSampleRate = remoteConfiguration.profiling.sampleRate\n  }\n  return appliedConfiguration\n\n  // share context to access metrics\n\n  function resolveConfigurationProperty(property: unknown): unknown {\n    if (Array.isArray(property)) {\n      return property.map(resolveConfigurationProperty)\n    }\n    if (isIndexableObject(property)) {\n      if (isSerializedOption(property)) {\n        const type = property.rcSerializedType\n        switch (type) {\n          case 'string':\n            return property.value\n          case 'regex':\n            return resolveRegex(property.value)\n          case 'dynamic':\n            return resolveDynamicOption(property)\n          default:\n            display.error(`Unsupported remote configuration: \"rcSerializedType\": \"${type as string}\"`)\n            return\n        }\n      }\n      return mapValues(property, resolveConfigurationProperty)\n    }\n    return property\n  }\n\n  function resolveContextProperty(\n    contextManager: ReturnType<typeof createContextManager>,\n    contextItems: ContextItem[]\n  ) {\n    contextItems.forEach(({ key, value }) => {\n      contextManager.setContextProperty(key, resolveConfigurationProperty(value))\n    })\n  }\n\n  function resolveDynamicOption(property: DynamicOption) {\n    const strategy = property.strategy\n    let resolvedValue: unknown\n    switch (strategy) {\n      case 'cookie':\n        resolvedValue = resolveCookieValue(property)\n        break\n      case 'dom':\n        resolvedValue = resolveDomValue(property)\n        break\n      case 'js':\n        resolvedValue = resolveJsValue(property)\n        break\n      case 'localStorage':\n        resolvedValue = resolveLocalStorageValue(property)\n        break\n      default:\n        display.error(`Unsupported remote configuration: \"strategy\": \"${strategy as string}\"`)\n        return\n    }\n    const extractor = property.extractor\n    if (extractor !== undefined && typeof resolvedValue === 'string') {\n      return extractValue(extractor, resolvedValue)\n    }\n    return resolvedValue\n  }\n\n  function resolveCookieValue({ name }: { name: string }) {\n    const value = getCookie(name)\n    metrics.increment('cookie', value !== undefined ? 'success' : 'missing')\n    return value\n  }\n\n  function resolveLocalStorageValue({ key }: { key: string }) {\n    let value: string | null\n    try {\n      value = localStorage.getItem(key)\n    } catch {\n      metrics.increment('localStorage', 'failure')\n      return\n    }\n    metrics.increment('localStorage', value !== null ? 'success' : 'missing')\n    return value ?? undefined\n  }\n\n  function resolveDomValue({ selector, attribute }: { selector: string; attribute?: string }) {\n    let element: Element | null\n    try {\n      element = document.querySelector(selector)\n    } catch {\n      display.error(`Invalid selector in the remote configuration: '${selector}'`)\n      metrics.increment('dom', 'failure')\n      return\n    }\n    if (!element) {\n      metrics.increment('dom', 'missing')\n      return\n    }\n    if (isForbidden(element, attribute)) {\n      display.error(`Forbidden element selected by the remote configuration: '${selector}'`)\n      metrics.increment('dom', 'failure')\n      return\n    }\n    const domValue = attribute !== undefined ? element.getAttribute(attribute) : element.textContent\n    if (domValue === null) {\n      metrics.increment('dom', 'missing')\n      return\n    }\n    metrics.increment('dom', 'success')\n    return domValue\n  }\n\n  function isForbidden(element: Element, attribute: string | undefined) {\n    return element.getAttribute('type') === 'password' && attribute === 'value'\n  }\n\n  function resolveJsValue({ path }: { path: string }): unknown {\n    let current = window as unknown as { [key: string]: unknown }\n    const pathParts = parseJsonPath(path)\n    if (pathParts.length === 0) {\n      display.error(`Invalid JSON path in the remote configuration: '${path}'`)\n      metrics.increment('js', 'failure')\n      return\n    }\n    for (const pathPart of pathParts) {\n      if (!(pathPart in current)) {\n        metrics.increment('js', 'missing')\n        return\n      }\n      try {\n        current = current[pathPart] as { [key: string]: unknown }\n      } catch (e) {\n        display.error(`Error accessing: '${path}'`, e)\n        metrics.increment('js', 'failure')\n        return\n      }\n    }\n    metrics.increment('js', 'success')\n    return current\n  }\n}\n\nexport function initMetrics() {\n  const metrics: RemoteConfigurationMetrics = { fetch: {} }\n  return {\n    get: () => metrics,\n    increment: (\n      metricName: 'fetch' | 'cache' | DynamicOption['strategy'],\n      type: keyof RemoteConfigurationMetricCounters\n    ) => {\n      if (!metrics[metricName]) {\n        metrics[metricName] = {}\n      }\n      if (!metrics[metricName][type]) {\n        metrics[metricName][type] = 0\n      }\n      metrics[metricName][type] = metrics[metricName][type] + 1\n    },\n  }\n}\n\nfunction isSerializedOption(value: object): value is SerializedOption {\n  return 'rcSerializedType' in value\n}\n\nfunction resolveRegex(pattern: string): RegExp | undefined {\n  try {\n    return new RegExp(pattern)\n  } catch {\n    display.error(`Invalid regex in the remote configuration: '${pattern}'`)\n  }\n}\n\nfunction extractValue(extractor: SerializedRegex, candidate: string) {\n  const resolvedExtractor = resolveRegex(extractor.value)\n  if (resolvedExtractor === undefined) {\n    return\n  }\n  return extractRegexMatch(candidate, resolvedExtractor)\n}\n\ntype FetchRemoteConfigurationResult =\n  { ok: true; value: RemoteConfiguration; lastModified?: number } | { ok: false; error: Error }\n\n/**\n * Reads the CDN publish time. `Last-Modified` is a CORS-safelisted response header, so it is\n * readable cross-origin without the CDN having to expose it explicitly. It carries an HTTP-date,\n * so the value is only accurate to the second.\n */\nfunction parseLastModified(response: Response): number | undefined {\n  const header = response.headers?.get('last-modified')\n  if (!header) {\n    return\n  }\n  const timestamp = new Date(header).getTime()\n\n  return isNaN(timestamp) ? undefined : timestamp\n}\n\nexport async function fetchRemoteConfiguration(\n  configuration: RumInitConfiguration\n): Promise<FetchRemoteConfigurationResult> {\n  let response: Response | undefined\n  try {\n    response = await fetch(buildEndpoint(configuration))\n  } catch {\n    response = undefined\n  }\n  if (!response?.ok) {\n    return {\n      ok: false,\n      error: new Error('Error fetching the remote configuration.'),\n    }\n  }\n  const remoteConfiguration: RemoteConfiguration = await response.json()\n  if (remoteConfiguration.rum || remoteConfiguration.profiling) {\n    return {\n      ok: true,\n      value: remoteConfiguration,\n      lastModified: parseLastModified(response),\n    }\n  }\n  return {\n    ok: false,\n    error: new Error('No remote configuration for RUM.'),\n  }\n}\n\nexport function getRemoteConfigurationId(configuration: RumInitConfiguration): string | undefined {\n  return configuration.remoteConfiguration?.id ?? configuration.remoteConfigurationId\n}\n\nexport function buildEndpoint(configuration: RumInitConfiguration) {\n  if (configuration.remoteConfigurationProxy) {\n    return configuration.remoteConfigurationProxy\n  }\n  const id = getRemoteConfigurationId(configuration)!\n  return buildEndpointUrl({\n    kubesenseRumEndpoint: configuration.kubesenseRumEndpoint,\n    path: `/${REMOTE_CONFIGURATION_VERSION}/${encodeURIComponent(id)}.json`,\n    subdomain: 'sdk-configuration',\n  })\n}\n\nfunction doBackgroundCacheSync(\n  initConfiguration: RumInitConfiguration,\n  cache: ReturnType<typeof createConfigurationCache>,\n  metrics: ReturnType<typeof initMetrics>\n) {\n  fetchRemoteConfiguration(initConfiguration)\n    .then((fetchResult) => {\n      if (!fetchResult.ok) {\n        metrics.increment('fetch', 'failure')\n        display.error(fetchResult.error)\n      } else {\n        metrics.increment('fetch', 'success')\n        cache.write(fetchResult.value, fetchResult.lastModified)\n      }\n    })\n    .catch(monitorError)\n    .finally(() => {\n      // monitor-until: forever\n      addTelemetryMetrics(TelemetryMetrics.REMOTE_CONFIGURATION_METRIC_NAME, { metrics: metrics.get() })\n    })\n}\n\nexport interface ResolvedRemoteConfiguration {\n  initConfiguration: RumInitConfiguration\n  /** Only set when a cached configuration was applied, and reported on configuration telemetry. */\n  metadata?: RemoteConfigurationMetadata\n}\n\n/**\n * Returns `undefined` when RUM must not start, which only happens with `required: true` and no\n * usable cache entry.\n */\nexport function getRemoteConfiguration(\n  initConfiguration: RumInitConfiguration,\n  supportedContextManagers: SupportedContextManagers\n): ResolvedRemoteConfiguration | undefined {\n  const configurationCache = createConfigurationCache({\n    remoteConfigurationId: getRemoteConfigurationId(initConfiguration)!,\n  })\n  const metrics = initMetrics()\n\n  const cacheResult = configurationCache.read()\n\n  metrics.increment('cache', CACHE_STATUS_TO_METRIC_MAP[cacheResult.status])\n\n  doBackgroundCacheSync(initConfiguration, configurationCache, metrics)\n\n  if (cacheResult.status === 'hit') {\n    return {\n      // Stamping is synchronous, so it always lands before the background sync above can write.\n      metadata: configurationCache.stampFirstApplied(cacheResult),\n      initConfiguration: applyRemoteConfiguration(\n        initConfiguration,\n        cacheResult.config,\n        supportedContextManagers,\n        metrics\n      ),\n    }\n  }\n\n  if (initConfiguration.remoteConfiguration?.required) {\n    return\n  }\n\n  return { initConfiguration }\n}\n"],"mappings":"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"}

package/esm/domain/configuration/remoteConfigurationCache.mjs

@@ -0,0 +1,92 @@
+import { timeStampNow } from "@kubesense/kubesense-js-core/time";
+import { isIndexableObject } from "@kubesense/kubesense-js-core/util";
+import { generateUUID, tryJsonParse } from "@kubesense/kubesense-browser-core";
+const CACHE_KEY_PREFIX = "dd_rc_";
+const CACHE_STATUS_TO_METRIC_MAP = {
+	hit: "success",
+	miss: "missing",
+	error: "failure"
+};
+function buildCacheKey(remoteConfigurationId) {
+	return `${CACHE_KEY_PREFIX}${remoteConfigurationId}`;
+}
+function isValidCacheEntry(value) {
+	if (typeof value !== "object" || value === null) return false;
+	const hasVersion = "version" in value && value.version === 3;
+	const hasConfig = "config" in value && typeof value.config === "object" && value.config !== null;
+	const hasMetadata = "metadata" in value && isIndexableObject(value.metadata) && typeof value.metadata.syncId === "string" && typeof value.metadata.lastSynced === "number";
+	return hasVersion && hasConfig && hasMetadata;
+}
+function persist(key, entry) {
+	try {
+		localStorage.setItem(key, JSON.stringify(entry));
+	} catch {}
+}
+function createConfigurationCache({ remoteConfigurationId }) {
+	const key = buildCacheKey(remoteConfigurationId);
+	return {
+		read() {
+			let raw;
+			try {
+				raw = localStorage.getItem(key);
+			} catch {
+				return { status: "error" };
+			}
+			if (raw === null) return { status: "miss" };
+			const parsed = tryJsonParse(raw);
+			if (parsed === void 0) {
+				this.remove();
+				return { status: "error" };
+			}
+			if (!isValidCacheEntry(parsed)) {
+				this.remove();
+				return { status: "error" };
+			}
+			return {
+				status: "hit",
+				config: parsed.config,
+				metadata: parsed.metadata
+			};
+		},
+		remove() {
+			try {
+				localStorage.removeItem(key);
+			} catch {}
+		},
+		write(config, lastModified) {
+			const cached = this.read();
+			if (cached.status === "hit" && JSON.stringify(cached.config) === JSON.stringify(config)) return;
+			persist(key, {
+				version: 3,
+				config,
+				metadata: {
+					lastModified,
+					lastSynced: timeStampNow(),
+					syncId: generateUUID()
+				}
+			});
+		},
+		/**
+		* Records when this configuration version was first put into effect. Stamped on the first page
+		* load that applies it, then reused by every later one, so the reported value marks a fixed
+		* point in time instead of drifting with each page load.
+		*/
+		stampFirstApplied(cached) {
+			if (cached.metadata.firstApplied !== void 0) return cached.metadata;
+			const metadata = {
+				...cached.metadata,
+				firstApplied: timeStampNow()
+			};
+			persist(key, {
+				version: 3,
+				config: cached.config,
+				metadata
+			});
+			return metadata;
+		}
+	};
+}
+//#endregion
+export { CACHE_KEY_PREFIX, CACHE_STATUS_TO_METRIC_MAP, buildCacheKey, createConfigurationCache };
+
+//# sourceMappingURL=remoteConfigurationCache.mjs.map

package/esm/domain/configuration/remoteConfigurationCache.mjs.map

@@ -0,0 +1 @@
+{"version":3,"file":"remoteConfigurationCache.mjs","names":[],"sources":["../../../src/domain/configuration/remoteConfigurationCache.ts"],"sourcesContent":["import { timeStampNow } from '@kubesense/kubesense-js-core/time'\nimport { generateUUID, tryJsonParse } from '@kubesense/kubesense-browser-core'\nimport { isIndexableObject } from '@kubesense/kubesense-js-core/util'\nimport type { TimeStamp } from '@kubesense/kubesense-js-core/time'\nimport type { RemoteConfiguration } from './remoteConfiguration'\n\nexport const CACHE_VERSION = 3\nexport const CACHE_KEY_PREFIX = 'dd_rc_'\n\n/**\n * Sync metadata for the cached configuration version, reported on configuration telemetry to\n * measure how long a published configuration takes to take effect.\n */\nexport interface RemoteConfigurationMetadata {\n  /** CDN publish time, from the `last-modified` response header. */\n  lastModified?: number\n  /** When the SDK fetched the version currently cached. */\n  lastSynced: TimeStamp\n  /** When this version was first applied. Stamped once, then reused on every later page load. */\n  firstApplied?: TimeStamp\n  /** Identifies one sync, so repeat page loads from a device collapse into a single unit. */\n  syncId: string\n}\n\ninterface CachedRemoteConfiguration {\n  version: number\n  config: RemoteConfiguration\n  metadata: RemoteConfigurationMetadata\n}\n\nexport type CacheReadStatus = 'hit' | 'miss' | 'error'\n\nexport interface CacheHitResult {\n  status: Extract<CacheReadStatus, 'hit'>\n  config: RemoteConfiguration\n  metadata: RemoteConfigurationMetadata\n}\n\nexport type CacheReadResult =\n  | {\n      status: Exclude<CacheReadStatus, 'hit'>\n    }\n  | CacheHitResult\n\nexport const CACHE_STATUS_TO_METRIC_MAP: Record<CacheReadStatus, 'success' | 'missing' | 'failure'> = {\n  hit: 'success',\n  miss: 'missing',\n  error: 'failure',\n}\n\nexport function buildCacheKey(remoteConfigurationId: string): string {\n  return `${CACHE_KEY_PREFIX}${remoteConfigurationId}`\n}\n\nfunction isValidCacheEntry(value: unknown): value is CachedRemoteConfiguration {\n  if (typeof value !== 'object' || value === null) {\n    return false\n  }\n\n  const hasVersion = 'version' in value && value.version === CACHE_VERSION\n  const hasConfig = 'config' in value && typeof value.config === 'object' && value.config !== null\n  const hasMetadata =\n    'metadata' in value &&\n    isIndexableObject(value.metadata) &&\n    typeof value.metadata.syncId === 'string' &&\n    typeof value.metadata.lastSynced === 'number'\n\n  return hasVersion && hasConfig && hasMetadata\n}\n\nfunction persist(key: string, entry: CachedRemoteConfiguration) {\n  try {\n    localStorage.setItem(key, JSON.stringify(entry))\n  } catch {\n    // Ignore\n  }\n}\n\nexport function createConfigurationCache({ remoteConfigurationId }: { remoteConfigurationId: string }) {\n  const key = buildCacheKey(remoteConfigurationId)\n\n  return {\n    read(): CacheReadResult {\n      let raw: string | null\n\n      try {\n        raw = localStorage.getItem(key)\n      } catch {\n        return { status: 'error' }\n      }\n\n      if (raw === null) {\n        return { status: 'miss' }\n      }\n\n      const parsed = tryJsonParse(raw)\n      if (parsed === undefined) {\n        this.remove()\n\n        return { status: 'error' }\n      }\n\n      if (!isValidCacheEntry(parsed)) {\n        this.remove()\n\n        return { status: 'error' }\n      }\n\n      return { status: 'hit', config: parsed.config, metadata: parsed.metadata }\n    },\n    remove() {\n      try {\n        localStorage.removeItem(key)\n      } catch {\n        // Ignore\n      }\n    },\n    write(config: RemoteConfiguration, lastModified?: number) {\n      const cached = this.read()\n\n      // Only a payload change counts as a sync. The SDK sends no `If-None-Match`, so it never\n      // observes a 304 and cannot otherwise tell a genuine sync from a repeated fetch of the same\n      // version. Skipping the write here is also what keeps `firstApplied` alive across refetches.\n      // TODO: compare on `ETag` instead once the CDN exposes it through\n      // `Access-Control-Expose-Headers`. The stringify compare is key-order sensitive, which holds\n      // only because both sides come from `JSON.parse` of the same CDN payload.\n      if (cached.status === 'hit' && JSON.stringify(cached.config) === JSON.stringify(config)) {\n        return\n      }\n\n      persist(key, {\n        version: CACHE_VERSION,\n        config,\n        metadata: { lastModified, lastSynced: timeStampNow(), syncId: generateUUID() },\n      })\n    },\n    /**\n     * Records when this configuration version was first put into effect. Stamped on the first page\n     * load that applies it, then reused by every later one, so the reported value marks a fixed\n     * point in time instead of drifting with each page load.\n     */\n    stampFirstApplied(cached: CacheHitResult): RemoteConfigurationMetadata {\n      if (cached.metadata.firstApplied !== undefined) {\n        return cached.metadata\n      }\n\n      const metadata: RemoteConfigurationMetadata = { ...cached.metadata, firstApplied: timeStampNow() }\n      persist(key, { version: CACHE_VERSION, config: cached.config, metadata })\n\n      return metadata\n    },\n  }\n}\n"],"mappings":";;;AAOA,MAAa,mBAAmB;AAqChC,MAAa,6BAAyF;CACpG,KAAK;CACL,MAAM;CACN,OAAO;AACT;AAEA,SAAgB,cAAc,uBAAuC;CACnE,OAAO,GAAG,mBAAmB;AAC/B;AAEA,SAAS,kBAAkB,OAAoD;CAC7E,IAAI,OAAO,UAAU,YAAY,UAAU,MACzC,OAAO;CAGT,MAAM,aAAa,aAAa,SAAS,MAAM,YAAA;CAC/C,MAAM,YAAY,YAAY,SAAS,OAAO,MAAM,WAAW,YAAY,MAAM,WAAW;CAC5F,MAAM,cACJ,cAAc,SACd,kBAAkB,MAAM,QAAQ,KAChC,OAAO,MAAM,SAAS,WAAW,YACjC,OAAO,MAAM,SAAS,eAAe;CAEvC,OAAO,cAAc,aAAa;AACpC;AAEA,SAAS,QAAQ,KAAa,OAAkC;CAC9D,IAAI;EACF,aAAa,QAAQ,KAAK,KAAK,UAAU,KAAK,CAAC;CACjD,QAAQ,CAER;AACF;AAEA,SAAgB,yBAAyB,EAAE,yBAA4D;CACrG,MAAM,MAAM,cAAc,qBAAqB;CAE/C,OAAO;EACL,OAAwB;GACtB,IAAI;GAEJ,IAAI;IACF,MAAM,aAAa,QAAQ,GAAG;GAChC,QAAQ;IACN,OAAO,EAAE,QAAQ,QAAQ;GAC3B;GAEA,IAAI,QAAQ,MACV,OAAO,EAAE,QAAQ,OAAO;GAG1B,MAAM,SAAS,aAAa,GAAG;GAC/B,IAAI,WAAW,KAAA,GAAW;IACxB,KAAK,OAAO;IAEZ,OAAO,EAAE,QAAQ,QAAQ;GAC3B;GAEA,IAAI,CAAC,kBAAkB,MAAM,GAAG;IAC9B,KAAK,OAAO;IAEZ,OAAO,EAAE,QAAQ,QAAQ;GAC3B;GAEA,OAAO;IAAE,QAAQ;IAAO,QAAQ,OAAO;IAAQ,UAAU,OAAO;GAAS;EAC3E;EACA,SAAS;GACP,IAAI;IACF,aAAa,WAAW,GAAG;GAC7B,QAAQ,CAER;EACF;EACA,MAAM,QAA6B,cAAuB;GACxD,MAAM,SAAS,KAAK,KAAK;GAQzB,IAAI,OAAO,WAAW,SAAS,KAAK,UAAU,OAAO,MAAM,MAAM,KAAK,UAAU,MAAM,GACpF;GAGF,QAAQ,KAAK;IACX,SAAA;IACA;IACA,UAAU;KAAE;KAAc,YAAY,aAAa;KAAG,QAAQ,aAAa;IAAE;GAC/E,CAAC;EACH;;;;;;EAMA,kBAAkB,QAAqD;GACrE,IAAI,OAAO,SAAS,iBAAiB,KAAA,GACnC,OAAO,OAAO;GAGhB,MAAM,WAAwC;IAAE,GAAG,OAAO;IAAU,cAAc,aAAa;GAAE;GACjG,QAAQ,KAAK;IAAE,SAAA;IAAwB,QAAQ,OAAO;IAAQ;GAAS,CAAC;GAExE,OAAO;EACT;CACF;AACF"}