@guidelytech/shared 0.10.0 → 0.11.0

package/dist/runtime.cjs

@@ -20,16 +20,33 @@ var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: tru
 // src/runtime.ts
 var runtime_exports = {};
 __export(runtime_exports, {
+  AGENT_METADATA_MAX_BYTES: () => AGENT_METADATA_MAX_BYTES,
+  AGENT_METADATA_MAX_KEYS: () => AGENT_METADATA_MAX_KEYS,
+  AGENT_OUTCOMES: () => AGENT_OUTCOMES,
+  AGENT_TOOL_CALLS_PER_TURN: () => AGENT_TOOL_CALLS_PER_TURN,
+  AGENT_TOOL_STATUSES: () => AGENT_TOOL_STATUSES,
+  AGENT_TURNS_PER_BATCH: () => AGENT_TURNS_PER_BATCH,
+  AGENT_TURN_MAX_TEXT: () => AGENT_TURN_MAX_TEXT,
+  AGENT_TURN_ROLES: () => AGENT_TURN_ROLES,
   ARTICLE_VISIBILITIES: () => ARTICLE_VISIBILITIES,
   CAPTURE_PARAM: () => CAPTURE_PARAM,
   CAPTURE_SCREENSHOT_MAX_BYTES: () => CAPTURE_SCREENSHOT_MAX_BYTES,
+  COMMON_LOCALES: () => COMMON_LOCALES,
   COMPLAINT_EVENTS: () => COMPLAINT_EVENTS,
   COMPLAINT_FIELD_TYPES: () => COMPLAINT_FIELD_TYPES,
   COMPLAINT_STATUSES: () => COMPLAINT_STATUSES,
+  CONTROL_VARIANT_ID: () => CONTROL_VARIANT_ID,
+  DEFAULT_FEATURE_ATTRIBUTE: () => DEFAULT_FEATURE_ATTRIBUTE,
+  DEFAULT_LOCALE: () => DEFAULT_LOCALE,
   DEFAULT_PLATFORMS: () => DEFAULT_PLATFORMS,
   EMBED_IFRAME_ATTRS: () => EMBED_IFRAME_ATTRS,
+  FEATURE_ATTRIBUTE_PATTERN: () => FEATURE_ATTRIBUTE_PATTERN,
+  FEATURE_RULE_LIMITS: () => FEATURE_RULE_LIMITS,
   FILE_LINK_CLASS: () => FILE_LINK_CLASS,
   GUIDELY_ID_ATTRIBUTE: () => GUIDELY_ID_ATTRIBUTE,
+  GUIDE_EXPERIMENT_GOALS: () => GUIDE_EXPERIMENT_GOALS,
+  GUIDE_EXPERIMENT_GOAL_LABELS: () => GUIDE_EXPERIMENT_GOAL_LABELS,
+  GUIDE_EXPERIMENT_STATUSES: () => GUIDE_EXPERIMENT_STATUSES,
   GUIDE_VISIBILITIES: () => GUIDE_VISIBILITIES,
   LOGGED_IN_AUDIENCE: () => LOGGED_IN_AUDIENCE,
   MAX_COLLECTION_DEPTH: () => MAX_COLLECTION_DEPTH,
@@ -38,6 +55,7 @@ __export(runtime_exports, {
   MAX_COMPLAINT_CHOICES: () => MAX_COMPLAINT_CHOICES,
   MAX_COMPLAINT_FIELDS: () => MAX_COMPLAINT_FIELDS,
   MAX_COMPLAINT_LENGTH: () => MAX_COMPLAINT_LENGTH,
+  MAX_CUSTOM_CSS: () => MAX_CUSTOM_CSS,
   MAX_PROPERTY_BYTES: () => MAX_PROPERTY_BYTES,
   MAX_STACK_FRAMES: () => MAX_STACK_FRAMES,
   MEDIA_FILE_MAX_BYTES: () => MEDIA_FILE_MAX_BYTES,
@@ -48,38 +66,65 @@ __export(runtime_exports, {
   MEDIA_VIDEO_MAX_BYTES: () => MEDIA_VIDEO_MAX_BYTES,
   MEDIA_VIDEO_TYPES: () => MEDIA_VIDEO_TYPES,
   NETWORK_PLUGIN: () => NETWORK_PLUGIN,
+  NOISY_DATA_ATTR: () => NOISY_DATA_ATTR,
+  PAGE_RULE_LIMITS: () => PAGE_RULE_LIMITS,
   PATH_ID_PATTERN: () => PATH_ID_PATTERN,
   PDF_BLOCK_CLASS: () => PDF_BLOCK_CLASS,
   PDF_MAX_PAGES: () => PDF_MAX_PAGES,
   PDF_PAGES_CLASS: () => PDF_PAGES_CLASS,
   PLATFORMS: () => PLATFORMS,
+  RC_MODULE_IDS: () => RC_MODULE_IDS,
+  RC_MODULE_LABELS: () => RC_MODULE_LABELS,
   RULE_FIELDS: () => RULE_FIELDS,
   RULE_OPERATORS: () => RULE_OPERATORS,
+  SCOUT_AGENT_ID: () => SCOUT_AGENT_ID,
   SENSITIVE_HEADER_PATTERN: () => SENSITIVE_HEADER_PATTERN,
   SENSITIVE_PARAM_PATTERN: () => SENSITIVE_PARAM_PATTERN,
   SENSITIVE_PROPERTY_PATTERN: () => SENSITIVE_PROPERTY_PATTERN,
   SERVER_ASSISTED_FIELDS: () => SERVER_ASSISTED_FIELDS,
   SHOW_ME_CLASS: () => SHOW_ME_CLASS,
   SHOW_ME_HREF_PREFIX: () => SHOW_ME_HREF_PREFIX,
+  SNAPSHOT_ATTRS: () => SNAPSHOT_ATTRS,
+  SNAPSHOT_LIMITS: () => SNAPSHOT_LIMITS,
   SOURCEMAP_MAX_FILES_PER_UPLOAD: () => SOURCEMAP_MAX_FILES_PER_UPLOAD,
   SOURCEMAP_MAX_FILE_BYTES: () => SOURCEMAP_MAX_FILE_BYTES,
+  SelectorSyntaxError: () => SelectorSyntaxError,
+  TAG_PROPERTY_LIMITS: () => TAG_PROPERTY_LIMITS,
   VIDEO_ATTRS: () => VIDEO_ATTRS,
+  WCAG_AA_LARGE: () => WCAG_AA_LARGE,
+  WCAG_AA_TEXT: () => WCAG_AA_TEXT,
   WS_MAX_MESSAGES_PER_SOCKET: () => WS_MAX_MESSAGES_PER_SOCKET,
   WS_MAX_MESSAGE_BYTES: () => WS_MAX_MESSAGE_BYTES,
+  applyGuideTranslations: () => applyGuideTranslations,
+  articleTextEntries: () => articleTextEntries,
+  assignGuideVariant: () => assignGuideVariant,
+  baseLanguage: () => baseLanguage,
   clamp: () => clamp,
   compare: () => compare,
   compareVersions: () => compareVersions,
   complaintReference: () => complaintReference,
+  compoundMatches: () => compoundMatches,
+  contrastIssues: () => contrastIssues,
+  contrastRatio: () => contrastRatio,
+  cssSelectorError: () => cssSelectorError,
   describeRule: () => describeRule,
   emptyRuleGroup: () => emptyRuleGroup,
   evaluateRule: () => evaluateRule,
   evaluateRules: () => evaluateRules,
+  evenWeights: () => evenWeights,
+  experimentBucketRules: () => experimentBucketRules,
+  experimentSalt: () => experimentSalt,
+  featureCssSelectors: () => featureCssSelectors,
+  featureRuleError: () => featureRuleError,
+  featureRuleMatchesClick: () => featureRuleMatchesClick,
   fingerprintError: () => fingerprintError,
   firstNameFromTraits: () => firstNameFromTraits,
   fnv1a: () => fnv1a,
   foldPathIds: () => foldPathIds,
   getPath: () => getPath,
+  guideLocales: () => guideLocales,
   guidePlatforms: () => guidePlatforms,
+  guideTextEntries: () => guideTextEntries,
   guidelyIdFromSelector: () => guidelyIdFromSelector,
   hasVideoMedia: () => hasVideoMedia,
   isAllowedEmbedSrc: () => isAllowedEmbedSrc,
@@ -92,6 +137,12 @@ __export(runtime_exports, {
   isRuleGroup: () => isRuleGroup,
   isSafeMediaUrl: () => isSafeMediaUrl,
   isVideoContentType: () => isVideoContentType,
+  localeName: () => localeName,
+  localizeAnnouncement: () => localizeAnnouncement,
+  localizeArticle: () => localizeArticle,
+  localizeGuide: () => localizeGuide,
+  localizeResourceCenter: () => localizeResourceCenter,
+  matchCssSelector: () => matchCssSelector,
   matchUrlPattern: () => matchUrlPattern,
   matchesAudiences: () => matchesAudiences,
   matchesHelpQuery: () => matchesHelpQuery,
@@ -99,25 +150,52 @@ __export(runtime_exports, {
   mediaMaxBytes: () => mediaMaxBytes,
   normalizeErrorMessage: () => normalizeErrorMessage,
   normalizeFrameFile: () => normalizeFrameFile,
+  normalizeLocale: () => normalizeLocale,
+  normalizeSnapshot: () => normalizeSnapshot,
+  orderedModules: () => orderedModules,
   pageLabel: () => pageLabel,
+  pagePattern: () => pagePattern,
+  pageRuleError: () => pageRuleError,
+  pageRuleMatches: () => pageRuleMatches,
+  pageRulesMatch: () => pageRulesMatch,
   pageTerms: () => pageTerms,
+  parseCssSelector: () => parseCssSelector,
+  parseHexColor: () => parseHexColor,
   parseStack: () => parseStack,
+  propertyAttributeAllowed: () => propertyAttributeAllowed,
+  queryConditionRegex: () => queryConditionRegex,
   randomId: () => randomId,
+  readableTextOn: () => readableTextOn,
+  relativeLuminance: () => relativeLuminance,
+  resolveLocale: () => resolveLocale,
+  resourceCenterLocales: () => resourceCenterLocales,
   resourceCenterSections: () => resourceCenterSections,
+  resourceCenterTextEntries: () => resourceCenterTextEntries,
   rolloutBucket: () => rolloutBucket,
   safeRegExp: () => safeRegExp,
+  sanitizeCustomCss: () => sanitizeCustomCss,
   sanitizeProperties: () => sanitizeProperties,
+  scopeCustomCss: () => scopeCustomCss,
   screenPath: () => screenPath,
   servedArticleAudiences: () => servedArticleAudiences,
   showMeHref: () => showMeHref,
   showMeKeyFromHref: () => showMeKeyFromHref,
   showMeKeys: () => showMeKeys,
   slugify: () => slugify,
+  snapshotFromSelector: () => snapshotFromSelector,
+  stableStringify: () => stableStringify,
   stripOrigin: () => stripOrigin,
   supportsPlatform: () => supportsPlatform,
   toEmbedUrl: () => toEmbedUrl,
+  translationCoverage: () => translationCoverage,
+  unreadAnnouncements: () => unreadAnnouncements,
+  variantProblems: () => variantProblems,
+  variantRanges: () => variantRanges,
+  visibleAnnouncements: () => visibleAnnouncements,
   visibleArticleIds: () => visibleArticleIds,
   visitorAudiences: () => visitorAudiences,
+  visitorLocales: () => visitorLocales,
+  withExperimentBucket: () => withExperimentBucket,
   withVisibility: () => withVisibility
 });
 module.exports = __toCommonJS(runtime_exports);
@@ -309,11 +387,15 @@ var RULE_FIELDS = [
   "datetime.dayOfWeek",
   "datetime.hour",
   "rollout.percentage",
+  /** Guide A/B tests: the visitor's 0-99 bucket for the salt in `key` (see guide-experiments.ts). */
+  "experiment.bucket",
   "environment",
   "locale",
   "app.platform",
   "app.screen",
-  "app.version"
+  "app.version",
+  "page.views",
+  "feature.clicks"
 ];
 function isRuleGroup(r) {
   return r.rules !== void 0;
@@ -373,6 +455,8 @@ function resolveField(rule, ctx) {
       return ctx.now.getHours();
     case "rollout.percentage":
       return rolloutBucket(ctx.userId || ctx.anonymousId, ctx.rolloutSalt || "guidely");
+    case "experiment.bucket":
+      return rule.key ? rolloutBucket(ctx.userId || ctx.anonymousId, rule.key) : void 0;
     case "environment":
       return ctx.environment;
     case "locale":
@@ -383,6 +467,9 @@ function resolveField(rule, ctx) {
       return ctx.screen;
     case "app.version":
       return ctx.appVersion;
+    case "page.views":
+    case "feature.clicks":
+      return rule.key ? ctx.tagUsage?.[rule.key] ?? 0 : 0;
     default:
       return void 0;
   }
@@ -482,7 +569,7 @@ function evaluateRules(group, ctx) {
   const value = group.op === "and" ? results.every(Boolean) : results.some(Boolean);
   return group.negate ? !value : value;
 }
-var SERVER_ASSISTED_FIELDS = ["audience.member", "guide.completed", "guide.dismissed", "guide.seen", "checklist.completed"];
+var SERVER_ASSISTED_FIELDS = ["audience.member", "guide.completed", "guide.dismissed", "guide.seen", "checklist.completed", "page.views", "feature.clicks"];
 var GUIDE_VISIBILITIES = ["everyone", "identified", "anonymous"];
 function withVisibility(targeting, visibility) {
   if (!visibility || visibility === "everyone") return targeting;
@@ -504,8 +591,8 @@ function sanitizeProperties(props) {
   for (const [k, v] of Object.entries(props)) {
     if (SENSITIVE_PROPERTY_PATTERN.test(k)) continue;
     if (typeof v === "function" || typeof v === "symbol") continue;
-    const str = typeof v === "string" ? v : JSON.stringify(v ?? null);
-    size += k.length + (str?.length ?? 0);
+    const str2 = typeof v === "string" ? v : JSON.stringify(v ?? null);
+    size += k.length + (str2?.length ?? 0);
     if (size > MAX_PROPERTY_BYTES) break;
     out[k.slice(0, 100)] = typeof v === "string" ? v.slice(0, 1e3) : v;
   }
@@ -783,6 +870,32 @@ function matchesHelpQuery(text, query) {
   const have = words(hay);
   return terms.every((t) => have.some((w) => w.startsWith(t) || t.length > 3 && t.endsWith("s") && w.startsWith(t.slice(0, -1))));
 }
+var RC_MODULE_IDS = ["announcements", "search", "checklists", "guides", "articles", "links", "faqs"];
+var RC_MODULE_LABELS = {
+  announcements: "What's new",
+  search: "Search",
+  checklists: "Checklists",
+  guides: "Guides & tours",
+  articles: "Articles",
+  links: "Links",
+  faqs: "FAQs"
+};
+function orderedModules(modules) {
+  const known = (modules ?? []).filter((m, i, all) => RC_MODULE_IDS.includes(m.id) && all.findIndex((x) => x.id === m.id) === i);
+  const missing = RC_MODULE_IDS.filter((id) => !known.some((m) => m.id === id)).map((id) => ({ id, enabled: true }));
+  return [...known, ...missing];
+}
+function visibleAnnouncements(items, member, now = Date.now()) {
+  return (items ?? []).filter((a) => {
+    const t = Date.parse(a.publishedAt);
+    return !Number.isNaN(t) && t <= now && matchesAudiences(a.audienceIds, member);
+  }).sort((a, b) => Date.parse(b.publishedAt) - Date.parse(a.publishedAt));
+}
+function unreadAnnouncements(items, lastSeenAt) {
+  const seen = lastSeenAt ? Date.parse(lastSeenAt) : NaN;
+  if (Number.isNaN(seen)) return items.length;
+  return items.filter((a) => Date.parse(a.publishedAt) > seen).length;
+}
 
 // src/howto-limits.ts
 var CAPTURE_PARAM = "guidely_capture";
@@ -812,12 +925,556 @@ function pageLabel(path) {
 }
 function firstNameFromTraits(traits) {
   if (!traits) return null;
-  const pick = (v) => typeof v === "string" ? v.trim() : "";
-  const first = pick(traits.firstName) || pick(traits.first_name) || pick(traits.firstname) || pick(traits.name).split(/\s+/)[0] || "";
+  const pick2 = (v) => typeof v === "string" ? v.trim() : "";
+  const first = pick2(traits.firstName) || pick2(traits.first_name) || pick2(traits.firstname) || pick2(traits.name).split(/\s+/)[0] || "";
   if (!first || first.length > 40 || first.includes("@") || !/\p{L}/u.test(first)) return null;
   return first;
 }
 
+// src/tagging.ts
+var SNAPSHOT_LIMITS = { classes: 8, className: 60, attrs: 6, attrValue: 100, ancestors: 5, hosts: 3, tag: 40, id: 80 };
+var SNAPSHOT_ATTRS = ["role", "name", "type", "aria-label", "title", "alt", "for", "href"];
+var NOISY_DATA_ATTR = /^data-(state|v-|react|radix|headlessui|svelte|orientation|highlighted|focus|key|index|side|align|disabled|selected|active|open|rbd|dnd|sveltekit|guidely-(mask|ignore|block))/i;
+var DEFAULT_FEATURE_ATTRIBUTE = "data-guidely-feature";
+var FEATURE_ATTRIBUTE_PATTERN = /^data-[a-z0-9][a-z0-9_.-]{0,60}$/;
+function str(v, max) {
+  return typeof v === "string" && v ? v.slice(0, max) : void 0;
+}
+function cleanNode(raw) {
+  if (!raw || typeof raw !== "object") return null;
+  const r = raw;
+  const t = str(r.t, SNAPSHOT_LIMITS.tag)?.toLowerCase();
+  if (!t || !/^[a-z][a-z0-9-]*$/.test(t)) return null;
+  const node = { t };
+  const id = str(r.id, SNAPSHOT_LIMITS.id);
+  if (id) node.id = id;
+  if (Array.isArray(r.c)) {
+    const c = r.c.filter((x) => typeof x === "string" && !!x && x.length <= SNAPSHOT_LIMITS.className && !/\s/.test(x)).slice(0, SNAPSHOT_LIMITS.classes);
+    if (c.length) node.c = c;
+  }
+  if (r.a && typeof r.a === "object" && !Array.isArray(r.a)) {
+    const a = {};
+    for (const [k, v] of Object.entries(r.a)) {
+      if (Object.keys(a).length >= SNAPSHOT_LIMITS.attrs) break;
+      const key = k.toLowerCase();
+      if (typeof v !== "string" || !(key.startsWith("data-") || SNAPSHOT_ATTRS.includes(key)) || key === "value" || key.length > 60) continue;
+      a[key] = v.slice(0, SNAPSHOT_LIMITS.attrValue);
+    }
+    if (Object.keys(a).length) node.a = a;
+  }
+  if (typeof r.n === "number" && Number.isInteger(r.n) && r.n >= 1 && r.n <= 1e4) node.n = r.n;
+  return node;
+}
+function normalizeSnapshot(raw) {
+  const el = cleanNode(raw);
+  if (!el) return null;
+  const r = raw;
+  const out = el;
+  if (Array.isArray(r.p)) {
+    const p = r.p.slice(0, SNAPSHOT_LIMITS.ancestors).map(cleanNode);
+    const cut = p.indexOf(null);
+    const list = cut === -1 ? p : p.slice(0, cut);
+    if (list.length) out.p = list;
+  }
+  if (Array.isArray(r.h)) {
+    const h = r.h.slice(0, SNAPSHOT_LIMITS.hosts).map(cleanNode).filter((x) => !!x);
+    if (h.length) out.h = h;
+  }
+  return out;
+}
+function stableStringify(v) {
+  if (Array.isArray(v)) return `[${v.map(stableStringify).join(",")}]`;
+  if (v && typeof v === "object") {
+    const o = v;
+    return `{${Object.keys(o).filter((k) => o[k] !== void 0).sort().map((k) => `${JSON.stringify(k)}:${stableStringify(o[k])}`).join(",")}}`;
+  }
+  return JSON.stringify(v ?? null);
+}
+var SelectorSyntaxError = class extends Error {
+};
+var IDENT_START = /[A-Za-z_\u00a0-\uffff-]/;
+var IDENT_CHAR = /[A-Za-z0-9_\u00a0-\uffff-]/;
+function parseCssSelector(input) {
+  const s = input.trim();
+  if (!s) throw new SelectorSyntaxError("Empty selector");
+  if (s.length > 1e3) throw new SelectorSyntaxError("Selector is too long");
+  let i = 0;
+  const peek = () => s[i];
+  const eof = () => i >= s.length;
+  const fail = (msg) => {
+    throw new SelectorSyntaxError(`${msg} at position ${i + 1}`);
+  };
+  const ws = () => {
+    let any = false;
+    while (!eof() && /\s/.test(s[i])) {
+      i++;
+      any = true;
+    }
+    return any;
+  };
+  const escape = () => {
+    i++;
+    const hex = /^[0-9a-fA-F]{1,6}/.exec(s.slice(i));
+    if (hex) {
+      i += hex[0].length;
+      if (s[i] === " ") i++;
+      return String.fromCodePoint(parseInt(hex[0], 16));
+    }
+    if (eof()) fail("Unfinished escape");
+    return s[i++];
+  };
+  const ident = () => {
+    let out = "";
+    if (s[i] === "\\") out += escape();
+    else if (!eof() && IDENT_START.test(s[i])) out += s[i++];
+    else fail("Expected a name");
+    while (!eof()) {
+      if (s[i] === "\\") out += escape();
+      else if (IDENT_CHAR.test(s[i])) out += s[i++];
+      else break;
+    }
+    return out;
+  };
+  const quoted = () => {
+    const q = s[i++];
+    let out = "";
+    while (!eof() && s[i] !== q) {
+      if (s[i] === "\\") out += escape();
+      else out += s[i++];
+    }
+    if (eof()) fail("Unterminated string");
+    i++;
+    return out;
+  };
+  const compound = () => {
+    const c = { classes: [], attrs: [] };
+    let any = false;
+    if (peek() === "*") {
+      i++;
+      any = true;
+    } else if (!eof() && (IDENT_START.test(peek()) || peek() === "\\")) {
+      c.tag = ident().toLowerCase();
+      any = true;
+    }
+    for (; ; ) {
+      const ch = peek();
+      if (ch === "#") {
+        i++;
+        c.id = ident();
+      } else if (ch === ".") {
+        i++;
+        c.classes.push(ident());
+      } else if (ch === "[") {
+        i++;
+        ws();
+        const name = ident().toLowerCase();
+        ws();
+        let op = "exists";
+        let value;
+        let insensitive = false;
+        if (peek() !== "]") {
+          const m = /^(=|\^=|\$=|\*=|~=|\|=)/.exec(s.slice(i));
+          if (!m) fail("Unsupported attribute operator");
+          op = m[1];
+          i += m[1].length;
+          ws();
+          value = peek() === '"' || peek() === "'" ? quoted() : ident();
+          ws();
+          if (peek() === "i" || peek() === "I") {
+            i++;
+            insensitive = true;
+            ws();
+          } else if (peek() === "s" || peek() === "S") {
+            i++;
+            ws();
+          }
+        }
+        if (peek() !== "]") fail("Expected ]");
+        i++;
+        c.attrs.push({ name, op, ...value !== void 0 ? { value } : {}, ...insensitive ? { insensitive } : {} });
+      } else if (ch === ":") {
+        i++;
+        if (peek() === ":") fail("Pseudo-elements are not supported");
+        const name = ident().toLowerCase();
+        if (name === "first-of-type") c.nth = { a: 0, b: 1 };
+        else if (name === "nth-of-type") {
+          if (peek() !== "(") fail("Expected (");
+          i++;
+          ws();
+          const m = /^(odd|even|\d+)/i.exec(s.slice(i));
+          if (!m) fail("Only :nth-of-type(n), odd or even are supported");
+          i += m[0].length;
+          ws();
+          if (peek() !== ")") fail("Expected )");
+          i++;
+          const v = m[0].toLowerCase();
+          c.nth = v === "odd" ? { a: 2, b: 1 } : v === "even" ? { a: 2, b: 0 } : { a: 0, b: Number(v) };
+        } else fail(`Unsupported pseudo-class :${name}`);
+      } else break;
+      any = true;
+    }
+    return any ? c : null;
+  };
+  const list = [];
+  for (; ; ) {
+    ws();
+    const sel = { compounds: [], combinators: [] };
+    const first = compound();
+    if (!first) fail("Expected a selector");
+    sel.compounds.push(first);
+    for (; ; ) {
+      const hadWs = ws();
+      if (eof() || peek() === ",") break;
+      let comb = " ";
+      if (s.startsWith(">>>", i)) {
+        comb = ">>>";
+        i += 3;
+        ws();
+      } else if (peek() === ">") {
+        comb = ">";
+        i++;
+        ws();
+      } else if (peek() === "+" || peek() === "~") fail("Sibling combinators are not supported");
+      else if (!hadWs) fail("Unexpected character");
+      const next = compound();
+      if (!next) fail("Expected a selector after the combinator");
+      sel.compounds.push(next);
+      sel.combinators.push(comb);
+    }
+    list.push(sel);
+    if (eof()) break;
+    i++;
+  }
+  return list;
+}
+function cssSelectorError(selector) {
+  try {
+    parseCssSelector(selector);
+    return null;
+  } catch (e) {
+    return e instanceof Error ? e.message : "Invalid selector";
+  }
+}
+function attrMatches(test, node) {
+  let actual;
+  if (test.name === "id") actual = node.id;
+  else if (test.name === "class") actual = node.c?.join(" ");
+  else actual = node.a?.[test.name];
+  if (actual === void 0) return false;
+  if (test.op === "exists") return true;
+  let v = test.value ?? "";
+  if (test.insensitive) {
+    actual = actual.toLowerCase();
+    v = v.toLowerCase();
+  }
+  switch (test.op) {
+    case "=":
+      return actual === v;
+    case "^=":
+      return !!v && actual.startsWith(v);
+    case "$=":
+      return !!v && actual.endsWith(v);
+    case "*=":
+      return !!v && actual.includes(v);
+    case "~=":
+      return !!v && actual.split(/\s+/).includes(v);
+    case "|=":
+      return actual === v || actual.startsWith(`${v}-`);
+    default:
+      return false;
+  }
+}
+function compoundMatches(c, node) {
+  if (c.tag && c.tag !== node.t) return false;
+  if (c.id !== void 0 && node.id !== c.id) return false;
+  for (const cls of c.classes) if (!node.c?.includes(cls)) return false;
+  for (const a of c.attrs) if (!attrMatches(a, node)) return false;
+  if (c.nth) {
+    if (!node.n) return false;
+    const { a, b } = c.nth;
+    if (a === 0 ? node.n !== b : (node.n - b) % a !== 0 || (node.n - b) / a < 0) return false;
+  }
+  return true;
+}
+function chainMatches(compounds, combinators, nodes, ci = compounds.length - 1, ni = 0) {
+  if (!compoundMatches(compounds[ci], nodes[ni])) return false;
+  if (ci === 0) return true;
+  const comb = combinators[ci - 1];
+  if (comb === ">") return ni + 1 < nodes.length && chainMatches(compounds, combinators, nodes, ci - 1, ni + 1);
+  for (let k = ni + 1; k < nodes.length; k++) if (chainMatches(compounds, combinators, nodes, ci - 1, k)) return true;
+  return false;
+}
+function complexMatches(sel, snap) {
+  const segments = [{ compounds: [sel.compounds[0]], combinators: [] }];
+  sel.combinators.forEach((comb, k) => {
+    const next = sel.compounds[k + 1];
+    if (comb === ">>>") segments.push({ compounds: [next], combinators: [] });
+    else {
+      const seg = segments[segments.length - 1];
+      seg.compounds.push(next);
+      seg.combinators.push(comb);
+    }
+  });
+  const last = segments.pop();
+  const nodes = [snap, ...snap.p ?? []];
+  if (!chainMatches(last.compounds, last.combinators, nodes)) return false;
+  const hosts = snap.h ?? [];
+  let from = 0;
+  for (let k = segments.length - 1; k >= 0; k--) {
+    const target = segments[k].compounds[segments[k].compounds.length - 1];
+    let found = -1;
+    for (let j = from; j < hosts.length; j++) {
+      if (compoundMatches(target, hosts[j])) {
+        found = j;
+        break;
+      }
+    }
+    if (found === -1) return false;
+    from = found + 1;
+  }
+  return true;
+}
+var parsedCache = /* @__PURE__ */ new Map();
+function matchCssSelector(selector, snap) {
+  let list;
+  if (typeof selector === "string") {
+    if (!parsedCache.has(selector)) {
+      if (parsedCache.size > 500) parsedCache.clear();
+      try {
+        parsedCache.set(selector, parseCssSelector(selector));
+      } catch {
+        parsedCache.set(selector, null);
+      }
+    }
+    list = parsedCache.get(selector);
+  } else list = selector;
+  return !!list && list.some((sel) => complexMatches(sel, snap));
+}
+function nodeOfCompound(c) {
+  const node = { t: c.tag ?? "*" };
+  if (c.id) node.id = c.id;
+  if (c.classes.length) node.c = c.classes.slice(0, SNAPSHOT_LIMITS.classes);
+  const a = {};
+  for (const t of c.attrs) if (t.op === "=" && t.value !== void 0) a[t.name] = t.value;
+  if (Object.keys(a).length) node.a = a;
+  if (c.nth && c.nth.a === 0) node.n = c.nth.b;
+  return node;
+}
+function snapshotFromSelector(selector, tag) {
+  let list;
+  try {
+    list = parseCssSelector(selector);
+  } catch {
+    return null;
+  }
+  if (list.length !== 1) return null;
+  const sel = list[0];
+  const segments = [[sel.compounds[0]]];
+  sel.combinators.forEach((comb, k) => {
+    if (comb === ">>>") segments.push([sel.compounds[k + 1]]);
+    else segments[segments.length - 1].push(sel.compounds[k + 1]);
+  });
+  const own = segments.pop();
+  const el = nodeOfCompound(own[own.length - 1]);
+  if (el.t === "*" && tag && /^[a-z][a-z0-9-]*$/i.test(tag)) el.t = tag.toLowerCase();
+  const snap = el;
+  const p = own.slice(0, -1).reverse().map(nodeOfCompound);
+  if (p.length) snap.p = p.slice(0, SNAPSHOT_LIMITS.ancestors);
+  const h = segments.reverse().map((seg) => nodeOfCompound(seg[seg.length - 1]));
+  if (h.length) snap.h = h.slice(0, SNAPSHOT_LIMITS.hosts);
+  return snap;
+}
+var PAGE_RULE_LIMITS = { rules: 20, value: 500, query: 5 };
+var escapeRe = (s) => s.replace(/[.+?^${}()|[\]\\*]/g, "\\$&");
+function globToRegex(pattern) {
+  let out = "";
+  for (let k = 0; k < pattern.length; k++) {
+    const ch = pattern[k];
+    if (ch === "*") {
+      if (pattern[k + 1] === "*") {
+        out += ".*";
+        k++;
+      } else out += "[^/]*";
+    } else if (ch === ":" && (k === 0 || pattern[k - 1] === "/") && /[A-Za-z_]/.test(pattern[k + 1] ?? "")) {
+      let j = k + 1;
+      while (j < pattern.length && /[\w]/.test(pattern[j])) j++;
+      out += "[^/]+";
+      k = j - 1;
+    } else out += escapeRe(ch);
+  }
+  return out;
+}
+function pagePattern(raw) {
+  let p = raw.trim();
+  const query = [];
+  const hash = p.indexOf("#");
+  if (hash !== -1) p = p.slice(0, hash);
+  const q = p.indexOf("?");
+  if (q !== -1) {
+    for (const part of p.slice(q + 1).split("&")) {
+      if (!part) continue;
+      const eq = part.indexOf("=");
+      const name = decodeSafe(eq === -1 ? part : part.slice(0, eq));
+      const value = eq === -1 ? void 0 : decodeSafe(part.slice(eq + 1));
+      if (!name) continue;
+      query.push(value === void 0 || value === "*" ? { name, op: "exists" } : { name, op: "equals", value });
+    }
+    p = p.slice(0, q);
+  }
+  let target = "path";
+  if (p.startsWith("//*")) p = p.slice(3);
+  let prefix = "";
+  const abs = /^(https?:)?\/\/([^/]+)(.*)$/i.exec(p);
+  if (abs) {
+    target = "url";
+    prefix = `https?://${globToRegex(abs[2].toLowerCase())}`;
+    p = abs[3] || "/";
+  }
+  if (!p.startsWith("/")) p = `/${p}`;
+  const body = p.length > 1 && p.endsWith("/") ? p.slice(0, -1) : p;
+  const src = body === "/" ? "/?" : `${globToRegex(body)}/?`;
+  return { source: `^${prefix}${src}$`, target, query: query.slice(0, PAGE_RULE_LIMITS.query) };
+}
+function decodeSafe(s) {
+  try {
+    return decodeURIComponent(s.replace(/\+/g, " "));
+  } catch {
+    return s;
+  }
+}
+function queryConditionRegex(c) {
+  const name = escapeRe(c.name);
+  switch (c.op) {
+    case "equals":
+      return `[?&]${name}=${escapeRe(encodeLoose(c.value ?? ""))}(&|#|$)`;
+    case "contains":
+      return `[?&]${name}=[^&#]*${escapeRe(encodeLoose(c.value ?? ""))}`;
+    default:
+      return `[?&]${name}(=|&|#|$)`;
+  }
+}
+function encodeLoose(v) {
+  return encodeURIComponent(v).replace(/%2F/gi, "/").replace(/%3A/gi, ":").replace(/%2C/gi, ",").replace(/%40/gi, "@");
+}
+function pathOnly(ctx) {
+  if (ctx.path) return ctx.path.split("?")[0] || "/";
+  if (!ctx.url) return null;
+  try {
+    return new URL(ctx.url, "http://x.invalid").pathname;
+  } catch {
+    return null;
+  }
+}
+function regexOrNull(source) {
+  try {
+    return new RegExp(source, "i");
+  } catch {
+    return null;
+  }
+}
+function pageRuleMatches(rule, ctx) {
+  const path = pathOnly(ctx);
+  if (rule.type === "title") {
+    const t = (ctx.title ?? "").toLowerCase();
+    const v = rule.value.toLowerCase();
+    return !!t && (rule.op === "contains" ? t.includes(v) : t === v);
+  }
+  if (rule.type === "regex") {
+    const re2 = regexOrNull(rule.value);
+    return !!re2 && path !== null && re2.test(path);
+  }
+  const pat = pagePattern(rule.value);
+  const re = regexOrNull(pat.source);
+  if (!re) return false;
+  let subject = path;
+  if (pat.target === "url") {
+    if (!ctx.url) return false;
+    subject = ctx.url.split(/[?#]/)[0];
+  }
+  if (subject === null || !re.test(subject)) return false;
+  const conds = [...pat.query, ...rule.query ?? []];
+  for (const c of conds) {
+    const hit = !!ctx.url && new RegExp(queryConditionRegex(c), "i").test(ctx.url);
+    if (c.op === "absent" ? hit : !hit) return false;
+  }
+  return true;
+}
+function pageRulesMatch(rules, ctx) {
+  const include = rules.filter((r) => !r.exclude);
+  if (!include.length || !include.some((r) => pageRuleMatches(r, ctx))) return false;
+  return !rules.some((r) => r.exclude && pageRuleMatches(r, ctx));
+}
+function pageRuleError(rule) {
+  const v = rule.value?.trim();
+  if (!v) return "A rule needs a value";
+  if (v.length > PAGE_RULE_LIMITS.value) return "The rule is too long";
+  if (rule.type === "regex") {
+    if (!regexOrNull(v)) return `"${v}" is not a valid regular expression`;
+    if (/\(\?[<=!]/.test(v) || /\\[1-9]/.test(v)) return "Look-arounds and back-references are not supported";
+  }
+  if (rule.type === "url" && !regexOrNull(pagePattern(v).source)) return `"${v}" is not a valid URL rule`;
+  for (const q of rule.query ?? []) if (!/^[A-Za-z0-9_.\-[\]]{1,60}$/.test(q.name)) return `"${q.name}" is not a query parameter name`;
+  return null;
+}
+var FEATURE_RULE_LIMITS = { rules: 20, value: 1e3 };
+function globMatch(pattern, value) {
+  const re = new RegExp(`^${pattern.split("*").map(escapeRe).join(".*")}$`, "s");
+  return re.test(value);
+}
+function featureRuleMatchesClick(rule, click, css) {
+  if (!rule.selector && !rule.text && !rule.tag && !rule.href) return false;
+  if (rule.selector) {
+    const sel = click.selector ?? "";
+    const v = rule.selector.value;
+    const ok = rule.selector.op === "css" ? css(v) : rule.selector.op === "exact" ? sel === v : rule.selector.op === "prefix" ? sel.startsWith(v) : rule.selector.op === "contains" ? sel.includes(v) : globMatch(v, sel);
+    if (!ok) return false;
+  }
+  if (rule.text) {
+    const t = (click.text ?? "").toLowerCase();
+    const v = rule.text.value.toLowerCase();
+    if (rule.text.op === "contains" ? !t.includes(v) : t !== v) return false;
+  }
+  if (rule.tag && (click.tag ?? "").toLowerCase() !== rule.tag.toLowerCase()) return false;
+  if (rule.href) {
+    const h = click.href ?? "";
+    const v = rule.href.value;
+    if (rule.href.op === "equals" ? h !== v : rule.href.op === "prefix" ? !h.startsWith(v) : !h.includes(v)) return false;
+  }
+  if (rule.platform && (click.platform ?? "web") !== rule.platform) return false;
+  return true;
+}
+function featureRuleError(rule) {
+  if (!rule.selector && !rule.text && !rule.tag && !rule.href) return "A feature rule needs a selector, text, tag or link condition";
+  if (rule.selector) {
+    const v = rule.selector.value?.trim();
+    if (!v) return "The selector is empty";
+    if (v.length > FEATURE_RULE_LIMITS.value) return "The selector is too long";
+    if (rule.selector.op === "css") {
+      const err = cssSelectorError(v);
+      if (err) return `Unsupported CSS selector: ${err}`;
+    }
+  }
+  if (rule.text && !rule.text.value.trim()) return "The text condition is empty";
+  if (rule.href && !rule.href.value.trim()) return "The link condition is empty";
+  if (rule.tag && !/^[a-z][a-z0-9-]{0,40}$/i.test(rule.tag)) return "The tag is not an element name";
+  if (rule.page?.pattern) return pageRuleError({ type: "url", value: rule.page.pattern });
+  return null;
+}
+function featureCssSelectors(rules) {
+  const out = [];
+  for (const r of rules) {
+    if (r.exclude || !r.selector) continue;
+    if ((r.selector.op === "css" || r.selector.op === "exact") && !cssSelectorError(r.selector.value)) out.push(r.selector.value);
+  }
+  return out;
+}
+var TAG_PROPERTY_LIMITS = { perTag: 10, total: 50, value: 100 };
+function propertyAttributeAllowed(name) {
+  const n = name.toLowerCase();
+  if (n === "value" || n.startsWith("on") || n === "style" || n === "srcdoc") return false;
+  return /^[a-z][a-z0-9_:.-]{0,60}$/.test(n);
+}
+
 // src/complaints-limits.ts
 var COMPLAINT_STATUSES = ["open", "in_review", "resolved"];
 var COMPLAINT_EVENTS = ["complaint.filed", "complaint.status_changed", "complaint.replied", "complaint.resolved"];
@@ -828,18 +1485,506 @@ var MAX_COMPLAINT_LENGTH = 4e3;
 var MAX_COMPLAINT_ANSWER_LENGTH = 500;
 var MAX_COMPLAINT_ATTACHMENT_BYTES = 2 * 1024 * 1024;
 var complaintReference = (number) => `CMP-${number}`;
+
+// src/agents-limits.ts
+var AGENT_TURN_ROLES = ["user", "assistant", "tool", "system"];
+var AGENT_OUTCOMES = ["success", "failure", "escalated", "abandoned"];
+var AGENT_TOOL_STATUSES = ["ok", "error"];
+var AGENT_TURN_MAX_TEXT = 2e4;
+var AGENT_TURNS_PER_BATCH = 100;
+var AGENT_TOOL_CALLS_PER_TURN = 50;
+var AGENT_METADATA_MAX_KEYS = 30;
+var AGENT_METADATA_MAX_BYTES = 4096;
+var SCOUT_AGENT_ID = "scout";
+
+// src/localization.ts
+var DEFAULT_LOCALE = "en";
+var COMMON_LOCALES = [
+  { code: "en", name: "English" },
+  { code: "en-GB", name: "English (UK)" },
+  { code: "fr", name: "French" },
+  { code: "fr-CA", name: "French (Canada)" },
+  { code: "de", name: "German" },
+  { code: "es", name: "Spanish" },
+  { code: "es-MX", name: "Spanish (Mexico)" },
+  { code: "it", name: "Italian" },
+  { code: "pt", name: "Portuguese" },
+  { code: "pt-BR", name: "Portuguese (Brazil)" },
+  { code: "nl", name: "Dutch" },
+  { code: "sv", name: "Swedish" },
+  { code: "da", name: "Danish" },
+  { code: "nb", name: "Norwegian" },
+  { code: "fi", name: "Finnish" },
+  { code: "pl", name: "Polish" },
+  { code: "cs", name: "Czech" },
+  { code: "tr", name: "Turkish" },
+  { code: "ru", name: "Russian" },
+  { code: "uk", name: "Ukrainian" },
+  { code: "ar", name: "Arabic" },
+  { code: "he", name: "Hebrew" },
+  { code: "hi", name: "Hindi" },
+  { code: "ja", name: "Japanese" },
+  { code: "ko", name: "Korean" },
+  { code: "zh-Hans", name: "Chinese (Simplified)" },
+  { code: "zh-Hant", name: "Chinese (Traditional)" },
+  { code: "id", name: "Indonesian" },
+  { code: "th", name: "Thai" },
+  { code: "vi", name: "Vietnamese" }
+];
+function localeName(code) {
+  const exact = COMMON_LOCALES.find((l) => l.code.toLowerCase() === code.toLowerCase());
+  if (exact) return exact.name;
+  const base = COMMON_LOCALES.find((l) => l.code.toLowerCase() === baseLanguage(code));
+  return base ? `${base.name} (${code})` : code;
+}
+function normalizeLocale(input) {
+  if (typeof input !== "string") return "";
+  const parts = input.trim().replace(/_/g, "-").split("-").filter(Boolean);
+  if (!parts.length || !/^[a-zA-Z]{2,3}$/.test(parts[0])) return "";
+  return parts.slice(0, 3).map((p, i) => i === 0 ? p.toLowerCase() : p.length === 4 ? p[0].toUpperCase() + p.slice(1).toLowerCase() : p.length === 2 ? p.toUpperCase() : p).join("-");
+}
+function baseLanguage(locale) {
+  return normalizeLocale(locale).split("-")[0] ?? "";
+}
+function resolveLocale(requested, available, defaultLocale = DEFAULT_LOCALE) {
+  const def = normalizeLocale(defaultLocale) || DEFAULT_LOCALE;
+  const avail = available.map(normalizeLocale).filter(Boolean);
+  const all = [def, ...avail.filter((a) => a.toLowerCase() !== def.toLowerCase())];
+  for (const raw of requested) {
+    const want = normalizeLocale(raw);
+    if (!want) continue;
+    const exact = all.find((a) => a.toLowerCase() === want.toLowerCase());
+    if (exact) return exact;
+    const base = baseLanguage(want);
+    const sameBase = all.find((a) => a.toLowerCase() === base) ?? all.find((a) => baseLanguage(a) === base);
+    if (sameBase) return sameBase;
+  }
+  return def;
+}
+function visitorLocales(explicit, traits, platform = []) {
+  const out = [];
+  const push = (v) => {
+    const n = normalizeLocale(v);
+    if (n && !out.includes(n)) out.push(n);
+  };
+  push(explicit);
+  push(traits?.language);
+  push(traits?.locale);
+  for (const p of platform) push(p);
+  return out;
+}
+function guideTextEntries(config) {
+  const out = [];
+  const add = (key, source, kind, label) => {
+    if (source && source.trim()) out.push({ key, source, kind, label });
+  };
+  config.steps.forEach((s, i) => {
+    const at = `Step ${i + 1}`;
+    add(`steps.${s.id}.title`, s.title, "text", `${at} \xB7 Title`);
+    add(`steps.${s.id}.body`, s.body, "html", `${at} \xB7 Body`);
+    add(`steps.${s.id}.customHtml`, s.customHtml, "html", `${at} \xB7 Custom HTML`);
+    add(`steps.${s.id}.imageAlt`, s.imageAlt, "text", `${at} \xB7 Image description`);
+    s.buttons.forEach((b) => add(`steps.${s.id}.buttons.${b.id}.label`, b.label, "text", `${at} \xB7 Button \u201C${b.label}\u201D`));
+  });
+  const c = config.checklist;
+  if (c) {
+    add("checklist.launcherLabel", c.launcherLabel, "text", "Checklist \xB7 Launcher label");
+    add("checklist.completionTitle", c.completionTitle, "text", "Checklist \xB7 Completion title");
+    add("checklist.completionBody", c.completionBody, "html", "Checklist \xB7 Completion message");
+    c.tasks.forEach((t, i) => {
+      add(`checklist.tasks.${t.id}.title`, t.title, "text", `Task ${i + 1} \xB7 Title`);
+      add(`checklist.tasks.${t.id}.description`, t.description, "html", `Task ${i + 1} \xB7 Description`);
+    });
+  }
+  const sv = config.survey;
+  if (sv) {
+    sv.questions.forEach((q, i) => {
+      const at = `Question ${i + 1}`;
+      add(`survey.questions.${q.id}.title`, q.title, "text", `${at} \xB7 Question`);
+      add(`survey.questions.${q.id}.description`, q.description, "text", `${at} \xB7 Description`);
+      add(`survey.questions.${q.id}.placeholder`, q.placeholder, "text", `${at} \xB7 Placeholder`);
+      add(`survey.questions.${q.id}.lowLabel`, q.lowLabel, "text", `${at} \xB7 Low label`);
+      add(`survey.questions.${q.id}.highLabel`, q.highLabel, "text", `${at} \xB7 High label`);
+      q.options.forEach((o) => add(`survey.questions.${q.id}.options.${o.id}.label`, o.label, "text", `${at} \xB7 Option \u201C${o.label}\u201D`));
+    });
+    add("survey.thankYouTitle", sv.thankYouTitle, "text", "Survey \xB7 Thank-you title");
+    add("survey.thankYouBody", sv.thankYouBody, "html", "Survey \xB7 Thank-you message");
+  }
+  return out;
+}
+function guideLocales(config) {
+  const t = config.localization?.translations ?? {};
+  return Object.keys(t).filter((l) => Object.values(t[l] ?? {}).some((v) => typeof v === "string" && v.trim() !== ""));
+}
+function pick(map, key, fallback) {
+  const v = map?.[key];
+  return typeof v === "string" && v.trim() !== "" ? v : fallback;
+}
+function applyGuideTranslations(config, map) {
+  if (!map || !Object.keys(map).length) return config;
+  return {
+    ...config,
+    steps: config.steps.map((s) => ({
+      ...s,
+      title: pick(map, `steps.${s.id}.title`, s.title),
+      body: pick(map, `steps.${s.id}.body`, s.body),
+      customHtml: pick(map, `steps.${s.id}.customHtml`, s.customHtml),
+      imageAlt: pick(map, `steps.${s.id}.imageAlt`, s.imageAlt),
+      buttons: s.buttons.map((b) => ({ ...b, label: pick(map, `steps.${s.id}.buttons.${b.id}.label`, b.label) }))
+    })),
+    checklist: config.checklist ? {
+      ...config.checklist,
+      launcherLabel: pick(map, "checklist.launcherLabel", config.checklist.launcherLabel),
+      completionTitle: pick(map, "checklist.completionTitle", config.checklist.completionTitle),
+      completionBody: pick(map, "checklist.completionBody", config.checklist.completionBody),
+      tasks: config.checklist.tasks.map((t) => ({ ...t, title: pick(map, `checklist.tasks.${t.id}.title`, t.title), description: pick(map, `checklist.tasks.${t.id}.description`, t.description) }))
+    } : config.checklist,
+    survey: config.survey ? {
+      ...config.survey,
+      thankYouTitle: pick(map, "survey.thankYouTitle", config.survey.thankYouTitle),
+      thankYouBody: pick(map, "survey.thankYouBody", config.survey.thankYouBody),
+      questions: config.survey.questions.map((q) => ({
+        ...q,
+        title: pick(map, `survey.questions.${q.id}.title`, q.title),
+        description: pick(map, `survey.questions.${q.id}.description`, q.description),
+        placeholder: pick(map, `survey.questions.${q.id}.placeholder`, q.placeholder),
+        lowLabel: pick(map, `survey.questions.${q.id}.lowLabel`, q.lowLabel),
+        highLabel: pick(map, `survey.questions.${q.id}.highLabel`, q.highLabel),
+        options: q.options.map((o) => ({ ...o, label: pick(map, `survey.questions.${q.id}.options.${o.id}.label`, o.label) }))
+      }))
+    } : config.survey
+  };
+}
+function localizeGuide(guide, requested, defaultLocale = DEFAULT_LOCALE) {
+  const translations = guide.config.localization?.translations ?? {};
+  const locale = resolveLocale(requested, guideLocales(guide.config), defaultLocale);
+  const key = Object.keys(translations).find((l) => normalizeLocale(l).toLowerCase() === locale.toLowerCase());
+  if (!key) return { ...guide, locale };
+  return { ...guide, locale, config: applyGuideTranslations(guide.config, translations[key]) };
+}
+function translationCoverage(entries, map, locale) {
+  const keys = new Set(entries.map((e) => e.key));
+  const missing = entries.filter((e) => !pick(map, e.key, void 0)).map((e) => e.key);
+  const stale = Object.keys(map ?? {}).filter((k) => !keys.has(k) && (map?.[k] ?? "").trim() !== "");
+  return { locale, total: entries.length, translated: entries.length - missing.length, missing, stale };
+}
+function resourceCenterTextEntries(rc) {
+  const out = [];
+  const add = (key, source, kind, label) => {
+    if (source && source.trim()) out.push({ key, source, kind, label });
+  };
+  add("title", rc.title, "text", "Title");
+  add("launcher.label", rc.launcher?.label, "text", "Launcher label");
+  rc.collections.forEach((c) => {
+    add(`collections.${c.id}.name`, c.name, "text", `Collection \u201C${c.name}\u201D`);
+    add(`collections.${c.id}.description`, c.description, "text", `Collection \u201C${c.name}\u201D \xB7 Description`);
+  });
+  rc.links.forEach((l) => add(`links.${l.id}.label`, l.label, "text", `Link \u201C${l.label}\u201D`));
+  rc.faqs.forEach((f, i) => {
+    add(`faqs.${f.id}.question`, f.question, "text", `FAQ ${i + 1} \xB7 Question`);
+    add(`faqs.${f.id}.answer`, f.answer, "html", `FAQ ${i + 1} \xB7 Answer`);
+  });
+  return out;
+}
+function articleTextEntries(a) {
+  const out = [];
+  if (a.title.trim()) out.push({ key: "title", source: a.title, kind: "text", label: "Title" });
+  if (a.summary?.trim()) out.push({ key: "summary", source: a.summary, kind: "text", label: "Summary" });
+  if (a.body?.trim()) out.push({ key: "body", source: a.body, kind: "html", label: "Body" });
+  return out;
+}
+function resourceCenterLocales(rc) {
+  const set = new Set(Object.keys(rc.translations ?? {}));
+  for (const a of rc.articles) for (const l of Object.keys(a.translations ?? {})) set.add(l);
+  for (const a of rc.announcements ?? []) for (const l of Object.keys(a.translations ?? {})) set.add(l);
+  return [...set];
+}
+function translationFor(map, locale) {
+  if (!map) return void 0;
+  const key = Object.keys(map).find((l) => normalizeLocale(l).toLowerCase() === locale.toLowerCase());
+  return key ? map[key] : void 0;
+}
+function localizeArticle(a, locale) {
+  const t = translationFor(a.translations, locale);
+  if (!t) return a;
+  const body = t.body?.trim() ? t.body : a.body;
+  return { ...a, title: t.title?.trim() ? t.title : a.title, summary: t.summary?.trim() ? t.summary : a.summary, body, ...t.bodyOmitted ? { bodyOmitted: true } : {} };
+}
+function localizeAnnouncement(a, locale) {
+  const t = translationFor(a.translations, locale);
+  if (!t) return a;
+  return { ...a, title: t.title?.trim() ? t.title : a.title, body: t.body?.trim() ? t.body : a.body };
+}
+function localizeResourceCenter(rc, requested, defaultLocale = DEFAULT_LOCALE) {
+  const locale = resolveLocale(requested, resourceCenterLocales(rc), defaultLocale);
+  if (locale.toLowerCase() === normalizeLocale(defaultLocale).toLowerCase()) return { ...rc, locale };
+  const map = translationFor(rc.translations, locale);
+  return {
+    ...rc,
+    locale,
+    title: pick(map, "title", rc.title),
+    launcher: { ...rc.launcher, label: pick(map, "launcher.label", rc.launcher.label) },
+    collections: rc.collections.map((c) => ({ ...c, name: pick(map, `collections.${c.id}.name`, c.name), description: pick(map, `collections.${c.id}.description`, c.description) })),
+    links: rc.links.map((l) => ({ ...l, label: pick(map, `links.${l.id}.label`, l.label) })),
+    faqs: rc.faqs.map((f) => ({ ...f, question: pick(map, `faqs.${f.id}.question`, f.question), answer: pick(map, `faqs.${f.id}.answer`, f.answer) })),
+    articles: rc.articles.map((a) => localizeArticle(a, locale)),
+    announcements: rc.announcements?.map((a) => localizeAnnouncement(a, locale))
+  };
+}
+
+// src/guide-experiments.ts
+var CONTROL_VARIANT_ID = "control";
+var GUIDE_EXPERIMENT_STATUSES = ["draft", "running", "completed"];
+var GUIDE_EXPERIMENT_GOALS = ["guide_completed", "event", "page_visit", "click_text"];
+var GUIDE_EXPERIMENT_GOAL_LABELS = {
+  guide_completed: "Completes the guide",
+  event: "Tracks an event",
+  page_visit: "Visits a page",
+  click_text: "Clicks an element with text"
+};
+function experimentSalt(experimentId) {
+  return `gx:${experimentId}`;
+}
+function variantRanges(variants) {
+  let at = 0;
+  return variants.map((v) => {
+    const from = at;
+    at = Math.min(100, at + Math.max(0, Math.round(v.weight)));
+    return { id: v.id, from, to: at };
+  });
+}
+function assignGuideVariant(variants, experimentId, subject) {
+  const bucket = rolloutBucket(subject, experimentSalt(experimentId));
+  return variantRanges(variants).find((r) => bucket >= r.from && bucket < r.to)?.id ?? null;
+}
+function experimentBucketRules(salt, from, to) {
+  return [
+    { id: "experiment-from", field: "experiment.bucket", key: salt, op: "gte", value: from },
+    { id: "experiment-to", field: "experiment.bucket", key: salt, op: "lt", value: to }
+  ];
+}
+function withExperimentBucket(targeting, salt, from, to) {
+  return { id: "experiment", op: "and", rules: [...experimentBucketRules(salt, from, to), targeting] };
+}
+function variantProblems(variants) {
+  const problems = [];
+  if (variants.length < 2) problems.push("An A/B test needs at least two variants.");
+  if (variants.length > 5) problems.push("An A/B test can have at most five variants.");
+  const guides = variants.filter((v) => v.guideId);
+  if (guides.length === 0) problems.push("At least one variant must show a guide.");
+  if (variants.filter((v) => !v.guideId).length > 1) problems.push("Only one variant can be the control group (no guide).");
+  if (new Set(guides.map((v) => v.guideId)).size !== guides.length) problems.push("Each variant needs its own guide.");
+  if (new Set(variants.map((v) => v.id)).size !== variants.length) problems.push("Variant ids must be unique.");
+  if (variants.some((v) => !Number.isInteger(v.weight) || v.weight < 1)) problems.push("Every variant needs a whole-number share of at least 1%.");
+  const total = variants.reduce((s, v) => s + v.weight, 0);
+  if (total !== 100) problems.push(`Traffic shares must add up to 100% (now ${total}%).`);
+  return problems;
+}
+function evenWeights(n) {
+  if (n <= 0) return [];
+  const base = Math.floor(100 / n);
+  return Array.from({ length: n }, (_, i) => base + (i < 100 - base * n ? 1 : 0));
+}
+
+// src/custom-css.ts
+var MAX_CUSTOM_CSS = 2e4;
+var BLOCKED_AT_RULES = /^@(import|charset|namespace|document|-moz-document)\b/i;
+var ALLOWED_AT_RULES = /^@(media|supports|container|layer|keyframes|-webkit-keyframes|font-face)\b/i;
+function splitBlocks(css) {
+  const out = [];
+  let i = 0;
+  const n = css.length;
+  while (i < n) {
+    let prelude = "";
+    let quote = null;
+    while (i < n) {
+      const ch = css[i];
+      if (quote) {
+        prelude += ch;
+        if (ch === "\\") prelude += css[++i] ?? "";
+        else if (ch === quote) quote = null;
+      } else if (ch === '"' || ch === "'") {
+        quote = ch;
+        prelude += ch;
+      } else if (ch === "{") break;
+      else if (ch === ";") {
+        prelude = "";
+      } else if (ch === "}") {
+        prelude = "";
+      } else prelude += ch;
+      i++;
+    }
+    if (i >= n) break;
+    i++;
+    let depth = 1;
+    let body = "";
+    quote = null;
+    while (i < n && depth > 0) {
+      const ch = css[i];
+      if (quote) {
+        body += ch;
+        if (ch === "\\") body += css[++i] ?? "";
+        else if (ch === quote) quote = null;
+      } else if (ch === '"' || ch === "'") {
+        quote = ch;
+        body += ch;
+      } else if (ch === "{") {
+        depth++;
+        body += ch;
+      } else if (ch === "}") {
+        depth--;
+        if (depth > 0) body += ch;
+      } else body += ch;
+      i++;
+    }
+    out.push({ prelude: prelude.trim(), body });
+  }
+  return out;
+}
+function splitSelectors(list) {
+  const out = [];
+  let depth = 0;
+  let cur = "";
+  for (const ch of list) {
+    if (ch === "(" || ch === "[") depth++;
+    else if (ch === ")" || ch === "]") depth = Math.max(0, depth - 1);
+    if (ch === "," && depth === 0) {
+      out.push(cur.trim());
+      cur = "";
+    } else cur += ch;
+  }
+  if (cur.trim()) out.push(cur.trim());
+  return out;
+}
+function safeUrl(raw) {
+  const u = raw.trim().replace(/^['"]|['"]$/g, "").trim();
+  return /^https:\/\//i.test(u) || /^data:image\/(png|jpe?g|gif|webp|svg\+xml)[;,]/i.test(u);
+}
+function cleanDeclarations(body) {
+  return body.replace(/url\(([^)]*)\)/gi, (m, inner) => safeUrl(inner) ? m : "none").replace(/expression\s*\(/gi, "(").replace(/javascript\s*:/gi, "").replace(/(^|[;{\s])(-moz-binding|behavior)\s*:[^;]*;?/gi, "$1").replace(/[{}]/g, "").trim();
+}
+function sanitizeCustomCss(input) {
+  if (!input) return "";
+  let css = String(input).slice(0, MAX_CUSTOM_CSS);
+  css = css.replace(/\/\*[\s\S]*?\*\//g, "").replace(/<(script|style)\b[^>]*>[\s\S]*?<\/\1\s*>/gi, "").replace(/<\/?[a-z!][^>]*>/gi, "").replace(/</g, "");
+  return render(splitBlocks(css), 0);
+}
+function render(blocks, depth) {
+  const parts = [];
+  for (const b of blocks) {
+    if (!b.prelude) continue;
+    if (b.prelude.startsWith("@")) {
+      if (BLOCKED_AT_RULES.test(b.prelude) || !ALLOWED_AT_RULES.test(b.prelude)) continue;
+      if (/^@(-webkit-)?keyframes|^@font-face/i.test(b.prelude)) {
+        const inner = /^@font-face/i.test(b.prelude) ? cleanDeclarations(b.body) : splitBlocks(b.body).map((k) => `${k.prelude}{${cleanDeclarations(k.body)}}`).join("");
+        parts.push(`${b.prelude}{${inner}}`);
+      } else if (depth < 3) parts.push(`${b.prelude}{${render(splitBlocks(b.body), depth + 1)}}`);
+      continue;
+    }
+    const selectors = splitSelectors(b.prelude).filter((s) => !/:host|::slotted|::part/i.test(s));
+    if (!selectors.length) continue;
+    parts.push(`${selectors.join(",")}{${cleanDeclarations(b.body)}}`);
+  }
+  return parts.join("\n");
+}
+function scopeCustomCss(css, scope) {
+  return scopeBlocks(splitBlocks(sanitizeCustomCss(css)), scope, 0);
+}
+function scopeBlocks(blocks, scope, depth) {
+  const parts = [];
+  for (const b of blocks) {
+    if (b.prelude.startsWith("@")) {
+      if (/^@(-webkit-)?keyframes|^@font-face/i.test(b.prelude)) parts.push(`${b.prelude}{${b.body}}`);
+      else if (depth < 3) parts.push(`${b.prelude}{${scopeBlocks(splitBlocks(b.body), scope, depth + 1)}}`);
+      continue;
+    }
+    const sels = splitSelectors(b.prelude).map((s) => {
+      const self = s.match(/^(:root|html|body|:scope|&)(?![\w-])(.*)$/i);
+      if (self) return `${scope}${self[2] ?? ""}`;
+      return `${scope} ${s}`;
+    });
+    parts.push(`${sels.join(",")}{${b.body}}`);
+  }
+  return parts.join("\n");
+}
+
+// src/contrast.ts
+var WCAG_AA_TEXT = 4.5;
+var WCAG_AA_LARGE = 3;
+function channel(c) {
+  const s = c / 255;
+  return s <= 0.03928 ? s / 12.92 : ((s + 0.055) / 1.055) ** 2.4;
+}
+function parseHexColor(hex) {
+  if (!hex) return null;
+  const m = hex.trim().match(/^#?([0-9a-f]{3}|[0-9a-f]{6})$/i);
+  if (!m) return null;
+  const h = m[1].length === 3 ? m[1].split("").map((c) => c + c).join("") : m[1];
+  return [parseInt(h.slice(0, 2), 16), parseInt(h.slice(2, 4), 16), parseInt(h.slice(4, 6), 16)];
+}
+function relativeLuminance(hex) {
+  const rgb = parseHexColor(hex);
+  if (!rgb) return null;
+  return 0.2126 * channel(rgb[0]) + 0.7152 * channel(rgb[1]) + 0.0722 * channel(rgb[2]);
+}
+function contrastRatio(a, b) {
+  const la = relativeLuminance(a);
+  const lb = relativeLuminance(b);
+  if (la === null || lb === null) return null;
+  const [hi, lo] = la > lb ? [la, lb] : [lb, la];
+  return Math.round((hi + 0.05) / (lo + 0.05) * 100) / 100;
+}
+function readableTextOn(background) {
+  const white = contrastRatio(background, "#ffffff") ?? 0;
+  const dark = contrastRatio(background, "#111827") ?? 0;
+  return white >= dark ? "#ffffff" : "#111827";
+}
+function contrastIssues(colors) {
+  const issues = [];
+  const { primaryColor, backgroundColor, textColor } = colors;
+  if (textColor && backgroundColor) {
+    const r = contrastRatio(textColor, backgroundColor);
+    if (r !== null && r < WCAG_AA_TEXT) issues.push({ pair: "text", ratio: r, required: WCAG_AA_TEXT, message: `Text on the background has a contrast of ${r}:1; WCAG AA needs ${WCAG_AA_TEXT}:1.` });
+  }
+  if (primaryColor) {
+    const label = contrastRatio(primaryColor, readableTextOn(primaryColor));
+    if (label !== null && label < WCAG_AA_TEXT) issues.push({ pair: "button", ratio: label, required: WCAG_AA_TEXT, message: `Button labels on the primary colour have a contrast of ${label}:1; WCAG AA needs ${WCAG_AA_TEXT}:1.` });
+    if (backgroundColor) {
+      const link = contrastRatio(primaryColor, backgroundColor);
+      if (link !== null && link < WCAG_AA_LARGE) issues.push({ pair: "link", ratio: link, required: WCAG_AA_LARGE, message: `The primary colour on the background (links, outlined buttons) has a contrast of ${link}:1; WCAG AA needs ${WCAG_AA_LARGE}:1.` });
+    }
+  }
+  return issues;
+}
 // Annotate the CommonJS export names for ESM import in node:
 0 && (module.exports = {
+  AGENT_METADATA_MAX_BYTES,
+  AGENT_METADATA_MAX_KEYS,
+  AGENT_OUTCOMES,
+  AGENT_TOOL_CALLS_PER_TURN,
+  AGENT_TOOL_STATUSES,
+  AGENT_TURNS_PER_BATCH,
+  AGENT_TURN_MAX_TEXT,
+  AGENT_TURN_ROLES,
   ARTICLE_VISIBILITIES,
   CAPTURE_PARAM,
   CAPTURE_SCREENSHOT_MAX_BYTES,
+  COMMON_LOCALES,
   COMPLAINT_EVENTS,
   COMPLAINT_FIELD_TYPES,
   COMPLAINT_STATUSES,
+  CONTROL_VARIANT_ID,
+  DEFAULT_FEATURE_ATTRIBUTE,
+  DEFAULT_LOCALE,
   DEFAULT_PLATFORMS,
   EMBED_IFRAME_ATTRS,
+  FEATURE_ATTRIBUTE_PATTERN,
+  FEATURE_RULE_LIMITS,
   FILE_LINK_CLASS,
   GUIDELY_ID_ATTRIBUTE,
+  GUIDE_EXPERIMENT_GOALS,
+  GUIDE_EXPERIMENT_GOAL_LABELS,
+  GUIDE_EXPERIMENT_STATUSES,
   GUIDE_VISIBILITIES,
   LOGGED_IN_AUDIENCE,
   MAX_COLLECTION_DEPTH,
@@ -848,6 +1993,7 @@ var complaintReference = (number) => `CMP-${number}`;
   MAX_COMPLAINT_CHOICES,
   MAX_COMPLAINT_FIELDS,
   MAX_COMPLAINT_LENGTH,
+  MAX_CUSTOM_CSS,
   MAX_PROPERTY_BYTES,
   MAX_STACK_FRAMES,
   MEDIA_FILE_MAX_BYTES,
@@ -858,38 +2004,65 @@ var complaintReference = (number) => `CMP-${number}`;
   MEDIA_VIDEO_MAX_BYTES,
   MEDIA_VIDEO_TYPES,
   NETWORK_PLUGIN,
+  NOISY_DATA_ATTR,
+  PAGE_RULE_LIMITS,
   PATH_ID_PATTERN,
   PDF_BLOCK_CLASS,
   PDF_MAX_PAGES,
   PDF_PAGES_CLASS,
   PLATFORMS,
+  RC_MODULE_IDS,
+  RC_MODULE_LABELS,
   RULE_FIELDS,
   RULE_OPERATORS,
+  SCOUT_AGENT_ID,
   SENSITIVE_HEADER_PATTERN,
   SENSITIVE_PARAM_PATTERN,
   SENSITIVE_PROPERTY_PATTERN,
   SERVER_ASSISTED_FIELDS,
   SHOW_ME_CLASS,
   SHOW_ME_HREF_PREFIX,
+  SNAPSHOT_ATTRS,
+  SNAPSHOT_LIMITS,
   SOURCEMAP_MAX_FILES_PER_UPLOAD,
   SOURCEMAP_MAX_FILE_BYTES,
+  SelectorSyntaxError,
+  TAG_PROPERTY_LIMITS,
   VIDEO_ATTRS,
+  WCAG_AA_LARGE,
+  WCAG_AA_TEXT,
   WS_MAX_MESSAGES_PER_SOCKET,
   WS_MAX_MESSAGE_BYTES,
+  applyGuideTranslations,
+  articleTextEntries,
+  assignGuideVariant,
+  baseLanguage,
   clamp,
   compare,
   compareVersions,
   complaintReference,
+  compoundMatches,
+  contrastIssues,
+  contrastRatio,
+  cssSelectorError,
   describeRule,
   emptyRuleGroup,
   evaluateRule,
   evaluateRules,
+  evenWeights,
+  experimentBucketRules,
+  experimentSalt,
+  featureCssSelectors,
+  featureRuleError,
+  featureRuleMatchesClick,
   fingerprintError,
   firstNameFromTraits,
   fnv1a,
   foldPathIds,
   getPath,
+  guideLocales,
   guidePlatforms,
+  guideTextEntries,
   guidelyIdFromSelector,
   hasVideoMedia,
   isAllowedEmbedSrc,
@@ -902,6 +2075,12 @@ var complaintReference = (number) => `CMP-${number}`;
   isRuleGroup,
   isSafeMediaUrl,
   isVideoContentType,
+  localeName,
+  localizeAnnouncement,
+  localizeArticle,
+  localizeGuide,
+  localizeResourceCenter,
+  matchCssSelector,
   matchUrlPattern,
   matchesAudiences,
   matchesHelpQuery,
@@ -909,25 +2088,52 @@ var complaintReference = (number) => `CMP-${number}`;
   mediaMaxBytes,
   normalizeErrorMessage,
   normalizeFrameFile,
+  normalizeLocale,
+  normalizeSnapshot,
+  orderedModules,
   pageLabel,
+  pagePattern,
+  pageRuleError,
+  pageRuleMatches,
+  pageRulesMatch,
   pageTerms,
+  parseCssSelector,
+  parseHexColor,
   parseStack,
+  propertyAttributeAllowed,
+  queryConditionRegex,
   randomId,
+  readableTextOn,
+  relativeLuminance,
+  resolveLocale,
+  resourceCenterLocales,
   resourceCenterSections,
+  resourceCenterTextEntries,
   rolloutBucket,
   safeRegExp,
+  sanitizeCustomCss,
   sanitizeProperties,
+  scopeCustomCss,
   screenPath,
   servedArticleAudiences,
   showMeHref,
   showMeKeyFromHref,
   showMeKeys,
   slugify,
+  snapshotFromSelector,
+  stableStringify,
   stripOrigin,
   supportsPlatform,
   toEmbedUrl,
+  translationCoverage,
+  unreadAnnouncements,
+  variantProblems,
+  variantRanges,
+  visibleAnnouncements,
   visibleArticleIds,
   visitorAudiences,
+  visitorLocales,
+  withExperimentBucket,
   withVisibility
 });
 //# sourceMappingURL=runtime.cjs.map