impact-nova 2.6.0-alpha.0 → 2.6.0

package/dist/lib/fiscal-calendar/index.d.ts

@@ -1,4 +1,4 @@
-export type { CalendarInterval, CalendarKind, CalendarSelection, CalendarSelectionMode, CivilDate, DateCellMeta, FiscalCalendarConfig, FiscalMode, FiscalMonthPattern, FiscalPeriod, FiscalQuarter, FiscalWeek, FiscalYearModel, FyLabelStyle, Granularity, LeapWeekPolicy, RetailPatternId, WeekSelection, Weekday, } from './types';
+export type { CalendarInterval, CalendarKind, CalendarSelection, CalendarSelectionMode, CivilDate, DateCellMeta, FiscalCalendarConfig, FiscalMode, FiscalMonthPattern, FiscalPeriod, FiscalQuarter, FiscalWeek, FiscalYearModel, FyAnchorRule, FyLabelStyle, Granularity, LeapWeekPolicy, RetailPatternId, WeekSelection, Weekday, } from './types';
 export { DEFAULT_FY_LABEL, DEFAULT_LEAP_WEEK_POLICY, FISCAL_PATTERNS, } from './types';
 export { addDays, civilFromLocalDate, compareCivil, diffDays, formatCivilRange, lastDayOfMonth, localDateFromCivil, parseCivilDate, toCivilDate, weekStart, weekday, } from './civil-date';
 export { buildFiscalYear, clearFiscalYearCache, formatFyLabel, resolvePattern, shiftedFyForDate, } from './build-year';
@@ -6,5 +6,5 @@ export { getCellMeta, getFiscalYearForDate, clearFiscalLookupCache } from './loo
 export { getFiscalPresets } from './presets';
 export type { FiscalPreset } from './presets';
 export { isSameInterval, nextIntervalSelection } from './selection';
-export { getCalendarWeekSelection, getFiscalWeekSelection, resolveWeekSelection, toFiscalCalendarConfig, } from './week-selection';
+export { getCalendarWeekSelection, getFiscalWeekSelection, resolveWeekSelection, resolveWeekStartsOn, toFiscalCalendarConfig, weekStartsOnFromFiscalConfig, } from './week-selection';
 export type { ResolveWeekSelectionOptions } from './week-selection';

package/dist/lib/fiscal-calendar/index.js

@@ -1,38 +1,40 @@
 import { DEFAULT_FY_LABEL as t, DEFAULT_LEAP_WEEK_POLICY as r, FISCAL_PATTERNS as o } from "./types.js";
-import { addDays as i, civilFromLocalDate as c, compareCivil as s, diffDays as F, formatCivilRange as f, lastDayOfMonth as m, localDateFromCivil as n, parseCivilDate as C, toCivilDate as D, weekStart as p, weekday as v } from "./civil-date.js";
-import { buildFiscalYear as d, clearFiscalYearCache as x, formatFyLabel as S, resolvePattern as g, shiftedFyForDate as E } from "./build-year.js";
+import { addDays as i, civilFromLocalDate as s, compareCivil as c, diffDays as F, formatCivilRange as n, lastDayOfMonth as f, localDateFromCivil as m, parseCivilDate as C, toCivilDate as v, weekStart as D, weekday as p } from "./civil-date.js";
+import { buildFiscalYear as S, clearFiscalYearCache as d, formatFyLabel as g, resolvePattern as k, shiftedFyForDate as x } from "./build-year.js";
 import { clearFiscalLookupCache as y, getCellMeta as A, getFiscalYearForDate as _ } from "./lookup.js";
