@envive-ai/react-hooks 0.3.61 → 0.3.63

package/dist/services/enviveConfigService/fetchBootstrapConfig.cjs

@@ -0,0 +1,102 @@
+const require_logger = require('../../application/logging/logger.cjs');
+const require_config_versions = require('../../types/config-versions.cjs');
+const require_fetchGraphQLConfig = require('./fetchGraphQLConfig.cjs');
+
+//#region src/services/enviveConfigService/fetchBootstrapConfig.ts
+const logger = new require_logger.default("fetchBootstrapConfig");
+const toBootstrapGates = (raw) => (raw ?? []).map((g) => ({
+	name: g.name,
+	value: g.value,
+	groupName: g.group_name ?? void 0
+}));
+const toBootstrapAssignments = (raw) => (raw ?? []).map((a) => ({
+	layer_name: a.layer_name,
+	namespace: a.namespace,
+	allocated_experiment_name: a.allocated_experiment_name,
+	group_name: a.group_name
+}));
+const toResolution = (raw) => raw ? {
+	baseVersion: raw.base_version,
+	baseVersionSource: raw.base_version_source
+} : void 0;
+const BOOTSTRAP_TIMEOUT_MS = 1500;
+const fetchBootstrapConfig = async ({ baseUrl, apiKey, userId, source, namespace, gateNames, url, orgId, orgShortName, contextSource, env, chatId, featureGates }) => {
+	const version = require_config_versions.configVersionOverride();
+	const controller = new AbortController();
+	const timeoutId = setTimeout(() => controller.abort(), BOOTSTRAP_TIMEOUT_MS);
+	let result;
+	try {
+		const response = await fetch(`${baseUrl}/v1/session/bootstrap`, {
+			method: "POST",
+			headers: {
+				"Content-Type": "application/json",
+				Authorization: `Bearer ${apiKey}`
+			},
+			body: JSON.stringify({
+				user_id: userId,
+				source,
+				namespace,
+				include_feature_gates: gateNames,
+				version,
+				url_resolving: {
+					url,
+					context: {
+						user_id: userId,
+						org_id: orgId,
+						org_short_name: orgShortName,
+						chat_id: chatId ?? "",
+						source: contextSource,
+						env
+					},
+					feature_gates: featureGates,
+					override_config_version: version
+				}
+			}),
+			signal: controller.signal
+		});
+		if (!response.ok) throw new Error(`Bootstrap config request failed: ${response.statusText}`);
+		result = await response.json();
+	} finally {
+		clearTimeout(timeoutId);
+	}
+	if (!result.org_config?.org?.org || !result.org_config?.gates?.length || !result.widget_config) throw new Error("Bootstrap config response missing required sections (org_config.org.org / org_config.gates / widget_config)");
+	const orgConfig = result.org_config;
+	const widgetConfig = result.widget_config;
+	const orgOrg = orgConfig.org?.org ?? {};
+	const resolution = toResolution(widgetConfig.resolution);
+	let orgConfigValues;
+	try {
+		orgConfigValues = {
+			...require_fetchGraphQLConfig.transformV3ProductsConfig(widgetConfig.products_config),
+			resolution
+		};
+	} catch (err) {
+		logger.logError("fetchBootstrapConfig | Error transforming products config", err);
+		orgConfigValues = {
+			colorsConfig: void 0,
+			frontendConfig: void 0,
+			resolution
+		};
+	}
+	return {
+		config: {
+			org: { org: {
+				id: orgOrg.id ?? "",
+				short_name: orgOrg.short_name ?? "",
+				display_name: orgOrg.display_name ?? "",
+				domain: orgOrg.domain ?? "",
+				status: orgOrg.status ?? "",
+				created_at: orgOrg.created_at ?? "",
+				updated_at: orgOrg.updated_at ?? ""
+			} },
+			gates: toBootstrapGates(orgConfig.gates),
+			experiment_assignments: toBootstrapAssignments(widgetConfig.experiment_assignments),
+			orgConfig: orgConfigValues
+		},
+		urlResolving: result.url_resolving ?? null
+	};
+};
+
+//#endregion
+exports.fetchBootstrapConfig = fetchBootstrapConfig;
+//# sourceMappingURL=data:application/json;charset=utf-8;base64,{"version":3,"file":"fetchBootstrapConfig.cjs","names":["Logger","configVersionOverride","result: RawBootstrapResponse","orgConfigValues: GraphQlConfigValues","transformV3ProductsConfig"],"sources":["../../../src/services/enviveConfigService/fetchBootstrapConfig.ts"],"sourcesContent":["import Logger from 'src/application/logging/logger';\nimport type { UrlResolverResponse } from 'src/atoms/app/variant';\nimport {\n  ExperimentConfigResolutionMetadata,\n  OrgConfigExperimentAssignment,\n  OrgConfigFeatureGate,\n} from 'src/application/models/api/orgConfigResults';\nimport type { GraphQlConfigValues } from 'src/contexts/graphqlContext';\nimport { configVersionOverride } from 'src/types/config-versions';\nimport { transformV3ProductsConfig } from './fetchGraphQLConfig';\n// Type-only import — erased at compile time, so this does not create a runtime\n// import cycle with enviveConfigService (which imports fetchBootstrapConfig).\nimport type { EnviveServiceConfig } from './enviveConfigService';\n\nconst logger = new Logger('fetchBootstrapConfig');\n\n// The url-resolving context bits the hooks layer can't derive on its own — the\n// injection bundle supplies env (a build-time var) and contextSource. org\n// identity is threaded from the getWidgetConfig response fetched moments earlier\n// (see enviveConfigService: bootstrap only runs on the gate-ON path, which reads\n// the gate off getWidgetConfig first, so org id/short_name are already in hand).\nexport interface FetchBootstrapConfigParams {\n  baseUrl: string;\n  apiKey: string;\n  userId: string;\n  // Config `source` (Statsig user property), 'app' in the injection bundle.\n  source: string;\n  // Scopes org_config.configs to this namespace. REQUIRED: without it pymono\n  // returns EVERY namespace on the org — including internal-only configs (the AI\n  // system prompt, brand-voice instructions, etc.) — in the response the public\n  // bundle receives. The legacy /v1/org/config call scoped it the same way.\n  namespace: string;\n  gateNames: string[];\n  // url_resolving inputs:\n  url: string;\n  orgId: string;\n  orgShortName: string;\n  // Context `source` for url_resolving ('app' | 'playground'); may differ from\n  // the config `source` above (playground = Envive Hub).\n  contextSource: string;\n  env: string;\n  chatId?: string;\n  // The override-aware feature gates (FeatureFlagService.getFeatureFlags()), so\n  // client-side gate overrides (query/window/localStorage) reach page-variant\n  // resolution — same as the legacy /v1/url_resolving request. Bootstrap merges\n  // these OVER its own server-resolved gates. Harmlessly ignored by pymono until\n  // SessionBootstrapUrlResolvingRequest gains the `feature_gates` field (the\n  // schema allows unknown fields; the model is `extra='ignore'`), so the FE can\n  // ship ahead of the backend.\n  featureGates?: Record<string, boolean>;\n}\n\nexport interface BootstrapResult {\n  config: EnviveServiceConfig;\n  // The initial page-variant result, ready to seed urlResolverAtom so the\n  // warm-up skips its own /v1/url_resolving call. null when bootstrap's\n  // (best-effort) url-resolving branch returned nothing.\n  urlResolving: UrlResolverResponse | null;\n}\n\n// --- raw wire shapes (POST /v1/session/bootstrap is REST snake_case) ---------\n\ninterface RawFeatureGate {\n  name?: string;\n  value?: boolean;\n  group_name?: string | null;\n  rule_id?: string | null;\n}\n\ninterface RawExperimentAssignment {\n  layer_name?: string;\n  namespace?: OrgConfigExperimentAssignment['namespace'];\n  allocated_experiment_name?: string | null;\n  group_name?: string | null;\n}\n\ninterface RawResolution {\n  base_version?: string;\n  base_version_source?: string;\n}\n\ninterface RawBootstrapResponse {\n  org_config?: {\n    org?: { org?: Record<string, string | undefined> };\n    gates?: RawFeatureGate[];\n  };\n  widget_config?: {\n    products_config?: Parameters<typeof transformV3ProductsConfig>[0];\n    // Read from widget_config (not org_config) to match getWidgetConfig — see the\n    // mapping below.\n    experiment_assignments?: RawExperimentAssignment[];\n    resolution?: RawResolution;\n  };\n  url_resolving?: UrlResolverResponse | null;\n}\n\n// gates arrive snake (`group_name`); getWidgetConfig's arrive camel. Only the\n// name/value are used for gate checks — groupName is carried for amplitude.\nconst toBootstrapGates = (raw: RawFeatureGate[] | undefined): OrgConfigFeatureGate[] =>\n  (raw ?? []).map(g => ({\n    name: g.name,\n    value: g.value,\n    groupName: g.group_name ?? undefined,\n  }));\n\n// experiment_assignments already match the snake OrgConfigExperimentAssignment\n// wire shape (unlike getWidgetConfig's camel, which needs toExperimentAssignments).\nconst toBootstrapAssignments = (\n  raw: RawExperimentAssignment[] | undefined,\n): OrgConfigExperimentAssignment[] =>\n  (raw ?? []).map(a => ({\n    layer_name: a.layer_name,\n    namespace: a.namespace,\n    allocated_experiment_name: a.allocated_experiment_name,\n    group_name: a.group_name,\n  }));\n\n// resolution is snake here (REST); getWidgetConfig's is camel (Ariadne).\nconst toResolution = (\n  raw: RawResolution | undefined,\n): ExperimentConfigResolutionMetadata | undefined =>\n  raw ? { baseVersion: raw.base_version, baseVersionSource: raw.base_version_source } : undefined;\n\n// One round trip for the config the widget client needs at init: org identity +\n// gates + experiment assignments + productsConfig/resolution, PLUS the initial\n// url-resolving result — the consolidation of `GET /v1/org/config`, GraphQL\n// `me.getWidgetConfig`, and `POST /v1/url_resolving` behind Matt's endpoint.\n//\n// Raw fetch (the npm client `@spiffy-ai/commerce-api-client` has no bootstrap\n// method, same as getWidgetConfig). Throws on network/HTTP failure/timeout — the\n// caller (enviveConfigService) falls back to the getWidgetConfig config it already\n// holds, so a bootstrap problem degrades to the proven path rather than aborting\n// injection.\n//\n// Bootstrap is an OPTIONAL upgrade that BLOCKS the pre-first-paint critical path\n// (a second call after getWidgetConfig already succeeded), and we already hold a\n// usable getWidgetConfig config to fall back to — so it is tightly bounded. Kept\n// low so a slow/hung endpoint adds at most this much to first paint; on timeout\n// the fetch aborts and we fall back to getWidgetConfig. CALIBRATE against the\n// endpoint's real p99 before ramping the gate (a value below p99 will make normal\n// bootstraps false-abort into the fallback, defeating the consolidation).\nconst BOOTSTRAP_TIMEOUT_MS = 1500;\n\nexport const fetchBootstrapConfig = async ({\n  baseUrl,\n  apiKey,\n  userId,\n  source,\n  namespace,\n  gateNames,\n  url,\n  orgId,\n  orgShortName,\n  contextSource,\n  env,\n  chatId,\n  featureGates,\n}: FetchBootstrapConfigParams): Promise<BootstrapResult> => {\n  const version = configVersionOverride();\n\n  // Armed before fetch and kept live across response.json() (a stalled body read\n  // must also be interruptible), cleared in finally. On timeout the fetch rejects\n  // with an AbortError → maybeUpgradeToBootstrap's catch falls back to getWidgetConfig.\n  const controller = new AbortController();\n  const timeoutId = setTimeout(() => controller.abort(), BOOTSTRAP_TIMEOUT_MS);\n  let result: RawBootstrapResponse;\n  try {\n    const response = await fetch(`${baseUrl}/v1/session/bootstrap`, {\n      method: 'POST',\n      headers: {\n        'Content-Type': 'application/json',\n        Authorization: `Bearer ${apiKey}`,\n      },\n      body: JSON.stringify({\n        user_id: userId,\n        source,\n        // Scope org_config.configs to the widget namespace — WITHOUT this, pymono\n        // returns every namespace's configs (internal ones included) to the browser.\n        namespace,\n        include_feature_gates: gateNames,\n        version,\n        url_resolving: {\n          url,\n          context: {\n            user_id: userId,\n            org_id: orgId,\n            org_short_name: orgShortName,\n            chat_id: chatId ?? '',\n            source: contextSource,\n            env,\n          },\n          // Override-aware gates so client gate overrides reach page-variant\n          // resolution (bootstrap merges these over its server-resolved gates).\n          // Ignored by pymono until the endpoint gains the field — safe to ship early.\n          feature_gates: featureGates,\n          // The config-version override comes ONLY from the URL query param\n          // (configVersionOverride) — the same source getWidgetConfig uses. It must\n          // NOT come from getWidgetConfig's resolved version: on the gate-ON path\n          // that response is discarded, and bootstrap resolves the config version\n          // server-side (scoping url_resolving to that resolved version, if desired,\n          // belongs on the server — not a getWidgetConfig dependency here).\n          override_config_version: version,\n        },\n      }),\n      signal: controller.signal,\n    });\n\n    if (!response.ok) {\n      throw new Error(`Bootstrap config request failed: ${response.statusText}`);\n    }\n    result = (await response.json()) as RawBootstrapResponse;\n  } finally {\n    clearTimeout(timeoutId);\n  }\n\n  // A 2xx with a missing/partial payload must NOT silently replace the known-good\n  // getWidgetConfig config with empty gates / mock products — that would disable the\n  // client session or drop experiments. Throw instead, so maybeUpgradeToBootstrap's\n  // catch falls back to the getWidgetConfig result it already holds. `gates` is\n  // required as a NON-EMPTY array: we always request the full gateNames list and\n  // only reach bootstrap because getWidgetConfig returned real gates, so an\n  // empty/absent gates response is degraded → fall back. (A products config that is\n  // present-but-malformed still degrades to mock below — only the top-level\n  // sections are required here.)\n  if (!result.org_config?.org?.org || !result.org_config?.gates?.length || !result.widget_config) {\n    throw new Error(\n      'Bootstrap config response missing required sections (org_config.org.org / org_config.gates / widget_config)',\n    );\n  }\n  const orgConfig = result.org_config;\n  const widgetConfig = result.widget_config;\n  // The guard above guarantees org.org at runtime; the `?? {}` only satisfies the\n  // type-narrowing (TS doesn't carry the optional-chain narrowing through the alias).\n  const orgOrg = orgConfig.org?.org ?? {};\n  const resolution = toResolution(widgetConfig.resolution);\n\n  // A malformed products config degrades to mock defaults WITHOUT losing the\n  // org / gates / experiments that came back fine — mirrors fetchUnifiedGraphQLConfig.\n  let orgConfigValues: GraphQlConfigValues;\n  try {\n    orgConfigValues = { ...transformV3ProductsConfig(widgetConfig.products_config), resolution };\n  } catch (err) {\n    logger.logError('fetchBootstrapConfig | Error transforming products config', err);\n    orgConfigValues = { colorsConfig: undefined, frontendConfig: undefined, resolution };\n  }\n\n  const config: EnviveServiceConfig = {\n    // org_config is byte-identical to the legacy /v1/org/config (snake), the\n    // exact shape EnviveServiceConfig.org was built to hold. Constructed\n    // defensively (like fetchUnifiedGraphQLConfig) rather than passed through.\n    org: {\n      org: {\n        id: orgOrg.id ?? '',\n        short_name: orgOrg.short_name ?? '',\n        display_name: orgOrg.display_name ?? '',\n        domain: orgOrg.domain ?? '',\n        status: orgOrg.status ?? '',\n        created_at: orgOrg.created_at ?? '',\n        updated_at: orgOrg.updated_at ?? '',\n      },\n    },\n    gates: toBootstrapGates(orgConfig.gates),\n    // From widget_config, NOT org_config: getWidgetConfig sources assignments from\n    // its widget config (ungated), whereas bootstrap's `org_config.experiment_assignments`\n    // is populated ONLY when the `use_unified_config` gate evaluates true SERVER-SIDE\n    // (pymono `unified_config_active`). Reading org_config would drop assignments —\n    // and the amplitude `experiment.{ns}.*` enrichment — on the client-override test\n    // path (gate ON via `?use_unified_config=true` but 0% server-side). widget_config\n    // matches getWidgetConfig in every case (equal when the gate is on; version pin\n    // empties both).\n    experiment_assignments: toBootstrapAssignments(widgetConfig.experiment_assignments),\n    orgConfig: orgConfigValues,\n  };\n\n  return { config, urlResolving: result.url_resolving ?? null };\n};\n"],"mappings":";;;;;AAcA,MAAM,SAAS,IAAIA,uBAAO,uBAAuB;AAoFjD,MAAM,oBAAoB,SACvB,OAAO,EAAE,EAAE,KAAI,OAAM;CACpB,MAAM,EAAE;CACR,OAAO,EAAE;CACT,WAAW,EAAE,cAAc;CAC5B,EAAE;AAIL,MAAM,0BACJ,SAEC,OAAO,EAAE,EAAE,KAAI,OAAM;CACpB,YAAY,EAAE;CACd,WAAW,EAAE;CACb,2BAA2B,EAAE;CAC7B,YAAY,EAAE;CACf,EAAE;AAGL,MAAM,gBACJ,QAEA,MAAM;CAAE,aAAa,IAAI;CAAc,mBAAmB,IAAI;CAAqB,GAAG;AAoBxF,MAAM,uBAAuB;AAE7B,MAAa,uBAAuB,OAAO,EACzC,SACA,QACA,QACA,QACA,WACA,WACA,KACA,OACA,cACA,eACA,KACA,QACA,mBAC0D;CAC1D,MAAM,UAAUC,+CAAuB;CAKvC,MAAM,aAAa,IAAI,iBAAiB;CACxC,MAAM,YAAY,iBAAiB,WAAW,OAAO,EAAE,qBAAqB;CAC5E,IAAIC;AACJ,KAAI;EACF,MAAM,WAAW,MAAM,MAAM,GAAG,QAAQ,wBAAwB;GAC9D,QAAQ;GACR,SAAS;IACP,gBAAgB;IAChB,eAAe,UAAU;IAC1B;GACD,MAAM,KAAK,UAAU;IACnB,SAAS;IACT;IAGA;IACA,uBAAuB;IACvB;IACA,eAAe;KACb;KACA,SAAS;MACP,SAAS;MACT,QAAQ;MACR,gBAAgB;MAChB,SAAS,UAAU;MACnB,QAAQ;MACR;MACD;KAID,eAAe;KAOf,yBAAyB;KAC1B;IACF,CAAC;GACF,QAAQ,WAAW;GACpB,CAAC;AAEF,MAAI,CAAC,SAAS,GACZ,OAAM,IAAI,MAAM,oCAAoC,SAAS,aAAa;AAE5E,WAAU,MAAM,SAAS,MAAM;WACvB;AACR,eAAa,UAAU;;AAYzB,KAAI,CAAC,OAAO,YAAY,KAAK,OAAO,CAAC,OAAO,YAAY,OAAO,UAAU,CAAC,OAAO,cAC/E,OAAM,IAAI,MACR,8GACD;CAEH,MAAM,YAAY,OAAO;CACzB,MAAM,eAAe,OAAO;CAG5B,MAAM,SAAS,UAAU,KAAK,OAAO,EAAE;CACvC,MAAM,aAAa,aAAa,aAAa,WAAW;CAIxD,IAAIC;AACJ,KAAI;AACF,oBAAkB;GAAE,GAAGC,qDAA0B,aAAa,gBAAgB;GAAE;GAAY;UACrF,KAAK;AACZ,SAAO,SAAS,6DAA6D,IAAI;AACjF,oBAAkB;GAAE,cAAc;GAAW,gBAAgB;GAAW;GAAY;;AA+BtF,QAAO;EAAE,QA5B2B;GAIlC,KAAK,EACH,KAAK;IACH,IAAI,OAAO,MAAM;IACjB,YAAY,OAAO,cAAc;IACjC,cAAc,OAAO,gBAAgB;IACrC,QAAQ,OAAO,UAAU;IACzB,QAAQ,OAAO,UAAU;IACzB,YAAY,OAAO,cAAc;IACjC,YAAY,OAAO,cAAc;IAClC,EACF;GACD,OAAO,iBAAiB,UAAU,MAAM;GASxC,wBAAwB,uBAAuB,aAAa,uBAAuB;GACnF,WAAW;GACZ;EAEgB,cAAc,OAAO,iBAAiB;EAAM"}

