@guidelytech/shared 0.9.0 → 0.11.0

package/dist/index.cjs

@@ -21,9 +21,22 @@ var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: tru
 var index_exports = {};
 __export(index_exports, {
   ADVANCE_ON: () => ADVANCE_ON,
+  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,
   ANNOTATION_COLORS: () => ANNOTATION_COLORS,
+  APP_LIFECYCLE_EVENTS: () => APP_LIFECYCLE_EVENTS,
   ARTICLE_VISIBILITIES: () => ARTICLE_VISIBILITIES,
   AUTOCAPTURE_EVENTS: () => AUTOCAPTURE_EVENTS,
+  AgentEventsRequestSchema: () => AgentEventsRequestSchema,
+  AgentMetadataSchema: () => AgentMetadataSchema,
+  AgentToolCallSchema: () => AgentToolCallSchema,
+  AgentTurnInputSchema: () => AgentTurnInputSchema,
   AppearanceSchema: () => AppearanceSchema,
   AuthoringPickSchema: () => AuthoringPickSchema,
   AutocaptureSettingsSchema: () => AutocaptureSettingsSchema,
@@ -31,9 +44,11 @@ __export(index_exports, {
   ButtonSchema: () => ButtonSchema,
   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,
   CaptureStepSchema: () => CaptureStepSchema,
   CapturedElementSchema: () => CapturedElementSchema,
   ChecklistConfigSchema: () => ChecklistConfigSchema,
@@ -42,28 +57,54 @@ __export(index_exports, {
   ConversationLookupSchema: () => ConversationLookupSchema,
   ConversationRatingSchema: () => ConversationRatingSchema,
   DEFAULT_CAPTURE_SETTINGS: () => DEFAULT_CAPTURE_SETTINGS,
+  DEFAULT_FEATURE_ATTRIBUTE: () => DEFAULT_FEATURE_ATTRIBUTE,
+  DEFAULT_LOCALE: () => DEFAULT_LOCALE,
   DEFAULT_PLATFORMS: () => DEFAULT_PLATFORMS,
   EMBED_IFRAME_ATTRS: () => EMBED_IFRAME_ATTRS,
   EVENT_NAMES: () => EVENT_NAMES,
   ErrorTrackingSettingsSchema: () => ErrorTrackingSettingsSchema,
   EventBatchSchema: () => EventBatchSchema,
+  FEATURE_ATTRIBUTE_PATTERN: () => FEATURE_ATTRIBUTE_PATTERN,
+  FEATURE_RULE_LIMITS: () => FEATURE_RULE_LIMITS,
+  FEEDBACK_EVENTS: () => FEEDBACK_EVENTS,
+  FEEDBACK_PRIORITIES: () => FEEDBACK_PRIORITIES,
+  FEEDBACK_PRIORITY_LABEL: () => FEEDBACK_PRIORITY_LABEL,
+  FEEDBACK_PRIORITY_WEIGHT: () => FEEDBACK_PRIORITY_WEIGHT,
+  FEEDBACK_STATUSES: () => FEEDBACK_STATUSES,
+  FEEDBACK_STATUS_LABEL: () => FEEDBACK_STATUS_LABEL,
   FILE_LINK_CLASS: () => FILE_LINK_CLASS,
+  FeedbackCommentSchema: () => FeedbackCommentSchema,
+  FeedbackFollowSchema: () => FeedbackFollowSchema,
+  FeedbackListRequestSchema: () => FeedbackListRequestSchema,
+  FeedbackSimilarSchema: () => FeedbackSimilarSchema,
+  FeedbackUpdatesReadSchema: () => FeedbackUpdatesReadSchema,
+  FeedbackVisitorSchema: () => FeedbackVisitorSchema,
+  FeedbackVoteSchema: () => FeedbackVoteSchema,
   FileComplaintSchema: () => FileComplaintSchema,
   FrequencySchema: () => FrequencySchema,
   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_KINDS: () => GUIDE_KINDS,
   GUIDE_LIFECYCLE_EVENTS: () => GUIDE_LIFECYCLE_EVENTS,
   GUIDE_STATUSES: () => GUIDE_STATUSES,
   GUIDE_TEMPLATES: () => GUIDE_TEMPLATES,
   GUIDE_VISIBILITIES: () => GUIDE_VISIBILITIES,
   GuideConfigSchema: () => GuideConfigSchema,
+  GuideLocalizationSchema: () => GuideLocalizationSchema,
+  GuideScheduleSchema: () => GuideScheduleSchema,
   GuideStateUpdateSchema: () => GuideStateUpdateSchema,
+  GuideThrottlingSchema: () => GuideThrottlingSchema,
   HEATMAP_VIEWPORTS: () => HEATMAP_VIEWPORTS,
   HOWTO_ACTIONS: () => HOWTO_ACTIONS,
   HOWTO_STEP_KINDS: () => HOWTO_STEP_KINDS,
   HowToAnnotationSchema: () => HowToAnnotationSchema,
   IdentifyRequestSchema: () => IdentifyRequestSchema,
+  LOCALE_PATTERN: () => LOCALE_PATTERN,
   LOGGED_IN_AUDIENCE: () => LOGGED_IN_AUDIENCE,
+  LocaleSchema: () => LocaleSchema,
+  LocalizationSettingsSchema: () => LocalizationSettingsSchema,
   MAX_ANNOTATIONS: () => MAX_ANNOTATIONS,
   MAX_COLLECTION_DEPTH: () => MAX_COLLECTION_DEPTH,
   MAX_COMPLAINT_ANSWER_LENGTH: () => MAX_COMPLAINT_ANSWER_LENGTH,
@@ -71,6 +112,11 @@ __export(index_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_FEEDBACK_COMMENT: () => MAX_FEEDBACK_COMMENT,
+  MAX_FEEDBACK_DESCRIPTION: () => MAX_FEEDBACK_DESCRIPTION,
+  MAX_FEEDBACK_NOTE: () => MAX_FEEDBACK_NOTE,
+  MAX_FEEDBACK_TITLE: () => MAX_FEEDBACK_TITLE,
   MAX_MESSAGE_LENGTH: () => MAX_MESSAGE_LENGTH,
   MAX_PROPERTY_BYTES: () => MAX_PROPERTY_BYTES,
   MAX_STACK_FRAMES: () => MAX_STACK_FRAMES,
@@ -84,8 +130,10 @@ __export(index_exports, {
   MESSAGE_AUTHORS: () => MESSAGE_AUTHORS,
   MessengerPageRequestSchema: () => MessengerPageRequestSchema,
   NETWORK_PLUGIN: () => NETWORK_PLUGIN,
+  NOISY_DATA_ATTR: () => NOISY_DATA_ATTR,
   NormalizedPointSchema: () => NormalizedPointSchema,
   NormalizedRectSchema: () => NormalizedRectSchema,
+  PAGE_RULE_LIMITS: () => PAGE_RULE_LIMITS,
   PATH_ID_PATTERN: () => PATH_ID_PATTERN,
   PDF_BLOCK_CLASS: () => PDF_BLOCK_CLASS,
   PDF_MAX_PAGES: () => PDF_MAX_PAGES,
@@ -95,6 +143,8 @@ __export(index_exports, {
   PostMessageSchema: () => PostMessageSchema,
   ProjectThemeSchema: () => ProjectThemeSchema,
   PublishedGuideSchema: () => PublishedGuideSchema,
+  RC_MODULE_IDS: () => RC_MODULE_IDS,
+  RC_MODULE_LABELS: () => RC_MODULE_LABELS,
   REPLAY_MAX_COMPRESSED_BYTES: () => REPLAY_MAX_COMPRESSED_BYTES,
   REPLAY_MAX_RAW_BYTES: () => REPLAY_MAX_RAW_BYTES,
   REPLY_TIMES: () => REPLY_TIMES,
@@ -104,6 +154,9 @@ __export(index_exports, {
   ReplaySettingsSchema: () => ReplaySettingsSchema,
   RuleGroupSchema: () => RuleGroupSchema,
   RuleSchema: () => RuleSchema,
+  SCOUT_AGENT_ID: () => SCOUT_AGENT_ID,
+  SCRIPT_STUB: () => SCRIPT_STUB,
+  SCRIPT_STUB_METHODS: () => SCRIPT_STUB_METHODS,
   SDK_API_VERSION: () => SDK_API_VERSION,
   SELECTOR_KINDS: () => SELECTOR_KINDS,
   SENSITIVE_HEADER_PATTERN: () => SENSITIVE_HEADER_PATTERN,
@@ -113,30 +166,46 @@ __export(index_exports, {
   SHARED_VERSION: () => SHARED_VERSION,
   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,
   STATUS_LEVELS: () => STATUS_LEVELS,
   STEP_TYPES: () => STEP_TYPES,
   SURVEY_QUESTION_TYPES: () => SURVEY_QUESTION_TYPES,
+  SdkAgentEventsSchema: () => SdkAgentEventsSchema,
   SdkEventSchema: () => SdkEventSchema,
   SelectorStrategySchema: () => SelectorStrategySchema,
+  SelectorSyntaxError: () => SelectorSyntaxError,
   StartConversationSchema: () => StartConversationSchema,
   StepBranchSchema: () => StepBranchSchema,
   StepSchema: () => StepSchema,
+  SubmitFeedbackSchema: () => SubmitFeedbackSchema,
   SurveyConfigSchema: () => SurveyConfigSchema,
   SurveyQuestionSchema: () => SurveyQuestionSchema,
   SurveyResponseRequestSchema: () => SurveyResponseRequestSchema,
+  TAG_PROPERTY_LIMITS: () => TAG_PROPERTY_LIMITS,
   TRIGGER_TYPES: () => TRIGGER_TYPES,
   TargetSchema: () => TargetSchema,
   TriggerSchema: () => TriggerSchema,
   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,
   cleanLabel: () => cleanLabel,
   compare: () => compare,
   compareVersions: () => compareVersions,
   complaintReference: () => complaintReference,
+  compoundMatches: () => compoundMatches,
+  contrastIssues: () => contrastIssues,
+  contrastRatio: () => contrastRatio,
+  cssSelectorError: () => cssSelectorError,
   defaultGuideConfig: () => defaultGuideConfig,
   defaultStep: () => defaultStep,
   describeCaptureStep: () => describeCaptureStep,
@@ -144,12 +213,21 @@ __export(index_exports, {
   emptyRuleGroup: () => emptyRuleGroup,
   evaluateRule: () => evaluateRule,
   evaluateRules: () => evaluateRules,
+  evenWeights: () => evenWeights,
+  experimentBucketRules: () => experimentBucketRules,
+  experimentSalt: () => experimentSalt,
+  featureCssSelectors: () => featureCssSelectors,
+  featureRuleError: () => featureRuleError,
+  featureRuleMatchesClick: () => featureRuleMatchesClick,
+  feedbackReference: () => feedbackReference,
   fingerprintError: () => fingerprintError,
   firstNameFromTraits: () => firstNameFromTraits,
   fnv1a: () => fnv1a,
   foldPathIds: () => foldPathIds,
   getPath: () => getPath,
+  guideLocales: () => guideLocales,
   guidePlatforms: () => guidePlatforms,
+  guideTextEntries: () => guideTextEntries,
   guidelyIdFromSelector: () => guidelyIdFromSelector,
   hasVideoMedia: () => hasVideoMedia,
   isAllowedEmbedSrc: () => isAllowedEmbedSrc,
@@ -162,6 +240,12 @@ __export(index_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,
@@ -169,30 +253,63 @@ __export(index_exports, {
   mediaMaxBytes: () => mediaMaxBytes,
   normalizeErrorMessage: () => normalizeErrorMessage,
   normalizeFrameFile: () => normalizeFrameFile,
+  normalizeLocale: () => normalizeLocale,
+  normalizeSnapshot: () => normalizeSnapshot,
+  orderedModules: () => orderedModules,
   pageLabel: () => pageLabel,
   pageName: () => pageName,
+  pagePattern: () => pagePattern,
+  pageRuleError: () => pageRuleError,
+  pageRuleMatches: () => pageRuleMatches,
+  pageRulesMatch: () => pageRulesMatch,
   pageTerms: () => pageTerms,
+  parseCssSelector: () => parseCssSelector,
+  parseCsvRows: () => parseCsvRows,
+  parseHexColor: () => parseHexColor,
   parseStack: () => parseStack,
+  parseTranslationCsv: () => parseTranslationCsv,
+  parseXliff: () => parseXliff,
+  propertyAttributeAllowed: () => propertyAttributeAllowed,
+  queryConditionRegex: () => queryConditionRegex,
   randomId: () => randomId,
+  readableTextOn: () => readableTextOn,
+  relativeLuminance: () => relativeLuminance,
   resolveCaptureSettings: () => resolveCaptureSettings,
+  resolveLocale: () => resolveLocale,
+  resourceCenterLocales: () => resourceCenterLocales,
   resourceCenterSections: () => resourceCenterSections,
+  resourceCenterTextEntries: () => resourceCenterTextEntries,
   rolloutBucket: () => rolloutBucket,
   safeRegExp: () => safeRegExp,
+  sanitizeCustomCss: () => sanitizeCustomCss,
   sanitizeProperties: () => sanitizeProperties,
+  scopeCustomCss: () => scopeCustomCss,
   screenPath: () => screenPath,
+  scriptSnippet: () => scriptSnippet,
   servedArticleAudiences: () => servedArticleAudiences,
   showMeHref: () => showMeHref,
   showMeKeyFromHref: () => showMeKeyFromHref,
   showMeKeys: () => showMeKeys,
   slugify: () => slugify,
+  snapshotFromSelector: () => snapshotFromSelector,
+  stableStringify: () => stableStringify,
   stripOrigin: () => stripOrigin,
   supportsPlatform: () => supportsPlatform,
   templateConfig: () => templateConfig,
   toEmbedUrl: () => toEmbedUrl,
+  toTranslationCsv: () => toTranslationCsv,
+  toXliff: () => toXliff,
+  translationCoverage: () => translationCoverage,
+  unreadAnnouncements: () => unreadAnnouncements,
   validateGuideConfig: () => validateGuideConfig,
+  variantProblems: () => variantProblems,
+  variantRanges: () => variantRanges,
+  visibleAnnouncements: () => visibleAnnouncements,
   visibleArticleIds: () => visibleArticleIds,
   visibleButtons: () => visibleButtons,
   visitorAudiences: () => visitorAudiences,
+  visitorLocales: () => visitorLocales,
+  withExperimentBucket: () => withExperimentBucket,
   withVisibility: () => withVisibility
 });
 module.exports = __toCommonJS(index_exports);
@@ -387,17 +504,21 @@ 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;
 }
-function emptyRuleGroup(id = "root") {
-  return { id, op: "and", rules: [] };
+function emptyRuleGroup(id2 = "root") {
+  return { id: id2, op: "and", rules: [] };
 }
 function has(set, v) {
   if (!set) return false;
@@ -451,6 +572,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":
@@ -461,6 +584,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;
   }
@@ -560,7 +686,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;
@@ -592,6 +718,57 @@ var RuleGroupSchema = import_zod.z.lazy(
 
 // src/guide.ts
 var import_zod2 = require("zod");
+
+// 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;
+}
+
+// src/guide.ts
 var GUIDE_KINDS = ["flow", "modal", "tooltip", "banner", "checklist", "survey", "announcement"];
 var GUIDE_STATUSES = ["draft", "published", "paused", "archived"];
 var STEP_TYPES = ["modal", "tooltip", "popover", "spotlight", "hotspot", "banner", "slideout", "checklist", "custom", "survey"];
@@ -640,6 +817,8 @@ var StepSchema = import_zod2.z.object({
   /** Sanitized HTML body (links, images, lists, formatting). */
   body: import_zod2.z.string().max(2e4).default(""),
   imageUrl: import_zod2.z.string().url().max(2e3).optional().or(import_zod2.z.literal("")),
+  /** Alternative text for `imageUrl` (screen readers); empty = decorative. */
+  imageAlt: import_zod2.z.string().max(300).optional(),
   buttons: import_zod2.z.array(ButtonSchema).max(6).default([]),
   target: TargetSchema.optional(),
   placement: import_zod2.z.enum(PLACEMENTS).default("auto"),
@@ -666,7 +845,12 @@ var StepSchema = import_zod2.z.object({
   /** Hotspot pulse dot settings. */
   hotspot: import_zod2.z.object({ size: import_zod2.z.number().int().min(8).max(40).default(14), pulse: import_zod2.z.boolean().default(true), openOn: import_zod2.z.enum(["click", "hover"]).default("click") }).optional(),
   /** Custom step: arbitrary sanitized HTML with no chrome. */
-  customHtml: import_zod2.z.string().max(5e4).optional()
+  customHtml: import_zod2.z.string().max(5e4).optional(),
+  /**
+   * Code block (custom steps only): JavaScript run on the web when the step shows, only while the
+   * workspace allows code blocks (an admin setting, off by default). Mobile SDKs never receive it.
+   */
+  code: import_zod2.z.string().max(2e4).optional()
 });
 var TRIGGER_TYPES = ["page_load", "url_match", "event", "element_click", "element_visible", "manual", "delay", "after_guide", "segment_enter"];
 var TriggerSchema = import_zod2.z.object({
@@ -688,7 +872,9 @@ var FrequencySchema = import_zod2.z.object({
   /** Guide ids that must not be active at the same time. */
   mutuallyExclusiveWith: import_zod2.z.array(import_zod2.z.string()).max(50).default([]),
   /** Re-show if dismissed (otherwise dismissal counts as completion for frequency). */
-  reshowAfterDismiss: import_zod2.z.boolean().default(false)
+  reshowAfterDismiss: import_zod2.z.boolean().default(false),
+  /** Bypass the project's guide throttling (always eligible as far as throttling goes). */
+  ignoreThrottling: import_zod2.z.boolean().optional()
 });
 var AppearanceSchema = import_zod2.z.object({
   theme: import_zod2.z.enum(["light", "dark", "auto"]).default("auto"),
@@ -700,7 +886,9 @@ var AppearanceSchema = import_zod2.z.object({
   overlayOpacity: import_zod2.z.number().min(0).max(1).optional(),
   zIndex: import_zod2.z.number().int().min(1).max(2147483647).optional(),
   preset: import_zod2.z.string().max(50).optional(),
-  animation: import_zod2.z.enum(["fade", "slide", "none"]).default("fade")
+  animation: import_zod2.z.enum(["fade", "slide", "none"]).default("fade"),
+  /** Custom CSS scoped to this guide's container (sanitized; see custom-css.ts). Web only. */
+  customCss: import_zod2.z.string().max(2e4).optional()
 });
 var ChecklistTaskSchema = import_zod2.z.object({
   id: import_zod2.z.string().min(1),
@@ -747,6 +935,26 @@ var SurveyConfigSchema = import_zod2.z.object({
   startAt: import_zod2.z.string().datetime().optional(),
   endAt: import_zod2.z.string().datetime().optional()
 });
+var GuideScheduleSchema = import_zod2.z.object({
+  startAt: import_zod2.z.string().datetime().optional(),
+  endAt: import_zod2.z.string().datetime().optional(),
+  timezone: import_zod2.z.string().max(64).optional()
+});
+var LOCALE_PATTERN = /^[a-zA-Z]{2,3}(-[a-zA-Z0-9]{2,8}){0,2}$/;
+var LocaleSchema = import_zod2.z.string().regex(LOCALE_PATTERN, "Use a language code such as fr or pt-BR").max(20);
+var GuideLocalizationSchema = import_zod2.z.object({
+  translations: import_zod2.z.record(LocaleSchema, import_zod2.z.record(import_zod2.z.string().max(200), import_zod2.z.string().max(5e4))).default({})
+});
+var LocalizationSettingsSchema = import_zod2.z.object({
+  defaultLocale: LocaleSchema.default("en"),
+  locales: import_zod2.z.array(LocaleSchema).max(50).default([])
+});
+var GuideThrottlingSchema = import_zod2.z.object({
+  enabled: import_zod2.z.boolean().default(false),
+  maxGuides: import_zod2.z.number().int().min(1).max(50).default(1),
+  windowHours: import_zod2.z.number().int().min(1).max(720).default(24),
+  minGapMinutes: import_zod2.z.number().int().min(0).max(10080).default(0)
+});
 var GuideConfigSchema = import_zod2.z.object({
   steps: import_zod2.z.array(StepSchema).max(50).default([]),
   /** Everyone, only identified (logged-in) users, or only anonymous visitors; applied on top of `targeting`. */
@@ -760,7 +968,11 @@ var GuideConfigSchema = import_zod2.z.object({
   /** Restrict guide to url pattern(s) (applied before trigger). On mobile these match the screen path `/<Screen>`. */
   urlPatterns: import_zod2.z.array(import_zod2.z.string().max(500)).max(20).default([]),
   /** Platforms that receive this guide. Guides created before mobile support are web-only. */
-  platforms: import_zod2.z.array(import_zod2.z.enum(PLATFORMS)).max(PLATFORMS.length).default(["web"])
+  platforms: import_zod2.z.array(import_zod2.z.enum(PLATFORMS)).max(PLATFORMS.length).default(["web"]),
+  /** Start / end window for any guide kind (surveys also honour `survey.startAt` / `endAt`). */
+  schedule: GuideScheduleSchema.optional(),
+  /** Translations (see localization.ts). */
+  localization: GuideLocalizationSchema.optional()
 });
 function defaultGuideConfig(kind) {
   return GuideConfigSchema.parse({
@@ -794,7 +1006,7 @@ function defaultStep(type, overrides = {}) {
 function visibleButtons(step, canGoBack) {
   return canGoBack ? step.buttons : step.buttons.filter((b) => b.action !== "back");
 }
-function validateGuideConfig(kind, config) {
+function validateGuideConfig(kind, config, theme) {
   const issues = [];
   if (kind === "checklist") {
     if (!config.checklist || config.checklist.tasks.length === 0) issues.push({ level: "error", message: "Checklist needs at least one task." });
@@ -831,6 +1043,15 @@ function validateGuideConfig(kind, config) {
   if (config.trigger.type === "element_click" && !config.trigger.value) issues.push({ level: "error", message: "Element click trigger needs a selector." });
   if (config.trigger.type === "url_match" && !config.trigger.value) issues.push({ level: "error", message: "URL trigger needs a pattern." });
   if (config.frequency.mode === "interval" && !config.frequency.intervalHours) issues.push({ level: "error", message: "Interval frequency needs an interval in hours." });
+  const sched = config.schedule;
+  if (sched?.startAt && sched.endAt && Date.parse(sched.endAt) <= Date.parse(sched.startAt)) issues.push({ level: "error", message: "The schedule ends before it starts." });
+  if (sched?.endAt && Date.parse(sched.endAt) < Date.now()) issues.push({ level: "warning", message: "The schedule has already ended, so nobody will see this guide." });
+  config.steps.forEach((step, i) => {
+    if (step.code && step.type !== "custom") issues.push({ level: "error", stepId: step.id, message: `Step ${i + 1}: code blocks can only run in custom steps.` });
+    if (step.code && mobile) issues.push({ level: "warning", stepId: step.id, message: `Step ${i + 1} runs a code block; mobile apps skip it.` });
+  });
+  const colors = { primaryColor: config.appearance.primaryColor ?? theme?.primaryColor, backgroundColor: config.appearance.backgroundColor ?? theme?.backgroundColor, textColor: config.appearance.textColor ?? theme?.textColor };
+  for (const c of contrastIssues(colors)) issues.push({ level: "warning", message: `Low contrast: ${c.message}` });
   return issues;
 }
 var ProjectThemeSchema = import_zod2.z.object({
@@ -840,7 +1061,9 @@ var ProjectThemeSchema = import_zod2.z.object({
   borderRadius: import_zod2.z.number().int().min(0).max(32).default(12),
   fontFamily: import_zod2.z.string().max(200).default("Inter, system-ui, -apple-system, sans-serif"),
   logoUrl: import_zod2.z.string().max(2e3).optional(),
-  brandName: import_zod2.z.string().max(100).optional()
+  brandName: import_zod2.z.string().max(100).optional(),
+  /** Custom CSS applied to every guide's container (sanitized and scoped like guide CSS). Web only. */
+  customCss: import_zod2.z.string().max(2e4).optional()
 });
 
 // src/events.ts
@@ -856,8 +1079,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;
   }
@@ -937,9 +1160,15 @@ var EVENT_NAMES = [
   "exception",
   "heatmap",
   // Feature flags: a user was bucketed into an experiment variation (properties: experimentKey, variationId, flagKey).
-  "experiment_viewed"
+  "experiment_viewed",
+  // Mobile app lifecycle (mobile/SPEC.md "Product analytics"): installs, updates, opens and backgrounding.
+  "app_install",
+  "app_update",
+  "app_open",
+  "app_background"
 ];
-var AUTOCAPTURE_EVENTS = ["page_view", "page_leave", "click", "rage_click", "exception", "heatmap"];
+var AUTOCAPTURE_EVENTS = ["page_view", "page_leave", "click", "rage_click", "exception", "heatmap", "app_install", "app_update", "app_open", "app_background"];
+var APP_LIFECYCLE_EVENTS = ["app_install", "app_update", "app_open", "app_background"];
 var GUIDE_LIFECYCLE_EVENTS = ["guide_viewed", "guide_started", "step_viewed", "step_completed", "guide_completed", "guide_skipped", "guide_dismissed", "guide_abandoned"];
 var SdkEventSchema = import_zod3.z.object({
   eventId: import_zod3.z.string().min(8).max(64),
@@ -1007,7 +1236,9 @@ var AuthoringPickSchema = import_zod4.z.object({
   selectors: import_zod4.z.array(import_zod4.z.object({ kind: import_zod4.z.string(), value: import_zod4.z.string().max(1e3), label: import_zod4.z.string().max(200).optional() })).max(10),
   textSnapshot: import_zod4.z.string().max(200).optional(),
   url: import_zod4.z.string().max(2e3).optional(),
-  rect: import_zod4.z.object({ x: import_zod4.z.number(), y: import_zod4.z.number(), width: import_zod4.z.number(), height: import_zod4.z.number() }).optional()
+  rect: import_zod4.z.object({ x: import_zod4.z.number(), y: import_zod4.z.number(), width: import_zod4.z.number(), height: import_zod4.z.number() }).optional(),
+  /** Compact snapshot of the picked element (tag mode: feature rules are proposed from it). */
+  elementSnapshot: import_zod4.z.record(import_zod4.z.unknown()).optional()
 });
 var PublishedGuideSchema = import_zod4.z.object({
   id: import_zod4.z.string(),
@@ -1085,22 +1316,153 @@ var FileComplaintSchema = import_zod6.z.object({
   }).optional().nullable()
 });
 
-// src/capture.ts
+// src/agents.ts
 var import_zod7 = require("zod");
-var AutocaptureSettingsSchema = import_zod7.z.object({ pageviews: import_zod7.z.boolean(), pageLeave: import_zod7.z.boolean(), clicks: import_zod7.z.boolean(), rageClicks: import_zod7.z.boolean(), heatmaps: import_zod7.z.boolean(), mouseMovement: import_zod7.z.boolean() }).partial();
-var ErrorTrackingSettingsSchema = import_zod7.z.object({ enabled: import_zod7.z.boolean() }).partial();
-var ReplaySettingsSchema = import_zod7.z.object({
-  enabled: import_zod7.z.boolean(),
-  sampleRate: import_zod7.z.number().int().min(0).max(100),
-  recordConsole: import_zod7.z.boolean(),
-  recordNetwork: import_zod7.z.boolean(),
-  recordNetworkPayloads: import_zod7.z.boolean(),
-  maskAllText: import_zod7.z.boolean(),
-  blockSelectors: import_zod7.z.array(import_zod7.z.string().min(1).max(200)).max(50),
-  retentionDays: import_zod7.z.number().int().min(1).max(365)
+
+// 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/agents.ts
+var ENVIRONMENTS = ["development", "staging", "production"];
+var AgentToolCallSchema = import_zod7.z.object({
+  name: import_zod7.z.string().trim().min(1).max(100),
+  status: import_zod7.z.enum(AGENT_TOOL_STATUSES).optional(),
+  latencyMs: import_zod7.z.number().int().min(0).max(36e5).optional()
+}).strip();
+var AgentMetadataSchema = import_zod7.z.record(import_zod7.z.string().max(100), import_zod7.z.unknown()).transform((m) => {
+  const out = {};
+  let size = 0;
+  for (const [k, v] of Object.entries(m)) {
+    const key = k.trim();
+    if (!key || key.startsWith("$") || SENSITIVE_PROPERTY_PATTERN.test(key)) continue;
+    if (!(typeof v === "string" || typeof v === "boolean" || v === null || typeof v === "number" && Number.isFinite(v))) continue;
+    const value = typeof v === "string" ? v.slice(0, 500) : v;
+    size += key.length + String(value).length;
+    if (size > AGENT_METADATA_MAX_BYTES || Object.keys(out).length >= AGENT_METADATA_MAX_KEYS) break;
+    out[key] = value;
+  }
+  return out;
+});
+var id = (max) => import_zod7.z.string().trim().min(1).max(max);
+var optionalId = (max) => import_zod7.z.string().trim().max(max).optional().nullable().transform((v) => v || null);
+var AgentTurnInputSchema = import_zod7.z.object({
+  type: import_zod7.z.literal("agent.conversation").optional(),
+  conversationId: id(128),
+  agentId: id(64).refine((v) => v.toLowerCase() !== SCOUT_AGENT_ID, { message: `"${SCOUT_AGENT_ID}" is reserved for Guidely's built-in Scout agent` }),
+  agentName: import_zod7.z.string().trim().max(100).optional(),
+  turnId: import_zod7.z.string().trim().min(1).max(128).optional(),
+  role: import_zod7.z.enum(AGENT_TURN_ROLES),
+  text: import_zod7.z.string().max(AGENT_TURN_MAX_TEXT).default(""),
+  toolCalls: import_zod7.z.array(AgentToolCallSchema).max(AGENT_TOOL_CALLS_PER_TURN).default([]),
+  latencyMs: import_zod7.z.number().int().min(0).max(36e5).optional(),
+  outcome: import_zod7.z.enum(AGENT_OUTCOMES).optional(),
+  taskSuccess: import_zod7.z.boolean().optional(),
+  occurredAt: import_zod7.z.string().datetime({ offset: true }).optional(),
+  userId: optionalId(256),
+  anonymousId: optionalId(128),
+  accountId: optionalId(256),
+  sessionId: optionalId(128),
+  metadata: AgentMetadataSchema.default({})
+});
+var turns = import_zod7.z.array(AgentTurnInputSchema).min(1).max(AGENT_TURNS_PER_BATCH);
+var sdkInfo = import_zod7.z.object({ name: import_zod7.z.string().max(60), version: import_zod7.z.string().max(30) }).optional();
+var SdkAgentEventsSchema = import_zod7.z.object({ turns, sdk: sdkInfo });
+var AgentEventsRequestSchema = import_zod7.z.preprocess(
+  (v) => {
+    if (Array.isArray(v)) return { turns: v };
+    if (v && typeof v === "object" && !("turns" in v)) {
+      const { environment, ...turn } = v;
+      return { turns: [turn], environment };
+    }
+    return v;
+  },
+  import_zod7.z.object({ turns, environment: import_zod7.z.enum(ENVIRONMENTS).default("production"), sdk: sdkInfo })
+);
+
+// src/feedback.ts
+var import_zod8 = require("zod");
+
+// src/feedback-limits.ts
+var FEEDBACK_STATUSES = ["new", "under_review", "planned", "in_progress", "released", "declined"];
+var FEEDBACK_STATUS_LABEL = {
+  new: "New",
+  under_review: "Under review",
+  planned: "Planned",
+  in_progress: "In progress",
+  released: "Released",
+  declined: "Declined"
+};
+var FEEDBACK_PRIORITIES = ["nice_to_have", "important", "critical"];
+var FEEDBACK_PRIORITY_LABEL = { nice_to_have: "Nice to have", important: "Important", critical: "Critical" };
+var FEEDBACK_PRIORITY_WEIGHT = { nice_to_have: 1, important: 2, critical: 3 };
+var FEEDBACK_EVENTS = ["request.created", "request.status_changed", "request.voted"];
+var MAX_FEEDBACK_TITLE = 140;
+var MAX_FEEDBACK_DESCRIPTION = 4e3;
+var MAX_FEEDBACK_COMMENT = 2e3;
+var MAX_FEEDBACK_NOTE = 500;
+var feedbackReference = (number) => `#${number}`;
+
+// src/feedback.ts
+var visitor = {
+  anonymousId: import_zod8.z.string().min(1).max(128),
+  userId: import_zod8.z.string().max(256).optional().nullable()
+};
+var FeedbackListRequestSchema = import_zod8.z.object({
+  ...visitor,
+  q: import_zod8.z.string().trim().max(200).optional(),
+  sort: import_zod8.z.enum(["top", "new", "trending"]).default("top"),
+  status: import_zod8.z.enum(FEEDBACK_STATUSES).optional(),
+  /** "open" = not released or declined. */
+  filter: import_zod8.z.enum(["open", "all", "mine", "following"]).default("open"),
+  productArea: import_zod8.z.string().trim().max(60).optional(),
+  page: import_zod8.z.number().int().min(1).max(100).default(1)
+});
+var FeedbackVisitorSchema = import_zod8.z.object(visitor);
+var SubmitFeedbackSchema = import_zod8.z.object({
+  ...visitor,
+  title: import_zod8.z.string().trim().min(3, "Give your idea a short title").max(MAX_FEEDBACK_TITLE),
+  description: import_zod8.z.string().trim().max(MAX_FEEDBACK_DESCRIPTION).default(""),
+  productArea: import_zod8.z.string().trim().max(60).optional().nullable(),
+  priority: import_zod8.z.enum(FEEDBACK_PRIORITIES).default("nice_to_have"),
+  /** Filed from this Scout conversation (Scout offered it). */
+  conversationId: import_zod8.z.string().min(1).max(64).optional().nullable(),
+  pageUrl: import_zod8.z.string().max(2e3).optional()
+});
+var FeedbackVoteSchema = import_zod8.z.object({
+  ...visitor,
+  priority: import_zod8.z.enum(FEEDBACK_PRIORITIES).default("nice_to_have"),
+  note: import_zod8.z.string().trim().max(MAX_FEEDBACK_NOTE).optional(),
+  conversationId: import_zod8.z.string().min(1).max(64).optional().nullable()
+});
+var FeedbackFollowSchema = import_zod8.z.object({ ...visitor, follow: import_zod8.z.boolean() });
+var FeedbackCommentSchema = import_zod8.z.object({ ...visitor, body: import_zod8.z.string().trim().min(1).max(MAX_FEEDBACK_COMMENT) });
+var FeedbackSimilarSchema = import_zod8.z.object({ ...visitor, title: import_zod8.z.string().trim().min(3).max(MAX_FEEDBACK_TITLE) });
+var FeedbackUpdatesReadSchema = import_zod8.z.object({ ...visitor, ids: import_zod8.z.array(import_zod8.z.string().min(1).max(64)).max(100).optional() });
+
+// src/capture.ts
+var import_zod9 = require("zod");
+var AutocaptureSettingsSchema = import_zod9.z.object({ pageviews: import_zod9.z.boolean(), pageLeave: import_zod9.z.boolean(), clicks: import_zod9.z.boolean(), rageClicks: import_zod9.z.boolean(), heatmaps: import_zod9.z.boolean(), mouseMovement: import_zod9.z.boolean(), appLifecycle: import_zod9.z.boolean() }).partial();
+var ErrorTrackingSettingsSchema = import_zod9.z.object({ enabled: import_zod9.z.boolean() }).partial();
+var ReplaySettingsSchema = import_zod9.z.object({
+  enabled: import_zod9.z.boolean(),
+  sampleRate: import_zod9.z.number().int().min(0).max(100),
+  recordConsole: import_zod9.z.boolean(),
+  recordNetwork: import_zod9.z.boolean(),
+  recordNetworkPayloads: import_zod9.z.boolean(),
+  maskAllText: import_zod9.z.boolean(),
+  blockSelectors: import_zod9.z.array(import_zod9.z.string().min(1).max(200)).max(50),
+  retentionDays: import_zod9.z.number().int().min(1).max(365)
 }).partial();
 var DEFAULT_CAPTURE_SETTINGS = {
-  autocapture: { pageviews: true, pageLeave: true, clicks: true, rageClicks: true, heatmaps: true, mouseMovement: true },
+  autocapture: { pageviews: true, pageLeave: true, clicks: true, rageClicks: true, heatmaps: true, mouseMovement: true, appLifecycle: true },
   errorTracking: { enabled: true },
   replay: { enabled: false, sampleRate: 100, recordConsole: true, recordNetwork: true, recordNetworkPayloads: false, maskAllText: false, blockSelectors: [], retentionDays: 30 }
 };
@@ -1118,18 +1480,18 @@ function resolveCaptureSettings(settings) {
   };
 }
 var HEATMAP_VIEWPORTS = { mobile: [0, 767], tablet: [768, 1279], desktop: [1280, 1e5] };
-var ReplayChunkSchema = import_zod7.z.object({
-  sessionId: import_zod7.z.string().min(1).max(128),
-  windowId: import_zod7.z.string().min(1).max(64),
-  seq: import_zod7.z.number().int().min(0).max(1e6),
-  anonymousId: import_zod7.z.string().min(1).max(128),
-  userId: import_zod7.z.string().max(256).optional().nullable(),
+var ReplayChunkSchema = import_zod9.z.object({
+  sessionId: import_zod9.z.string().min(1).max(128),
+  windowId: import_zod9.z.string().min(1).max(64),
+  seq: import_zod9.z.number().int().min(0).max(1e6),
+  anonymousId: import_zod9.z.string().min(1).max(128),
+  userId: import_zod9.z.string().max(256).optional().nullable(),
   /** rrweb `eventWithTime` objects, in order. */
-  events: import_zod7.z.array(import_zod7.z.object({ type: import_zod7.z.number().int(), timestamp: import_zod7.z.number() }).passthrough()).min(1).max(5e4),
-  url: import_zod7.z.string().max(2e3).optional(),
-  device: import_zod7.z.object({ type: import_zod7.z.string().max(20), browser: import_zod7.z.string().max(40).optional(), os: import_zod7.z.string().max(40).optional() }).optional(),
-  viewport: import_zod7.z.object({ width: import_zod7.z.number().int().min(0).max(1e5), height: import_zod7.z.number().int().min(0).max(1e5) }).optional(),
-  sdk: import_zod7.z.object({ name: import_zod7.z.string().max(60), version: import_zod7.z.string().max(30) }).optional()
+  events: import_zod9.z.array(import_zod9.z.object({ type: import_zod9.z.number().int(), timestamp: import_zod9.z.number() }).passthrough()).min(1).max(5e4),
+  url: import_zod9.z.string().max(2e3).optional(),
+  device: import_zod9.z.object({ type: import_zod9.z.string().max(20), browser: import_zod9.z.string().max(40).optional(), os: import_zod9.z.string().max(40).optional() }).optional(),
+  viewport: import_zod9.z.object({ width: import_zod9.z.number().int().min(0).max(1e5), height: import_zod9.z.number().int().min(0).max(1e5) }).optional(),
+  sdk: import_zod9.z.object({ name: import_zod9.z.string().max(60), version: import_zod9.z.string().max(30) }).optional()
 });
 var REPLAY_MAX_COMPRESSED_BYTES = 2 * 1024 * 1024;
 var REPLAY_MAX_RAW_BYTES = 16 * 1024 * 1024;
@@ -1313,8 +1675,8 @@ var GUIDE_TEMPLATES = [
     }
   }
 ];
-function templateConfig(id) {
-  const t = GUIDE_TEMPLATES.find((x) => x.id === id);
+function templateConfig(id2) {
+  const t = GUIDE_TEMPLATES.find((x) => x.id === id2);
   if (!t) return null;
   return { template: t, config: GuideConfigSchema.parse(t.config) };
 }
@@ -1374,19 +1736,19 @@ function parseStart(v) {
   if (!m || !m[0]) return 0;
   return Math.min(Number(m[1] ?? 0) * 3600 + Number(m[2] ?? 0) * 60 + Number(m[3] ?? 0), 86400);
 }
-function youtube(id, start) {
-  if (!YOUTUBE_ID.test(id)) return null;
+function youtube(id2, start) {
+  if (!YOUTUBE_ID.test(id2)) return null;
   return {
     provider: "youtube",
-    src: `https://www.youtube-nocookie.com/embed/${id}${start ? `?start=${start}` : ""}`,
-    watchUrl: `https://www.youtube.com/watch?v=${id}${start ? `&t=${start}s` : ""}`,
+    src: `https://www.youtube-nocookie.com/embed/${id2}${start ? `?start=${start}` : ""}`,
+    watchUrl: `https://www.youtube.com/watch?v=${id2}${start ? `&t=${start}s` : ""}`,
     title: "YouTube video"
   };
 }
-function vimeo(id, hash) {
-  if (!VIMEO_ID.test(id) || hash !== null && !VIMEO_HASH.test(hash)) return null;
+function vimeo(id2, hash) {
+  if (!VIMEO_ID.test(id2) || hash !== null && !VIMEO_HASH.test(hash)) return null;
   const h = hash ? hash.toLowerCase() : null;
-  return { provider: "vimeo", src: `https://player.vimeo.com/video/${id}${h ? `?h=${h}` : ""}`, watchUrl: `https://vimeo.com/${id}${h ? `/${h}` : ""}`, title: "Vimeo video" };
+  return { provider: "vimeo", src: `https://player.vimeo.com/video/${id2}${h ? `?h=${h}` : ""}`, watchUrl: `https://vimeo.com/${id2}${h ? `/${h}` : ""}`, title: "Vimeo video" };
 }
 function toEmbedUrl(input) {
   const u = parseUrl(input);
@@ -1412,16 +1774,16 @@ function toEmbedUrl(input) {
       return parts[0] === "video" && parts.length === 2 ? vimeo(parts[1], u.searchParams.get("h")) : null;
     case "loom.com":
       if ((parts[0] === "share" || parts[0] === "embed") && parts.length === 2 && LOOM_ID.test(parts[1])) {
-        const id = parts[1].toLowerCase();
-        return { provider: "loom", src: `https://www.loom.com/embed/${id}`, watchUrl: `https://www.loom.com/share/${id}`, title: "Loom video" };
+        const id2 = parts[1].toLowerCase();
+        return { provider: "loom", src: `https://www.loom.com/embed/${id2}`, watchUrl: `https://www.loom.com/share/${id2}`, title: "Loom video" };
       }
       return null;
     default: {
-      let id;
-      if (host === "fast.wistia.net" || host === "fast.wistia.com") id = parts[0] === "embed" && parts[1] === "iframe" && parts.length === 3 ? parts[2] : void 0;
-      else if (host === "wi.st" || host === "wistia.com" || /^[a-z0-9-]+\.wistia\.com$/.test(host)) id = parts[0] === "medias" && parts.length === 2 ? parts[1] : void 0;
-      if (!id || !WISTIA_ID.test(id)) return null;
-      return { provider: "wistia", src: `https://fast.wistia.net/embed/iframe/${id}`, watchUrl: `https://fast.wistia.net/embed/iframe/${id}`, title: "Wistia video" };
+      let id2;
+      if (host === "fast.wistia.net" || host === "fast.wistia.com") id2 = parts[0] === "embed" && parts[1] === "iframe" && parts.length === 3 ? parts[2] : void 0;
+      else if (host === "wi.st" || host === "wistia.com" || /^[a-z0-9-]+\.wistia\.com$/.test(host)) id2 = parts[0] === "medias" && parts.length === 2 ? parts[1] : void 0;
+      if (!id2 || !WISTIA_ID.test(id2)) return null;
+      return { provider: "wistia", src: `https://fast.wistia.net/embed/iframe/${id2}`, watchUrl: `https://fast.wistia.net/embed/iframe/${id2}`, title: "Wistia video" };
     }
   }
 }
@@ -1452,7 +1814,7 @@ var MAX_COLLECTION_DEPTH = 3;
 function matchesAudiences(required, member) {
   if (!required || required.length === 0) return true;
   if (!member) return false;
-  const has2 = member instanceof Set ? (id) => member.has(id) : (id) => member.includes(id);
+  const has2 = member instanceof Set ? (id2) => member.has(id2) : (id2) => member.includes(id2);
   return required.some(has2);
 }
 function resourceCenterSections(collections, articles, member) {
@@ -1506,7 +1868,7 @@ function servedArticleAudiences(audienceIds, visibility) {
   return visibility === "identified" && audienceIds.length === 0 ? [LOGGED_IN_AUDIENCE] : [...audienceIds];
 }
 function visitorAudiences(audienceIds, identified) {
-  const ids = audienceIds.filter((id) => id !== LOGGED_IN_AUDIENCE);
+  const ids = audienceIds.filter((id2) => id2 !== LOGGED_IN_AUDIENCE);
   return identified ? [...ids, LOGGED_IN_AUDIENCE] : ids;
 }
 function visibleArticleIds(collections, articles, member) {
@@ -1542,9 +1904,35 @@ 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((id2) => !known.some((m) => m.id === id2)).map((id2) => ({ id: id2, 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.ts
-var import_zod8 = require("zod");
+var import_zod10 = require("zod");
 
 // src/howto-limits.ts
 var CAPTURE_PARAM = "guidely_capture";
@@ -1553,36 +1941,36 @@ var CAPTURE_SCREENSHOT_MAX_BYTES = 8 * 1024 * 1024;
 // src/howto.ts
 var HOWTO_STEP_KINDS = ["action", "text", "heading", "tip", "alert"];
 var HOWTO_ACTIONS = ["click", "type", "select", "navigate"];
-var NormalizedRectSchema = import_zod8.z.object({
-  x: import_zod8.z.number().min(0).max(1),
-  y: import_zod8.z.number().min(0).max(1),
-  width: import_zod8.z.number().min(0).max(1),
-  height: import_zod8.z.number().min(0).max(1)
+var NormalizedRectSchema = import_zod10.z.object({
+  x: import_zod10.z.number().min(0).max(1),
+  y: import_zod10.z.number().min(0).max(1),
+  width: import_zod10.z.number().min(0).max(1),
+  height: import_zod10.z.number().min(0).max(1)
 });
-var CapturedElementSchema = import_zod8.z.object({
+var CapturedElementSchema = import_zod10.z.object({
   /** Visible name: aria-label, associated label, text, placeholder, alt or title. */
-  label: import_zod8.z.string().max(200).default(""),
+  label: import_zod10.z.string().max(200).default(""),
   /** button, link, tab, menuitem, checkbox, radio, field, dropdown, option, element… */
-  role: import_zod8.z.string().max(40).default("element"),
-  tag: import_zod8.z.string().max(40).default("")
+  role: import_zod10.z.string().max(40).default("element"),
+  tag: import_zod10.z.string().max(40).default("")
 });
-var CaptureStepSchema = import_zod8.z.object({
+var CaptureStepSchema = import_zod10.z.object({
   /** Random id from the SDK; a retried upload with the same id is stored once. */
-  clientId: import_zod8.z.string().min(1).max(64),
-  action: import_zod8.z.enum(HOWTO_ACTIONS),
-  url: import_zod8.z.string().max(2e3),
-  pageTitle: import_zod8.z.string().max(300).default(""),
+  clientId: import_zod10.z.string().min(1).max(64),
+  action: import_zod10.z.enum(HOWTO_ACTIONS),
+  url: import_zod10.z.string().max(2e3),
+  pageTitle: import_zod10.z.string().max(300).default(""),
   element: CapturedElementSchema.optional(),
   /** Typed text or chosen option; absent when it was sensitive (`valueRedacted`). */
-  value: import_zod8.z.string().max(200).optional(),
-  valueRedacted: import_zod8.z.boolean().default(false),
+  value: import_zod10.z.string().max(200).optional(),
+  valueRedacted: import_zod10.z.boolean().default(false),
   /** Selectors for the element, so the step can later become an interactive tour step. */
-  selectors: import_zod8.z.array(SelectorStrategySchema).max(10).default([]),
+  selectors: import_zod10.z.array(SelectorStrategySchema).max(10).default([]),
   /** Where the element sits in the screenshot. */
   highlight: NormalizedRectSchema.optional(),
   /** Number of regions the SDK blurred in the screenshot before upload. */
-  redactions: import_zod8.z.number().int().min(0).max(1e3).default(0),
-  occurredAt: import_zod8.z.string().datetime().optional()
+  redactions: import_zod10.z.number().int().min(0).max(1e3).default(0),
+  occurredAt: import_zod10.z.string().datetime().optional()
 });
 function quoted(s) {
   const t = (s ?? "").replace(/\s+/g, " ").trim();
@@ -1653,12 +2041,12 @@ function hostAndPath(url) {
     return url.slice(0, 80);
   }
 }
-var NormalizedPointSchema = import_zod8.z.object({ x: import_zod8.z.number().min(0).max(1), y: import_zod8.z.number().min(0).max(1) });
+var NormalizedPointSchema = import_zod10.z.object({ x: import_zod10.z.number().min(0).max(1), y: import_zod10.z.number().min(0).max(1) });
 var ANNOTATION_COLORS = ["brand", "red", "amber", "green", "black", "white"];
-var HowToAnnotationSchema = import_zod8.z.discriminatedUnion("type", [
-  import_zod8.z.object({ id: import_zod8.z.string().min(1).max(32), type: import_zod8.z.literal("arrow"), from: NormalizedPointSchema, to: NormalizedPointSchema, color: import_zod8.z.enum(ANNOTATION_COLORS).default("brand") }),
-  import_zod8.z.object({ id: import_zod8.z.string().min(1).max(32), type: import_zod8.z.literal("text"), at: NormalizedPointSchema, text: import_zod8.z.string().trim().min(1).max(120), color: import_zod8.z.enum(ANNOTATION_COLORS).default("brand") }),
-  import_zod8.z.object({ id: import_zod8.z.string().min(1).max(32), type: import_zod8.z.literal("box"), rect: NormalizedRectSchema, color: import_zod8.z.enum(ANNOTATION_COLORS).default("brand") })
+var HowToAnnotationSchema = import_zod10.z.discriminatedUnion("type", [
+  import_zod10.z.object({ id: import_zod10.z.string().min(1).max(32), type: import_zod10.z.literal("arrow"), from: NormalizedPointSchema, to: NormalizedPointSchema, color: import_zod10.z.enum(ANNOTATION_COLORS).default("brand") }),
+  import_zod10.z.object({ id: import_zod10.z.string().min(1).max(32), type: import_zod10.z.literal("text"), at: NormalizedPointSchema, text: import_zod10.z.string().trim().min(1).max(120), color: import_zod10.z.enum(ANNOTATION_COLORS).default("brand") }),
+  import_zod10.z.object({ id: import_zod10.z.string().min(1).max(32), type: import_zod10.z.literal("box"), rect: NormalizedRectSchema, color: import_zod10.z.enum(ANNOTATION_COLORS).default("brand") })
 ]);
 var MAX_ANNOTATIONS = 30;
 
@@ -1686,21 +2074,1128 @@ 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 id2 = str(r.id, SNAPSHOT_LIMITS.id);
+  if (id2) node.id = id2;
+  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 quoted2 = () => {
+    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() === "'" ? quoted2() : 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/snippet.ts
+var SCRIPT_STUB_METHODS = [
+  "identify",
+  "track",
+  "page",
+  "reset",
+  "setAccount",
+  "updateTraits",
+  "setConsent",
+  "setLocale",
+  "startGuide",
+  "stopGuide",
+  "dismissGuide",
+  "openMessenger",
+  "closeMessenger",
+  "showNewMessage",
+  "openResourceCenter",
+  "closeResourceCenter",
+  "openChecklist",
+  "closeChecklist",
+  "completeChecklistTask",
+  "openComplaint",
+  "openIdeas",
+  "captureException",
+  "agentConversation",
+  "trackAgentTurn",
+  "on"
+];
+var SCRIPT_STUB = `!function(w){if(w.Guidely)return;var g=w.Guidely={_q:[]},c=g._c={};function q(o,k){o[k]=function(){g._q.push([o===c?1:0,k,[].slice.call(arguments)])}}q(g,"init");"${SCRIPT_STUB_METHODS.join(" ")}".split(" ").forEach(function(k){q(c,k)});c.isFeatureEnabled=function(k,f){return!!f};c.getFeatureValue=function(k,f){return f};g.get=function(){return c}}(window);`;
+function scriptSnippet(scriptUrl, initOptions) {
+  return `<script>
+  ${SCRIPT_STUB}
+  Guidely.init(${initOptions});
+</script>
+<script src="${scriptUrl}" async></script>`;
+}
+
+// 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/translation-files.ts
+function xmlEscape(s) {
+  return s.replace(/&/g, "&amp;").replace(/</g, "&lt;").replace(/>/g, "&gt;").replace(/"/g, "&quot;");
+}
+function xmlUnescape(s) {
+  return s.replace(/<!\[CDATA\[([\s\S]*?)\]\]>/g, (_, c) => c.replace(/&/g, "&amp;").replace(/</g, "&lt;").replace(/>/g, "&gt;")).replace(/&lt;/g, "<").replace(/&gt;/g, ">").replace(/&quot;/g, '"').replace(/&apos;/g, "'").replace(/&#(\d+);/g, (_, d) => String.fromCodePoint(Number(d))).replace(/&#x([0-9a-f]+);/gi, (_, h) => String.fromCodePoint(parseInt(h, 16))).replace(/&amp;/g, "&");
+}
+function toXliff(units, opts) {
+  const body = units.map(
+    (u) => `      <trans-unit id="${xmlEscape(u.key)}">
+        <source>${xmlEscape(u.source)}</source>
+        <target${u.target ? "" : ' state="needs-translation"'}>${xmlEscape(u.target)}</target>${u.note ? `
+        <note>${xmlEscape(u.note)}</note>` : ""}
+      </trans-unit>`
+  ).join("\n");
+  return `<?xml version="1.0" encoding="UTF-8"?>
+<xliff version="1.2" xmlns="urn:oasis:names:tc:xliff:document:1.2">
+  <file original="${xmlEscape(opts.original)}" source-language="${xmlEscape(opts.sourceLocale)}" target-language="${xmlEscape(opts.targetLocale)}" datatype="html">
+    <body>
+${body}
+    </body>
+  </file>
+</xliff>
+`;
+}
+function parseXliff(xml) {
+  const target = xml.match(/target-language="([^"]+)"/)?.[1] ?? xml.match(/\btrgLang="([^"]+)"/)?.[1];
+  const entries = {};
+  for (const m of xml.matchAll(/<(trans-unit|unit)\b[^>]*\bid="([^"]*)"[^>]*>([\s\S]*?)<\/\1>/g)) {
+    const key = xmlUnescape(m[2]);
+    const t = m[3].match(/<target\b[^>]*>([\s\S]*?)<\/target>/);
+    const text = t ? xmlUnescape(t[1]) : "";
+    if (key && text.trim()) entries[key] = text;
+  }
+  return { targetLocale: target ? xmlUnescape(target) : void 0, entries };
+}
+function csvCell(s) {
+  return /[",\n\r]/.test(s) ? `"${s.replace(/"/g, '""')}"` : s;
+}
+function toTranslationCsv(units, targetLocale) {
+  const rows = [["key", "context", "source", targetLocale], ...units.map((u) => [u.key, u.note ?? "", u.source, u.target])];
+  return rows.map((r) => r.map(csvCell).join(",")).join("\r\n") + "\r\n";
+}
+function parseCsvRows(text) {
+  const rows = [];
+  let row = [];
+  let cell = "";
+  let quoted2 = false;
+  const src = text.replace(/^\uFEFF/, "");
+  for (let i = 0; i < src.length; i++) {
+    const ch = src[i];
+    if (quoted2) {
+      if (ch === '"') {
+        if (src[i + 1] === '"') {
+          cell += '"';
+          i++;
+        } else quoted2 = false;
+      } else cell += ch;
+    } else if (ch === '"') quoted2 = true;
+    else if (ch === ",") {
+      row.push(cell);
+      cell = "";
+    } else if (ch === "\n" || ch === "\r") {
+      if (ch === "\r" && src[i + 1] === "\n") i++;
+      row.push(cell);
+      rows.push(row);
+      row = [];
+      cell = "";
+    } else cell += ch;
+  }
+  if (cell !== "" || row.length) {
+    row.push(cell);
+    rows.push(row);
+  }
+  return rows.filter((r) => r.some((c) => c.trim() !== ""));
+}
+function parseTranslationCsv(text) {
+  const [header, ...rows] = parseCsvRows(text);
+  if (!header) return { entries: {} };
+  const names = header.map((h) => h.trim());
+  const lower = names.map((h) => h.toLowerCase());
+  const keyCol = lower.indexOf("key");
+  if (keyCol < 0) return { entries: {} };
+  let targetCol = lower.indexOf("target");
+  if (targetCol < 0) {
+    for (let i = names.length - 1; i >= 0; i--) {
+      if (!["key", "context", "source", "label", "note"].includes(lower[i])) {
+        targetCol = i;
+        break;
+      }
+    }
+  }
+  if (targetCol < 0) return { entries: {} };
+  const entries = {};
+  for (const r of rows) {
+    const key = (r[keyCol] ?? "").trim();
+    const value = r[targetCol] ?? "";
+    if (key && value.trim()) entries[key] = value;
+  }
+  return { targetLocale: lower[targetCol] === "target" ? void 0 : names[targetCol], entries };
+}
+
 // src/index.ts
 var SDK_API_VERSION = "v1";
-var SHARED_VERSION = "0.9.0";
+var SHARED_VERSION = "0.11.0";
 // Annotate the CommonJS export names for ESM import in node:
 0 && (module.exports = {
   ADVANCE_ON,
+  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,
   ANNOTATION_COLORS,
+  APP_LIFECYCLE_EVENTS,
   ARTICLE_VISIBILITIES,
   AUTOCAPTURE_EVENTS,
+  AgentEventsRequestSchema,
+  AgentMetadataSchema,
+  AgentToolCallSchema,
+  AgentTurnInputSchema,
   AppearanceSchema,
   AuthoringPickSchema,
   AutocaptureSettingsSchema,
@@ -1708,9 +3203,11 @@ var SHARED_VERSION = "0.9.0";
   ButtonSchema,
   CAPTURE_PARAM,
   CAPTURE_SCREENSHOT_MAX_BYTES,
+  COMMON_LOCALES,
   COMPLAINT_EVENTS,
   COMPLAINT_FIELD_TYPES,
   COMPLAINT_STATUSES,
+  CONTROL_VARIANT_ID,
   CaptureStepSchema,
   CapturedElementSchema,
   ChecklistConfigSchema,
@@ -1719,28 +3216,54 @@ var SHARED_VERSION = "0.9.0";
   ConversationLookupSchema,
   ConversationRatingSchema,
   DEFAULT_CAPTURE_SETTINGS,
+  DEFAULT_FEATURE_ATTRIBUTE,
+  DEFAULT_LOCALE,
   DEFAULT_PLATFORMS,
   EMBED_IFRAME_ATTRS,
   EVENT_NAMES,
   ErrorTrackingSettingsSchema,
   EventBatchSchema,
+  FEATURE_ATTRIBUTE_PATTERN,
+  FEATURE_RULE_LIMITS,
+  FEEDBACK_EVENTS,
+  FEEDBACK_PRIORITIES,
+  FEEDBACK_PRIORITY_LABEL,
+  FEEDBACK_PRIORITY_WEIGHT,
+  FEEDBACK_STATUSES,
+  FEEDBACK_STATUS_LABEL,
   FILE_LINK_CLASS,
+  FeedbackCommentSchema,
+  FeedbackFollowSchema,
+  FeedbackListRequestSchema,
+  FeedbackSimilarSchema,
+  FeedbackUpdatesReadSchema,
+  FeedbackVisitorSchema,
+  FeedbackVoteSchema,
   FileComplaintSchema,
   FrequencySchema,
   GUIDELY_ID_ATTRIBUTE,
+  GUIDE_EXPERIMENT_GOALS,
+  GUIDE_EXPERIMENT_GOAL_LABELS,
+  GUIDE_EXPERIMENT_STATUSES,
   GUIDE_KINDS,
   GUIDE_LIFECYCLE_EVENTS,
   GUIDE_STATUSES,
   GUIDE_TEMPLATES,
   GUIDE_VISIBILITIES,
   GuideConfigSchema,
+  GuideLocalizationSchema,
+  GuideScheduleSchema,
   GuideStateUpdateSchema,
+  GuideThrottlingSchema,
   HEATMAP_VIEWPORTS,
   HOWTO_ACTIONS,
   HOWTO_STEP_KINDS,
   HowToAnnotationSchema,
   IdentifyRequestSchema,
+  LOCALE_PATTERN,
   LOGGED_IN_AUDIENCE,
+  LocaleSchema,
+  LocalizationSettingsSchema,
   MAX_ANNOTATIONS,
   MAX_COLLECTION_DEPTH,
   MAX_COMPLAINT_ANSWER_LENGTH,
@@ -1748,6 +3271,11 @@ var SHARED_VERSION = "0.9.0";
   MAX_COMPLAINT_CHOICES,
   MAX_COMPLAINT_FIELDS,
   MAX_COMPLAINT_LENGTH,
+  MAX_CUSTOM_CSS,
+  MAX_FEEDBACK_COMMENT,
+  MAX_FEEDBACK_DESCRIPTION,
+  MAX_FEEDBACK_NOTE,
+  MAX_FEEDBACK_TITLE,
   MAX_MESSAGE_LENGTH,
   MAX_PROPERTY_BYTES,
   MAX_STACK_FRAMES,
@@ -1761,8 +3289,10 @@ var SHARED_VERSION = "0.9.0";
   MESSAGE_AUTHORS,
   MessengerPageRequestSchema,
   NETWORK_PLUGIN,
+  NOISY_DATA_ATTR,
   NormalizedPointSchema,
   NormalizedRectSchema,
+  PAGE_RULE_LIMITS,
   PATH_ID_PATTERN,
   PDF_BLOCK_CLASS,
   PDF_MAX_PAGES,
@@ -1772,6 +3302,8 @@ var SHARED_VERSION = "0.9.0";
   PostMessageSchema,
   ProjectThemeSchema,
   PublishedGuideSchema,
+  RC_MODULE_IDS,
+  RC_MODULE_LABELS,
   REPLAY_MAX_COMPRESSED_BYTES,
   REPLAY_MAX_RAW_BYTES,
   REPLY_TIMES,
@@ -1781,6 +3313,9 @@ var SHARED_VERSION = "0.9.0";
   ReplaySettingsSchema,
   RuleGroupSchema,
   RuleSchema,
+  SCOUT_AGENT_ID,
+  SCRIPT_STUB,
+  SCRIPT_STUB_METHODS,
   SDK_API_VERSION,
   SELECTOR_KINDS,
   SENSITIVE_HEADER_PATTERN,
@@ -1790,30 +3325,46 @@ var SHARED_VERSION = "0.9.0";
   SHARED_VERSION,
   SHOW_ME_CLASS,
   SHOW_ME_HREF_PREFIX,
+  SNAPSHOT_ATTRS,
+  SNAPSHOT_LIMITS,
   SOURCEMAP_MAX_FILES_PER_UPLOAD,
   SOURCEMAP_MAX_FILE_BYTES,
   STATUS_LEVELS,
   STEP_TYPES,
   SURVEY_QUESTION_TYPES,
+  SdkAgentEventsSchema,
   SdkEventSchema,
   SelectorStrategySchema,
+  SelectorSyntaxError,
   StartConversationSchema,
   StepBranchSchema,
   StepSchema,
+  SubmitFeedbackSchema,
   SurveyConfigSchema,
   SurveyQuestionSchema,
   SurveyResponseRequestSchema,
+  TAG_PROPERTY_LIMITS,
   TRIGGER_TYPES,
   TargetSchema,
   TriggerSchema,
   VIDEO_ATTRS,
+  WCAG_AA_LARGE,
+  WCAG_AA_TEXT,
   WS_MAX_MESSAGES_PER_SOCKET,
   WS_MAX_MESSAGE_BYTES,
+  applyGuideTranslations,
+  articleTextEntries,
+  assignGuideVariant,
+  baseLanguage,
   clamp,
   cleanLabel,
   compare,
   compareVersions,
   complaintReference,
+  compoundMatches,
+  contrastIssues,
+  contrastRatio,
+  cssSelectorError,
   defaultGuideConfig,
   defaultStep,
   describeCaptureStep,
@@ -1821,12 +3372,21 @@ var SHARED_VERSION = "0.9.0";
   emptyRuleGroup,
   evaluateRule,
   evaluateRules,
+  evenWeights,
+  experimentBucketRules,
+  experimentSalt,
+  featureCssSelectors,
+  featureRuleError,
+  featureRuleMatchesClick,
+  feedbackReference,
   fingerprintError,
   firstNameFromTraits,
   fnv1a,
   foldPathIds,
   getPath,
+  guideLocales,
   guidePlatforms,
+  guideTextEntries,
   guidelyIdFromSelector,
   hasVideoMedia,
   isAllowedEmbedSrc,
@@ -1839,6 +3399,12 @@ var SHARED_VERSION = "0.9.0";
   isRuleGroup,
   isSafeMediaUrl,
   isVideoContentType,
+  localeName,
+  localizeAnnouncement,
+  localizeArticle,
+  localizeGuide,
+  localizeResourceCenter,
+  matchCssSelector,
   matchUrlPattern,
   matchesAudiences,
   matchesHelpQuery,
@@ -1846,30 +3412,63 @@ var SHARED_VERSION = "0.9.0";
   mediaMaxBytes,
   normalizeErrorMessage,
   normalizeFrameFile,
+  normalizeLocale,
+  normalizeSnapshot,
+  orderedModules,
   pageLabel,
   pageName,
+  pagePattern,
+  pageRuleError,
+  pageRuleMatches,
+  pageRulesMatch,
   pageTerms,
+  parseCssSelector,
+  parseCsvRows,
+  parseHexColor,
   parseStack,
+  parseTranslationCsv,
+  parseXliff,
+  propertyAttributeAllowed,
+  queryConditionRegex,
   randomId,
+  readableTextOn,
+  relativeLuminance,
   resolveCaptureSettings,
+  resolveLocale,
+  resourceCenterLocales,
   resourceCenterSections,
+  resourceCenterTextEntries,
   rolloutBucket,
   safeRegExp,
+  sanitizeCustomCss,
   sanitizeProperties,
+  scopeCustomCss,
   screenPath,
+  scriptSnippet,
   servedArticleAudiences,
   showMeHref,
   showMeKeyFromHref,
   showMeKeys,
   slugify,
+  snapshotFromSelector,
+  stableStringify,
   stripOrigin,
   supportsPlatform,
   templateConfig,
   toEmbedUrl,
+  toTranslationCsv,
+  toXliff,
+  translationCoverage,
+  unreadAnnouncements,
   validateGuideConfig,
+  variantProblems,
+  variantRanges,
+  visibleAnnouncements,
   visibleArticleIds,
   visibleButtons,
   visitorAudiences,
+  visitorLocales,
+  withExperimentBucket,
   withVisibility
 });
 //# sourceMappingURL=index.cjs.map