-import { getFiscalPresets as Y } from "./presets.js";
-import { isSameInterval as I, nextIntervalSelection as T } from "./selection.js";
-import { getCalendarWeekSelection as b, getFiscalWeekSelection as u, resolveWeekSelection as w, toFiscalCalendarConfig as M } from "./week-selection.js";
+import { getFiscalPresets as W } from "./presets.js";
+import { isSameInterval as h, nextIntervalSelection as I } from "./selection.js";
+import { getCalendarWeekSelection as T, getFiscalWeekSelection as w, resolveWeekSelection as b, resolveWeekStartsOn as u, toFiscalCalendarConfig as M, weekStartsOnFromFiscalConfig as R } from "./week-selection.js";
 export {
   t as DEFAULT_FY_LABEL,
   r as DEFAULT_LEAP_WEEK_POLICY,
   o as FISCAL_PATTERNS,
   i as addDays,
-  d as buildFiscalYear,
-  c as civilFromLocalDate,
+  S as buildFiscalYear,
+  s as civilFromLocalDate,
   y as clearFiscalLookupCache,
-  x as clearFiscalYearCache,
-  s as compareCivil,
+  d as clearFiscalYearCache,
+  c as compareCivil,
   F as diffDays,
-  f as formatCivilRange,
-  S as formatFyLabel,
-  b as getCalendarWeekSelection,
+  n as formatCivilRange,
+  g as formatFyLabel,
+  T as getCalendarWeekSelection,
   A as getCellMeta,
-  Y as getFiscalPresets,
-  u as getFiscalWeekSelection,
+  W as getFiscalPresets,
+  w as getFiscalWeekSelection,
   _ as getFiscalYearForDate,
-  I as isSameInterval,
-  m as lastDayOfMonth,
-  n as localDateFromCivil,
-  T as nextIntervalSelection,
+  h as isSameInterval,
+  f as lastDayOfMonth,
+  m as localDateFromCivil,
+  I as nextIntervalSelection,
   C as parseCivilDate,
-  g as resolvePattern,
-  w as resolveWeekSelection,
-  E as shiftedFyForDate,
-  D as toCivilDate,
+  k as resolvePattern,
+  b as resolveWeekSelection,
+  u as resolveWeekStartsOn,
+  x as shiftedFyForDate,
+  v as toCivilDate,
   M as toFiscalCalendarConfig,
-  p as weekStart,
-  v as weekday
+  D as weekStart,
+  R as weekStartsOnFromFiscalConfig,
+  p as weekday
 };

package/dist/lib/fiscal-calendar/week-selection.d.ts

@@ -1,5 +1,10 @@
 import { CalendarKind, FiscalMode, FiscalMonthPattern, Granularity, WeekSelection, FiscalCalendarConfig, Weekday } from './types';
 export type { FiscalMode, FiscalMonthPattern };