package/dist/services/enviveConfigService/fetchBootstrapConfig.js

@@ -0,0 +1,102 @@
+import logger_default from "../../application/logging/logger.js";
+import { configVersionOverride } from "../../types/config-versions.js";
+import { transformV3ProductsConfig } from "./fetchGraphQLConfig.js";
+
+//#region src/services/enviveConfigService/fetchBootstrapConfig.ts
+const logger = new logger_default("fetchBootstrapConfig");
+const toBootstrapGates = (raw) => (raw ?? []).map((g) => ({
+	name: g.name,
+	value: g.value,
+	groupName: g.group_name ?? void 0
+}));
+const toBootstrapAssignments = (raw) => (raw ?? []).map((a) => ({
+	layer_name: a.layer_name,
+	namespace: a.namespace,
+	allocated_experiment_name: a.allocated_experiment_name,
+	group_name: a.group_name
+}));
+const toResolution = (raw) => raw ? {
+	baseVersion: raw.base_version,
+	baseVersionSource: raw.base_version_source
+} : void 0;
+const BOOTSTRAP_TIMEOUT_MS = 1500;
+const fetchBootstrapConfig = async ({ baseUrl, apiKey, userId, source, namespace, gateNames, url, orgId, orgShortName, contextSource, env, chatId, featureGates }) => {
+	const version = configVersionOverride();
+	const controller = new AbortController();
+	const timeoutId = setTimeout(() => controller.abort(), BOOTSTRAP_TIMEOUT_MS);
+	let result;
+	try {
+		const response = await fetch(`${baseUrl}/v1/session/bootstrap`, {
+			method: "POST",
+			headers: {
+				"Content-Type": "application/json",
+				Authorization: `Bearer ${apiKey}`
+			},
+			body: JSON.stringify({
+				user_id: userId,
+				source,
+				namespace,
+				include_feature_gates: gateNames,
+				version,
+				url_resolving: {
+					url,
+					context: {
+						user_id: userId,
+						org_id: orgId,
+						org_short_name: orgShortName,
+						chat_id: chatId ?? "",
+						source: contextSource,
+						env
+					},
+					feature_gates: featureGates,
+					override_config_version: version
+				}
+			}),
+			signal: controller.signal
+		});
+		if (!response.ok) throw new Error(`Bootstrap config request failed: ${response.statusText}`);
+		result = await response.json();
+	} finally {
+		clearTimeout(timeoutId);
+	}
+	if (!result.org_config?.org?.org || !result.org_config?.gates?.length || !result.widget_config) throw new Error("Bootstrap config response missing required sections (org_config.org.org / org_config.gates / widget_config)");
+	const orgConfig = result.org_config;
+	const widgetConfig = result.widget_config;
+	const orgOrg = orgConfig.org?.org ?? {};
+	const resolution = toResolution(widgetConfig.resolution);
+	let orgConfigValues;
+	try {
+		orgConfigValues = {
+			...transformV3ProductsConfig(widgetConfig.products_config),
+			resolution
+		};
+	} catch (err) {
+		logger.logError("fetchBootstrapConfig | Error transforming products config", err);
+		orgConfigValues = {
+			colorsConfig: void 0,
+			frontendConfig: void 0,
+			resolution
+		};
+	}
+	return {
+		config: {
+			org: { org: {
+				id: orgOrg.id ?? "",
+				short_name: orgOrg.short_name ?? "",
+				display_name: orgOrg.display_name ?? "",
+				domain: orgOrg.domain ?? "",
+				status: orgOrg.status ?? "",
+				created_at: orgOrg.created_at ?? "",
+				updated_at: orgOrg.updated_at ?? ""
+			} },
+			gates: toBootstrapGates(orgConfig.gates),
+			experiment_assignments: toBootstrapAssignments(widgetConfig.experiment_assignments),
+			orgConfig: orgConfigValues
+		},
+		urlResolving: result.url_resolving ?? null
+	};
+};
+
+//#endregion
+export { fetchBootstrapConfig };
+//# sourceMappingURL=data:application/json;charset=utf-8;base64,{"version":3,"file":"fetchBootstrapConfig.js","names":["Logger","result: RawBootstrapResponse","orgConfigValues: GraphQlConfigValues"],"sources":["../../../src/services/enviveConfigService/fetchBootstrapConfig.ts"],"sourcesContent":["import Logger from 'src/application/logging/logger';\nimport type { UrlResolverResponse } from 'src/atoms/app/variant';\nimport {\n  ExperimentConfigResolutionMetadata,\n  OrgConfigExperimentAssignment,\n  OrgConfigFeatureGate,\n} from 'src/application/models/api/orgConfigResults';\nimport type { GraphQlConfigValues } from 'src/contexts/graphqlContext';\nimport { configVersionOverride } from 'src/types/config-versions';\nimport { transformV3ProductsConfig } from './fetchGraphQLConfig';\n// Type-only import — erased at compile time, so this does not create a runtime\n// import cycle with enviveConfigService (which imports fetchBootstrapConfig).\nimport type { EnviveServiceConfig } from './enviveConfigService';\n\nconst logger = new Logger('fetchBootstrapConfig');\n\n// The url-resolving context bits the hooks layer can't derive on its own — the\n// injection bundle supplies env (a build-time var) and contextSource. org\n// identity is threaded from the getWidgetConfig response fetched moments earlier\n// (see enviveConfigService: bootstrap only runs on the gate-ON path, which reads\n// the gate off getWidgetConfig first, so org id/short_name are already in hand).\nexport interface FetchBootstrapConfigParams {\n  baseUrl: string;\n  apiKey: string;\n  userId: string;\n  // Config `source` (Statsig user property), 'app' in the injection bundle.\n  source: string;\n  // Scopes org_config.configs to this namespace. REQUIRED: without it pymono\n  // returns EVERY namespace on the org — including internal-only configs (the AI\n  // system prompt, brand-voice instructions, etc.) — in the response the public\n  // bundle receives. The legacy /v1/org/config call scoped it the same way.\n  namespace: string;\n  gateNames: string[];\n  // url_resolving inputs:\n  url: string;\n  orgId: string;\n  orgShortName: string;\n  // Context `source` for url_resolving ('app' | 'playground'); may differ from\n  // the config `source` above (playground = Envive Hub).\n  contextSource: string;\n  env: string;\n  chatId?: string;\n  // The override-aware feature gates (FeatureFlagService.getFeatureFlags()), so\n  // client-side gate overrides (query/window/localStorage) reach page-variant\n  // resolution — same as the legacy /v1/url_resolving request. Bootstrap merges\n  // these OVER its own server-resolved gates. Harmlessly ignored by pymono until\n  // SessionBootstrapUrlResolvingRequest gains the `feature_gates` field (the\n  // schema allows unknown fields; the model is `extra='ignore'`), so the FE can\n  // ship ahead of the backend.\n  featureGates?: Record<string, boolean>;\n}\n\nexport interface BootstrapResult {\n  config: EnviveServiceConfig;\n  // The initial page-variant result, ready to seed urlResolverAtom so the\n  // warm-up skips its own /v1/url_resolving call. null when bootstrap's\n  // (best-effort) url-resolving branch returned nothing.\n  urlResolving: UrlResolverResponse | null;\n}\n\n// --- raw wire shapes (POST /v1/session/bootstrap is REST snake_case) ---------\n\ninterface RawFeatureGate {\n  name?: string;\n  value?: boolean;\n  group_name?: string | null;\n  rule_id?: string | null;\n}\n\ninterface RawExperimentAssignment {\n  layer_name?: string;\n  namespace?: OrgConfigExperimentAssignment['namespace'];\n  allocated_experiment_name?: string | null;\n  group_name?: string | null;\n}\n\ninterface RawResolution {\n  base_version?: string;\n  base_version_source?: string;\n}\n\ninterface RawBootstrapResponse {\n  org_config?: {\n    org?: { org?: Record<string, string | undefined> };\n    gates?: RawFeatureGate[];\n  };\n  widget_config?: {\n    products_config?: Parameters<typeof transformV3ProductsConfig>[0];\n    // Read from widget_config (not org_config) to match getWidgetConfig — see the\n    // mapping below.\n    experiment_assignments?: RawExperimentAssignment[];\n    resolution?: RawResolution;\n  };\n  url_resolving?: UrlResolverResponse | null;\n}\n\n// gates arrive snake (`group_name`); getWidgetConfig's arrive camel. Only the\n// name/value are used for gate checks — groupName is carried for amplitude.\nconst toBootstrapGates = (raw: RawFeatureGate[] | undefined): OrgConfigFeatureGate[] =>\n  (raw ?? []).map(g => ({\n    name: g.name,\n    value: g.value,\n    groupName: g.group_name ?? undefined,\n  }));\n\n// experiment_assignments already match the snake OrgConfigExperimentAssignment\n// wire shape (unlike getWidgetConfig's camel, which needs toExperimentAssignments).\nconst toBootstrapAssignments = (\n  raw: RawExperimentAssignment[] | undefined,\n): OrgConfigExperimentAssignment[] =>\n  (raw ?? []).map(a => ({\n    layer_name: a.layer_name,\n    namespace: a.namespace,\n    allocated_experiment_name: a.allocated_experiment_name,\n    group_name: a.group_name,\n  }));\n\n// resolution is snake here (REST); getWidgetConfig's is camel (Ariadne).\nconst toResolution = (\n  raw: RawResolution | undefined,\n): ExperimentConfigResolutionMetadata | undefined =>\n  raw ? { baseVersion: raw.base_version, baseVersionSource: raw.base_version_source } : undefined;\n\n// One round trip for the config the widget client needs at init: org identity +\n// gates + experiment assignments + productsConfig/resolution, PLUS the initial\n// url-resolving result — the consolidation of `GET /v1/org/config`, GraphQL\n// `me.getWidgetConfig`, and `POST /v1/url_resolving` behind Matt's endpoint.\n//\n// Raw fetch (the npm client `@spiffy-ai/commerce-api-client` has no bootstrap\n// method, same as getWidgetConfig). Throws on network/HTTP failure/timeout — the\n// caller (enviveConfigService) falls back to the getWidgetConfig config it already\n// holds, so a bootstrap problem degrades to the proven path rather than aborting\n// injection.\n//\n// Bootstrap is an OPTIONAL upgrade that BLOCKS the pre-first-paint critical path\n// (a second call after getWidgetConfig already succeeded), and we already hold a\n// usable getWidgetConfig config to fall back to — so it is tightly bounded. Kept\n// low so a slow/hung endpoint adds at most this much to first paint; on timeout\n// the fetch aborts and we fall back to getWidgetConfig. CALIBRATE against the\n// endpoint's real p99 before ramping the gate (a value below p99 will make normal\n// bootstraps false-abort into the fallback, defeating the consolidation).\nconst BOOTSTRAP_TIMEOUT_MS = 1500;\n\nexport const fetchBootstrapConfig = async ({\n  baseUrl,\n  apiKey,\n  userId,\n  source,\n  namespace,\n  gateNames,\n  url,\n  orgId,\n  orgShortName,\n  contextSource,\n  env,\n  chatId,\n  featureGates,\n}: FetchBootstrapConfigParams): Promise<BootstrapResult> => {\n  const version = configVersionOverride();\n\n  // Armed before fetch and kept live across response.json() (a stalled body read\n  // must also be interruptible), cleared in finally. On timeout the fetch rejects\n  // with an AbortError → maybeUpgradeToBootstrap's catch falls back to getWidgetConfig.\n  const controller = new AbortController();\n  const timeoutId = setTimeout(() => controller.abort(), BOOTSTRAP_TIMEOUT_MS);\n  let result: RawBootstrapResponse;\n  try {\n    const response = await fetch(`${baseUrl}/v1/session/bootstrap`, {\n      method: 'POST',\n      headers: {\n        'Content-Type': 'application/json',\n        Authorization: `Bearer ${apiKey}`,\n      },\n      body: JSON.stringify({\n        user_id: userId,\n        source,\n        // Scope org_config.configs to the widget namespace — WITHOUT this, pymono\n        // returns every namespace's configs (internal ones included) to the browser.\n        namespace,\n        include_feature_gates: gateNames,\n        version,\n        url_resolving: {\n          url,\n          context: {\n            user_id: userId,\n            org_id: orgId,\n            org_short_name: orgShortName,\n            chat_id: chatId ?? '',\n            source: contextSource,\n            env,\n          },\n          // Override-aware gates so client gate overrides reach page-variant\n          // resolution (bootstrap merges these over its server-resolved gates).\n          // Ignored by pymono until the endpoint gains the field — safe to ship early.\n          feature_gates: featureGates,\n          // The config-version override comes ONLY from the URL query param\n          // (configVersionOverride) — the same source getWidgetConfig uses. It must\n          // NOT come from getWidgetConfig's resolved version: on the gate-ON path\n          // that response is discarded, and bootstrap resolves the config version\n          // server-side (scoping url_resolving to that resolved version, if desired,\n          // belongs on the server — not a getWidgetConfig dependency here).\n          override_config_version: version,\n        },\n      }),\n      signal: controller.signal,\n    });\n\n    if (!response.ok) {\n      throw new Error(`Bootstrap config request failed: ${response.statusText}`);\n    }\n    result = (await response.json()) as RawBootstrapResponse;\n  } finally {\n    clearTimeout(timeoutId);\n  }\n\n  // A 2xx with a missing/partial payload must NOT silently replace the known-good\n  // getWidgetConfig config with empty gates / mock products — that would disable the\n  // client session or drop experiments. Throw instead, so maybeUpgradeToBootstrap's\n  // catch falls back to the getWidgetConfig result it already holds. `gates` is\n  // required as a NON-EMPTY array: we always request the full gateNames list and\n  // only reach bootstrap because getWidgetConfig returned real gates, so an\n  // empty/absent gates response is degraded → fall back. (A products config that is\n  // present-but-malformed still degrades to mock below — only the top-level\n  // sections are required here.)\n  if (!result.org_config?.org?.org || !result.org_config?.gates?.length || !result.widget_config) {\n    throw new Error(\n      'Bootstrap config response missing required sections (org_config.org.org / org_config.gates / widget_config)',\n    );\n  }\n  const orgConfig = result.org_config;\n  const widgetConfig = result.widget_config;\n  // The guard above guarantees org.org at runtime; the `?? {}` only satisfies the\n  // type-narrowing (TS doesn't carry the optional-chain narrowing through the alias).\n  const orgOrg = orgConfig.org?.org ?? {};\n  const resolution = toResolution(widgetConfig.resolution);\n\n  // A malformed products config degrades to mock defaults WITHOUT losing the\n  // org / gates / experiments that came back fine — mirrors fetchUnifiedGraphQLConfig.\n  let orgConfigValues: GraphQlConfigValues;\n  try {\n    orgConfigValues = { ...transformV3ProductsConfig(widgetConfig.products_config), resolution };\n  } catch (err) {\n    logger.logError('fetchBootstrapConfig | Error transforming products config', err);\n    orgConfigValues = { colorsConfig: undefined, frontendConfig: undefined, resolution };\n  }\n\n  const config: EnviveServiceConfig = {\n    // org_config is byte-identical to the legacy /v1/org/config (snake), the\n    // exact shape EnviveServiceConfig.org was built to hold. Constructed\n    // defensively (like fetchUnifiedGraphQLConfig) rather than passed through.\n    org: {\n      org: {\n        id: orgOrg.id ?? '',\n        short_name: orgOrg.short_name ?? '',\n        display_name: orgOrg.display_name ?? '',\n        domain: orgOrg.domain ?? '',\n        status: orgOrg.status ?? '',\n        created_at: orgOrg.created_at ?? '',\n        updated_at: orgOrg.updated_at ?? '',\n      },\n    },\n    gates: toBootstrapGates(orgConfig.gates),\n    // From widget_config, NOT org_config: getWidgetConfig sources assignments from\n    // its widget config (ungated), whereas bootstrap's `org_config.experiment_assignments`\n    // is populated ONLY when the `use_unified_config` gate evaluates true SERVER-SIDE\n    // (pymono `unified_config_active`). Reading org_config would drop assignments —\n    // and the amplitude `experiment.{ns}.*` enrichment — on the client-override test\n    // path (gate ON via `?use_unified_config=true` but 0% server-side). widget_config\n    // matches getWidgetConfig in every case (equal when the gate is on; version pin\n    // empties both).\n    experiment_assignments: toBootstrapAssignments(widgetConfig.experiment_assignments),\n    orgConfig: orgConfigValues,\n  };\n\n  return { config, urlResolving: result.url_resolving ?? null };\n};\n"],"mappings":";;;;;AAcA,MAAM,SAAS,IAAIA,eAAO,uBAAuB;AAoFjD,MAAM,oBAAoB,SACvB,OAAO,EAAE,EAAE,KAAI,OAAM;CACpB,MAAM,EAAE;CACR,OAAO,EAAE;CACT,WAAW,EAAE,cAAc;CAC5B,EAAE;AAIL,MAAM,0BACJ,SAEC,OAAO,EAAE,EAAE,KAAI,OAAM;CACpB,YAAY,EAAE;CACd,WAAW,EAAE;CACb,2BAA2B,EAAE;CAC7B,YAAY,EAAE;CACf,EAAE;AAGL,MAAM,gBACJ,QAEA,MAAM;CAAE,aAAa,IAAI;CAAc,mBAAmB,IAAI;CAAqB,GAAG;AAoBxF,MAAM,uBAAuB;AAE7B,MAAa,uBAAuB,OAAO,EACzC,SACA,QACA,QACA,QACA,WACA,WACA,KACA,OACA,cACA,eACA,KACA,QACA,mBAC0D;CAC1D,MAAM,UAAU,uBAAuB;CAKvC,MAAM,aAAa,IAAI,iBAAiB;CACxC,MAAM,YAAY,iBAAiB,WAAW,OAAO,EAAE,qBAAqB;CAC5E,IAAIC;AACJ,KAAI;EACF,MAAM,WAAW,MAAM,MAAM,GAAG,QAAQ,wBAAwB;GAC9D,QAAQ;GACR,SAAS;IACP,gBAAgB;IAChB,eAAe,UAAU;IAC1B;GACD,MAAM,KAAK,UAAU;IACnB,SAAS;IACT;IAGA;IACA,uBAAuB;IACvB;IACA,eAAe;KACb;KACA,SAAS;MACP,SAAS;MACT,QAAQ;MACR,gBAAgB;MAChB,SAAS,UAAU;MACnB,QAAQ;MACR;MACD;KAID,eAAe;KAOf,yBAAyB;KAC1B;IACF,CAAC;GACF,QAAQ,WAAW;GACpB,CAAC;AAEF,MAAI,CAAC,SAAS,GACZ,OAAM,IAAI,MAAM,oCAAoC,SAAS,aAAa;AAE5E,WAAU,MAAM,SAAS,MAAM;WACvB;AACR,eAAa,UAAU;;AAYzB,KAAI,CAAC,OAAO,YAAY,KAAK,OAAO,CAAC,OAAO,YAAY,OAAO,UAAU,CAAC,OAAO,cAC/E,OAAM,IAAI,MACR,8GACD;CAEH,MAAM,YAAY,OAAO;CACzB,MAAM,eAAe,OAAO;CAG5B,MAAM,SAAS,UAAU,KAAK,OAAO,EAAE;CACvC,MAAM,aAAa,aAAa,aAAa,WAAW;CAIxD,IAAIC;AACJ,KAAI;AACF,oBAAkB;GAAE,GAAG,0BAA0B,aAAa,gBAAgB;GAAE;GAAY;UACrF,KAAK;AACZ,SAAO,SAAS,6DAA6D,IAAI;AACjF,oBAAkB;GAAE,cAAc;GAAW,gBAAgB;GAAW;GAAY;;AA+BtF,QAAO;EAAE,QA5B2B;GAIlC,KAAK,EACH,KAAK;IACH,IAAI,OAAO,MAAM;IACjB,YAAY,OAAO,cAAc;IACjC,cAAc,OAAO,gBAAgB;IACrC,QAAQ,OAAO,UAAU;IACzB,QAAQ,OAAO,UAAU;IACzB,YAAY,OAAO,cAAc;IACjC,YAAY,OAAO,cAAc;IAClC,EACF;GACD,OAAO,iBAAiB,UAAU,MAAM;GASxC,wBAAwB,uBAAuB,aAAa,uBAAuB;GACnF,WAAW;GACZ;EAEgB,cAAc,OAAO,iBAAiB;EAAM"}

