@contractspec/lib.contracts-spec 2.0.0

package/dist/node/app-config/runtime.js

@@ -0,0 +1,734 @@
+import { createRequire } from "node:module";
+var __defProp = Object.defineProperty;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __moduleCache = /* @__PURE__ */ new WeakMap;
+var __toCommonJS = (from) => {
+  var entry = __moduleCache.get(from), desc;
+  if (entry)
+    return entry;
+  entry = __defProp({}, "__esModule", { value: true });
+  if (from && typeof from === "object" || typeof from === "function")
+    __getOwnPropNames(from).map((key) => !__hasOwnProp.call(entry, key) && __defProp(entry, key, {
+      get: () => from[key],
+      enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable
+    }));
+  __moduleCache.set(from, entry);
+  return entry;
+};
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, {
+      get: all[name],
+      enumerable: true,
+      configurable: true,
+      set: (newValue) => all[name] = () => newValue
+    });
+};
+var __esm = (fn, res) => () => (fn && (res = fn(fn = 0)), res);
+var __require = /* @__PURE__ */ createRequire(import.meta.url);
+
+// src/app-config/runtime.ts
+function resolveAppConfig(blueprint, tenant, deps = {}) {
+  const capabilities = mergeCapabilities(blueprint.capabilities, tenant.capabilities);
+  const features = mergeFeatures(blueprint.features, tenant.features);
+  const dataViews = mergeMappings(blueprint.dataViews ?? {}, tenant.dataViewOverrides);
+  const workflows = mergeMappings(blueprint.workflows ?? {}, tenant.workflowOverrides);
+  const policies = mergePolicies(blueprint.policies ?? [], tenant.additionalPolicies ?? []);
+  const theme = mergeTheme(blueprint.theme, tenant.themeOverride);
+  const telemetry = mergeTelemetry(blueprint.telemetry, tenant.telemetryOverride);
+  const experiments = mergeExperiments(blueprint.experiments, tenant.experiments);
+  const featureFlags = mergeFeatureFlags(blueprint.featureFlags ?? [], tenant.featureFlags ?? []);
+  const routes = mergeRoutes(blueprint.routes ?? [], tenant.routeOverrides ?? []);
+  const { resolved: integrations } = evaluateIntegrationSlots(blueprint.integrationSlots, tenant.integrations, deps.integrationConnections, deps.integrationSpecs);
+  const knowledge = resolveKnowledgeBindings(tenant.knowledge, deps.knowledgeSpaces, deps.knowledgeSources);
+  const branding = resolveBranding(blueprint.branding, tenant);
+  const translation = resolveTranslation(blueprint.translationCatalog, tenant.locales, tenant.translationOverrides);
+  return {
+    appId: blueprint.meta.appId,
+    tenantId: tenant.meta.tenantId,
+    environment: tenant.meta.environment,
+    blueprintName: blueprint.meta.key,
+    blueprintVersion: blueprint.meta.version,
+    configVersion: tenant.meta.version,
+    capabilities,
+    features,
+    dataViews,
+    workflows,
+    policies,
+    theme,
+    telemetry,
+    experiments,
+    featureFlags,
+    routes,
+    integrations,
+    knowledge,
+    translation,
+    branding,
+    notes: tenant.notes ?? blueprint.notes
+  };
+}
+function composeAppConfig(blueprint, tenant, deps, options = {}) {
+  const resolved = resolveAppConfig(blueprint, tenant, deps);
+  const missing = [];
+  const integrationEvaluation = evaluateIntegrationSlots(blueprint.integrationSlots, tenant.integrations, deps.integrationConnections, deps.integrationSpecs);
+  resolved.integrations = integrationEvaluation.resolved;
+  missing.push(...integrationEvaluation.missing);
+  missing.push(...collectMissingKnowledge(tenant.knowledge ?? [], deps.knowledgeSpaces, deps.knowledgeSources));
+  const capabilities = resolveCapabilityRefs(resolved.capabilities.enabled, deps.capabilities, missing);
+  const features = resolveFeatureRefs(resolved.features.include, deps.features, missing);
+  const dataViews = resolvePointerRecord(resolved.dataViews, deps.dataViews, "dataView", missing);
+  const workflows = resolvePointerRecord(resolved.workflows, deps.workflows, "workflow", missing);
+  const policies = resolvePolicies(resolved.policies, deps.policies, missing);
+  const { theme, fallbacks, themeMissing } = resolveThemeBinding(resolved.theme, deps.themes);
+  missing.push(...themeMissing);
+  const { telemetry, telemetryMissing } = resolveTelemetryBinding(resolved.telemetry, deps.telemetry);
+  missing.push(...telemetryMissing);
+  const experiments = resolveExperimentsSpecs(resolved.experiments, deps.experiments, missing);
+  if (options.strict && missing.length > 0) {
+    const reasons = missing.map((item) => `${item.type}:${item.identifier}`).join(", ");
+    throw new Error(`composeAppConfig: missing references -> ${reasons}`);
+  }
+  return {
+    resolved,
+    capabilities,
+    features,
+    dataViews,
+    workflows,
+    policies,
+    theme,
+    themeFallbacks: fallbacks,
+    telemetry,
+    experiments,
+    integrations: resolved.integrations,
+    knowledge: resolved.knowledge,
+    missing
+  };
+}
+function mergeCapabilities(blueprint, tenant) {
+  const enabled = dedupeRefs([...blueprint?.enabled ?? [], ...tenant?.enable ?? []], capabilityKey);
+  const disabled = dedupeRefs([...blueprint?.disabled ?? [], ...tenant?.disable ?? []], capabilityKey);
+  const disabledKeys = new Set(disabled.map(capabilityKey));
+  const filteredEnabled = enabled.filter((ref) => !disabledKeys.has(capabilityKey(ref)));
+  return { enabled: filteredEnabled, disabled };
+}
+function mergeFeatures(blueprint, tenant) {
+  const include = dedupeRefs([...blueprint?.include ?? [], ...tenant?.include ?? []], featureKey);
+  const exclude = dedupeRefs([...blueprint?.exclude ?? [], ...tenant?.exclude ?? []], featureKey);
+  const excludeSet = new Set(exclude.map(featureKey));
+  const filteredInclude = include.filter((ref) => !excludeSet.has(featureKey(ref)));
+  return { include: filteredInclude, exclude };
+}
+function mergeMappings(blueprint, overrides) {
+  const merged = { ...blueprint };
+  if (!overrides)
+    return merged;
+  for (const override of overrides) {
+    if (!override)
+      continue;
+    if (!override.pointer) {
+      delete merged[override.slot];
+    } else {
+      merged[override.slot] = override.pointer;
+    }
+  }
+  return merged;
+}
+function mergePolicies(blueprint, additional) {
+  return dedupeRefs([...blueprint, ...additional], policyKey);
+}
+function mergeTheme(blueprint, override) {
+  if (!blueprint && !override)
+    return;
+  const primary = override?.primary ?? blueprint?.primary;
+  if (!primary)
+    return;
+  const fallbacks = override?.fallbacks ?? blueprint?.fallbacks ?? [];
+  return { primary, fallbacks };
+}
+function mergeTelemetry(blueprint, override) {
+  if (!blueprint && !override)
+    return;
+  const binding = {
+    spec: blueprint?.spec,
+    disabledEvents: blueprint?.disabledEvents ? [...blueprint.disabledEvents] : undefined,
+    samplingOverrides: blueprint?.samplingOverrides ? { ...blueprint.samplingOverrides } : undefined
+  };
+  if (override?.spec !== undefined) {
+    binding.spec = override.spec ?? undefined;
+  }
+  if (override?.disabledEvents) {
+    binding.disabledEvents = dedupeStrings([
+      ...binding.disabledEvents ?? [],
+      ...override.disabledEvents
+    ]);
+  }
+  if (override?.samplingOverrides) {
+    binding.samplingOverrides = {
+      ...binding.samplingOverrides ?? {},
+      ...override.samplingOverrides
+    };
+  }
+  if (!binding.spec && !binding.disabledEvents?.length) {
+    return;
+  }
+  return binding;
+}
+function mergeExperiments(blueprint, tenant) {
+  const defaultActive = blueprint?.active ?? [];
+  const defaultPaused = blueprint?.paused ?? [];
+  const tenantActive = tenant?.active;
+  const tenantPaused = tenant?.paused;
+  const activeSource = tenantActive && tenantActive.length > 0 ? tenantActive : defaultActive;
+  const pausedSource = tenantPaused && tenantPaused.length > 0 ? tenantPaused : defaultPaused;
+  const active = dedupeRefs(activeSource, experimentKey);
+  let paused = dedupeRefs(pausedSource, experimentKey);
+  const activeKeys = new Set(active.map(experimentKey));
+  paused = paused.filter((ref) => !activeKeys.has(experimentKey(ref)));
+  const catalog = dedupeRefs([
+    ...defaultActive,
+    ...defaultPaused,
+    ...tenantActive ?? [],
+    ...tenantPaused ?? []
+  ], experimentKey);
+  return { catalog, active, paused };
+}
+function resolveBranding(defaults, tenant) {
+  const override = tenant.branding;
+  const tenantMeta = tenant.meta;
+  const baseDomain = "app.localhost";
+  const domain = override?.customDomain ?? (override?.subdomain ? `${override.subdomain}.${baseDomain}` : `${tenantMeta.tenantId}.${baseDomain}`);
+  const localePreferenceOrder = [];
+  if (tenant.locales?.defaultLocale) {
+    localePreferenceOrder.push(tenant.locales.defaultLocale);
+  }
+  if (override?.appName) {
+    localePreferenceOrder.push("default", "en");
+  }
+  let appName;
+  if (override?.appName) {
+    for (const key of localePreferenceOrder) {
+      const candidate = override.appName[key];
+      if (candidate) {
+        appName = candidate;
+        break;
+      }
+    }
+    if (!appName) {
+      const [, firstValue] = Object.entries(override.appName)[0] ?? [];
+      if (typeof firstValue === "string") {
+        appName = firstValue;
+      }
+    }
+  }
+  if (!appName) {
+    appName = defaults?.appNameKey ?? tenantMeta.appId;
+  }
+  const assetEntries = new Map;
+  const applyAssets = (assets2) => {
+    if (!assets2)
+      return;
+    for (const asset of assets2) {
+      if (!asset?.type)
+        continue;
+      if ("url" in asset && asset.url) {
+        assetEntries.set(asset.type, asset.url);
+      }
+    }
+  };
+  applyAssets(defaults?.assets);
+  applyAssets(override?.assets);
+  const assets = {
+    logo: assetEntries.get("logo"),
+    logoDark: assetEntries.get("logo-dark"),
+    favicon: assetEntries.get("favicon"),
+    ogImage: assetEntries.get("og-image")
+  };
+  const colors = {
+    primary: override?.colors?.primary ?? defaults?.colorTokens?.primary ?? "#1f2937",
+    secondary: override?.colors?.secondary ?? defaults?.colorTokens?.secondary ?? "#4b5563"
+  };
+  return {
+    appName,
+    assets,
+    colors,
+    domain
+  };
+}
+function resolveTranslation(catalogPointer, locales, overrides) {
+  const defaultLocale = locales?.defaultLocale ?? "en";
+  const enabled = locales?.enabledLocales ?? [];
+  const supportedLocales = dedupeStrings([defaultLocale, ...enabled]);
+  const entries = overrides?.entries ?? [];
+  return {
+    defaultLocale,
+    supportedLocales,
+    blueprintCatalog: catalogPointer,
+    tenantOverrides: entries
+  };
+}
+function mergeFeatureFlags(blueprint, overrides) {
+  const merged = new Map;
+  for (const flag of blueprint) {
+    merged.set(flag.key, { ...flag });
+  }
+  for (const override of overrides) {
+    merged.set(override.key, { ...override });
+  }
+  return [...merged.values()];
+}
+function mergeRoutes(blueprint, overrides) {
+  const routes = new Map;
+  for (const route of blueprint) {
+    routes.set(route.path, { ...route });
+  }
+  for (const override of overrides) {
+    const existing = routes.get(override.path) ?? { path: override.path };
+    if (override.label !== undefined) {
+      if (override.label === null)
+        delete existing.label;
+      else
+        existing.label = override.label;
+    }
+    if (override.dataView !== undefined) {
+      if (override.dataView === null)
+        delete existing.dataView;
+      else
+        existing.dataView = override.dataView;
+    }
+    if (override.workflow !== undefined) {
+      if (override.workflow === null)
+        delete existing.workflow;
+      else
+        existing.workflow = override.workflow;
+    }
+    if (override.guard !== undefined) {
+      if (override.guard === null)
+        delete existing.guard;
+      else
+        existing.guard = override.guard;
+    }
+    if (override.featureFlag !== undefined) {
+      if (override.featureFlag === null)
+        delete existing.featureFlag;
+      else
+        existing.featureFlag = override.featureFlag;
+    }
+    if (override.experiment !== undefined) {
+      if (override.experiment === null)
+        delete existing.experiment;
+      else
+        existing.experiment = override.experiment;
+    }
+    routes.set(existing.path, existing);
+  }
+  return [...routes.values()];
+}
+function evaluateIntegrationSlots(slots, bindings, connections, specs) {
+  const resolved = [];
+  const missing = [];
+  const missingKeys = new Set;
+  const recordMissing = (entry) => {
+    const key = `${entry.type}:${entry.identifier}`;
+    if (missingKeys.has(key))
+      return;
+    missingKeys.add(key);
+    missing.push(entry);
+  };
+  const slotList = slots ?? [];
+  const slotById = new Map;
+  for (const slot of slotList) {
+    slotById.set(slot.slotId, slot);
+  }
+  const bindingsBySlot = new Map;
+  for (const binding of bindings ?? []) {
+    const slot = slotById.get(binding.slotId);
+    if (!slot) {
+      recordMissing({
+        type: "integrationSlot",
+        identifier: `slot:${binding.slotId}`
+      });
+      continue;
+    }
+    const entries = bindingsBySlot.get(binding.slotId);
+    if (entries)
+      entries.push(binding);
+    else
+      bindingsBySlot.set(binding.slotId, [binding]);
+  }
+  for (const slot of slotList) {
+    const slotBindings = bindingsBySlot.get(slot.slotId) ?? [];
+    if (slot.required && slotBindings.length === 0) {
+      recordMissing({
+        type: "integrationSlot",
+        identifier: `slot:${slot.slotId}`
+      });
+    }
+  }
+  if (!connections || !specs) {
+    return { resolved, missing };
+  }
+  const connectionById = new Map;
+  for (const connection of connections) {
+    connectionById.set(connection.meta.id, connection);
+  }
+  for (const slot of slotList) {
+    const slotBindings = bindingsBySlot.get(slot.slotId) ?? [];
+    if (slotBindings.length === 0)
+      continue;
+    const orderedBindings = [...slotBindings].sort((a, b) => {
+      const aPriority = a.priority ?? Number.MAX_SAFE_INTEGER;
+      const bPriority = b.priority ?? Number.MAX_SAFE_INTEGER;
+      if (aPriority === bPriority)
+        return 0;
+      return aPriority < bPriority ? -1 : 1;
+    });
+    let slotResolved = false;
+    for (const binding of orderedBindings) {
+      const connection = connectionById.get(binding.connectionId);
+      if (!connection) {
+        recordMissing({
+          type: "integrationConnection",
+          identifier: `connection:${binding.connectionId}`
+        });
+        continue;
+      }
+      const spec = specs.get(connection.meta.integrationKey, connection.meta.integrationVersion);
+      if (!spec) {
+        recordMissing({
+          type: "integrationSpec",
+          identifier: `spec:${connection.meta.integrationKey}.v${connection.meta.integrationVersion}`
+        });
+        continue;
+      }
+      if (spec.meta.category !== slot.requiredCategory) {
+        recordMissing({
+          type: "integrationSpec",
+          identifier: `spec:${spec.meta.key}.category`
+        });
+        continue;
+      }
+      if (!spec.supportedModes.includes(connection.ownershipMode)) {
+        recordMissing({
+          type: "integrationSpec",
+          identifier: `spec:${spec.meta.key}.mode:${connection.ownershipMode}`
+        });
+        continue;
+      }
+      if (slot.allowedModes && slot.allowedModes.length > 0 && !slot.allowedModes.includes(connection.ownershipMode)) {
+        recordMissing({
+          type: "integrationConnection",
+          identifier: `connection:${connection.meta.id}:mode`
+        });
+        continue;
+      }
+      if (slot.requiredCapabilities && !slot.requiredCapabilities.every((requirement) => integrationProvidesCapability(spec, requirement))) {
+        recordMissing({
+          type: "integrationSpec",
+          identifier: `spec:${spec.meta.key}.capabilities`
+        });
+        continue;
+      }
+      resolved.push({
+        slot,
+        binding,
+        connection,
+        spec
+      });
+      slotResolved = true;
+      break;
+    }
+    if (!slotResolved && slot.required) {
+      recordMissing({
+        type: "integrationSlot",
+        identifier: `slot:${slot.slotId}`
+      });
+    }
+  }
+  return { resolved, missing };
+}
+function integrationProvidesCapability(spec, required) {
+  return spec.capabilities.provides.some((capability) => {
+    if (capability.key !== required.key)
+      return false;
+    if (required.version == null)
+      return true;
+    return capability.version === required.version;
+  });
+}
+function resolveKnowledgeBindings(bindings, spaces, sources) {
+  if (!bindings?.length || !spaces)
+    return [];
+  const sourceList = sources ?? [];
+  return bindings.map((binding) => {
+    const space = spaces.get(binding.spaceKey, binding.spaceVersion);
+    if (!space)
+      return null;
+    const relevantSources = sourceList.filter((source) => {
+      if (source.meta.spaceKey !== binding.spaceKey)
+        return false;
+      if (binding.spaceVersion != null) {
+        return source.meta.spaceVersion === binding.spaceVersion;
+      }
+      return true;
+    });
+    return {
+      binding,
+      space,
+      sources: relevantSources
+    };
+  }).filter((entry) => entry !== null);
+}
+function collectMissingKnowledge(bindings, spaces, sources) {
+  if (!bindings.length || !spaces)
+    return [];
+  const missing = [];
+  const sourceList = sources ?? [];
+  for (const binding of bindings) {
+    const space = spaces.get(binding.spaceKey, binding.spaceVersion);
+    if (!space) {
+      missing.push({
+        type: "knowledgeSpace",
+        identifier: binding.spaceVersion ? `${binding.spaceKey}@${binding.spaceVersion}` : binding.spaceKey
+      });
+      continue;
+    }
+    if (sources) {
+      const relevantSources = sourceList.filter((source) => {
+        if (source.meta.spaceKey !== binding.spaceKey)
+          return false;
+        if (binding.spaceVersion != null) {
+          return source.meta.spaceVersion === binding.spaceVersion;
+        }
+        return true;
+      });
+      if (relevantSources.length === 0) {
+        missing.push({
+          type: "knowledgeSource",
+          identifier: binding.spaceVersion ? `${binding.spaceKey}@${binding.spaceVersion}` : binding.spaceKey
+        });
+      }
+    }
+  }
+  return missing;
+}
+function resolveCapabilityRefs(refs, registry, missing) {
+  if (!registry) {
+    if (refs.length > 0) {
+      for (const ref of refs) {
+        missing.push({
+          type: "capability",
+          identifier: capabilityKey(ref)
+        });
+      }
+    }
+    return [];
+  }
+  const resolved = [];
+  for (const ref of refs) {
+    const spec = registry.get(ref.key, ref.version);
+    if (!spec) {
+      missing.push({
+        type: "capability",
+        identifier: capabilityKey(ref)
+      });
+      continue;
+    }
+    resolved.push(spec);
+  }
+  return resolved;
+}
+function resolveFeatureRefs(refs, registry, missing) {
+  if (!registry) {
+    if (refs.length > 0) {
+      for (const ref of refs) {
+        missing.push({ type: "feature", identifier: ref.key });
+      }
+    }
+    return [];
+  }
+  const resolved = [];
+  for (const ref of refs) {
+    const spec = registry.get(ref.key);
+    if (!spec) {
+      missing.push({ type: "feature", identifier: ref.key });
+      continue;
+    }
+    resolved.push(spec);
+  }
+  return resolved;
+}
+function resolvePointerRecord(record, registry, type, missing) {
+  if (!registry) {
+    if (Object.keys(record).length > 0) {
+      for (const [slot, pointer] of Object.entries(record)) {
+        missing.push({
+          type,
+          identifier: `${slot} -> ${specPointerKey(pointer)}`
+        });
+      }
+    }
+    return {};
+  }
+  const resolved = {};
+  for (const [slot, pointer] of Object.entries(record)) {
+    const spec = registry.get(pointer.key, pointer.version);
+    if (!spec) {
+      missing.push({
+        type,
+        identifier: `${slot} -> ${specPointerKey(pointer)}`
+      });
+      continue;
+    }
+    resolved[slot] = spec;
+  }
+  return resolved;
+}
+function resolvePolicies(policies, registry, missing) {
+  if (!registry) {
+    if (policies.length > 0) {
+      for (const policy of policies) {
+        missing.push({
+          type: "policy",
+          identifier: policyKey(policy)
+        });
+      }
+    }
+    return [];
+  }
+  const resolved = [];
+  for (const policy of policies) {
+    const spec = registry.get(policy.key, policy.version);
+    if (!spec) {
+      missing.push({
+        type: "policy",
+        identifier: policyKey(policy)
+      });
+      continue;
+    }
+    resolved.push(spec);
+  }
+  return resolved;
+}
+function resolveThemeBinding(binding, registry) {
+  const themeMissing = [];
+  if (!binding) {
+    return { theme: undefined, fallbacks: [], themeMissing };
+  }
+  if (!registry) {
+    themeMissing.push({
+      type: "theme",
+      identifier: `${binding.primary.key}.v${binding.primary.version}`
+    });
+    for (const fallback of binding.fallbacks ?? []) {
+      themeMissing.push({
+        type: "theme",
+        identifier: `${fallback.key}.v${fallback.version}`
+      });
+    }
+    return { theme: undefined, fallbacks: [], themeMissing };
+  }
+  const theme = registry.get(binding.primary.key, binding.primary.version);
+  if (!theme) {
+    themeMissing.push({
+      type: "theme",
+      identifier: `${binding.primary.key}.v${binding.primary.version}`
+    });
+  }
+  const fallbacks = [];
+  for (const fallback of binding.fallbacks ?? []) {
+    const spec = registry.get(fallback.key, fallback.version);
+    if (!spec) {
+      themeMissing.push({
+        type: "theme",
+        identifier: `${fallback.key}.v${fallback.version}`
+      });
+      continue;
+    }
+    fallbacks.push(spec);
+  }
+  return { theme: theme ?? undefined, fallbacks, themeMissing };
+}
+function resolveTelemetryBinding(binding, registry) {
+  const telemetryMissing = [];
+  if (!binding?.spec) {
+    return { telemetry: undefined, telemetryMissing };
+  }
+  if (!registry) {
+    telemetryMissing.push({
+      type: "telemetry",
+      identifier: specPointerKey(binding.spec)
+    });
+    return { telemetry: undefined, telemetryMissing };
+  }
+  const telemetry = registry.get(binding.spec.key, binding.spec.version);
+  if (!telemetry) {
+    telemetryMissing.push({
+      type: "telemetry",
+      identifier: specPointerKey(binding.spec)
+    });
+  }
+  return { telemetry: telemetry ?? undefined, telemetryMissing };
+}
+function resolveExperimentsSpecs(experiments, registry, missing) {
+  const resolveList = (refs) => {
+    if (refs.length === 0)
+      return [];
+    if (!registry) {
+      for (const ref of refs) {
+        missing.push({
+          type: "experiment",
+          identifier: experimentKey(ref)
+        });
+      }
+      return [];
+    }
+    const resolved = [];
+    for (const ref of refs) {
+      const spec = registry.get(ref.key, ref.version);
+      if (!spec) {
+        missing.push({
+          type: "experiment",
+          identifier: experimentKey(ref)
+        });
+        continue;
+      }
+      resolved.push(spec);
+    }
+    return resolved;
+  };
+  return {
+    active: resolveList(experiments.active),
+    paused: resolveList(experiments.paused)
+  };
+}
+function capabilityKey(ref) {
+  return `${ref.key}${ref.version ? `.v${ref.version}` : ""}`;
+}
+function featureKey(ref) {
+  return ref.key;
+}
+function specPointerKey(pointer) {
+  return `${pointer.key}${pointer.version ? `.v${pointer.version}` : ""}`;
+}
+function policyKey(ref) {
+  return `${ref.key}${ref.version ? `.v${ref.version}` : ""}`;
+}
+function experimentKey(ref) {
+  return `${ref.key}${ref.version ? `.v${ref.version}` : ""}`;
+}
+function dedupeRefs(refs, keyFn) {
+  const map = new Map;
+  for (const ref of refs) {
+    map.set(keyFn(ref), ref);
+  }
+  return [...map.values()];
+}
+function dedupeStrings(values) {
+  return [...new Set(values)];
+}
+export {
+  resolveAppConfig,
+  composeAppConfig
+};