@uniformdev/context 20.6.1 → 20.6.2-alpha.11

package/dist/index.mjs

@@ -516,7 +516,7 @@ var GroupCriteriaEvaluator = class {
 _evaluators = new WeakMap();
 
 // src/placement/criteria/evaluateVariantMatch.ts
-function evaluateVariantMatch(variantId, match, vec, onLogMessage) {
+function evaluateVariantMatch(variantId, match, vec, onLogMessage, quirks) {
   onLogMessage == null ? void 0 : onLogMessage(["info", 301, "GROUP", { id: variantId, op: match == null ? void 0 : match.op }]);
   let result;
   try {
@@ -524,9 +524,9 @@ function evaluateVariantMatch(variantId, match, vec, onLogMessage) {
       onLogMessage == null ? void 0 : onLogMessage(["info", 302, { matched: true, description: "default variation" }]);
       result = true;
     } else if (!match.op || match.op === "&") {
-      result = match.crit.every((c) => evaluateDimensionMatch(c, vec, onLogMessage));
+      result = match.crit.every((c) => evaluateMatch(c, vec, quirks != null ? quirks : {}, onLogMessage));
     } else {
-      result = match.crit.some((c) => evaluateDimensionMatch(c, vec, onLogMessage));
+      result = match.crit.some((c) => evaluateMatch(c, vec, quirks != null ? quirks : {}, onLogMessage));
     }
     onLogMessage == null ? void 0 : onLogMessage(["info", 303, result]);
   } finally {
@@ -534,9 +534,16 @@ function evaluateVariantMatch(variantId, match, vec, onLogMessage) {
   }
   return result;
 }
+function evaluateMatch(crit, vec, quirks, onLogMessage) {
+  if ("t" in crit && crit.t === "q") {
+    return evaluateQuirkMatch(crit, quirks, onLogMessage);
+  } else {
+    return evaluateDimensionMatch(crit, vec, onLogMessage);
+  }
+}
 function evaluateDimensionMatch(crit, vec, onLogMessage) {
   var _a, _b;
-  const { op, l: lhs } = crit;
+  const { l: lhs, op } = crit;
   const lhsScore = (_a = vec[lhs]) != null ? _a : 0;
   if (op === "^") {
     const [cat] = lhs.split(ENR_SEPARATOR);
@@ -603,33 +610,65 @@ function evaluateDimensionMatch(crit, vec, onLogMessage) {
   }
   if (op === ">") {
     const result = lhsScore > rhsScore;
-    explain(onLogMessage, result, crit, lhsScore, rhsScore);
+    explainScore(onLogMessage, result, crit, lhsScore, rhsScore);
     return result;
   } else if (op === ">=") {
     const result = lhsScore >= rhsScore;
-    explain(onLogMessage, result, crit, lhsScore, rhsScore);
+    explainScore(onLogMessage, result, crit, lhsScore, rhsScore);
     return result;
   } else if (op === "<") {
     const result = lhsScore < rhsScore;
-    explain(onLogMessage, result, crit, lhsScore, rhsScore);
+    explainScore(onLogMessage, result, crit, lhsScore, rhsScore);
     return result;
   } else if (op === "<=") {
     const result = lhsScore <= rhsScore;
-    explain(onLogMessage, result, crit, lhsScore, rhsScore);
+    explainScore(onLogMessage, result, crit, lhsScore, rhsScore);
     return result;
   } else if (op === "=") {
     const result = lhsScore === rhsScore;
-    explain(onLogMessage, result, crit, lhsScore, rhsScore);
+    explainScore(onLogMessage, result, crit, lhsScore, rhsScore);
     return result;
   } else if (op === "!=") {
     const result = lhsScore !== rhsScore;
-    explain(onLogMessage, result, crit, lhsScore, rhsScore);
+    explainScore(onLogMessage, result, crit, lhsScore, rhsScore);
     return result;
   } else {
-    throw new Error(`Unknown op: ${op}`);
+    onLogMessage == null ? void 0 : onLogMessage([
+      "error",
+      302,
+      {
+        matched: false,
+        description: `${crit.l} ${crit.op} ${crit.rDim ? `${crit.rDim}` : crit.r}: Unknown op ${crit.op}.`
+      }
+    ]);
+    return false;
+  }
+}
+function evaluateQuirkMatch(crit, quirks, onLogMessage) {
+  var _a;
+  const { l: targetQuirk, op, r: targetValue } = crit;
+  const targetQuirkValue = (_a = quirks[targetQuirk]) != null ? _a : "";
+  if (op === "=") {
+    const result = targetQuirkValue === targetValue;
+    explainQuirk(onLogMessage, result, crit, targetQuirkValue);
+    return result;
+  } else if (op === "!=") {
+    const result = targetQuirkValue !== targetValue;
+    explainQuirk(onLogMessage, result, crit, targetQuirkValue);
+    return result;
+  } else {
+    onLogMessage == null ? void 0 : onLogMessage([
+      "error",
+      302,
+      {
+        matched: false,
+        description: `Quirk ${crit.l} ${crit.op} ${crit.r}: Unknown quirk op ${crit.op}.`
+      }
+    ]);
+    return false;
   }
 }
-function explain(onLogMessage, result, crit, lhsScore, rhsScore) {
+function explainScore(onLogMessage, result, crit, lhsScore, rhsScore) {
   onLogMessage == null ? void 0 : onLogMessage([
     "info",
     302,
@@ -639,9 +678,20 @@ function explain(onLogMessage, result, crit, lhsScore, rhsScore) {
     }
   ]);
 }
+function explainQuirk(onLogMessage, result, crit, lhs) {
+  onLogMessage == null ? void 0 : onLogMessage([
+    "info",
+    302,
+    {
+      matched: result,
+      description: `Quirk ${crit.l}[${lhs}] ${crit.op} ${crit.r}`
+    }
+  ]);
+}
 
-// src/placement/personalize.ts
-function personalizeVariations({
+// src/placement/topDownCriteriaPersonalizationSelectionAlgorithm.ts
+var TOP_DOWN_CRITERIA_PERSONALIZATION_ALGORITHM = "default";
+function topDownCriteriaPersonalizationSelectionAlgorithm({
   name,
   context,
   variations,
@@ -651,27 +701,35 @@ function personalizeVariations({
   var _a, _b, _c;
   onLogMessage == null ? void 0 : onLogMessage(["info", 300, "GROUP", { name, take }]);
   try {
-    const variantMatches = [];
-    const defaultVariants = [];
-    const needsConsent = context.requireConsentForPersonalization;
-    const canEvaluate = !needsConsent || context.storage.data.consent;
-    for (const variant of variations) {
-      if ((_a = variant.pz) == null ? void 0 : _a.crit.length) {
-        if (canEvaluate && variantMatches.length !== take && evaluateVariantMatch(variant.id, variant.pz, context.scores, onLogMessage)) {
-          variantMatches.push(variant);
+    const variationMatches = [];
+    const defaultVariations = [];
+    const needsConsentToPersonalize = context.requireConsentForPersonalization;
+    const personalizationAllowed = !needsConsentToPersonalize || context.storage.data.consent;
+    for (const variation of variations) {
+      const isInvalidFormat = variation.pz && (typeof variation.pz !== "object" || variation.pz === null || !("crit" in variation.pz && Array.isArray(variation.pz.crit)));
+      let validVariation;
+      if (isInvalidFormat) {
+        const { pz, ...validParts } = variation;
+        validVariation = validParts;
+      } else {
+        validVariation = variation;
+      }
+      if ((_a = validVariation.pz) == null ? void 0 : _a.crit.length) {
+        if (personalizationAllowed && variationMatches.length !== take && evaluateVariantMatch(variation.id, validVariation.pz, context.scores, onLogMessage, context.quirks)) {
+          variationMatches.push(validVariation);
         }
       } else {
-        defaultVariants.push(variant);
+        defaultVariations.push(validVariation);
       }
     }
     const result = [];
-    for (let i = 0; i < variantMatches.length; i++) {
+    for (let i = 0; i < variationMatches.length; i++) {
       let isControl = (_b = context.storage.data.controlGroup) != null ? _b : false;
-      const variant = variantMatches[i];
-      if (!isControl && typeof ((_c = variant.pz) == null ? void 0 : _c.control) === "number") {
+      const variation = variationMatches[i];
+      if (!isControl && typeof ((_c = variation.pz) == null ? void 0 : _c.control) === "number") {
         isControl = context.getPersonalizeVariantControl(name, i);
         if (typeof isControl === "undefined") {
-          isControl = rollForControlGroup(variant.pz.control);
+          isControl = rollForControlGroup(variation.pz.control);
           context.storage.updateData([
             {
               type: "setpersonalizecontrol",
@@ -684,13 +742,13 @@ function personalizeVariations({
           ]);
         }
       }
-      let variantToAdd = variant;
+      let variantToAdd = variation;
       if (isControl) {
-        const defaultReplacement = defaultVariants.shift();
+        const defaultReplacement = defaultVariations.shift();
         if (defaultReplacement) {
           variantToAdd = {
             ...defaultReplacement,
-            id: variant.id
+            id: variation.id
           };
         } else {
           variantToAdd = void 0;
@@ -700,8 +758,8 @@ function personalizeVariations({
         result.push({ ...variantToAdd, control: isControl });
       }
     }
-    while (result.length < take && defaultVariants.length) {
-      result.push({ ...defaultVariants.shift(), control: false });
+    while (result.length < take && defaultVariations.length) {
+      result.push({ ...defaultVariations.shift(), control: false });
     }
     const personalized = result.some((v) => {
       var _a2;
@@ -716,7 +774,86 @@ function personalizeVariations({
   }
 }
 
-// src/placement/test.ts
+// src/placement/personalizeVariations.ts
+function personalizeVariations(options) {
+  return topDownCriteriaPersonalizationSelectionAlgorithm(options);
+}
+
+// src/placement/strongestScorePersonalizationSelectionAlgorithm.ts
+var STRONGEST_SCORE_PERSONALIZATION_ALGORITHM = "ssc";
+function strongestScorePersonalizationSelectionAlgorithm({
+  name,
+  context,
+  variations,
+  take = 1,
+  onLogMessage
+}) {
+  var _a, _b;
+  onLogMessage == null ? void 0 : onLogMessage(["info", 300, "GROUP", { name, take }]);
+  try {
+    const variationMatches = [];
+    const defaultVariations = [];
+    const needsConsentToPersonalize = context.requireConsentForPersonalization;
+    const isInGlobalControlGroup = (_a = context.storage.data.controlGroup) != null ? _a : false;
+    const personalizationAllowed = !needsConsentToPersonalize || context.storage.data.consent;
+    for (const variation of variations) {
+      const isInvalidFormat = variation.pz && typeof variation.pz !== "object";
+      let validVariation;
+      if (isInvalidFormat) {
+        const { pz, ...validParts } = variation;
+        validVariation = validParts;
+      } else {
+        validVariation = variation;
+      }
+      if ((_b = validVariation.pz) == null ? void 0 : _b.dim) {
+        if (!personalizationAllowed) {
+          continue;
+        }
+        const score = context.scores[validVariation.pz.dim];
+        if (score === void 0 || score <= 0) {
+          continue;
+        }
+        variationMatches.push({ variation: validVariation, score });
+      } else {
+        defaultVariations.push(validVariation);
+      }
+    }
+    variationMatches.sort((a, b) => b.score - a.score);
+    const result = [];
+    for (let i = 0; i < variationMatches.length; i++) {
+      const variationMatch = variationMatches[i];
+      let variantToAdd = variationMatch.variation;
+      if (i >= take) {
+        continue;
+      }
+      if (isInGlobalControlGroup) {
+        const defaultReplacement = defaultVariations.shift();
+        if (defaultReplacement) {
+          variantToAdd = {
+            ...defaultReplacement,
+            id: variationMatch.variation.id
+          };
+        } else {
+          variantToAdd = void 0;
+        }
+      }
+      if (variantToAdd) {
+        result.push({ ...variantToAdd, control: isInGlobalControlGroup });
+      }
+    }
+    while (result.length < take && defaultVariations.length) {
+      result.push({ ...defaultVariations.shift(), control: false });
+    }
+    return {
+      personalized: variationMatches.length > 0 && !isInGlobalControlGroup,
+      variations: result
+    };
+  } finally {
+    onLogMessage == null ? void 0 : onLogMessage(["info", 300, "ENDGROUP"]);
+  }
+}
+
+// src/placement/normalizeVariationDistributions.ts
 var normalizeVariationDistributions = (variations) => {
   const { values, total, missingDistribution } = variations.reduce(
     (previous, current) => {
@@ -735,7 +872,12 @@ var normalizeVariationDistributions = (variations) => {
     }
   );
   if (total > 100) {
-    throw new Error(`Total distribution ${total} is over the maximum 100.`);
+    const autoScaleFactor = 100 / total;
+    values.forEach((value, index) => {
+      if (typeof value === "number") {
+        values[index] = value * autoScaleFactor;
+      }
+    });
   } else if (total < 100) {
     const remainder = 100 - total;
     const missingSlice = remainder / missingDistribution;
@@ -747,6 +889,8 @@ var normalizeVariationDistributions = (variations) => {
   }
   return values;
 };
+
+// src/placement/testVariations.ts
 var testVariations = ({
   name,
   context,
@@ -1513,11 +1657,12 @@ import { dequal as dequal5 } from "dequal/lite";
 import mitt3 from "mitt";
 var CONTEXTUAL_EDITING_TEST_NAME = "contextual_editing_test";
 var CONTEXTUAL_EDITING_TEST_SELECTED_VARIANT_ID = "contextual_editing_test_selected_variant";
-var _serverTransitionState, _scores, _state, _pzCache, _plugins, _commands, _requireConsentForPersonalization, _mitt3, _Context_instances, emitTest_fn, updateGoals_fn, updateComputedScores_fn, calculateScores_fn;
+var _personalizationSelectionAlgorithms, _serverTransitionState, _scores, _state, _pzCache, _plugins, _commands, _requireConsentForPersonalization, _mitt3, _Context_instances, emitTest_fn, updateGoals_fn, updateComputedScores_fn, calculateScores_fn;
 var Context = class {
   constructor(options) {
     __privateAdd(this, _Context_instances);
     __publicField(this, "manifest");
+    __privateAdd(this, _personalizationSelectionAlgorithms);
     __privateAdd(this, _serverTransitionState);
     __privateAdd(this, _scores, {});
     __privateAdd(this, _state);
@@ -1534,7 +1679,7 @@ var Context = class {
       off: __privateGet(this, _mitt3).off
     });
     __publicField(this, "storage");
-    var _a, _b;
+    var _a, _b, _c;
     const { manifest, ...storageOptions } = options;
     __privateSet(this, _state, {});
     __privateSet(this, _plugins, options.plugins);
@@ -1542,7 +1687,20 @@ var Context = class {
     if (typeof options.transitionStore !== "undefined") {
       __privateSet(this, _commands, []);
     }
+    __privateSet(this, _personalizationSelectionAlgorithms, {
+      [TOP_DOWN_CRITERIA_PERSONALIZATION_ALGORITHM]: topDownCriteriaPersonalizationSelectionAlgorithm,
+      [STRONGEST_SCORE_PERSONALIZATION_ALGORITHM]: strongestScorePersonalizationSelectionAlgorithm
+    });
     (_a = __privateGet(this, _plugins)) == null ? void 0 : _a.forEach((plugin) => {
+      if (!plugin.personalizationSelectionAlgorithms) {
+        return;
+      }
+      __privateSet(this, _personalizationSelectionAlgorithms, {
+        ...__privateGet(this, _personalizationSelectionAlgorithms),
+        ...plugin.personalizationSelectionAlgorithms
+      });
+    });
+    (_b = __privateGet(this, _plugins)) == null ? void 0 : _b.forEach((plugin) => {
       if (!plugin.logDrain) {
         return;
       }
@@ -1593,7 +1751,7 @@ var Context = class {
         __privateGet(this, _mitt3).emit("quirksUpdated", quirks.quirks);
         __privateGet(this, _mitt3).emit("log", ["info", 4, quirks.quirks]);
       });
-      (_b = __privateGet(this, _plugins)) == null ? void 0 : _b.forEach((plugin) => {
+      (_c = __privateGet(this, _plugins)) == null ? void 0 : _c.forEach((plugin) => {
         if (!plugin.init) {
           return;
         }
@@ -1843,7 +2001,17 @@ var Context = class {
   }
   /** Executes a personalized placement with a given set of variants */
   personalize(options) {
-    const value = personalizeVariations({
+    var _a;
+    const algorithmName = (_a = options.algorithm) != null ? _a : TOP_DOWN_CRITERIA_PERSONALIZATION_ALGORITHM;
+    const algorithm = __privateGet(this, _personalizationSelectionAlgorithms)[algorithmName];
+    if (!algorithm) {
+      __privateGet(this, _mitt3).emit("log", ["warn", 304, { algorithm: algorithmName }]);
+      return {
+        personalized: false,
+        variations: []
+      };
+    }
+    const value = algorithm({
       ...options,
       context: this,
       onLogMessage: (message) => __privateGet(this, _mitt3).emit("log", message)
@@ -1917,6 +2085,7 @@ var Context = class {
     __privateGet(this, _mitt3).emit("personalizationResult", event);
   }
 };
+_personalizationSelectionAlgorithms = new WeakMap();
 _serverTransitionState = new WeakMap();
 _scores = new WeakMap();
 _state = new WeakMap();
@@ -2512,6 +2681,10 @@ var messageContent = {
   301: ({ id, op }) => ["personalization", `testing variation ${id} (${op === "|" ? "OR" : "AND"})`],
   302: ({ matched, description }) => ["personalization", `${description} is ${matched}`],
   303: (selected) => ["personalization", selected ? "selected variation" : "did not select variation"],
+  304: ({ algorithm }) => [
+    "personalization",
+    `personalization selection algorithm '${algorithm}' not found. Hiding placement.`
+  ],
   // TESTING
   400: (name) => ["testing", `executing A/B test '${name}'`],
   401: (testName) => ["testing", `${testName} is not registered in the manifest; it will not be run.`],
@@ -2616,7 +2789,9 @@ export {
   PAIR_SEP,
   QUIRK_SEP,
   SERVER_STATE_ID,
+  STRONGEST_SCORE_PERSONALIZATION_ALGORITHM,
   ScriptType,
+  TOP_DOWN_CRITERIA_PERSONALIZATION_ALGORITHM,
   TYPE_SEP,
   TransitionDataStore,
   UNIFORM_DEFAULT_COOKIE_NAME,
@@ -2658,5 +2833,7 @@ export {
   serializePersonalizeVariants,
   serializeQuickConnect,
   serializeQuirks,
-  testVariations
+  strongestScorePersonalizationSelectionAlgorithm,
+  testVariations,
+  topDownCriteriaPersonalizationSelectionAlgorithm
 };

package/dist/{types-EJl31yuP.d.mts → types-CzIkFCDD.d.mts}

@@ -859,6 +859,10 @@ type LogMessages = {
     }>;
     /** Final result for a personalized variation */
     303: MessageFunc<boolean>;
+    /** Personalization algorithm not found */
+    304: MessageFunc<{
+        algorithm: string;
+    }>;
     /** A/B test placement executing */
     400: MessageFunc<string>;
     /** A/B Test definition did not exist */
@@ -898,23 +902,34 @@ type LogMessageSingle<TID extends keyof LogMessages = keyof LogMessages> = [
 type LogMessageGroup<TID extends keyof LogMessages = keyof LogMessages> = [severity: Severity, id: TID, group: 'GROUP', ...args: Parameters<LogMessages[TID]>] | [severity: Severity, id: TID, group: 'ENDGROUP'];
 type LogDrain = (message: LogMessage) => void;
 
-type VariantMatchCriteria = {
+/** Data for a personalization variation using the top-down criteria selection algorithm */
+interface VariantMatchCriteria extends VariationMatchMetadata {
     /**
      * Operation for match criteria
      *
      * @defaultValue `&`
      */
     op?: '&' | '|';
-    crit: DimensionMatch[];
-    /**
-     * Name of the variant for analytics tracking.
-     */
-    name?: string;
+    crit: Array<DimensionMatch | QuirkMatch>;
     /**
      * Control group percentage for the variant.
      */
     control?: number;
-};
+}
+/** Data for a personalization variation using the TODO selection algorithm */
+interface VariationMatchDimensionCriteria extends VariationMatchMetadata {
+    /** The dimension this content is relevant to */
+    dim: string | undefined;
+}
+/** Data that must exist on a personalization variation regardless of selection algorithm */
+interface VariationMatchMetadata {
+    /**
+     * Name of the variation for analytics tracking.
+     * NOTE: name is optional for backwards compatibility, but it is HIGHLY recommended to specify a name
+     * as the default fallback is not helpfully named and is reliant on the order of the variations array.
+     */
+    name?: string;
+}
 type DimensionMatch = {
     /**
      * Left hand side of the match expression (name of dimension in score vector)
@@ -953,17 +968,48 @@ type DimensionMatch = {
      */
     rDim?: string;
 };
+type QuirkMatch = {
+    /**
+     * Type of match expression; 'q' discriminates quirk matches from dimension matches
+     */
+    t: 'q';
+    /**
+     * Left hand side of the match expression (name of quirk)
+     * NOTE: if the quirk is not present
+     */
+    l: string;
+    /**
+     * Operator of the match expression
+     * Comparison operators:
+     * =: `l` is equal to the right hand side expression
+     * !=: `l` is not equal to the right hand side expression
+     */
+    op: '=' | '!=';
+    /**
+     * Right hand side of the match expression
+     * This value is treated as a constant value, if it is present. If it's a string, it is parsed to an integer.
+     * To reference another score dimension as the RHS, use the `rDim` property instead.
+     * `r` and `rDim` are mutually exclusive; if both are specified, then `rDim` wins.
+     */
+    r: string;
+    /**
+     * Only here to maintain object compatibility with DimensionMatch.
+     * Completely ignored.
+     * @deprecated this is not used with QuirkMatch.
+     */
+    rDim?: string;
+};
 
 /** Content that is tagged for adding enrichment score when triggered by behavior (i.e. being shown that content) */
 type BehaviorTag = {
     beh?: EnrichmentData[];
 };
 /** Defines the shape of a personalized content variant */
-type PersonalizedVariant = {
+type PersonalizedVariant<TCriteria = VariantMatchCriteria> = {
     /** A unique identifier for this variation */
     id: string;
     /** Match criteria for this variation */
-    pz?: VariantMatchCriteria;
+    pz?: TCriteria;
 };
 /** The result of computing personalized content from variations */
 type PersonalizedResult<TVariant> = {
@@ -971,6 +1017,7 @@ type PersonalizedResult<TVariant> = {
     personalized: boolean;
     /** Matching variations */
     variations: Array<TVariant & {
+        /** Whether the visitor is part of this variation's local control group (also true if part of global control group) */
         control: boolean;
     }>;
 };
@@ -995,19 +1042,28 @@ type TestResult<TVariant> = {
      */
     variantAssigned: boolean;
 };
-
-type PersonalizeOptions<TVariant> = {
+interface PersonalizeOptions<TVariant> {
+    /** Name of placement (sent to analytics) */
+    name: string;
+    /** Possible variations to place  */
+    variations: Iterable<TVariant>;
+    /** Maximum number of variants to place (default: 1) */
+    take?: number;
+    /** Name of the personalization selection algorithm to use. Defaults to top-down criteria when not specified. */
+    algorithm?: string;
+}
+interface PersonalizationSelectionAlgorithmOptions<TCriteria, TVariant extends PersonalizedVariant<TCriteria> = PersonalizedVariant<TCriteria>> {
     /** Name of placement (sent to analytics) */
     name: string;
-    /** Possible variants to place  */
+    /** Possible variations to place  */
     variations: Iterable<TVariant>;
     /** Maximum number of variants to place (default: 1) */
     take?: number;
+    /** Callback for logging messages */
     onLogMessage?: (message: LogMessage) => void;
-};
-declare function personalizeVariations<TVariant extends PersonalizedVariant>({ name, context, variations, take, onLogMessage, }: PersonalizeOptions<TVariant> & {
+    /** Context instance */
     context: Context;
-}): PersonalizedResult<TVariant>;
+}
 
 type TestOptions<TVariant extends TestVariant> = {
     /** The name of the test that is being run, must be included in the manifest. */
@@ -1022,18 +1078,31 @@ declare const testVariations: <TVariant extends TestVariant>({ name, context, va
 
 declare const CONTEXTUAL_EDITING_TEST_NAME = "contextual_editing_test";
 declare const CONTEXTUAL_EDITING_TEST_SELECTED_VARIANT_ID = "contextual_editing_test_selected_variant";
+type PersonalizationSelectionAlgorithm<TCriteria = unknown> = (options: PersonalizationSelectionAlgorithmOptions<TCriteria>) => PersonalizedResult<PersonalizedVariant<TCriteria>>;
+type PersonalizationSelectionAlgorithms<TCriteria = unknown> = Record<string, PersonalizationSelectionAlgorithm<TCriteria>>;
 /**
  * Defines a plugin for Uniform Context.
  * The plugin should attach event handlers in its creation function.
  * @returns A function that detaches any event handlers when called
  */
 type ContextPlugin = {
+    /** Defines a log drain for the plugin, which all log messages are sent to */
     logDrain?: LogDrain;
+    /** Initializes the plugin (attach event handlers here if needed) */
     init?: (context: Context) => () => void;
+    /** Plugin-specific actions to perform when a user is forgotten */
     forget?: () => Promise<void> | void;
+    /** Plugin-specific actions to perform when the visitor context is updated */
     update?: (newData: Partial<ContextState>) => Promise<void> | void;
+    /**
+     * Allows the plugin to register named personalization selection algorithms
+     *
+     * Important: the `default` and `strongestMatch` algorithms are automatically registered.
+     * We strongly advise against replacing these.
+     */
+    personalizationSelectionAlgorithms?: PersonalizationSelectionAlgorithms<any>;
 };
-type ContextOptions = {
+interface ContextOptions extends Omit<VisitorDataStoreOptions, 'manifest' | 'onServerTransitionScoresReceived'> {
     /** The Context Manifest to load (from the Context API) */
     manifest: ManifestV2;
     /**
@@ -1050,16 +1119,19 @@ type ContextOptions = {
      * `true`: personalization is not run at all unless storage consent is given
      */
     requireConsentForPersonalization?: boolean;
-} & Omit<VisitorDataStoreOptions, 'manifest' | 'onServerTransitionScoresReceived'>;
+}
+type PersonalizationEventVariantId = {
+    /** The variant ID that was selected */
+    id: string;
+    /** Whether the visitor is part of this variant's local control group (also true if part of global control group) */
+    control: boolean;
+};
 /** Emitted when a personalization runs */
 type PersonalizationEvent = {
     /** Name of the personalized placement */
     name: string;
     /** Selected variant ID(s) */
-    variantIds: {
-        id: string;
-        control: boolean;
-    }[];
+    variantIds: PersonalizationEventVariantId[];
     /** Whether the user was part of the control group (and did not receive any personalization) */
     control: boolean | undefined;
     /**
@@ -1113,7 +1185,7 @@ interface ContextInstance {
     setTestVariantId(testName: string, variantId: string): void;
     log(...message: LogMessage): void;
     test<TVariant extends TestVariant>(options: TestOptions<TVariant>): TestResult<TVariant>;
-    personalize<TVariant extends PersonalizedVariant>(options: PersonalizeOptions<TVariant>): PersonalizedResult<TVariant>;
+    personalize<TVariant extends PersonalizedVariant<any>>(options: PersonalizeOptions<TVariant>): PersonalizedResult<TVariant>;
     forget(fromAllDevices: boolean): Promise<void>;
     getServerToClientTransitionState(): ServerToClientTransitionState;
     readonly manifest: ManifestInstance;
@@ -1178,7 +1250,7 @@ declare class Context implements ContextInstance {
     /** Executes an A/B test with a given set of variants, showing the visitor's assigned variant (or selecting one to assign, if none is set yet) */
     test<TVariant extends TestVariant>(options: TestOptions<TVariant>): TestResult<TVariant>;
     /** Executes a personalized placement with a given set of variants */
-    personalize<TVariant extends PersonalizedVariant>(options: PersonalizeOptions<TVariant>): PersonalizedResult<TVariant>;
+    personalize<TVariant extends PersonalizedVariant<any>>(options: PersonalizeOptions<TVariant>): PersonalizedResult<TVariant>;
     /**
      * Forgets the visitor's data and resets the Context to its initial state.
      * @param fromAllDevices for an identified user, whether to delete all their data (for the entire account) - true, or data for this device (sign out) - false
@@ -1265,4 +1337,4 @@ declare global {
     }
 }
 
-export { type AggregateDimensionInput as $, type AggregateDimension as A, type MessageFunc as B, type ContextPlugin as C, type DecayFunction as D, type LogMessageSingle as E, type LogMessageGroup as F, ManifestInstance as G, GroupCriteriaEvaluator as H, type CriteriaEvaluatorResult as I, type CriteriaEvaluatorParameters as J, type SignalData as K, type LogDrain as L, type MessageCategory as M, type ManifestV2 as N, type OutputSeverity as O, type PersonalizationEvent as P, type Quirks as Q, type PersonalizationManifest as R, type ScoreVector as S, TransitionDataStore as T, type Signal as U, type VisitorData as V, type SignalCriteriaGroup as W, type SignalCriteria as X, type EnrichmentCategory as Y, type NumberMatch as Z, type TestDefinition as _, type StorageCommands as a, type TestOptions as a0, testVariations as a1, type DimensionMatch as a2, type PersonalizeOptions as a3, personalizeVariations as a4, type BehaviorTag as a5, type PersonalizedVariant as a6, type PersonalizedResult as a7, type TestVariant as a8, type TestResult as a9, type ContextStateUpdate as aA, type GoalStateUpdate as aB, type paths as aC, type StorageCommand as aa, type SetGoalCommand as ab, type ModifyScoreCommand as ac, type ModifySessionScoreCommand as ad, type SetConsentCommand as ae, type SetQuirkCommand as af, type SetTestCommand as ag, type IdentifyCommand as ah, type SetControlGroupCommand as ai, type SetPersonalizeVariantControlCommand as aj, areCommandsEqual as ak, type ServerToClientTransitionState as al, SERVER_STATE_ID as am, type TransitionDataStoreEvents as an, type DecayOptions as ao, type VisitorDataStoreOptions as ap, type VisitorDataStoreEvents as aq, VisitorDataStore as ar, type Tests as as, type Goals as at, type EnrichmentData as au, type PersonalizeControlVariant as av, type PersonalizeVariants as aw, type EventData as ax, emptyVisitorData as ay, type ContextState as az, type TransitionDataStoreOptions as b, type CriteriaEvaluator as c, type StringMatch as d, type VariantMatchCriteria as e, type LogMessage as f, type DevToolsEvents as g, CONTEXTUAL_EDITING_TEST_NAME as h, CONTEXTUAL_EDITING_TEST_SELECTED_VARIANT_ID as i, type ContextOptions as j, type TestEvent as k, type ContextEvents as l, type ContextInstance as m, Context as n, type DevToolsUiVersion as o, type DevToolsState as p, type DevToolsActions as q, type DevToolsEvent as r, type DevToolsLogEvent as s, type DevToolsDataEvent as t, type DevToolsHelloEvent as u, type DevToolsUpdateEvent as v, type DevToolsRawCommandsEvent as w, type DevToolsForgetEvent as x, type LogMessages as y, type Severity as z };
+export { type ManifestV2 as $, type AggregateDimension as A, type DevToolsLogEvent as B, type ContextPlugin as C, type DecayFunction as D, type DevToolsDataEvent as E, type DevToolsHelloEvent as F, type DevToolsUpdateEvent as G, type DevToolsRawCommandsEvent as H, type DevToolsForgetEvent as I, type LogMessages as J, type Severity as K, type LogDrain as L, type MessageCategory as M, type MessageFunc as N, type OutputSeverity as O, type PersonalizedVariant as P, type Quirks as Q, type LogMessageSingle as R, type ScoreVector as S, TransitionDataStore as T, type LogMessageGroup as U, type VisitorData as V, ManifestInstance as W, GroupCriteriaEvaluator as X, type CriteriaEvaluatorResult as Y, type CriteriaEvaluatorParameters as Z, type SignalData as _, type StorageCommands as a, type PersonalizationManifest as a0, type Signal as a1, type SignalCriteriaGroup as a2, type SignalCriteria as a3, type EnrichmentCategory as a4, type NumberMatch as a5, type TestDefinition as a6, type AggregateDimensionInput as a7, type TestOptions as a8, testVariations as a9, type EnrichmentData as aA, type PersonalizeControlVariant as aB, type PersonalizeVariants as aC, type EventData as aD, emptyVisitorData as aE, type ContextState as aF, type ContextStateUpdate as aG, type GoalStateUpdate as aH, type paths as aI, type VariationMatchMetadata as aa, type DimensionMatch as ab, type QuirkMatch as ac, type BehaviorTag as ad, type TestVariant as ae, type TestResult as af, type StorageCommand as ag, type SetGoalCommand as ah, type ModifyScoreCommand as ai, type ModifySessionScoreCommand as aj, type SetConsentCommand as ak, type SetQuirkCommand as al, type SetTestCommand as am, type IdentifyCommand as an, type SetControlGroupCommand as ao, type SetPersonalizeVariantControlCommand as ap, areCommandsEqual as aq, type ServerToClientTransitionState as ar, SERVER_STATE_ID as as, type TransitionDataStoreEvents as at, type DecayOptions as au, type VisitorDataStoreOptions as av, type VisitorDataStoreEvents as aw, VisitorDataStore as ax, type Tests as ay, type Goals as az, type TransitionDataStoreOptions as b, type CriteriaEvaluator as c, type StringMatch as d, type VariantMatchCriteria as e, type LogMessage as f, type PersonalizeOptions as g, Context as h, type PersonalizedResult as i, type VariationMatchDimensionCriteria as j, type PersonalizationSelectionAlgorithmOptions as k, type DevToolsEvents as l, CONTEXTUAL_EDITING_TEST_NAME as m, CONTEXTUAL_EDITING_TEST_SELECTED_VARIANT_ID as n, type PersonalizationSelectionAlgorithm as o, type PersonalizationSelectionAlgorithms as p, type ContextOptions as q, type PersonalizationEventVariantId as r, type PersonalizationEvent as s, type TestEvent as t, type ContextEvents as u, type ContextInstance as v, type DevToolsUiVersion as w, type DevToolsState as x, type DevToolsActions as y, type DevToolsEvent as z };