package/dist/services/enviveConfigService/fetchGraphQLConfig.cjs

@@ -234,4 +234,5 @@ const fetchUnifiedGraphQLConfig = async (baseUrl, apiKey, userId, gateNames, sou
 
 //#endregion
 exports.fetchUnifiedGraphQLConfig = fetchUnifiedGraphQLConfig;
-//# sourceMappingURL=data:application/json;charset=utf-8;base64,{"version":3,"file":"fetchGraphQLConfig.cjs","names":["Logger","DEFAULT_PAGE_VARIANTS: PageVariantConfig[]","PageVariantTestType","mockV3ColorsConfig","mockV3FrontendConfig","transformSnakeToCamel","validateAndTransformMountingConfig","v3pageVariants: PageVariantConfig[]","validateAndTransformPageVariants","getWidgetConfigQuery","configVersionOverride","orgConfig: GraphQlConfigValues"],"sources":["../../../src/services/enviveConfigService/fetchGraphQLConfig.ts"],"sourcesContent":["import Logger from 'src/application/logging/logger';\nimport {\n  CamelCasedPropertiesDeep,\n  transformSnakeToCamel,\n  validateAndTransformMountingConfig,\n  validateAndTransformPageVariants,\n} from 'src/application/models';\nimport { FrontendConfigV3 } from 'src/application/models/frontendConfigV3';\nimport { ColorMappingV3 } from 'src/application/models/colorsConfigV3';\n// Type-only: a value import would pull the FloatingButton component (and\n// React) through the package's component index into the injection bundle's\n// pre-config chunk.\nimport type { FloatingButtonLocation } from '@envive-ai/react-toolkit-v3/FloatingButton';\nimport { getWidgetConfigQuery } from 'src/application/models/graphql/queries/getWidgetConfigQuery';\nimport { mockV3ColorsConfig, mockV3FrontendConfig } from 'src/contexts/graphqlContext/mockV3Config';\nimport { WidgetConfigV3 } from 'src/contexts/typesV3';\nimport { PageVariantConfig, PageVariantTestType, WidgetMountingConfig } from 'src/contexts/types';\nimport type { GraphQlConfigValues } from 'src/contexts/graphqlContext';\nimport { configVersionOverride } from 'src/types/config-versions';\nimport {\n  ExperimentConfigResolutionMetadata,\n  OrgConfigExperimentAssignment,\n  OrgConfigFeatureGate,\n} from 'src/application/models/api/orgConfigResults';\n// Type-only import — erased at compile time, so this does not create a runtime\n// import cycle with enviveConfigService (which imports fetchUnifiedGraphQLConfig).\nimport type { EnviveServiceConfig } from './enviveConfigService';\n\nconst logger = new Logger('fetchGraphQLConfig');\n\ntype FrontendConfigV3Response = CamelCasedPropertiesDeep<FrontendConfigV3>;\ntype ColorsConfigV3Response = CamelCasedPropertiesDeep<ColorMappingV3>;\n\nexport const DEFAULT_PAGE_VARIANTS: PageVariantConfig[] = [\n  {\n    variantId: 'plp',\n    variantType: 'plp',\n    plpIdExtractor: 'url-resolver-plp-id',\n    widgetMounting: [],\n    variantTests: [{ testType: PageVariantTestType.UrlResolver }],\n  },\n  {\n    variantId: 'pdp',\n    variantType: 'pdp',\n    productIdExtractor: 'url-resolver-product-id',\n    widgetMounting: [],\n    variantTests: [{ testType: PageVariantTestType.UrlResolver }],\n  },\n];\n\n// String-literal values of the FloatingButtonLocation enum; keep in sync\n// with @envive-ai/react-toolkit-v3/FloatingButton/types/types.ts.\nconst FLOATING_BUTTON_POSITIONS = [\n  'bottom-left',\n  'middle-left',\n  'middle-right',\n  'bottom-right',\n] as const;\n\nconst mapPositionToCamelCase = (position: string): FloatingButtonLocation => {\n  if ((FLOATING_BUTTON_POSITIONS as readonly string[]).includes(position)) {\n    return position as FloatingButtonLocation;\n  }\n  throw new Error(`Invalid position: ${position}`);\n};\n\nconst v3FrontendConfigCleanup = (\n  v3RootConfig: FrontendConfigV3Response,\n): FrontendConfigV3Response => {\n  const { uiConfigs } = v3RootConfig;\n  if (!uiConfigs) return v3RootConfig;\n  const { floatingButton, lookAndFeel } = uiConfigs as any;\n  if (!floatingButton || !lookAndFeel) return v3RootConfig;\n  const { fontSize, lineHeight, letterSpacing } = lookAndFeel.typography as any;\n  return {\n    ...v3RootConfig,\n    uiConfigs: {\n      ...uiConfigs,\n      floatingButton: {\n        ...floatingButton,\n        position: mapPositionToCamelCase(\n          v3RootConfig.uiConfigs?.floatingButton?.position as string,\n        ),\n      },\n      lookAndFeel: {\n        ...lookAndFeel,\n        chatHeaderLogoDarkSrc: lookAndFeel.chatHeaderLogoDarkSrc || lookAndFeel.chatHeaderLogoSrc,\n        chatHeaderLogoLightSrc: lookAndFeel.chatHeaderLogoLightSrc || lookAndFeel.chatHeaderLogoSrc,\n        typography: {\n          ...lookAndFeel.typography,\n          fontSize: {\n            b1: fontSize?.b1 || fontSize?.b_1,\n            b2: fontSize?.b2 || fontSize?.b_2,\n            b3: fontSize?.b3 || fontSize?.b_3,\n            b4: fontSize?.b4 || fontSize?.b_4,\n            b5: fontSize?.b5 || fontSize?.b_5,\n            h1: fontSize?.h1 || fontSize?.h_1,\n            h2: fontSize?.h2 || fontSize?.h_2,\n            h3: fontSize?.h3 || fontSize?.h_3,\n            l1: fontSize?.l1 || fontSize?.l_1,\n            l2: fontSize?.l2 || fontSize?.l_2,\n            t1: fontSize?.t1 || fontSize?.t_1,\n            t2: fontSize?.t2 || fontSize?.t_2,\n            t3: fontSize?.t3 || fontSize?.t_3,\n          },\n          letterSpacing: {\n            ...lookAndFeel.typography.letterSpacing,\n            b1: letterSpacing?.b1 || letterSpacing?.b_1,\n            b2: letterSpacing?.b2 || letterSpacing?.b_2,\n            b3: letterSpacing?.b3 || letterSpacing?.b_3,\n            b4: letterSpacing?.b4 || letterSpacing?.b_4,\n            b5: letterSpacing?.b5 || letterSpacing?.b_5,\n            h1: letterSpacing?.h1 || letterSpacing?.h_1,\n            h2: letterSpacing?.h2 || letterSpacing?.h_2,\n            h3: letterSpacing?.h3 || letterSpacing?.h_3,\n            l1: letterSpacing?.l1 || letterSpacing?.l_1,\n            l2: letterSpacing?.l2 || letterSpacing?.l_2,\n            t1: letterSpacing?.t1 || letterSpacing?.t_1,\n            t2: letterSpacing?.t2 || letterSpacing?.t_2,\n            t3: letterSpacing?.t3 || letterSpacing?.t_3,\n          },\n          lineHeight: {\n            ...lookAndFeel.typography.lineHeight,\n            '114': lineHeight?.lh_114 || lineHeight?.[114],\n            '116': lineHeight?.lh_116 || lineHeight?.[116],\n            '118': lineHeight?.lh_118 || lineHeight?.[118],\n            '120': lineHeight?.lh_120 || lineHeight?.[120],\n            '124': lineHeight?.lh_124 || lineHeight?.[124],\n            '128': lineHeight?.lh_128 || lineHeight?.[128],\n            '130': lineHeight?.lh_130 || lineHeight?.[130],\n            '133': lineHeight?.lh_133 || lineHeight?.[133],\n            '140': lineHeight?.lh_140 || lineHeight?.[140],\n            '148': lineHeight?.lh_148 || lineHeight?.[148],\n            b1: lineHeight?.b1 || lineHeight?.b_1,\n            b2: lineHeight?.b2 || lineHeight?.b_2,\n            b3: lineHeight?.b3 || lineHeight?.b_3,\n            b4: lineHeight?.b4 || lineHeight?.b_4,\n            b5: lineHeight?.b5 || lineHeight?.b_5,\n            h1: lineHeight?.h1 || lineHeight?.h_1,\n            h2: lineHeight?.h2 || lineHeight?.h_2,\n            h3: lineHeight?.h3 || lineHeight?.h_3,\n            l1: lineHeight?.l1 || lineHeight?.l_1,\n            l2: lineHeight?.l2 || lineHeight?.l_2,\n            t1: lineHeight?.t1 || lineHeight?.t_1,\n            t2: lineHeight?.t2 || lineHeight?.t_2,\n            t3: lineHeight?.t3 || lineHeight?.t_3,\n          },\n        },\n      },\n    },\n  };\n};\n\n// Turns a raw productsConfig payload (from getProductsConfigByVersion or\n// getWidgetConfig) into the camelCase GraphQlConfigValues shape the rest of\n// the toolkit consumes. Returns mock config when colors are absent.\nconst transformV3ProductsConfig = (\n  productsConfig:\n    | {\n        frontend?: { values?: { merchant_override_css?: string } };\n        v_three_config?: { values?: any };\n      }\n    | undefined,\n): GraphQlConfigValues => {\n  const v3RootConfig = productsConfig?.v_three_config?.values;\n  const frontendValues = productsConfig?.frontend?.values;\n\n  if (!v3RootConfig?.colors) {\n    logger.logDebug('transformV3ProductsConfig | No colors found, returning mock config');\n    return {\n      colorsConfig: mockV3ColorsConfig,\n      frontendConfig: mockV3FrontendConfig as FrontendConfigV3Response,\n      orgPageConfig: {\n        pageVariants: DEFAULT_PAGE_VARIANTS,\n        widgetConfigs: {},\n        mountingConfigs: {},\n      },\n    };\n  }\n\n  const v3FrontendConfig = v3FrontendConfigCleanup(\n    transformSnakeToCamel(v3RootConfig) as FrontendConfigV3Response,\n  );\n\n  const merchantOverrideCss =\n    v3FrontendConfig.uiConfigs?.merchantOverrideCss || frontendValues?.merchant_override_css;\n\n  const v3MountingConfigsArray = (transformSnakeToCamel(v3RootConfig?.mounting_configs) ??\n    []) as unknown as { key: string; config: WidgetMountingConfig }[];\n  const v3MountingConfigs = v3MountingConfigsArray.reduce(\n    (acc, { key, config }) => {\n      try {\n        acc[key] = validateAndTransformMountingConfig(config, key);\n      } catch (error) {\n        logger.logWarn('Invalid mounting config, skipping', error, { key });\n      }\n      return acc;\n    },\n    {} as Record<string, WidgetMountingConfig>,\n  );\n\n  const v3WidgetConfigsArray = (transformSnakeToCamel(v3RootConfig?.widget_configs) ??\n    []) as unknown as WidgetConfigV3[];\n  const v3WidgetConfigs = Object.fromEntries(\n    v3WidgetConfigsArray?.map(({ widgetConfigId, ...rest }: WidgetConfigV3) => [\n      widgetConfigId,\n      { widgetConfigId, ...rest } as WidgetConfigV3,\n    ]),\n  ) as Record<string, WidgetConfigV3>;\n\n  const v3pageVariants: PageVariantConfig[] = Array.isArray(v3RootConfig?.page_variants)\n    ? v3RootConfig.page_variants.reduce((acc: PageVariantConfig[], variant: unknown) => {\n        try {\n          acc.push(validateAndTransformPageVariants(variant as Record<string, unknown>));\n        } catch (error) {\n          logger.logWarn('Invalid page variant, skipping', error, { variant });\n        }\n        return acc;\n      }, [])\n    : DEFAULT_PAGE_VARIANTS;\n\n  const v3ColorsConfig = transformSnakeToCamel(v3RootConfig?.colors?.values);\n\n  return {\n    colorsConfig: v3ColorsConfig as ColorsConfigV3Response,\n    frontendConfig: {\n      ...(v3FrontendConfig as FrontendConfigV3Response),\n      merchantOverrideCss,\n      widgetConfigs: v3WidgetConfigs,\n    },\n    orgPageConfig: {\n      pageVariants: v3pageVariants,\n      widgetConfigs: v3WidgetConfigs,\n      mountingConfigs: v3MountingConfigs,\n    },\n  };\n};\n\n// The camelCase `experimentAssignments` GraphQL shape → the snake_case wire\n// shape amplitudeService reads (it previously arrived from REST /v1/org/config).\nconst toExperimentAssignments = (\n  raw:\n    | ReadonlyArray<{\n        layerName?: string;\n        namespace?: OrgConfigExperimentAssignment['namespace'];\n        allocatedExperimentName?: string | null;\n        groupName?: string | null;\n      }>\n    | undefined,\n): OrgConfigExperimentAssignment[] =>\n  (raw ?? []).map(a => ({\n    layer_name: a.layerName,\n    namespace: a.namespace,\n    allocated_experiment_name: a.allocatedExperimentName,\n    group_name: a.groupName,\n  }));\n\n// The unified `getWidgetConfig` config path — now the single source of session\n// config. Returns everything the client needs in one call: org identity,\n// feature gates, and experiment assignments (which used to come from REST\n// `/v1/org/config`), plus the productsConfig and the resolution metadata pymono\n// used to pick the version (callers thread `resolution.baseVersion` into\n// downstream inference so it's scoped to the version that produced the rendered\n// widgets). `gateNames` selects which gates to evaluate; `source` feeds Statsig\n// user properties. A `spiffy_config_version` / `envive_config_version` URL\n// param, when present, is threaded through as the `version` variable to pin a\n// specific version (bypasses the merchant experiment — QA / rollback).\n//\n// Throws on network/GraphQL failure: with org + gates sourced here, there is no\n// partial-render fallback (inject.ts aborts injection on the throw), matching\n// how the old /v1/org/config call behaved.\nexport const fetchUnifiedGraphQLConfig = async (\n  baseUrl: string,\n  apiKey: string,\n  userId: string,\n  gateNames: string[],\n  source: string,\n): Promise<EnviveServiceConfig> => {\n  const query = getWidgetConfigQuery();\n  const version = configVersionOverride();\n  const response = await fetch(`${baseUrl}/v1/graphql`, {\n    method: 'POST',\n    headers: {\n      'Content-Type': 'application/json',\n      Authorization: `Bearer ${apiKey}`,\n    },\n    body: JSON.stringify({ query, variables: { userId, version, gateNames, source } }),\n  });\n\n  if (!response.ok) {\n    throw new Error(`Unified config request failed: ${response.statusText}`);\n  }\n\n  const result = await response.json();\n  if (result.errors) {\n    throw new Error(`Unified config GraphQL errors: ${JSON.stringify(result.errors)}`);\n  }\n\n  const me = result.data?.me;\n  const widgetConfig = me?.getWidgetConfig;\n  const org = me?.org;\n\n  // A malformed products config (e.g. an invalid floating-button position)\n  // degrades to no config — widgets fall back to their mock defaults — WITHOUT\n  // losing the org / gates / experiments that came back fine. The fetch itself\n  // still throws above; only the products-config transform is guarded here.\n  const resolution = widgetConfig?.resolution as ExperimentConfigResolutionMetadata | undefined;\n  let orgConfig: GraphQlConfigValues;\n  try {\n    orgConfig = { ...transformV3ProductsConfig(widgetConfig?.productsConfig), resolution };\n  } catch (err) {\n    logger.logError('fetchUnifiedGraphQLConfig | Error transforming products config', err);\n    orgConfig = { colorsConfig: undefined, frontendConfig: undefined, resolution };\n  }\n\n  return {\n    // GraphQL Organization is camelCase; the rest of the app reads the\n    // snake_case shape /v1/org/config used to return. `status` isn't exposed by\n    // the GraphQL type (and isn't consumed downstream) — default it.\n    org: {\n      org: {\n        id: org?.id ?? '',\n        short_name: org?.shortName ?? '',\n        display_name: org?.displayName ?? '',\n        domain: org?.domain ?? '',\n        status: '',\n        created_at: org?.createdAt ?? '',\n        updated_at: org?.updatedAt ?? '',\n      },\n    },\n    gates: (\n      (widgetConfig?.gates ?? []) as Array<{\n        name?: string;\n        value?: boolean;\n        groupName?: string;\n      }>\n    ).map(\n      (g): OrgConfigFeatureGate => ({\n        name: g.name,\n        value: g.value,\n        groupName: g.groupName,\n      }),\n    ),\n    experiment_assignments: toExperimentAssignments(widgetConfig?.experimentAssignments),\n    orgConfig,\n  };\n};\n"],"mappings":"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"}
+exports.transformV3ProductsConfig = transformV3ProductsConfig;
+//# sourceMappingURL=data:application/json;charset=utf-8;base64,{"version":3,"file":"fetchGraphQLConfig.cjs","names":["Logger","DEFAULT_PAGE_VARIANTS: PageVariantConfig[]","PageVariantTestType","mockV3ColorsConfig","mockV3FrontendConfig","transformSnakeToCamel","validateAndTransformMountingConfig","v3pageVariants: PageVariantConfig[]","validateAndTransformPageVariants","getWidgetConfigQuery","configVersionOverride","orgConfig: GraphQlConfigValues"],"sources":["../../../src/services/enviveConfigService/fetchGraphQLConfig.ts"],"sourcesContent":["import Logger from 'src/application/logging/logger';\nimport {\n  CamelCasedPropertiesDeep,\n  transformSnakeToCamel,\n  validateAndTransformMountingConfig,\n  validateAndTransformPageVariants,\n} from 'src/application/models';\nimport { FrontendConfigV3 } from 'src/application/models/frontendConfigV3';\nimport { ColorMappingV3 } from 'src/application/models/colorsConfigV3';\n// Type-only: a value import would pull the FloatingButton component (and\n// React) through the package's component index into the injection bundle's\n// pre-config chunk.\nimport type { FloatingButtonLocation } from '@envive-ai/react-toolkit-v3/FloatingButton';\nimport { getWidgetConfigQuery } from 'src/application/models/graphql/queries/getWidgetConfigQuery';\nimport { mockV3ColorsConfig, mockV3FrontendConfig } from 'src/contexts/graphqlContext/mockV3Config';\nimport { WidgetConfigV3 } from 'src/contexts/typesV3';\nimport { PageVariantConfig, PageVariantTestType, WidgetMountingConfig } from 'src/contexts/types';\nimport type { GraphQlConfigValues } from 'src/contexts/graphqlContext';\nimport { configVersionOverride } from 'src/types/config-versions';\nimport {\n  ExperimentConfigResolutionMetadata,\n  OrgConfigExperimentAssignment,\n  OrgConfigFeatureGate,\n} from 'src/application/models/api/orgConfigResults';\n// Type-only import — erased at compile time, so this does not create a runtime\n// import cycle with enviveConfigService (which imports fetchUnifiedGraphQLConfig).\nimport type { EnviveServiceConfig } from './enviveConfigService';\n\nconst logger = new Logger('fetchGraphQLConfig');\n\ntype FrontendConfigV3Response = CamelCasedPropertiesDeep<FrontendConfigV3>;\ntype ColorsConfigV3Response = CamelCasedPropertiesDeep<ColorMappingV3>;\n\nexport const DEFAULT_PAGE_VARIANTS: PageVariantConfig[] = [\n  {\n    variantId: 'plp',\n    variantType: 'plp',\n    plpIdExtractor: 'url-resolver-plp-id',\n    widgetMounting: [],\n    variantTests: [{ testType: PageVariantTestType.UrlResolver }],\n  },\n  {\n    variantId: 'pdp',\n    variantType: 'pdp',\n    productIdExtractor: 'url-resolver-product-id',\n    widgetMounting: [],\n    variantTests: [{ testType: PageVariantTestType.UrlResolver }],\n  },\n];\n\n// String-literal values of the FloatingButtonLocation enum; keep in sync\n// with @envive-ai/react-toolkit-v3/FloatingButton/types/types.ts.\nconst FLOATING_BUTTON_POSITIONS = [\n  'bottom-left',\n  'middle-left',\n  'middle-right',\n  'bottom-right',\n] as const;\n\nconst mapPositionToCamelCase = (position: string): FloatingButtonLocation => {\n  if ((FLOATING_BUTTON_POSITIONS as readonly string[]).includes(position)) {\n    return position as FloatingButtonLocation;\n  }\n  throw new Error(`Invalid position: ${position}`);\n};\n\nconst v3FrontendConfigCleanup = (\n  v3RootConfig: FrontendConfigV3Response,\n): FrontendConfigV3Response => {\n  const { uiConfigs } = v3RootConfig;\n  if (!uiConfigs) return v3RootConfig;\n  const { floatingButton, lookAndFeel } = uiConfigs as any;\n  if (!floatingButton || !lookAndFeel) return v3RootConfig;\n  const { fontSize, lineHeight, letterSpacing } = lookAndFeel.typography as any;\n  return {\n    ...v3RootConfig,\n    uiConfigs: {\n      ...uiConfigs,\n      floatingButton: {\n        ...floatingButton,\n        position: mapPositionToCamelCase(\n          v3RootConfig.uiConfigs?.floatingButton?.position as string,\n        ),\n      },\n      lookAndFeel: {\n        ...lookAndFeel,\n        chatHeaderLogoDarkSrc: lookAndFeel.chatHeaderLogoDarkSrc || lookAndFeel.chatHeaderLogoSrc,\n        chatHeaderLogoLightSrc: lookAndFeel.chatHeaderLogoLightSrc || lookAndFeel.chatHeaderLogoSrc,\n        typography: {\n          ...lookAndFeel.typography,\n          fontSize: {\n            b1: fontSize?.b1 || fontSize?.b_1,\n            b2: fontSize?.b2 || fontSize?.b_2,\n            b3: fontSize?.b3 || fontSize?.b_3,\n            b4: fontSize?.b4 || fontSize?.b_4,\n            b5: fontSize?.b5 || fontSize?.b_5,\n            h1: fontSize?.h1 || fontSize?.h_1,\n            h2: fontSize?.h2 || fontSize?.h_2,\n            h3: fontSize?.h3 || fontSize?.h_3,\n            l1: fontSize?.l1 || fontSize?.l_1,\n            l2: fontSize?.l2 || fontSize?.l_2,\n            t1: fontSize?.t1 || fontSize?.t_1,\n            t2: fontSize?.t2 || fontSize?.t_2,\n            t3: fontSize?.t3 || fontSize?.t_3,\n          },\n          letterSpacing: {\n            ...lookAndFeel.typography.letterSpacing,\n            b1: letterSpacing?.b1 || letterSpacing?.b_1,\n            b2: letterSpacing?.b2 || letterSpacing?.b_2,\n            b3: letterSpacing?.b3 || letterSpacing?.b_3,\n            b4: letterSpacing?.b4 || letterSpacing?.b_4,\n            b5: letterSpacing?.b5 || letterSpacing?.b_5,\n            h1: letterSpacing?.h1 || letterSpacing?.h_1,\n            h2: letterSpacing?.h2 || letterSpacing?.h_2,\n            h3: letterSpacing?.h3 || letterSpacing?.h_3,\n            l1: letterSpacing?.l1 || letterSpacing?.l_1,\n            l2: letterSpacing?.l2 || letterSpacing?.l_2,\n            t1: letterSpacing?.t1 || letterSpacing?.t_1,\n            t2: letterSpacing?.t2 || letterSpacing?.t_2,\n            t3: letterSpacing?.t3 || letterSpacing?.t_3,\n          },\n          lineHeight: {\n            ...lookAndFeel.typography.lineHeight,\n            '114': lineHeight?.lh_114 || lineHeight?.[114],\n            '116': lineHeight?.lh_116 || lineHeight?.[116],\n            '118': lineHeight?.lh_118 || lineHeight?.[118],\n            '120': lineHeight?.lh_120 || lineHeight?.[120],\n            '124': lineHeight?.lh_124 || lineHeight?.[124],\n            '128': lineHeight?.lh_128 || lineHeight?.[128],\n            '130': lineHeight?.lh_130 || lineHeight?.[130],\n            '133': lineHeight?.lh_133 || lineHeight?.[133],\n            '140': lineHeight?.lh_140 || lineHeight?.[140],\n            '148': lineHeight?.lh_148 || lineHeight?.[148],\n            b1: lineHeight?.b1 || lineHeight?.b_1,\n            b2: lineHeight?.b2 || lineHeight?.b_2,\n            b3: lineHeight?.b3 || lineHeight?.b_3,\n            b4: lineHeight?.b4 || lineHeight?.b_4,\n            b5: lineHeight?.b5 || lineHeight?.b_5,\n            h1: lineHeight?.h1 || lineHeight?.h_1,\n            h2: lineHeight?.h2 || lineHeight?.h_2,\n            h3: lineHeight?.h3 || lineHeight?.h_3,\n            l1: lineHeight?.l1 || lineHeight?.l_1,\n            l2: lineHeight?.l2 || lineHeight?.l_2,\n            t1: lineHeight?.t1 || lineHeight?.t_1,\n            t2: lineHeight?.t2 || lineHeight?.t_2,\n            t3: lineHeight?.t3 || lineHeight?.t_3,\n          },\n        },\n      },\n    },\n  };\n};\n\n// Turns a raw productsConfig payload (from getProductsConfigByVersion,\n// getWidgetConfig, or the /v1/session/bootstrap widget_config) into the\n// camelCase GraphQlConfigValues shape the rest of the toolkit consumes.\n// Returns mock config when colors are absent. Exported so fetchBootstrapConfig\n// reuses the exact same transform (bootstrap's products_config carries the same\n// `.{section}.values` shape as getWidgetConfig's productsConfig).\nexport const transformV3ProductsConfig = (\n  productsConfig:\n    | {\n        frontend?: { values?: { merchant_override_css?: string } };\n        v_three_config?: { values?: any };\n      }\n    | undefined,\n): GraphQlConfigValues => {\n  const v3RootConfig = productsConfig?.v_three_config?.values;\n  const frontendValues = productsConfig?.frontend?.values;\n\n  if (!v3RootConfig?.colors) {\n    logger.logDebug('transformV3ProductsConfig | No colors found, returning mock config');\n    return {\n      colorsConfig: mockV3ColorsConfig,\n      frontendConfig: mockV3FrontendConfig as FrontendConfigV3Response,\n      orgPageConfig: {\n        pageVariants: DEFAULT_PAGE_VARIANTS,\n        widgetConfigs: {},\n        mountingConfigs: {},\n      },\n    };\n  }\n\n  const v3FrontendConfig = v3FrontendConfigCleanup(\n    transformSnakeToCamel(v3RootConfig) as FrontendConfigV3Response,\n  );\n\n  const merchantOverrideCss =\n    v3FrontendConfig.uiConfigs?.merchantOverrideCss || frontendValues?.merchant_override_css;\n\n  const v3MountingConfigsArray = (transformSnakeToCamel(v3RootConfig?.mounting_configs) ??\n    []) as unknown as { key: string; config: WidgetMountingConfig }[];\n  const v3MountingConfigs = v3MountingConfigsArray.reduce(\n    (acc, { key, config }) => {\n      try {\n        acc[key] = validateAndTransformMountingConfig(config, key);\n      } catch (error) {\n        logger.logWarn('Invalid mounting config, skipping', error, { key });\n      }\n      return acc;\n    },\n    {} as Record<string, WidgetMountingConfig>,\n  );\n\n  const v3WidgetConfigsArray = (transformSnakeToCamel(v3RootConfig?.widget_configs) ??\n    []) as unknown as WidgetConfigV3[];\n  const v3WidgetConfigs = Object.fromEntries(\n    v3WidgetConfigsArray?.map(({ widgetConfigId, ...rest }: WidgetConfigV3) => [\n      widgetConfigId,\n      { widgetConfigId, ...rest } as WidgetConfigV3,\n    ]),\n  ) as Record<string, WidgetConfigV3>;\n\n  const v3pageVariants: PageVariantConfig[] = Array.isArray(v3RootConfig?.page_variants)\n    ? v3RootConfig.page_variants.reduce((acc: PageVariantConfig[], variant: unknown) => {\n        try {\n          acc.push(validateAndTransformPageVariants(variant as Record<string, unknown>));\n        } catch (error) {\n          logger.logWarn('Invalid page variant, skipping', error, { variant });\n        }\n        return acc;\n      }, [])\n    : DEFAULT_PAGE_VARIANTS;\n\n  const v3ColorsConfig = transformSnakeToCamel(v3RootConfig?.colors?.values);\n\n  return {\n    colorsConfig: v3ColorsConfig as ColorsConfigV3Response,\n    frontendConfig: {\n      ...(v3FrontendConfig as FrontendConfigV3Response),\n      merchantOverrideCss,\n      widgetConfigs: v3WidgetConfigs,\n    },\n    orgPageConfig: {\n      pageVariants: v3pageVariants,\n      widgetConfigs: v3WidgetConfigs,\n      mountingConfigs: v3MountingConfigs,\n    },\n  };\n};\n\n// The camelCase `experimentAssignments` GraphQL shape → the snake_case wire\n// shape amplitudeService reads (it previously arrived from REST /v1/org/config).\nconst toExperimentAssignments = (\n  raw:\n    | ReadonlyArray<{\n        layerName?: string;\n        namespace?: OrgConfigExperimentAssignment['namespace'];\n        allocatedExperimentName?: string | null;\n        groupName?: string | null;\n      }>\n    | undefined,\n): OrgConfigExperimentAssignment[] =>\n  (raw ?? []).map(a => ({\n    layer_name: a.layerName,\n    namespace: a.namespace,\n    allocated_experiment_name: a.allocatedExperimentName,\n    group_name: a.groupName,\n  }));\n\n// The unified `getWidgetConfig` config path — now the single source of session\n// config. Returns everything the client needs in one call: org identity,\n// feature gates, and experiment assignments (which used to come from REST\n// `/v1/org/config`), plus the productsConfig and the resolution metadata pymono\n// used to pick the version (callers thread `resolution.baseVersion` into\n// downstream inference so it's scoped to the version that produced the rendered\n// widgets). `gateNames` selects which gates to evaluate; `source` feeds Statsig\n// user properties. A `spiffy_config_version` / `envive_config_version` URL\n// param, when present, is threaded through as the `version` variable to pin a\n// specific version (bypasses the merchant experiment — QA / rollback).\n//\n// Throws on network/GraphQL failure: with org + gates sourced here, there is no\n// partial-render fallback (inject.ts aborts injection on the throw), matching\n// how the old /v1/org/config call behaved.\nexport const fetchUnifiedGraphQLConfig = async (\n  baseUrl: string,\n  apiKey: string,\n  userId: string,\n  gateNames: string[],\n  source: string,\n): Promise<EnviveServiceConfig> => {\n  const query = getWidgetConfigQuery();\n  const version = configVersionOverride();\n  const response = await fetch(`${baseUrl}/v1/graphql`, {\n    method: 'POST',\n    headers: {\n      'Content-Type': 'application/json',\n      Authorization: `Bearer ${apiKey}`,\n    },\n    body: JSON.stringify({ query, variables: { userId, version, gateNames, source } }),\n  });\n\n  if (!response.ok) {\n    throw new Error(`Unified config request failed: ${response.statusText}`);\n  }\n\n  const result = await response.json();\n  if (result.errors) {\n    throw new Error(`Unified config GraphQL errors: ${JSON.stringify(result.errors)}`);\n  }\n\n  const me = result.data?.me;\n  const widgetConfig = me?.getWidgetConfig;\n  const org = me?.org;\n\n  // A malformed products config (e.g. an invalid floating-button position)\n  // degrades to no config — widgets fall back to their mock defaults — WITHOUT\n  // losing the org / gates / experiments that came back fine. The fetch itself\n  // still throws above; only the products-config transform is guarded here.\n  const resolution = widgetConfig?.resolution as ExperimentConfigResolutionMetadata | undefined;\n  let orgConfig: GraphQlConfigValues;\n  try {\n    orgConfig = { ...transformV3ProductsConfig(widgetConfig?.productsConfig), resolution };\n  } catch (err) {\n    logger.logError('fetchUnifiedGraphQLConfig | Error transforming products config', err);\n    orgConfig = { colorsConfig: undefined, frontendConfig: undefined, resolution };\n  }\n\n  return {\n    // GraphQL Organization is camelCase; the rest of the app reads the\n    // snake_case shape /v1/org/config used to return. `status` isn't exposed by\n    // the GraphQL type (and isn't consumed downstream) — default it.\n    org: {\n      org: {\n        id: org?.id ?? '',\n        short_name: org?.shortName ?? '',\n        display_name: org?.displayName ?? '',\n        domain: org?.domain ?? '',\n        status: '',\n        created_at: org?.createdAt ?? '',\n        updated_at: org?.updatedAt ?? '',\n      },\n    },\n    gates: (\n      (widgetConfig?.gates ?? []) as Array<{\n        name?: string;\n        value?: boolean;\n        groupName?: string;\n      }>\n    ).map(\n      (g): OrgConfigFeatureGate => ({\n        name: g.name,\n        value: g.value,\n        groupName: g.groupName,\n      }),\n    ),\n    experiment_assignments: toExperimentAssignments(widgetConfig?.experimentAssignments),\n    orgConfig,\n  };\n};\n"],"mappings":"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"}

package/dist/services/enviveConfigService/fetchGraphQLConfig.js

@@ -233,5 +233,5 @@ const fetchUnifiedGraphQLConfig = async (baseUrl, apiKey, userId, gateNames, sou
 };
 
 //#endregion
-export { fetchUnifiedGraphQLConfig };
-//# sourceMappingURL=data:application/json;charset=utf-8;base64,{"version":3,"file":"fetchGraphQLConfig.js","names":["Logger","DEFAULT_PAGE_VARIANTS: PageVariantConfig[]","v3pageVariants: PageVariantConfig[]","orgConfig: GraphQlConfigValues"],"sources":["../../../src/services/enviveConfigService/fetchGraphQLConfig.ts"],"sourcesContent":["import Logger from 'src/application/logging/logger';\nimport {\n  CamelCasedPropertiesDeep,\n  transformSnakeToCamel,\n  validateAndTransformMountingConfig,\n  validateAndTransformPageVariants,\n} from 'src/application/models';\nimport { FrontendConfigV3 } from 'src/application/models/frontendConfigV3';\nimport { ColorMappingV3 } from 'src/application/models/colorsConfigV3';\n// Type-only: a value import would pull the FloatingButton component (and\n// React) through the package's component index into the injection bundle's\n// pre-config chunk.\nimport type { FloatingButtonLocation } from '@envive-ai/react-toolkit-v3/FloatingButton';\nimport { getWidgetConfigQuery } from 'src/application/models/graphql/queries/getWidgetConfigQuery';\nimport { mockV3ColorsConfig, mockV3FrontendConfig } from 'src/contexts/graphqlContext/mockV3Config';\nimport { WidgetConfigV3 } from 'src/contexts/typesV3';\nimport { PageVariantConfig, PageVariantTestType, WidgetMountingConfig } from 'src/contexts/types';\nimport type { GraphQlConfigValues } from 'src/contexts/graphqlContext';\nimport { configVersionOverride } from 'src/types/config-versions';\nimport {\n  ExperimentConfigResolutionMetadata,\n  OrgConfigExperimentAssignment,\n  OrgConfigFeatureGate,\n} from 'src/application/models/api/orgConfigResults';\n// Type-only import — erased at compile time, so this does not create a runtime\n// import cycle with enviveConfigService (which imports fetchUnifiedGraphQLConfig).\nimport type { EnviveServiceConfig } from './enviveConfigService';\n\nconst logger = new Logger('fetchGraphQLConfig');\n\ntype FrontendConfigV3Response = CamelCasedPropertiesDeep<FrontendConfigV3>;\ntype ColorsConfigV3Response = CamelCasedPropertiesDeep<ColorMappingV3>;\n\nexport const DEFAULT_PAGE_VARIANTS: PageVariantConfig[] = [\n  {\n    variantId: 'plp',\n    variantType: 'plp',\n    plpIdExtractor: 'url-resolver-plp-id',\n    widgetMounting: [],\n    variantTests: [{ testType: PageVariantTestType.UrlResolver }],\n  },\n  {\n    variantId: 'pdp',\n    variantType: 'pdp',\n    productIdExtractor: 'url-resolver-product-id',\n    widgetMounting: [],\n    variantTests: [{ testType: PageVariantTestType.UrlResolver }],\n  },\n];\n\n// String-literal values of the FloatingButtonLocation enum; keep in sync\n// with @envive-ai/react-toolkit-v3/FloatingButton/types/types.ts.\nconst FLOATING_BUTTON_POSITIONS = [\n  'bottom-left',\n  'middle-left',\n  'middle-right',\n  'bottom-right',\n] as const;\n\nconst mapPositionToCamelCase = (position: string): FloatingButtonLocation => {\n  if ((FLOATING_BUTTON_POSITIONS as readonly string[]).includes(position)) {\n    return position as FloatingButtonLocation;\n  }\n  throw new Error(`Invalid position: ${position}`);\n};\n\nconst v3FrontendConfigCleanup = (\n  v3RootConfig: FrontendConfigV3Response,\n): FrontendConfigV3Response => {\n  const { uiConfigs } = v3RootConfig;\n  if (!uiConfigs) return v3RootConfig;\n  const { floatingButton, lookAndFeel } = uiConfigs as any;\n  if (!floatingButton || !lookAndFeel) return v3RootConfig;\n  const { fontSize, lineHeight, letterSpacing } = lookAndFeel.typography as any;\n  return {\n    ...v3RootConfig,\n    uiConfigs: {\n      ...uiConfigs,\n      floatingButton: {\n        ...floatingButton,\n        position: mapPositionToCamelCase(\n          v3RootConfig.uiConfigs?.floatingButton?.position as string,\n        ),\n      },\n      lookAndFeel: {\n        ...lookAndFeel,\n        chatHeaderLogoDarkSrc: lookAndFeel.chatHeaderLogoDarkSrc || lookAndFeel.chatHeaderLogoSrc,\n        chatHeaderLogoLightSrc: lookAndFeel.chatHeaderLogoLightSrc || lookAndFeel.chatHeaderLogoSrc,\n        typography: {\n          ...lookAndFeel.typography,\n          fontSize: {\n            b1: fontSize?.b1 || fontSize?.b_1,\n            b2: fontSize?.b2 || fontSize?.b_2,\n            b3: fontSize?.b3 || fontSize?.b_3,\n            b4: fontSize?.b4 || fontSize?.b_4,\n            b5: fontSize?.b5 || fontSize?.b_5,\n            h1: fontSize?.h1 || fontSize?.h_1,\n            h2: fontSize?.h2 || fontSize?.h_2,\n            h3: fontSize?.h3 || fontSize?.h_3,\n            l1: fontSize?.l1 || fontSize?.l_1,\n            l2: fontSize?.l2 || fontSize?.l_2,\n            t1: fontSize?.t1 || fontSize?.t_1,\n            t2: fontSize?.t2 || fontSize?.t_2,\n            t3: fontSize?.t3 || fontSize?.t_3,\n          },\n          letterSpacing: {\n            ...lookAndFeel.typography.letterSpacing,\n            b1: letterSpacing?.b1 || letterSpacing?.b_1,\n            b2: letterSpacing?.b2 || letterSpacing?.b_2,\n            b3: letterSpacing?.b3 || letterSpacing?.b_3,\n            b4: letterSpacing?.b4 || letterSpacing?.b_4,\n            b5: letterSpacing?.b5 || letterSpacing?.b_5,\n            h1: letterSpacing?.h1 || letterSpacing?.h_1,\n            h2: letterSpacing?.h2 || letterSpacing?.h_2,\n            h3: letterSpacing?.h3 || letterSpacing?.h_3,\n            l1: letterSpacing?.l1 || letterSpacing?.l_1,\n            l2: letterSpacing?.l2 || letterSpacing?.l_2,\n            t1: letterSpacing?.t1 || letterSpacing?.t_1,\n            t2: letterSpacing?.t2 || letterSpacing?.t_2,\n            t3: letterSpacing?.t3 || letterSpacing?.t_3,\n          },\n          lineHeight: {\n            ...lookAndFeel.typography.lineHeight,\n            '114': lineHeight?.lh_114 || lineHeight?.[114],\n            '116': lineHeight?.lh_116 || lineHeight?.[116],\n            '118': lineHeight?.lh_118 || lineHeight?.[118],\n            '120': lineHeight?.lh_120 || lineHeight?.[120],\n            '124': lineHeight?.lh_124 || lineHeight?.[124],\n            '128': lineHeight?.lh_128 || lineHeight?.[128],\n            '130': lineHeight?.lh_130 || lineHeight?.[130],\n            '133': lineHeight?.lh_133 || lineHeight?.[133],\n            '140': lineHeight?.lh_140 || lineHeight?.[140],\n            '148': lineHeight?.lh_148 || lineHeight?.[148],\n            b1: lineHeight?.b1 || lineHeight?.b_1,\n            b2: lineHeight?.b2 || lineHeight?.b_2,\n            b3: lineHeight?.b3 || lineHeight?.b_3,\n            b4: lineHeight?.b4 || lineHeight?.b_4,\n            b5: lineHeight?.b5 || lineHeight?.b_5,\n            h1: lineHeight?.h1 || lineHeight?.h_1,\n            h2: lineHeight?.h2 || lineHeight?.h_2,\n            h3: lineHeight?.h3 || lineHeight?.h_3,\n            l1: lineHeight?.l1 || lineHeight?.l_1,\n            l2: lineHeight?.l2 || lineHeight?.l_2,\n            t1: lineHeight?.t1 || lineHeight?.t_1,\n            t2: lineHeight?.t2 || lineHeight?.t_2,\n            t3: lineHeight?.t3 || lineHeight?.t_3,\n          },\n        },\n      },\n    },\n  };\n};\n\n// Turns a raw productsConfig payload (from getProductsConfigByVersion or\n// getWidgetConfig) into the camelCase GraphQlConfigValues shape the rest of\n// the toolkit consumes. Returns mock config when colors are absent.\nconst transformV3ProductsConfig = (\n  productsConfig:\n    | {\n        frontend?: { values?: { merchant_override_css?: string } };\n        v_three_config?: { values?: any };\n      }\n    | undefined,\n): GraphQlConfigValues => {\n  const v3RootConfig = productsConfig?.v_three_config?.values;\n  const frontendValues = productsConfig?.frontend?.values;\n\n  if (!v3RootConfig?.colors) {\n    logger.logDebug('transformV3ProductsConfig | No colors found, returning mock config');\n    return {\n      colorsConfig: mockV3ColorsConfig,\n      frontendConfig: mockV3FrontendConfig as FrontendConfigV3Response,\n      orgPageConfig: {\n        pageVariants: DEFAULT_PAGE_VARIANTS,\n        widgetConfigs: {},\n        mountingConfigs: {},\n      },\n    };\n  }\n\n  const v3FrontendConfig = v3FrontendConfigCleanup(\n    transformSnakeToCamel(v3RootConfig) as FrontendConfigV3Response,\n  );\n\n  const merchantOverrideCss =\n    v3FrontendConfig.uiConfigs?.merchantOverrideCss || frontendValues?.merchant_override_css;\n\n  const v3MountingConfigsArray = (transformSnakeToCamel(v3RootConfig?.mounting_configs) ??\n    []) as unknown as { key: string; config: WidgetMountingConfig }[];\n  const v3MountingConfigs = v3MountingConfigsArray.reduce(\n    (acc, { key, config }) => {\n      try {\n        acc[key] = validateAndTransformMountingConfig(config, key);\n      } catch (error) {\n        logger.logWarn('Invalid mounting config, skipping', error, { key });\n      }\n      return acc;\n    },\n    {} as Record<string, WidgetMountingConfig>,\n  );\n\n  const v3WidgetConfigsArray = (transformSnakeToCamel(v3RootConfig?.widget_configs) ??\n    []) as unknown as WidgetConfigV3[];\n  const v3WidgetConfigs = Object.fromEntries(\n    v3WidgetConfigsArray?.map(({ widgetConfigId, ...rest }: WidgetConfigV3) => [\n      widgetConfigId,\n      { widgetConfigId, ...rest } as WidgetConfigV3,\n    ]),\n  ) as Record<string, WidgetConfigV3>;\n\n  const v3pageVariants: PageVariantConfig[] = Array.isArray(v3RootConfig?.page_variants)\n    ? v3RootConfig.page_variants.reduce((acc: PageVariantConfig[], variant: unknown) => {\n        try {\n          acc.push(validateAndTransformPageVariants(variant as Record<string, unknown>));\n        } catch (error) {\n          logger.logWarn('Invalid page variant, skipping', error, { variant });\n        }\n        return acc;\n      }, [])\n    : DEFAULT_PAGE_VARIANTS;\n\n  const v3ColorsConfig = transformSnakeToCamel(v3RootConfig?.colors?.values);\n\n  return {\n    colorsConfig: v3ColorsConfig as ColorsConfigV3Response,\n    frontendConfig: {\n      ...(v3FrontendConfig as FrontendConfigV3Response),\n      merchantOverrideCss,\n      widgetConfigs: v3WidgetConfigs,\n    },\n    orgPageConfig: {\n      pageVariants: v3pageVariants,\n      widgetConfigs: v3WidgetConfigs,\n      mountingConfigs: v3MountingConfigs,\n    },\n  };\n};\n\n// The camelCase `experimentAssignments` GraphQL shape → the snake_case wire\n// shape amplitudeService reads (it previously arrived from REST /v1/org/config).\nconst toExperimentAssignments = (\n  raw:\n    | ReadonlyArray<{\n        layerName?: string;\n        namespace?: OrgConfigExperimentAssignment['namespace'];\n        allocatedExperimentName?: string | null;\n        groupName?: string | null;\n      }>\n    | undefined,\n): OrgConfigExperimentAssignment[] =>\n  (raw ?? []).map(a => ({\n    layer_name: a.layerName,\n    namespace: a.namespace,\n    allocated_experiment_name: a.allocatedExperimentName,\n    group_name: a.groupName,\n  }));\n\n// The unified `getWidgetConfig` config path — now the single source of session\n// config. Returns everything the client needs in one call: org identity,\n// feature gates, and experiment assignments (which used to come from REST\n// `/v1/org/config`), plus the productsConfig and the resolution metadata pymono\n// used to pick the version (callers thread `resolution.baseVersion` into\n// downstream inference so it's scoped to the version that produced the rendered\n// widgets). `gateNames` selects which gates to evaluate; `source` feeds Statsig\n// user properties. A `spiffy_config_version` / `envive_config_version` URL\n// param, when present, is threaded through as the `version` variable to pin a\n// specific version (bypasses the merchant experiment — QA / rollback).\n//\n// Throws on network/GraphQL failure: with org + gates sourced here, there is no\n// partial-render fallback (inject.ts aborts injection on the throw), matching\n// how the old /v1/org/config call behaved.\nexport const fetchUnifiedGraphQLConfig = async (\n  baseUrl: string,\n  apiKey: string,\n  userId: string,\n  gateNames: string[],\n  source: string,\n): Promise<EnviveServiceConfig> => {\n  const query = getWidgetConfigQuery();\n  const version = configVersionOverride();\n  const response = await fetch(`${baseUrl}/v1/graphql`, {\n    method: 'POST',\n    headers: {\n      'Content-Type': 'application/json',\n      Authorization: `Bearer ${apiKey}`,\n    },\n    body: JSON.stringify({ query, variables: { userId, version, gateNames, source } }),\n  });\n\n  if (!response.ok) {\n    throw new Error(`Unified config request failed: ${response.statusText}`);\n  }\n\n  const result = await response.json();\n  if (result.errors) {\n    throw new Error(`Unified config GraphQL errors: ${JSON.stringify(result.errors)}`);\n  }\n\n  const me = result.data?.me;\n  const widgetConfig = me?.getWidgetConfig;\n  const org = me?.org;\n\n  // A malformed products config (e.g. an invalid floating-button position)\n  // degrades to no config — widgets fall back to their mock defaults — WITHOUT\n  // losing the org / gates / experiments that came back fine. The fetch itself\n  // still throws above; only the products-config transform is guarded here.\n  const resolution = widgetConfig?.resolution as ExperimentConfigResolutionMetadata | undefined;\n  let orgConfig: GraphQlConfigValues;\n  try {\n    orgConfig = { ...transformV3ProductsConfig(widgetConfig?.productsConfig), resolution };\n  } catch (err) {\n    logger.logError('fetchUnifiedGraphQLConfig | Error transforming products config', err);\n    orgConfig = { colorsConfig: undefined, frontendConfig: undefined, resolution };\n  }\n\n  return {\n    // GraphQL Organization is camelCase; the rest of the app reads the\n    // snake_case shape /v1/org/config used to return. `status` isn't exposed by\n    // the GraphQL type (and isn't consumed downstream) — default it.\n    org: {\n      org: {\n        id: org?.id ?? '',\n        short_name: org?.shortName ?? '',\n        display_name: org?.displayName ?? '',\n        domain: org?.domain ?? '',\n        status: '',\n        created_at: org?.createdAt ?? '',\n        updated_at: org?.updatedAt ?? '',\n      },\n    },\n    gates: (\n      (widgetConfig?.gates ?? []) as Array<{\n        name?: string;\n        value?: boolean;\n        groupName?: string;\n      }>\n    ).map(\n      (g): OrgConfigFeatureGate => ({\n        name: g.name,\n        value: g.value,\n        groupName: g.groupName,\n      }),\n    ),\n    experiment_assignments: toExperimentAssignments(widgetConfig?.experimentAssignments),\n    orgConfig,\n  };\n};\n"],"mappings":"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"}
+export { fetchUnifiedGraphQLConfig, transformV3ProductsConfig };
+//# sourceMappingURL=data:application/json;charset=utf-8;base64,{"version":3,"file":"fetchGraphQLConfig.js","names":["Logger","DEFAULT_PAGE_VARIANTS: PageVariantConfig[]","v3pageVariants: PageVariantConfig[]","orgConfig: GraphQlConfigValues"],"sources":["../../../src/services/enviveConfigService/fetchGraphQLConfig.ts"],"sourcesContent":["import Logger from 'src/application/logging/logger';\nimport {\n  CamelCasedPropertiesDeep,\n  transformSnakeToCamel,\n  validateAndTransformMountingConfig,\n  validateAndTransformPageVariants,\n} from 'src/application/models';\nimport { FrontendConfigV3 } from 'src/application/models/frontendConfigV3';\nimport { ColorMappingV3 } from 'src/application/models/colorsConfigV3';\n// Type-only: a value import would pull the FloatingButton component (and\n// React) through the package's component index into the injection bundle's\n// pre-config chunk.\nimport type { FloatingButtonLocation } from '@envive-ai/react-toolkit-v3/FloatingButton';\nimport { getWidgetConfigQuery } from 'src/application/models/graphql/queries/getWidgetConfigQuery';\nimport { mockV3ColorsConfig, mockV3FrontendConfig } from 'src/contexts/graphqlContext/mockV3Config';\nimport { WidgetConfigV3 } from 'src/contexts/typesV3';\nimport { PageVariantConfig, PageVariantTestType, WidgetMountingConfig } from 'src/contexts/types';\nimport type { GraphQlConfigValues } from 'src/contexts/graphqlContext';\nimport { configVersionOverride } from 'src/types/config-versions';\nimport {\n  ExperimentConfigResolutionMetadata,\n  OrgConfigExperimentAssignment,\n  OrgConfigFeatureGate,\n} from 'src/application/models/api/orgConfigResults';\n// Type-only import — erased at compile time, so this does not create a runtime\n// import cycle with enviveConfigService (which imports fetchUnifiedGraphQLConfig).\nimport type { EnviveServiceConfig } from './enviveConfigService';\n\nconst logger = new Logger('fetchGraphQLConfig');\n\ntype FrontendConfigV3Response = CamelCasedPropertiesDeep<FrontendConfigV3>;\ntype ColorsConfigV3Response = CamelCasedPropertiesDeep<ColorMappingV3>;\n\nexport const DEFAULT_PAGE_VARIANTS: PageVariantConfig[] = [\n  {\n    variantId: 'plp',\n    variantType: 'plp',\n    plpIdExtractor: 'url-resolver-plp-id',\n    widgetMounting: [],\n    variantTests: [{ testType: PageVariantTestType.UrlResolver }],\n  },\n  {\n    variantId: 'pdp',\n    variantType: 'pdp',\n    productIdExtractor: 'url-resolver-product-id',\n    widgetMounting: [],\n    variantTests: [{ testType: PageVariantTestType.UrlResolver }],\n  },\n];\n\n// String-literal values of the FloatingButtonLocation enum; keep in sync\n// with @envive-ai/react-toolkit-v3/FloatingButton/types/types.ts.\nconst FLOATING_BUTTON_POSITIONS = [\n  'bottom-left',\n  'middle-left',\n  'middle-right',\n  'bottom-right',\n] as const;\n\nconst mapPositionToCamelCase = (position: string): FloatingButtonLocation => {\n  if ((FLOATING_BUTTON_POSITIONS as readonly string[]).includes(position)) {\n    return position as FloatingButtonLocation;\n  }\n  throw new Error(`Invalid position: ${position}`);\n};\n\nconst v3FrontendConfigCleanup = (\n  v3RootConfig: FrontendConfigV3Response,\n): FrontendConfigV3Response => {\n  const { uiConfigs } = v3RootConfig;\n  if (!uiConfigs) return v3RootConfig;\n  const { floatingButton, lookAndFeel } = uiConfigs as any;\n  if (!floatingButton || !lookAndFeel) return v3RootConfig;\n  const { fontSize, lineHeight, letterSpacing } = lookAndFeel.typography as any;\n  return {\n    ...v3RootConfig,\n    uiConfigs: {\n      ...uiConfigs,\n      floatingButton: {\n        ...floatingButton,\n        position: mapPositionToCamelCase(\n          v3RootConfig.uiConfigs?.floatingButton?.position as string,\n        ),\n      },\n      lookAndFeel: {\n        ...lookAndFeel,\n        chatHeaderLogoDarkSrc: lookAndFeel.chatHeaderLogoDarkSrc || lookAndFeel.chatHeaderLogoSrc,\n        chatHeaderLogoLightSrc: lookAndFeel.chatHeaderLogoLightSrc || lookAndFeel.chatHeaderLogoSrc,\n        typography: {\n          ...lookAndFeel.typography,\n          fontSize: {\n            b1: fontSize?.b1 || fontSize?.b_1,\n            b2: fontSize?.b2 || fontSize?.b_2,\n            b3: fontSize?.b3 || fontSize?.b_3,\n            b4: fontSize?.b4 || fontSize?.b_4,\n            b5: fontSize?.b5 || fontSize?.b_5,\n            h1: fontSize?.h1 || fontSize?.h_1,\n            h2: fontSize?.h2 || fontSize?.h_2,\n            h3: fontSize?.h3 || fontSize?.h_3,\n            l1: fontSize?.l1 || fontSize?.l_1,\n            l2: fontSize?.l2 || fontSize?.l_2,\n            t1: fontSize?.t1 || fontSize?.t_1,\n            t2: fontSize?.t2 || fontSize?.t_2,\n            t3: fontSize?.t3 || fontSize?.t_3,\n          },\n          letterSpacing: {\n            ...lookAndFeel.typography.letterSpacing,\n            b1: letterSpacing?.b1 || letterSpacing?.b_1,\n            b2: letterSpacing?.b2 || letterSpacing?.b_2,\n            b3: letterSpacing?.b3 || letterSpacing?.b_3,\n            b4: letterSpacing?.b4 || letterSpacing?.b_4,\n            b5: letterSpacing?.b5 || letterSpacing?.b_5,\n            h1: letterSpacing?.h1 || letterSpacing?.h_1,\n            h2: letterSpacing?.h2 || letterSpacing?.h_2,\n            h3: letterSpacing?.h3 || letterSpacing?.h_3,\n            l1: letterSpacing?.l1 || letterSpacing?.l_1,\n            l2: letterSpacing?.l2 || letterSpacing?.l_2,\n            t1: letterSpacing?.t1 || letterSpacing?.t_1,\n            t2: letterSpacing?.t2 || letterSpacing?.t_2,\n            t3: letterSpacing?.t3 || letterSpacing?.t_3,\n          },\n          lineHeight: {\n            ...lookAndFeel.typography.lineHeight,\n            '114': lineHeight?.lh_114 || lineHeight?.[114],\n            '116': lineHeight?.lh_116 || lineHeight?.[116],\n            '118': lineHeight?.lh_118 || lineHeight?.[118],\n            '120': lineHeight?.lh_120 || lineHeight?.[120],\n            '124': lineHeight?.lh_124 || lineHeight?.[124],\n            '128': lineHeight?.lh_128 || lineHeight?.[128],\n            '130': lineHeight?.lh_130 || lineHeight?.[130],\n            '133': lineHeight?.lh_133 || lineHeight?.[133],\n            '140': lineHeight?.lh_140 || lineHeight?.[140],\n            '148': lineHeight?.lh_148 || lineHeight?.[148],\n            b1: lineHeight?.b1 || lineHeight?.b_1,\n            b2: lineHeight?.b2 || lineHeight?.b_2,\n            b3: lineHeight?.b3 || lineHeight?.b_3,\n            b4: lineHeight?.b4 || lineHeight?.b_4,\n            b5: lineHeight?.b5 || lineHeight?.b_5,\n            h1: lineHeight?.h1 || lineHeight?.h_1,\n            h2: lineHeight?.h2 || lineHeight?.h_2,\n            h3: lineHeight?.h3 || lineHeight?.h_3,\n            l1: lineHeight?.l1 || lineHeight?.l_1,\n            l2: lineHeight?.l2 || lineHeight?.l_2,\n            t1: lineHeight?.t1 || lineHeight?.t_1,\n            t2: lineHeight?.t2 || lineHeight?.t_2,\n            t3: lineHeight?.t3 || lineHeight?.t_3,\n          },\n        },\n      },\n    },\n  };\n};\n\n// Turns a raw productsConfig payload (from getProductsConfigByVersion,\n// getWidgetConfig, or the /v1/session/bootstrap widget_config) into the\n// camelCase GraphQlConfigValues shape the rest of the toolkit consumes.\n// Returns mock config when colors are absent. Exported so fetchBootstrapConfig\n// reuses the exact same transform (bootstrap's products_config carries the same\n// `.{section}.values` shape as getWidgetConfig's productsConfig).\nexport const transformV3ProductsConfig = (\n  productsConfig:\n    | {\n        frontend?: { values?: { merchant_override_css?: string } };\n        v_three_config?: { values?: any };\n      }\n    | undefined,\n): GraphQlConfigValues => {\n  const v3RootConfig = productsConfig?.v_three_config?.values;\n  const frontendValues = productsConfig?.frontend?.values;\n\n  if (!v3RootConfig?.colors) {\n    logger.logDebug('transformV3ProductsConfig | No colors found, returning mock config');\n    return {\n      colorsConfig: mockV3ColorsConfig,\n      frontendConfig: mockV3FrontendConfig as FrontendConfigV3Response,\n      orgPageConfig: {\n        pageVariants: DEFAULT_PAGE_VARIANTS,\n        widgetConfigs: {},\n        mountingConfigs: {},\n      },\n    };\n  }\n\n  const v3FrontendConfig = v3FrontendConfigCleanup(\n    transformSnakeToCamel(v3RootConfig) as FrontendConfigV3Response,\n  );\n\n  const merchantOverrideCss =\n    v3FrontendConfig.uiConfigs?.merchantOverrideCss || frontendValues?.merchant_override_css;\n\n  const v3MountingConfigsArray = (transformSnakeToCamel(v3RootConfig?.mounting_configs) ??\n    []) as unknown as { key: string; config: WidgetMountingConfig }[];\n  const v3MountingConfigs = v3MountingConfigsArray.reduce(\n    (acc, { key, config }) => {\n      try {\n        acc[key] = validateAndTransformMountingConfig(config, key);\n      } catch (error) {\n        logger.logWarn('Invalid mounting config, skipping', error, { key });\n      }\n      return acc;\n    },\n    {} as Record<string, WidgetMountingConfig>,\n  );\n\n  const v3WidgetConfigsArray = (transformSnakeToCamel(v3RootConfig?.widget_configs) ??\n    []) as unknown as WidgetConfigV3[];\n  const v3WidgetConfigs = Object.fromEntries(\n    v3WidgetConfigsArray?.map(({ widgetConfigId, ...rest }: WidgetConfigV3) => [\n      widgetConfigId,\n      { widgetConfigId, ...rest } as WidgetConfigV3,\n    ]),\n  ) as Record<string, WidgetConfigV3>;\n\n  const v3pageVariants: PageVariantConfig[] = Array.isArray(v3RootConfig?.page_variants)\n    ? v3RootConfig.page_variants.reduce((acc: PageVariantConfig[], variant: unknown) => {\n        try {\n          acc.push(validateAndTransformPageVariants(variant as Record<string, unknown>));\n        } catch (error) {\n          logger.logWarn('Invalid page variant, skipping', error, { variant });\n        }\n        return acc;\n      }, [])\n    : DEFAULT_PAGE_VARIANTS;\n\n  const v3ColorsConfig = transformSnakeToCamel(v3RootConfig?.colors?.values);\n\n  return {\n    colorsConfig: v3ColorsConfig as ColorsConfigV3Response,\n    frontendConfig: {\n      ...(v3FrontendConfig as FrontendConfigV3Response),\n      merchantOverrideCss,\n      widgetConfigs: v3WidgetConfigs,\n    },\n    orgPageConfig: {\n      pageVariants: v3pageVariants,\n      widgetConfigs: v3WidgetConfigs,\n      mountingConfigs: v3MountingConfigs,\n    },\n  };\n};\n\n// The camelCase `experimentAssignments` GraphQL shape → the snake_case wire\n// shape amplitudeService reads (it previously arrived from REST /v1/org/config).\nconst toExperimentAssignments = (\n  raw:\n    | ReadonlyArray<{\n        layerName?: string;\n        namespace?: OrgConfigExperimentAssignment['namespace'];\n        allocatedExperimentName?: string | null;\n        groupName?: string | null;\n      }>\n    | undefined,\n): OrgConfigExperimentAssignment[] =>\n  (raw ?? []).map(a => ({\n    layer_name: a.layerName,\n    namespace: a.namespace,\n    allocated_experiment_name: a.allocatedExperimentName,\n    group_name: a.groupName,\n  }));\n\n// The unified `getWidgetConfig` config path — now the single source of session\n// config. Returns everything the client needs in one call: org identity,\n// feature gates, and experiment assignments (which used to come from REST\n// `/v1/org/config`), plus the productsConfig and the resolution metadata pymono\n// used to pick the version (callers thread `resolution.baseVersion` into\n// downstream inference so it's scoped to the version that produced the rendered\n// widgets). `gateNames` selects which gates to evaluate; `source` feeds Statsig\n// user properties. A `spiffy_config_version` / `envive_config_version` URL\n// param, when present, is threaded through as the `version` variable to pin a\n// specific version (bypasses the merchant experiment — QA / rollback).\n//\n// Throws on network/GraphQL failure: with org + gates sourced here, there is no\n// partial-render fallback (inject.ts aborts injection on the throw), matching\n// how the old /v1/org/config call behaved.\nexport const fetchUnifiedGraphQLConfig = async (\n  baseUrl: string,\n  apiKey: string,\n  userId: string,\n  gateNames: string[],\n  source: string,\n): Promise<EnviveServiceConfig> => {\n  const query = getWidgetConfigQuery();\n  const version = configVersionOverride();\n  const response = await fetch(`${baseUrl}/v1/graphql`, {\n    method: 'POST',\n    headers: {\n      'Content-Type': 'application/json',\n      Authorization: `Bearer ${apiKey}`,\n    },\n    body: JSON.stringify({ query, variables: { userId, version, gateNames, source } }),\n  });\n\n  if (!response.ok) {\n    throw new Error(`Unified config request failed: ${response.statusText}`);\n  }\n\n  const result = await response.json();\n  if (result.errors) {\n    throw new Error(`Unified config GraphQL errors: ${JSON.stringify(result.errors)}`);\n  }\n\n  const me = result.data?.me;\n  const widgetConfig = me?.getWidgetConfig;\n  const org = me?.org;\n\n  // A malformed products config (e.g. an invalid floating-button position)\n  // degrades to no config — widgets fall back to their mock defaults — WITHOUT\n  // losing the org / gates / experiments that came back fine. The fetch itself\n  // still throws above; only the products-config transform is guarded here.\n  const resolution = widgetConfig?.resolution as ExperimentConfigResolutionMetadata | undefined;\n  let orgConfig: GraphQlConfigValues;\n  try {\n    orgConfig = { ...transformV3ProductsConfig(widgetConfig?.productsConfig), resolution };\n  } catch (err) {\n    logger.logError('fetchUnifiedGraphQLConfig | Error transforming products config', err);\n    orgConfig = { colorsConfig: undefined, frontendConfig: undefined, resolution };\n  }\n\n  return {\n    // GraphQL Organization is camelCase; the rest of the app reads the\n    // snake_case shape /v1/org/config used to return. `status` isn't exposed by\n    // the GraphQL type (and isn't consumed downstream) — default it.\n    org: {\n      org: {\n        id: org?.id ?? '',\n        short_name: org?.shortName ?? '',\n        display_name: org?.displayName ?? '',\n        domain: org?.domain ?? '',\n        status: '',\n        created_at: org?.createdAt ?? '',\n        updated_at: org?.updatedAt ?? '',\n      },\n    },\n    gates: (\n      (widgetConfig?.gates ?? []) as Array<{\n        name?: string;\n        value?: boolean;\n        groupName?: string;\n      }>\n    ).map(\n      (g): OrgConfigFeatureGate => ({\n        name: g.name,\n        value: g.value,\n        groupName: g.groupName,\n      }),\n    ),\n    experiment_assignments: toExperimentAssignments(widgetConfig?.experimentAssignments),\n    orgConfig,\n  };\n};\n"],"mappings":"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"}