+export declare function weekStartsOnFromFiscalConfig(fiscalConfig?: FiscalCalendarConfig): Weekday | undefined;
+export declare function resolveWeekStartsOn(options: {
+    weekStartsOn?: Weekday;
+    fiscalConfig?: FiscalCalendarConfig;
+}): Weekday;
 export declare function getFiscalWeekSelection(date: Date, weekStartsOn: Weekday): WeekSelection;
 export declare function getCalendarWeekSelection(date: Date, weekStartsOn: Weekday): WeekSelection;
 export interface ResolveWeekSelectionOptions {

package/dist/lib/fiscal-calendar/week-selection.js

@@ -1,80 +1,87 @@
-import { FISCAL_PATTERNS as y } from "./types.js";
+import { FISCAL_PATTERNS as M } from "./types.js";
 import { buildFiscalYear as d } from "./build-year.js";
-import { civilFromLocalDate as m, parseCivilDate as w, localDateFromCivil as l } from "./civil-date.js";
-import { getCellMeta as k } from "./lookup.js";
-function D(t, n) {
-  const e = new Date(t), r = (e.getDay() + 7 - n) % 7;
-  return e.setDate(e.getDate() - r), e.setHours(0, 0, 0, 0), e;
+import { civilFromLocalDate as k, parseCivilDate as w, localDateFromCivil as l } from "./civil-date.js";
+import { getCellMeta as m } from "./lookup.js";
+function O(t) {
+  if (t)
+    return t.kind === "retail", t.weekStartsOn;
+}
+function S(t) {
+  return t.weekStartsOn ?? O(t.fiscalConfig) ?? 1;
 }
-function h(t, n) {
+function u(t, n) {
+  const e = new Date(t), a = (e.getDay() + 7 - n) % 7;
+  return e.setDate(e.getDate() - a), e.setHours(0, 0, 0, 0), e;
+}
+function D(t, n) {
   const e = new Date(t);
   return e.setDate(e.getDate() + n), e;
 }
-function c(t, n) {
-  const e = D(t, n), a = h(e, 6), o = new Date(t.getFullYear(), t.getMonth(), 1).getDay(), i = e.getDate(), s = e.getMonth() === t.getMonth() ? i : 1, f = Math.ceil((s + o) / 7);
+function f(t, n) {
+  const e = u(t, n), r = D(e, 6), i = new Date(t.getFullYear(), t.getMonth(), 1).getDay(), o = e.getDate(), s = e.getMonth() === t.getMonth() ? o : 1, c = Math.ceil((s + i) / 7);
   return {
     year: t.getFullYear(),
     month: t.getMonth(),
-    weekOfMonth: Math.max(1, f),
+    weekOfMonth: Math.max(1, c),
     startDate: e,
-    endDate: a
+    endDate: r
   };
 }
-function O(t, n) {
-  const e = D(t, n), a = h(e, 6), r = new Date(t.getFullYear(), t.getMonth(), 1), o = new Date(t.getFullYear(), t.getMonth() + 1, 0), i = e < r ? new Date(r) : new Date(e), s = a > o ? new Date(o) : new Date(a), u = new Date(i.getFullYear(), i.getMonth(), 1).getDay(), g = i.getDate(), M = Math.ceil((g + u) / 7);
+function F(t, n) {
+  const e = u(t, n), r = D(e, 6), a = new Date(t.getFullYear(), t.getMonth(), 1), i = new Date(t.getFullYear(), t.getMonth() + 1, 0), o = e < a ? new Date(a) : new Date(e), s = r > i ? new Date(i) : new Date(r), h = new Date(o.getFullYear(), o.getMonth(), 1).getDay(), g = o.getDate(), y = Math.ceil((g + h) / 7);
   return {
-    year: i.getFullYear(),
-    month: i.getMonth(),
-    weekOfMonth: Math.max(1, M),
-    startDate: i,
+    year: o.getFullYear(),
+    month: o.getMonth(),
+    weekOfMonth: Math.max(1, y),
+    startDate: o,
     endDate: s
   };
 }
-function F(t, n, e) {
-  const a = k(t, m(n));
-  if (a?.fy == null || a.fiscalPeriod == null)
-    return c(n, e);
-  const r = d(t, a.fy).periods.find(
-    (i) => i.period === a.fiscalPeriod
+function p(t, n, e) {
+  const r = m(t, k(n));
+  if (r?.fy == null || r.fiscalPeriod == null)
+    return f(n, e);
+  const a = d(t, r.fy).periods.find(
+    (o) => o.period === r.fiscalPeriod
   );
-  if (!r) return c(n, e);
-  const o = w(r.start);
+  if (!a) return f(n, e);
+  const i = w(a.start);
   return {
-    year: o.y,
-    month: o.m - 1,
-    weekOfMonth: r.period,
-    startDate: l(r.start),
-    endDate: l(r.end)
+    year: i.y,
+    month: i.m - 1,
+    weekOfMonth: a.period,
+    startDate: l(a.start),
+    endDate: l(a.end)
   };
 }
-function v(t, n = {}) {
+function P(t, n = {}) {
   const {
     calendarKind: e = "gregorian",
-    fiscalMode: a = "basic",
-    granularity: r,
-    weekStartsOn: o = 1,
-    fiscalConfig: i
-  } = n;
-  if (e !== "fiscal")
-    return O(t, o);
-  if (a === "basic" || r !== "period")
-    return c(t, o);
-  const s = i ?? S(n);
-  return s ? F(s, t, o) : c(t, o);
+    fiscalMode: r = "basic",
+    granularity: a,
+    weekStartsOn: i,
+    fiscalConfig: o
+  } = n, s = o ?? W(n), c = S({
+    weekStartsOn: i,
+    fiscalConfig: s
+  });
+  return e !== "fiscal" ? F(t, c) : r === "basic" || a !== "period" || !s ? f(t, c) : p(s, t, c);
 }
-function S(t) {
+function W(t) {
   if (t.calendarKind !== "fiscal") return;
   const n = t.weekStartsOn ?? 1, e = t.fiscalYearStartMonth ?? 1;
   return {
     kind: "retail",
-    pattern: t.fiscalMonthPattern ?? y["4-5-4"],
+    pattern: t.fiscalMonthPattern ?? M["4-5-4"],
     weekStartsOn: n,
-    fyAnchor: { month: e, day: 1, rule: "on-or-before" }
+    fyAnchor: { month: e, day: 1, rule: "closest-weekday" }
   };
 }
 export {
-  O as getCalendarWeekSelection,
-  c as getFiscalWeekSelection,
-  v as resolveWeekSelection,
-  S as toFiscalCalendarConfig
+  F as getCalendarWeekSelection,
+  f as getFiscalWeekSelection,
+  P as resolveWeekSelection,
+  S as resolveWeekStartsOn,
+  W as toFiscalCalendarConfig,
+  O as weekStartsOnFromFiscalConfig
 };

package/dist/lib/guidance/engine/guidance-engine.d.ts

@@ -6,6 +6,7 @@ import { GuidanceTargetRefRegistry } from '../targets/ref-registry';
 type Listener = () => void;
 export declare class GuidanceEngine {
     private sessionState;
+    private activationToken;
     private readonly listeners;
     private readonly eventHandlers;
     private readonly guideRegistry;
@@ -47,9 +48,17 @@ export declare class GuidanceEngine {
     private resolveGuideStartStepIndex;
     dismiss(dismissMode?: 'session' | 'forever' | 'snoozed'): Promise<void>;
     snooze(guideId?: string): Promise<void>;
+    goToPreviousStep(): Promise<void>;
+    goToStep(stepId: string): Promise<void>;
     advanceStep(): Promise<void>;
     retryCurrentStep(): Promise<void>;
     skipStep(): Promise<void>;
+    /**
+     * Leaves a step whose target will not appear, including while the engine is
+     * still waiting for that target.
+     */
+    continuePastUnavailableStep(): Promise<void>;
+    private moveToFollowingStep;
     getRenderInstruction(): RenderInstruction | null;
     private syncRenderInstructionCache;
     evaluateTriggers(routeScope?: string): Promise<void>;

package/dist/lib/guidance/engine/guidance-engine.js

@@ -1,15 +1,16 @@
-import { GuideRegistry as l } from "./guide-registry.js";
-import { getStepIndex as u, getNextStepId as p, getStepById as S, resolveLocalizedStepContent as f } from "./step-navigation.js";
+import { GuideRegistry as S } from "./guide-registry.js";
+import { getStepIndex as u, getNextStepId as c, getStepById as g, resolveLocalizedStepContent as f } from "./step-navigation.js";
 import { TriggerPluginRegistry as v } from "../triggers/trigger-registry.js";
 import { registerBuiltInTriggerPlugins as w } from "../triggers/built-in-triggers.js";
-import { TargetResolver as m, resolveTargetSynchronously as y, waitForTargetResolved as I } from "../targets/target-resolver.js";
+import { TargetResolver as m, resolveTargetSynchronously as I, waitForTargetResolved as y } from "../targets/target-resolver.js";
 import { GuidanceTargetRefRegistry as R } from "../targets/ref-registry.js";
-import { buildGuidanceStorageKey as a, buildSessionStatsKey as g, createDefaultSessionStats as G } from "../storage/storage-keys.js";
+import { buildGuidanceStorageKey as r, buildSessionStatsKey as h, createDefaultSessionStats as G } from "../storage/storage-keys.js";
 class _ {
   sessionState = { status: "idle" };
+  activationToken = 0;
   listeners = /* @__PURE__ */ new Set();
   eventHandlers = /* @__PURE__ */ new Map();
-  guideRegistry = new l();
+  guideRegistry = new S();
   triggerRegistry = new v();
   targetRefRegistry = new R();
   targetResolver;
@@ -127,7 +128,7 @@ class _ {
     const e = this.sessionState.guideId;
     if (e) {
       if (t === "forever" && await this.config.storage.set({
-        [a(this.config.tenantId, e, "dismissed")]: {
+        [r(this.config.tenantId, e, "dismissed")]: {
           dismissed: !0,
           timestamp: Date.now()
         }
@@ -141,6 +142,26 @@ class _ {
   async snooze(t) {
     (t ?? this.sessionState.guideId) && await this.dismiss("snoozed");
   }
+  async goToPreviousStep() {
+    const t = this.sessionState.guideId, e = this.sessionState.stepId;
+    if (!t || !e || this.sessionState.status !== "active")
+      return;
+    const s = this.guideRegistry.get(t);
+    if (!s)
+      return;
+    const i = u(s, e);
+    i <= 0 || s.steps[i - 1]?.advanceOn !== "click-next" || await this.activateGuide(s, i - 1);
+  }
+  async goToStep(t) {
+    const e = this.sessionState.guideId;
+    if (!e || this.sessionState.status !== "active")
+      return;
+    const s = this.guideRegistry.get(e);
+    if (!s)
+      return;
+    const i = u(s, t);
+    i < 0 || await this.activateGuide(s, i);
+  }
   async advanceStep() {
     const t = this.sessionState.guideId, e = this.sessionState.stepId;
     if (!t || !e || this.sessionState.status !== "active")
@@ -149,10 +170,10 @@ class _ {
     if (!s)
       return;
     this.track("step.completed", { guideId: t, stepId: e });
-    const i = await p(
+    const i = await c(
       s,
       e,
-      (r) => this.triggerRegistry.evaluateExpression(r, this.buildTriggerContext())
+      (a) => this.triggerRegistry.evaluateExpression(a, this.buildTriggerContext())
     );
     if (!i) {
       await this.completeGuide(t);
@@ -173,7 +194,38 @@ class _ {
   }
   async skipStep() {
     const t = this.sessionState.guideId, e = this.sessionState.stepId;
-    !t || !e || (this.track("step.skipped", { guideId: t, stepId: e }), await this.advanceStep());
+    if (!t || !e || this.sessionState.status !== "active")
+      return;
+    const s = this.guideRegistry.get(t);
+    !s || !g(s, e)?.skippable || await this.moveToFollowingStep();
+  }
+  /**
+   * Leaves a step whose target will not appear, including while the engine is
+   * still waiting for that target.
+   */
+  async continuePastUnavailableStep() {
+    const t = this.sessionState.status;
+    t !== "evaluating" && t !== "blocked" && t !== "active" || (this.activationToken += 1, await this.moveToFollowingStep());
+  }
+  async moveToFollowingStep() {
+    const t = this.sessionState.guideId, e = this.sessionState.stepId;
+    if (!t || !e)
+      return;
+    const s = this.guideRegistry.get(t);
+    if (!s)
+      return;
+    this.track("step.skipped", { guideId: t, stepId: e });
+    const i = await c(
+      s,
+      e,
+      (a) => this.triggerRegistry.evaluateExpression(a, this.buildTriggerContext())
+    );
+    if (!i) {
+      await this.completeGuide(t);
+      return;
+    }
+    const n = u(s, i);
+    await this.activateGuide(s, n);
   }
   getRenderInstruction() {
     return this.cachedRenderInstruction;
@@ -183,11 +235,12 @@ class _ {
       this.cachedRenderInstruction = null;
       return;
     }
-    const t = this.guideRegistry.get(this.sessionState.guideId), e = t ? S(t, this.sessionState.stepId) : void 0;
+    const t = this.guideRegistry.get(this.sessionState.guideId), e = t ? g(t, this.sessionState.stepId) : void 0;
     if (!t || !e) {
       this.cachedRenderInstruction = null;
       return;
     }
+    const s = this.sessionState.stepIndex > 0 ? t.steps[this.sessionState.stepIndex - 1] : void 0;
     this.cachedRenderInstruction = {
       guideId: t.id,
       stepId: e.id,
@@ -197,7 +250,11 @@ class _ {
       content: f(t, e, this.config.locale),
       target: this.sessionState.resolvedTarget ?? null,
       skippable: e.skippable,
-      advanceOn: e.advanceOn
+      advanceOn: e.advanceOn,
+      canGoBack: s?.advanceOn === "click-next",
+      placement: e.placement ?? "auto",
+      modalBehavior: e.modalBehavior,
+      interactionFooter: e.interactionFooter
     };
   }
   async evaluateTriggers(t) {
@@ -207,106 +264,111 @@ class _ {
     if (e.guidesShownThisSession >= this.config.maxGuidesPerSession || e.lastGuideEndedAt && Date.now() - e.lastGuideEndedAt < this.config.cooldownBetweenGuides)
       return;
     const s = t ? this.guideRegistry.getForRoute(t) : [], i = s.length > 0 ? s : this.guideRegistry.getAll();
-    await this.hydrateVisitCounts(i.map((o) => o.id));
+    await this.hydrateVisitCounts(i.map((d) => d.id));
     const n = [];
-    for (const o of this.guideRegistry.getSortedByPriority(
-      i.map((d) => d.id)
+    for (const d of this.guideRegistry.getSortedByPriority(
+      i.map((o) => o.id)
     ))
-      await this.isGuideEligible(o, e) && n.push(o);
+      await this.isGuideEligible(d, e) && n.push(d);
     if (!n.length)
       return;
-    const r = n[0];
+    const a = n[0];
     this.log("evaluateTriggers.start", {
-      guideId: r.id,
+      guideId: a.id,
       routePath: this.routePath
-    }), this.track("guide.triggered", { guideId: r.id }), await this.start(r.id);
+    }), this.track("guide.triggered", { guideId: a.id }), await this.start(a.id);
   }
   async activateGuide(t, e) {
-    const s = t.steps[e];
-    if (!s) {
+    const s = ++this.activationToken, i = t.steps[e];
+    if (!i) {
       await this.completeGuide(t.id);
       return;
     }
-    let i = null;
-    if (s.target) {
-      if (i = y(
+    let n = null;
+    if (i.target) {
+      if (n = I(
         this.targetResolver,
-        s.target
-      ), i?.element || (this.setSession({
+        i.target
+      ), n?.element || (this.setSession({
         status: "evaluating",
         guideId: t.id,
         stepIndex: e,
-        stepId: s.id
-      }), i = await I(
+        stepId: i.id
+      }), n = await y(
         this.targetResolver,
-        s.target,
-        s.timeout ?? 5e3
-      )), !i?.element) {
+        i.target,
+        i.timeout ?? 5e3,
+        () => s !== this.activationToken
+      )), s !== this.activationToken)
+        return;
+      if (!n?.element) {
         this.log("activateGuide.blocked", {
           guideId: t.id,
-          stepId: s.id,
+          stepId: i.id,
           stepIndex: e,
-          reason: i ? "target_not_visible" : "target_not_found",
-          targetId: s.target?.targetId
+          reason: n ? "target_not_visible" : "target_not_found",
+          targetId: i.target?.targetId
         }), this.setSession({
           status: "blocked",
           guideId: t.id,
           stepIndex: e,
-          stepId: s.id,
-          reason: i ? "target_not_visible" : "target_not_found"
+          stepId: i.id,
+          reason: n ? "target_not_visible" : "target_not_found"
         });
         return;
       }
-    } else if (s.renderer !== "announcement") {
+    } else if (i.renderer !== "announcement") {
       this.log("activateGuide.blocked", {
         guideId: t.id,
-        stepId: s.id,
+        stepId: i.id,
         stepIndex: e,
         reason: "target_not_found"
       }), this.setSession({
         status: "blocked",
         guideId: t.id,
         stepIndex: e,
-        stepId: s.id,
+        stepId: i.id,
         reason: "target_not_found"
       });
       return;
     }
-    const n = this.sessionState;
-    if (n.status === "idle" || n.guideId !== t.id) {
-      this.log("guideStart", { guideId: t.id, stepId: s.id }), this.emitEvent("guideStart", { guideId: t.id, stepId: s.id }), this.track("guide.started", { guideId: t.id });
+    if (s !== this.activationToken)
+      return;
+    const a = this.sessionState;
+    if (a.status === "idle" || a.guideId !== t.id) {
+      this.log("guideStart", { guideId: t.id, stepId: i.id }), this.emitEvent("guideStart", { guideId: t.id, stepId: i.id }), this.track("guide.started", { guideId: t.id });
       const o = await this.loadSessionStats();
       o.guidesShownThisSession += 1, await this.saveSessionStats(o), await this.incrementVisitCount(t.id);
     }
-    this.emitEvent("stepChange", { guideId: t.id, stepId: s.id }), this.track("step.viewed", { guideId: t.id, stepId: s.id }), this.log("step.active", {
+    this.emitEvent("stepChange", { guideId: t.id, stepId: i.id }), this.track("step.viewed", { guideId: t.id, stepId: i.id }), this.log("step.active", {
       guideId: t.id,
-      stepId: s.id,
+      stepId: i.id,
       stepIndex: e,
-      hasTarget: !!s.target
+      hasTarget: !!i.target
     }), this.setSession({
       status: "active",
       guideId: t.id,
       stepIndex: e,
-      stepId: s.id,
-      resolvedTarget: i?.element ? {
-        ...i,
-        rect: i.element.getBoundingClientRect()
+      stepId: i.id,
+      resolvedTarget: n?.element ? {
+        ...n,
+        rect: n.element.getBoundingClientRect()
       } : void 0
     }), t.persistence.resumeOnRefresh && await this.config.storage.set({
-      [a(this.config.tenantId, t.id, "lastStep")]: {
-        stepId: s.id,
+      [r(this.config.tenantId, t.id, "lastStep")]: {
+        stepId: i.id,
         timestamp: Date.now()
       }
     });
   }
   async completeGuide(t) {
     this.guideRegistry.get(t)?.persistence.mode === "showOnce" && await this.config.storage.set({
-      [a(this.config.tenantId, t, "dismissed")]: {
+      [r(this.config.tenantId, t, "dismissed")]: {
         dismissed: !0,
         timestamp: Date.now()
       }
     }), await this.config.storage.delete([
-      a(this.config.tenantId, t, "lastStep")
+      r(this.config.tenantId, t, "lastStep")
     ]);
     const s = await this.loadSessionStats();
     s.lastGuideEndedAt = Date.now(), await this.saveSessionStats(s), this.emitEvent("guideEnd", { guideId: t, reason: "completed" }), this.track("guide.completed", { guideId: t }), this.setSession({ status: "completed", guideId: t }), await this.dequeueNextGuide();
@@ -321,19 +383,19 @@ class _ {
     return this.isGuideEligible(s, i);
   }
   async isGuideEligible(t, e) {
-    const s = a(
+    const s = r(
       this.config.tenantId,
       t.id,
       "dismissed"
     );
     if ((await this.config.storage.get([s]))[s]?.dismissed && t.persistence.mode !== "replayable")
       return !1;
-    const r = e.snoozedUntil[t.id];
-    if (r && Date.now() < r || (e.dismissedCounts[t.id] ?? 0) >= 3 && t.persistence.mode === "showOnce")
+    const a = e.snoozedUntil[t.id];
+    if (a && Date.now() < a || (e.dismissedCounts[t.id] ?? 0) >= 3 && t.persistence.mode === "showOnce")
       return !1;
     if (t.persistence.schedule) {
-      const d = Date.now(), c = Date.parse(t.persistence.schedule.start), h = Date.parse(t.persistence.schedule.end);
-      if (d < c || d > h)
+      const o = Date.now(), l = Date.parse(t.persistence.schedule.start), p = Date.parse(t.persistence.schedule.end);
+      if (o < l || o > p)
         return !1;
     }
     return this.triggerRegistry.evaluateAll(
@@ -371,31 +433,31 @@ class _ {
     await this.start(t);
   }
   async loadSessionStats() {
-    const t = g(this.config.tenantId);
+    const t = h(this.config.tenantId);
     return (await this.config.storage.get([t]))[t] ?? G();
   }
   async saveSessionStats(t) {
     await this.config.storage.set({
-      [g(this.config.tenantId)]: t
+      [h(this.config.tenantId)]: t
     });
   }
   async hydrateVisitCounts(t) {
     if (!t.length)
       return;
     const e = t.map(
-      (i) => a(this.config.tenantId, i, "visitCount")
+      (i) => r(this.config.tenantId, i, "visitCount")
     ), s = await this.config.storage.get(e);
     for (const i of t) {
-      const n = a(
+      const n = r(
         this.config.tenantId,
         i,
         "visitCount"
-      ), r = s[n];
-      typeof r == "number" && (this.visitCounts[i] = r);
+      ), a = s[n];
+      typeof a == "number" && (this.visitCounts[i] = a);
     }
   }
   async incrementVisitCount(t) {
-    const e = a(
+    const e = r(
       this.config.tenantId,
       t,
       "visitCount"
@@ -413,7 +475,7 @@ class _ {
   }
   async clearPersistedLastStep(t) {
     await this.config.storage.delete([
-      a(this.config.tenantId, t, "lastStep")
+      r(this.config.tenantId, t, "lastStep")
     ]);
   }
   scheduleEvaluation() {