arcy.js 0.1.0 → 0.1.2

package/dist/flow-M7W3H3C5.js

@@ -0,0 +1,1422 @@
+import { FLOW_CONTRACT, FLOW_GLOBAL, createFlowRunState, createPreviewRunState, uuidV4 } from './chunk-FR6SJSDU.js';
+import { readFlowDetail, normalizeOptionReply, validateFillReply, fetchFlowRun } from './chunk-CQ2DESAJ.js';
+import { matchTarget } from './chunk-NIHUDSWK.js';
+import { collectElementsDeep, isInteractive, captureEventFingerprint } from './chunk-NY3NXM2V.js';
+
+/* arcy.js — https://arcyai.com */
+
+// src/fingerprint/manifest.ts
+var LIVE_MANIFEST_MAX_ELEMENTS = 40;
+function captureLiveManifest(doc = document) {
+  try {
+    const candidates = collectElementsDeep(doc);
+    const manifest = [];
+    for (const el of candidates) {
+      if (manifest.length >= LIVE_MANIFEST_MAX_ELEMENTS) break;
+      if (!isInteractive(el)) continue;
+      manifest.push(captureEventFingerprint(el));
+    }
+    return manifest;
+  } catch {
+    return [];
+  }
+}
+
+// src/flow/condition.ts
+var MAX_CONDITION_DEPTH = 3;
+var CONDITION_TYPES = [
+  "attribute",
+  "current_page",
+  "element",
+  "text_input",
+  "user_fills_input",
+  "current_time",
+  "user_idle",
+  "visitor",
+  "always_true",
+  "group"
+];
+function isTargetFingerprint(value) {
+  if (!value || typeof value !== "object") return false;
+  const v = value;
+  return v.v === 1 && !!v.core && typeof v.core === "object" && typeof v.core.tag === "string" && (v.selector === null || typeof v.selector === "string") && typeof v.ordinal === "number" && typeof v.precision === "number";
+}
+function parseNode(value, depth) {
+  if (depth > MAX_CONDITION_DEPTH) return null;
+  if (!value || typeof value !== "object") return null;
+  const v = value;
+  const type = v.type;
+  if (typeof type !== "string" || !CONDITION_TYPES.includes(type)) {
+    return null;
+  }
+  switch (type) {
+    case "attribute": {
+      if (typeof v.codeName !== "string" || typeof v.operator !== "string") return null;
+      return {
+        type: "attribute",
+        codeName: v.codeName,
+        operator: v.operator,
+        value: v.value
+      };
+    }
+    case "current_page": {
+      if (!Array.isArray(v.matches) || !Array.isArray(v.doesNotMatch)) return null;
+      return {
+        type: "current_page",
+        matches: v.matches.filter((m) => typeof m === "string"),
+        doesNotMatch: v.doesNotMatch.filter(
+          (m) => typeof m === "string"
+        )
+      };
+    }
+    case "element": {
+      if (!isTargetFingerprint(v.target) || typeof v.state !== "string") return null;
+      return {
+        type: "element",
+        target: v.target,
+        state: v.state
+      };
+    }
+    case "text_input": {
+      if (!isTargetFingerprint(v.target) || typeof v.operator !== "string" || typeof v.value !== "string") {
+        return null;
+      }
+      return {
+        type: "text_input",
+        target: v.target,
+        operator: v.operator,
+        value: v.value
+      };
+    }
+    case "user_fills_input": {
+      if (!isTargetFingerprint(v.target)) return null;
+      return { type: "user_fills_input", target: v.target };
+    }
+    case "current_time": {
+      const from = v.from;
+      const to = v.to;
+      if (from !== null && typeof from !== "string" || to !== null && typeof to !== "string") {
+        return null;
+      }
+      return { type: "current_time", from: from ?? null, to: to ?? null };
+    }
+    case "user_idle": {
+      const seconds = v.seconds;
+      if (typeof seconds !== "number" || !Number.isFinite(seconds) || seconds < 1 || seconds > 600) {
+        return null;
+      }
+      return { type: "user_idle", seconds };
+    }
+    case "visitor": {
+      if (v.state !== "first_visit" && v.state !== "returning") return null;
+      return { type: "visitor", state: v.state };
+    }
+    case "always_true":
+      return { type: "always_true" };
+    case "group": {
+      if (!Array.isArray(v.children) || v.operator !== "and" && v.operator !== "or") {
+        return null;
+      }
+      const children = [];
+      for (const child of v.children) {
+        const parsed = parseNode(child, depth + 1);
+        if (parsed) children.push(parsed);
+      }
+      return { type: "group", operator: v.operator, children };
+    }
+    default:
+      return null;
+  }
+}
+function parseTriggerCondition(value) {
+  if (!value || typeof value !== "object") return null;
+  const v = value;
+  if (v.v !== 1) return null;
+  const node = parseNode(v.node, 0);
+  return node ? { v: 1, node } : null;
+}
+function parseHHMM(value) {
+  const match = /^(\d{2}):(\d{2})$/.exec(value);
+  if (!match) return null;
+  const hours = Number(match[1]);
+  const minutes = Number(match[2]);
+  if (hours > 23 || minutes > 59) return null;
+  return hours * 60 + minutes;
+}
+function evaluateCurrentTime(node, now) {
+  if (node.from === null && node.to === null) return true;
+  const nowMinutes = now.getHours() * 60 + now.getMinutes();
+  const from = node.from !== null ? parseHHMM(node.from) : null;
+  const to = node.to !== null ? parseHHMM(node.to) : null;
+  if (node.from !== null && from === null) return false;
+  if (node.to !== null && to === null) return false;
+  if (from !== null && to === null) return nowMinutes >= from;
+  if (from === null && to !== null) return nowMinutes <= to;
+  if (from !== null && to !== null) {
+    if (from <= to) return nowMinutes >= from && nowMinutes <= to;
+    return nowMinutes >= from || nowMinutes <= to;
+  }
+  return true;
+}
+function globMatches(pattern, value) {
+  const escaped = pattern.split("*").map((part) => part.replace(/[.*+?^${}()|[\]\\]/g, "\\$&")).join(".*");
+  try {
+    return new RegExp(`^${escaped}$`).test(value);
+  } catch {
+    return false;
+  }
+}
+function evaluateCurrentPage(node, href) {
+  if (node.doesNotMatch.some((pattern) => globMatches(pattern, href))) return false;
+  if (node.matches.length === 0) return true;
+  return node.matches.some((pattern) => globMatches(pattern, href));
+}
+function compareText(operator, live, expected) {
+  if (live === void 0) return false;
+  switch (operator) {
+    case "is":
+      return live === expected;
+    case "is_not":
+      return live !== expected;
+    case "contains":
+      return live.includes(expected);
+    case "does_not_contain":
+      return !live.includes(expected);
+    case "starts_with":
+      return live.startsWith(expected);
+    case "ends_with":
+      return live.endsWith(expected);
+    // D1297's catalogue fill-out. The empty pair reads the LIVE value only,
+    // so an authored `value` is ignored rather than misread.
+    case "is_empty":
+      return live === "";
+    case "is_not_empty":
+      return live !== "";
+    // Numeric compares parse both sides; either side not a number means the
+    // condition cannot hold (never throw, never coerce NaN into an answer).
+    case "greater_than":
+    case "less_than": {
+      const liveNumber = Number(live);
+      const expectedNumber = Number(expected);
+      if (live.trim() === "" || !Number.isFinite(liveNumber) || !Number.isFinite(expectedNumber)) {
+        return false;
+      }
+      return operator === "greater_than" ? liveNumber > expectedNumber : liveNumber < expectedNumber;
+    }
+    // The same `*` glob `current_page` uses, applied to a field value.
+    case "matches_pattern":
+      return globMatches(expected, live);
+    default:
+      return false;
+  }
+}
+function isElementVisible(el, doc) {
+  try {
+    if (el.getClientRects().length === 0) return false;
+  } catch {
+    return false;
+  }
+  try {
+    const style = doc.defaultView?.getComputedStyle(el);
+    if (style && style.visibility === "hidden") return false;
+  } catch {
+  }
+  return true;
+}
+function isElementFocused(el, doc) {
+  try {
+    let active = doc.activeElement;
+    while (active) {
+      if (active === el || el.contains(active)) return true;
+      const root = active.shadowRoot;
+      active = root?.activeElement ?? null;
+    }
+  } catch {
+  }
+  return false;
+}
+function evaluateElement(node, ctx) {
+  const result = matchTarget(node.target, ctx.doc);
+  switch (node.state) {
+    case "is_present":
+      return result.status === "matched";
+    case "is_not_present":
+      return result.status === "not_found";
+    case "is_disabled":
+    case "is_not_disabled": {
+      if (result.status !== "matched") return false;
+      const disabled = "disabled" in result.element && result.element.disabled === true;
+      return node.state === "is_disabled" ? disabled : !disabled;
+    }
+    case "is_clicked":
+      return ctx.wasClicked(node.target);
+    case "is_not_clicked":
+      return !ctx.wasClicked(node.target);
+    case "is_visible":
+      return result.status === "matched" && isElementVisible(result.element, ctx.doc);
+    case "is_not_visible":
+      return result.status !== "matched" || !isElementVisible(result.element, ctx.doc);
+    case "is_checked":
+    case "is_not_checked": {
+      if (result.status !== "matched") return false;
+      const checked = "checked" in result.element && result.element.checked === true;
+      return node.state === "is_checked" ? checked : !checked;
+    }
+    case "is_focused":
+      return result.status === "matched" && isElementFocused(result.element, ctx.doc);
+    case "is_not_focused":
+      return result.status !== "matched" || !isElementFocused(result.element, ctx.doc);
+    default:
+      return false;
+  }
+}
+function evaluateAttribute(node, ctx) {
+  const live = ctx.getTrait?.(node.codeName);
+  switch (node.operator) {
+    case "has_any_value":
+      return live !== void 0 && live !== null && live !== "";
+    case "is_empty":
+      return live === void 0 || live === null || live === "";
+  }
+  if (live === void 0) return false;
+  const liveText = String(live);
+  const expected = node.value === void 0 ? "" : String(node.value);
+  return compareText(node.operator, liveText, expected);
+}
+function evaluateCondition(node, ctx) {
+  switch (node.type) {
+    case "always_true":
+      return true;
+    case "current_time":
+      return evaluateCurrentTime(node, ctx.now());
+    case "current_page":
+      return evaluateCurrentPage(node, ctx.href());
+    case "element":
+      return evaluateElement(node, ctx);
+    case "attribute":
+      return evaluateAttribute(node, ctx);
+    case "text_input": {
+      const live = ctx.readInputValue(node.target);
+      return compareText(node.operator, live, node.value);
+    }
+    case "user_fills_input": {
+      const live = ctx.readInputValue(node.target);
+      const initial = ctx.initialInputValue(node.target);
+      return live !== void 0 && live !== "" && live !== initial;
+    }
+    case "user_idle": {
+      const idle = ctx.idleSeconds?.();
+      return idle !== void 0 && idle >= node.seconds;
+    }
+    case "visitor": {
+      const first = ctx.isFirstVisit?.();
+      if (first === void 0) return false;
+      return node.state === "first_visit" ? first : !first;
+    }
+    case "group": {
+      if (node.children.length === 0) return false;
+      return node.operator === "and" ? node.children.every((child) => evaluateCondition(child, ctx)) : node.children.some((child) => evaluateCondition(child, ctx));
+    }
+    default:
+      return false;
+  }
+}
+function needsIntervalCheck(node) {
+  if (node.type === "current_time" || node.type === "user_idle") return true;
+  if (node.type === "group") return node.children.some(needsIntervalCheck);
+  return false;
+}
+function needsIdleCheck(node) {
+  if (node.type === "user_idle") return true;
+  if (node.type === "group") return node.children.some(needsIdleCheck);
+  return false;
+}
+
+// src/flow/runtime.ts
+var TRIGGER_THROTTLE_MS = 250;
+var TIME_CHECK_INTERVAL_MS = 15e3;
+var IDLE_CHECK_INTERVAL_MS = 1e3;
+var ACTIVITY_EVENTS = [
+  "pointerdown",
+  "pointermove",
+  "keydown",
+  "wheel",
+  "scroll",
+  "touchstart"
+];
+var ELEMENT_WAIT_POLL_MS = 250;
+var PAGE_READY_MAX_MS = 3e3;
+var STEP_SETTLE_MS = 250;
+var noopTrack = () => {
+};
+var defaultExecutor = () => Promise.resolve({ status: "wait" });
+function findStepIndex(flow, cvid) {
+  return flow.steps.findIndex((step) => step.cvid === cvid);
+}
+function findElementTargets(node) {
+  if (!node) return [];
+  if (node.type === "element") return [node.target];
+  if (node.type === "group") return node.children.flatMap((child) => findElementTargets(child));
+  return [];
+}
+var ActiveRun = class {
+  constructor(flow, stepIndex, startedAt, flowSessionId, doc, win, runState, executor, getTrait, isFirstVisit, track, now, setTimeoutImpl, clearTimeoutImpl, setIntervalImpl, clearIntervalImpl) {
+    this.flow = flow;
+    this.stepIndex = stepIndex;
+    this.startedAt = startedAt;
+    this.flowSessionId = flowSessionId;
+    this.doc = doc;
+    this.win = win;
+    this.runState = runState;
+    this.executor = executor;
+    this.getTrait = getTrait;
+    this.isFirstVisit = isFirstVisit;
+    this.track = track;
+    this.now = now;
+    this.setTimeoutImpl = setTimeoutImpl;
+    this.clearTimeoutImpl = clearTimeoutImpl;
+    this.setIntervalImpl = setIntervalImpl;
+    this.clearIntervalImpl = clearIntervalImpl;
+    this.stopped = false;
+    this.dwellTimer = null;
+    this.observer = null;
+    this.intervalHandle = null;
+    this.throttleHandle = null;
+    this.lastCheck = 0;
+    this.trueSince = /* @__PURE__ */ new Map();
+    this.clicked = /* @__PURE__ */ new Set();
+    this.initialValues = /* @__PURE__ */ new Map();
+    this.clickListener = null;
+    /** When the end user last did anything, for `user_idle` (D1299). Reset at
+     *  each step's watch start, so a step mounted on an already-quiet page
+     *  starts its idle clock at zero rather than firing instantly. */
+    this.lastActivityAt = 0;
+    /** The activity listeners `startWatch` installs when a trigger tree holds
+     *  a `user_idle` leaf. They stamp `lastActivityAt` and nothing else: the
+     *  idle interval is what re-evaluates. */
+    this.activityListeners = [];
+    /** ADR 0166: true while a fill question is awaiting the end user's
+     *  answer. Suspends trigger evaluation for the duration. */
+    this.inputPending = false;
+    /** Extra capture-phase listeners `startWatch` installs alongside the
+     *  click listener (D1297): typing, focus moves and checkbox flips change
+     *  nothing a MutationObserver can see, yet `text_input`, `is_focused`
+     *  and `is_checked` conditions all turn on them. */
+    this.inputListeners = [];
+    /** Parsed once per step, keyed by trigger cvid, so every condition
+     *  evaluation and every `is_clicked`/`user_fills_input` cache lookup
+     *  within one step's lifetime shares the SAME `TargetFingerprint` object
+     *  identity. `condition.ts`'s parse is otherwise pure and re-parsing on
+     *  every tick would mint a fresh object each time, silently breaking the
+     *  `Map`/`Set` identity these caches rely on. */
+    this.parsedTriggers = /* @__PURE__ */ new Map();
+    /** Read by anything else that wants to know why a run ended, alongside
+     *  the `finish()` telemetry emission below. */
+    this.lastStopReason = null;
+    /** 26.4: the bar's status surface. Set by `beginRun` rather than passed
+     *  through the constructor, which already carries fifteen positional
+     *  arguments. Never throws into the run (ADR 0050). */
+    this.onStatus = null;
+    /** D1085: the shell's apology surface, fired once per run that ended on
+     *  an error. Set by `beginRun`, same reasoning as `onStatus`. */
+    this.onFailure = null;
+    /** ADR 0166/D1294: withdraws a fill question still waiting in the chat
+     *  surface the moment the run ends, whatever ended it. Set by `beginRun`,
+     *  same reasoning as `onStatus`. Never throws into the run (ADR 0050). */
+    this.onCancelFill = null;
+  }
+  resolveElement(target, toleranceMs = 0) {
+    return matchTarget(target, this.doc);
+  }
+  /** The wait window (D1085): the flow's own `waitSeconds`, polled. Resolves
+   *  early the moment the element is matched and connected, or with the last
+   *  failed result once the window closes. A stopped or jumped-away run
+   *  resolves immediately with whatever the DOM says right now; the caller's
+   *  own staleness guard discards the outcome either way. */
+  waitForElement(target) {
+    const check = () => {
+      const result = matchTarget(target, this.doc);
+      const found = result.status === "matched" && result.element.isConnected;
+      return { result, found };
+    };
+    const first = check();
+    const windowMs = Math.max(0, this.flow.waitSeconds * 1e3);
+    if (first.found || windowMs === 0) return Promise.resolve(first.result);
+    const startIndex = this.stepIndex;
+    const deadline = this.now() + windowMs;
+    return new Promise((resolve) => {
+      const tick = () => {
+        const attempt = check();
+        if (attempt.found || this.stopped || this.stepIndex !== startIndex || this.now() >= deadline) {
+          resolve(attempt.result);
+          return;
+        }
+        this.setTimeoutImpl(tick, ELEMENT_WAIT_POLL_MS);
+      };
+      this.setTimeoutImpl(tick, ELEMENT_WAIT_POLL_MS);
+    });
+  }
+  conditionContext() {
+    return {
+      doc: this.doc,
+      now: () => new Date(this.now()),
+      href: () => this.win.location?.href ?? "",
+      getTrait: this.getTrait,
+      idleSeconds: () => Math.max(0, (this.now() - this.lastActivityAt) / 1e3),
+      isFirstVisit: this.isFirstVisit,
+      wasClicked: (target) => this.clicked.has(target),
+      readInputValue: (target) => {
+        const result = matchTarget(target, this.doc);
+        if (result.status !== "matched") return void 0;
+        const el = result.element;
+        return typeof el.value === "string" ? el.value : void 0;
+      },
+      initialInputValue: (target) => {
+        if (!this.initialValues.has(target)) {
+          const result = matchTarget(target, this.doc);
+          const el = result.status === "matched" ? result.element : null;
+          this.initialValues.set(
+            target,
+            el && typeof el.value === "string" ? el.value : void 0
+          );
+        }
+        return this.initialValues.get(target);
+      }
+    };
+  }
+  currentStep() {
+    return this.flow.steps[this.stepIndex];
+  }
+  persist() {
+    const step = this.currentStep();
+    if (!step) return;
+    this.runState.save({
+      flowId: this.flow.cvid,
+      currentStepCvid: step.cvid,
+      flowSessionId: this.flowSessionId,
+      startedAt: this.startedAt
+    });
+  }
+  teardownWatch() {
+    this.observer?.disconnect();
+    this.observer = null;
+    if (this.intervalHandle !== null) {
+      this.clearIntervalImpl(this.intervalHandle);
+      this.intervalHandle = null;
+    }
+    if (this.throttleHandle !== null) {
+      this.clearTimeoutImpl(this.throttleHandle);
+      this.throttleHandle = null;
+    }
+    if (this.dwellTimer !== null) {
+      this.clearTimeoutImpl(this.dwellTimer);
+      this.dwellTimer = null;
+    }
+    if (this.clickListener) {
+      try {
+        this.doc.removeEventListener("click", this.clickListener, true);
+      } catch {
+      }
+      this.clickListener = null;
+    }
+    for (const [name, listener] of this.inputListeners) {
+      try {
+        this.doc.removeEventListener(name, listener, true);
+      } catch {
+      }
+    }
+    this.inputListeners = [];
+    for (const [name, listener] of this.activityListeners) {
+      try {
+        this.doc.removeEventListener(name, listener, true);
+      } catch {
+      }
+    }
+    this.activityListeners = [];
+    this.inputPending = false;
+    this.trueSince.clear();
+    this.clicked.clear();
+    this.initialValues.clear();
+  }
+  jumpTo(cvid) {
+    const index = findStepIndex(this.flow, cvid);
+    if (index === -1) {
+      this.finish("error", { reason: "step_not_found" });
+      return;
+    }
+    this.stopStep();
+    this.stepIndex = index;
+    this.persist();
+    this.enterStep();
+  }
+  emitStatus(status) {
+    try {
+      this.onStatus?.(status);
+    } catch {
+    }
+  }
+  /** The end user pressed stop on the bar. The same ending a `dismiss_flow`
+   *  trigger produces, so one abandoned run is one `flow_abandoned` event
+   *  however it was abandoned. */
+  dismiss() {
+    if (this.stopped) return;
+    this.finish("dismissed");
+  }
+  emit(name, payload) {
+    try {
+      this.track(
+        name,
+        {
+          flowId: this.flow.cvid,
+          flowSessionId: this.flowSessionId,
+          stepCvid: this.currentStep()?.cvid
+        },
+        payload
+      );
+    } catch {
+    }
+  }
+  finish(reason, payload) {
+    this.lastStopReason = reason;
+    const eventName = reason === "completed" ? "flow_completed" : reason === "dismissed" ? "flow_abandoned" : "flow_error";
+    this.emit(eventName, payload);
+    try {
+      this.onCancelFill?.();
+    } catch {
+    }
+    this.stopStep();
+    this.stopped = true;
+    this.runState.clear();
+    if (reason === "completed") {
+      this.emitStatus({
+        name: this.flow.publicName ?? this.flow.name,
+        step: this.flow.steps.length,
+        total: this.flow.steps.length,
+        phase: "done"
+      });
+    }
+    this.emitStatus(null);
+    if (reason === "error") {
+      try {
+        this.onFailure?.();
+      } catch {
+      }
+    }
+  }
+  stopStep() {
+    this.teardownWatch();
+  }
+  fireTrigger(trigger) {
+    if (trigger.actionType === "dismiss_flow") {
+      this.finish("dismissed");
+      return;
+    }
+    if (trigger.actionType === "go_to_step" && trigger.targetStepCvid) {
+      this.jumpTo(trigger.targetStepCvid);
+    }
+  }
+  parsedTrigger(trigger) {
+    if (!this.parsedTriggers.has(trigger.cvid)) {
+      this.parsedTriggers.set(trigger.cvid, parseTriggerCondition(trigger.condition));
+    }
+    return this.parsedTriggers.get(trigger.cvid) ?? null;
+  }
+  checkTriggers(step, ctx) {
+    if (this.stopped) return;
+    if (this.inputPending) return;
+    const now = this.now();
+    for (const trigger of [...step.triggers].sort((a, b) => a.position - b.position)) {
+      const parsed = this.parsedTrigger(trigger);
+      if (!parsed) continue;
+      const isTrue = evaluateCondition(parsed.node, ctx);
+      const key = trigger.cvid;
+      if (!isTrue) {
+        this.trueSince.delete(key);
+        continue;
+      }
+      const since = this.trueSince.get(key) ?? now;
+      if (!this.trueSince.has(key)) this.trueSince.set(key, since);
+      const waitMs = (trigger.waitSeconds ?? 0) * 1e3;
+      if (now - since >= waitMs) {
+        this.fireTrigger(trigger);
+        return;
+      }
+    }
+  }
+  scheduleCheck(step) {
+    if (this.stopped || this.throttleHandle !== null) return;
+    const wait = Math.max(0, TRIGGER_THROTTLE_MS - (this.now() - this.lastCheck));
+    this.throttleHandle = this.setTimeoutImpl(() => {
+      this.throttleHandle = null;
+      this.lastCheck = this.now();
+      this.checkTriggers(step, this.conditionContext());
+    }, wait);
+  }
+  startWatch(step) {
+    const anyNeedsInterval = step.triggers.some((trigger) => {
+      const parsed = this.parsedTrigger(trigger);
+      return parsed ? needsIntervalCheck(parsed.node) : false;
+    });
+    const anyNeedsIdle = step.triggers.some((trigger) => {
+      const parsed = this.parsedTrigger(trigger);
+      return parsed ? needsIdleCheck(parsed.node) : false;
+    });
+    this.lastActivityAt = this.now();
+    if (typeof MutationObserver === "function") {
+      try {
+        this.observer = new MutationObserver(() => this.scheduleCheck(step));
+        this.observer.observe(this.doc.documentElement, {
+          childList: true,
+          subtree: true,
+          attributes: true,
+          characterData: true
+        });
+      } catch {
+      }
+    }
+    if (anyNeedsInterval) {
+      try {
+        this.intervalHandle = this.setIntervalImpl(
+          () => this.scheduleCheck(step),
+          anyNeedsIdle ? IDLE_CHECK_INTERVAL_MS : TIME_CHECK_INTERVAL_MS
+        );
+      } catch {
+      }
+    }
+    if (anyNeedsIdle) {
+      for (const name of ACTIVITY_EVENTS) {
+        const listener = () => {
+          this.lastActivityAt = this.now();
+        };
+        try {
+          this.doc.addEventListener(name, listener, { capture: true, passive: true });
+          this.activityListeners.push([name, listener]);
+        } catch {
+        }
+      }
+    }
+    this.clickListener = (event) => {
+      for (const trigger of step.triggers) {
+        const parsed = this.parsedTrigger(trigger);
+        const target = findElementTargets(parsed?.node);
+        for (const t of target) {
+          const result = matchTarget(t, this.doc);
+          if (result.status === "matched" && event.target instanceof Node && (result.element === event.target || result.element.contains(event.target))) {
+            this.clicked.add(t);
+          }
+        }
+      }
+      this.scheduleCheck(step);
+    };
+    try {
+      this.doc.addEventListener("click", this.clickListener, true);
+    } catch {
+      this.clickListener = null;
+    }
+    for (const name of ["input", "change", "focusin", "focusout"]) {
+      const listener = () => this.scheduleCheck(step);
+      try {
+        this.doc.addEventListener(name, listener, true);
+        this.inputListeners.push([name, listener]);
+      } catch {
+      }
+    }
+    this.checkTriggers(step, this.conditionContext());
+  }
+  async runExecutor(step) {
+    const startIndex = this.stepIndex;
+    try {
+      const outcome = await this.executor(step, {
+        doc: this.doc,
+        win: this.win,
+        resolveElement: (target, toleranceMs) => this.resolveElement(target, toleranceMs),
+        waitForElement: (target) => this.waitForElement(target),
+        setInputPending: (pending) => {
+          this.inputPending = pending;
+        }
+      });
+      if (this.stopped || this.stepIndex !== startIndex) return;
+      if (outcome.status === "advance") {
+        this.emit("flow_step_completed");
+        if (step.isCompletion) {
+          this.finish("completed");
+          return;
+        }
+        const nextIndex = this.stepIndex + 1;
+        if (nextIndex >= this.flow.steps.length) {
+          this.finish("completed");
+          return;
+        }
+        this.stopStep();
+        this.stepIndex = nextIndex;
+        this.persist();
+        this.enterStep();
+        return;
+      }
+      if (outcome.status === "navigated") {
+        this.emit("flow_step_completed");
+        if (outcome.navigateTarget === "new_tab") {
+          this.finish("completed");
+          return;
+        }
+        this.stopStep();
+        if (step.isCompletion) {
+          this.finish("completed");
+          return;
+        }
+        const nextIndex = this.stepIndex + 1;
+        if (nextIndex >= this.flow.steps.length) {
+          this.finish("completed");
+          return;
+        }
+        this.stepIndex = nextIndex;
+        this.persist();
+        return;
+      }
+      if (outcome.status === "error") {
+        this.finish(
+          "error",
+          outcome.reason === "element_not_found" ? { reason: outcome.reason, liveManifest: captureLiveManifest(this.doc) } : { reason: outcome.reason }
+        );
+        return;
+      }
+    } catch {
+    }
+  }
+  enterStep() {
+    const step = this.currentStep();
+    if (!step || this.stopped) {
+      this.finish(step ? "completed" : "error", step ? void 0 : { reason: "missing_step" });
+      return;
+    }
+    this.persist();
+    this.emit("flow_step_entered");
+    this.emitStatus({
+      name: this.flow.publicName ?? this.flow.name,
+      step: this.stepIndex + 1,
+      total: this.flow.steps.length,
+      phase: "running"
+    });
+    const begin = () => {
+      if (this.stopped) return;
+      this.startWatch(step);
+      void this.runExecutor(step);
+    };
+    this.waitForPageReady(begin);
+  }
+  /** Holds until the document is past parsing, then one `STEP_SETTLE_MS`
+   *  beat, then runs `begin`. Gives up waiting on `readyState` after
+   *  `PAGE_READY_MAX_MS` and starts the step regardless: a page that slow is
+   *  `waitForElement`'s problem, and it has the flow's full wait window for
+   *  it. Uses the same `dwellTimer` slot as the old dwell, so `stopStep`
+   *  cancels a pending entry exactly as before. */
+  waitForPageReady(begin) {
+    const deadline = this.now() + PAGE_READY_MAX_MS;
+    const settleThenBegin = () => {
+      this.dwellTimer = this.setTimeoutImpl(() => {
+        this.dwellTimer = null;
+        begin();
+      }, STEP_SETTLE_MS);
+    };
+    const check = () => {
+      if (this.stopped) return;
+      if (this.doc.readyState !== "loading" || this.now() >= deadline) {
+        settleThenBegin();
+        return;
+      }
+      this.dwellTimer = this.setTimeoutImpl(() => {
+        this.dwellTimer = null;
+        check();
+      }, ELEMENT_WAIT_POLL_MS);
+    };
+    check();
+  }
+  begin() {
+    this.enterStep();
+  }
+  stop() {
+    if (this.stopped) return;
+    try {
+      this.onCancelFill?.();
+    } catch {
+    }
+    this.stopStep();
+    this.stopped = true;
+  }
+};
+function createFlowRuntime(options) {
+  const {
+    context,
+    executor = defaultExecutor,
+    track = context.track ?? noopTrack,
+    now = () => Date.now(),
+    setTimeoutImpl = (fn, ms) => setTimeout(fn, ms),
+    clearTimeoutImpl = (handle) => clearTimeout(handle),
+    setIntervalImpl = (fn, ms) => setInterval(fn, ms),
+    clearIntervalImpl = (handle) => clearInterval(handle)
+  } = options;
+  const doc = context.doc ?? document;
+  const win = context.win ?? window;
+  const runState = createFlowRunState(context.token);
+  const apiOptions = {
+    apiBase: context.apiBase,
+    sessionToken: context.sessionToken,
+    sessionId: context.sessionId
+  };
+  let active = null;
+  async function loadFlow(flowCvid) {
+    const result = await fetchFlowRun(flowCvid, apiOptions);
+    return result.ok ? result.flow : null;
+  }
+  function beginRun(flow, stepIndex, startedAt, flowSessionId, overrides = {}) {
+    active?.stop();
+    active = new ActiveRun(
+      flow,
+      stepIndex,
+      startedAt,
+      flowSessionId,
+      doc,
+      win,
+      overrides.runState ?? runState,
+      executor,
+      context.getTrait,
+      context.isFirstVisit,
+      overrides.track ?? track,
+      now,
+      setTimeoutImpl,
+      clearTimeoutImpl,
+      setIntervalImpl,
+      clearIntervalImpl
+    );
+    active.onStatus = (status) => context.onStatus?.(status);
+    active.onFailure = () => context.onFailure?.();
+    active.onCancelFill = () => context.cancelFill?.();
+    active.begin();
+  }
+  return {
+    async start(flowCvid) {
+      const flow = await loadFlow(flowCvid);
+      if (!flow || flow.steps.length === 0) return;
+      const flowSessionId = uuidV4();
+      try {
+        track("flow_started", { flowId: flow.cvid, flowSessionId });
+      } catch {
+      }
+      beginRun(flow, 0, now(), flowSessionId);
+    },
+    async resume() {
+      const pending = runState.read();
+      if (!pending) return false;
+      const flow = await loadFlow(pending.flowId);
+      if (!flow || flow.steps.length === 0) {
+        runState.clear();
+        return false;
+      }
+      const stepIndex = findStepIndex(flow, pending.currentStepCvid);
+      if (stepIndex === -1) {
+        runState.clear();
+        return false;
+      }
+      beginRun(flow, stepIndex, pending.startedAt, pending.flowSessionId);
+      return true;
+    },
+    stop() {
+      active?.dismiss();
+      active = null;
+    },
+    // ── Preview (ADR 0137, D1081) ────────────────────────────────────────
+    // A real run through the exact same ActiveRun, differing in only two
+    // injected seams: run state persists to `arcy.preview.<token>`
+    // (sessionStorage, carrying the draft itself, since the spent nonce
+    // cannot serve it twice), and telemetry is `noopTrack`, so a preview
+    // never touches funnel numbers even if the page-level telemetry stop
+    // were somehow missed. Everything else - executor, promptFill, status
+    // surface, failure stop - is the production path, which is the whole
+    // point of previewing.
+    async startPreview(raw) {
+      const flow = readFlowDetail(raw);
+      if (!flow || flow.steps.length === 0) return;
+      const previewState = createPreviewRunState(context.token);
+      beginRun(flow, 0, now(), uuidV4(), {
+        runState: previewStateAdapter(previewState, raw),
+        track: noopTrack
+      });
+    },
+    async resumePreview() {
+      const previewState = createPreviewRunState(context.token);
+      const pending = previewState.read();
+      if (!pending) return false;
+      const flow = readFlowDetail(pending.flow);
+      if (!flow || flow.steps.length === 0) {
+        previewState.clear();
+        return false;
+      }
+      const stepIndex = findStepIndex(flow, pending.currentStepCvid);
+      if (stepIndex === -1) {
+        previewState.clear();
+        return false;
+      }
+      beginRun(flow, stepIndex, pending.startedAt, pending.flowSessionId, {
+        runState: previewStateAdapter(previewState, pending.flow),
+        track: noopTrack
+      });
+      return true;
+    },
+    destroy() {
+      active?.stop();
+      active = null;
+    }
+  };
+}
+function previewStateAdapter(previewState, rawFlow) {
+  return {
+    // ActiveRun only ever writes; reads happen in resumePreview() above.
+    read: () => null,
+    save: (run) => previewState.save({ ...run, flow: rawFlow }),
+    clear: () => previewState.clear()
+  };
+}
+
+// src/flow/executor.ts
+var SCROLL_MARGIN = 24;
+function scrollOffsetFor(rect, viewportHeight, occlusion) {
+  const floor = viewportHeight - Math.max(0, occlusion);
+  if (!(viewportHeight > 0) || floor <= 0) return 0;
+  if (rect.bottom > floor) {
+    const needed = rect.bottom - floor + SCROLL_MARGIN;
+    const room = Math.max(0, rect.top - SCROLL_MARGIN);
+    return Math.min(needed, room);
+  }
+  if (rect.top < 0) return rect.top - SCROLL_MARGIN;
+  return 0;
+}
+function scrollIntoViewAboveBar(el, ctx, options) {
+  try {
+    const occlusion = options.getBottomOcclusion?.() ?? 0;
+    const rect = el.getBoundingClientRect();
+    const height = ctx.doc.documentElement?.clientHeight || ctx.win.innerHeight || 0;
+    const delta = scrollOffsetFor(rect, height, occlusion);
+    if (delta === 0) return;
+    ctx.win.scrollBy({ top: delta, behavior: "smooth" });
+  } catch {
+  }
+}
+function dispatchClickSequence(el, doc) {
+  const win = doc.defaultView;
+  const PointerCtor = win?.PointerEvent;
+  const rect = (() => {
+    try {
+      return el.getBoundingClientRect();
+    } catch {
+      return null;
+    }
+  })();
+  const point = {
+    bubbles: true,
+    cancelable: true,
+    clientX: rect ? rect.left + rect.width / 2 : 0,
+    clientY: rect ? rect.top + rect.height / 2 : 0
+  };
+  const firePointer = (type) => {
+    try {
+      if (typeof PointerCtor === "function") {
+        el.dispatchEvent(new PointerCtor(type, { ...point, pointerType: "mouse" }));
+      }
+    } catch {
+    }
+  };
+  const fireMouse = (type) => {
+    try {
+      el.dispatchEvent(new MouseEvent(type, point));
+    } catch {
+    }
+  };
+  firePointer("pointerover");
+  firePointer("pointerenter");
+  firePointer("pointerdown");
+  fireMouse("mousedown");
+  try {
+    if (typeof el.focus === "function") el.focus();
+  } catch {
+  }
+  firePointer("pointerup");
+  fireMouse("mouseup");
+  fireMouse("click");
+}
+function setNativeValue(el, value) {
+  const proto = el instanceof HTMLTextAreaElement ? HTMLTextAreaElement.prototype : el instanceof HTMLInputElement ? HTMLInputElement.prototype : el instanceof HTMLSelectElement ? HTMLSelectElement.prototype : null;
+  if (!proto) return false;
+  const descriptor = Object.getOwnPropertyDescriptor(proto, "value");
+  const setter = descriptor?.set;
+  if (!setter) return false;
+  try {
+    setter.call(el, value);
+    return true;
+  } catch {
+    return false;
+  }
+}
+function dispatchInputChange(el, doc) {
+  const win = doc.defaultView;
+  try {
+    el.dispatchEvent(new (win?.Event ?? Event)("input", { bubbles: true }));
+  } catch {
+  }
+  try {
+    el.dispatchEvent(new (win?.Event ?? Event)("change", { bubbles: true }));
+  } catch {
+  }
+}
+async function dispatchClickStep(step, ctx, options) {
+  if (!isTargetFingerprint(step.target)) {
+    return { status: "error", reason: "invalid_target" };
+  }
+  const result = await ctx.waitForElement(step.target);
+  if (result.status !== "matched" || !result.element.isConnected) {
+    return { status: "error", reason: "element_not_found" };
+  }
+  scrollIntoViewAboveBar(result.element, ctx, options);
+  try {
+    dispatchClickSequence(result.element, ctx.doc);
+  } catch {
+    return { status: "error", reason: "dispatch_failed" };
+  }
+  return { status: "advance" };
+}
+var AUTHORED_INPUT_TYPES = [
+  "text",
+  "number",
+  "email",
+  "date",
+  "url",
+  "tel"
+];
+function readAuthoredInputType(value) {
+  return AUTHORED_INPUT_TYPES.includes(value) ? value : null;
+}
+var INPUT_TYPE_TO_KIND = {
+  text: "text",
+  search: "text",
+  number: "number",
+  email: "email",
+  url: "url",
+  tel: "tel",
+  password: "password",
+  date: "date",
+  time: "time",
+  "datetime-local": "datetime",
+  month: "month",
+  week: "week",
+  checkbox: "checkbox",
+  radio: "radio",
+  range: "range"
+};
+function readAttr(el, name) {
+  try {
+    const value = el.getAttribute(name);
+    return value === null || value === "" ? null : value;
+  } catch {
+    return null;
+  }
+}
+function selectOptions(el) {
+  const options = [];
+  for (let i = 0; i < el.options.length; i += 1) {
+    const option = el.options[i];
+    if (!option || option.disabled) continue;
+    const label = (option.label || option.textContent || "").trim();
+    if (option.value === "") continue;
+    options.push({ value: option.value, label: label || option.value });
+  }
+  return options;
+}
+function radioOptions(el, doc) {
+  const name = el.getAttribute("name");
+  const scope = el.form ?? doc;
+  const group = [];
+  if (name) {
+    try {
+      const selector = `input[type="radio"][name="${CSS.escape(name)}"]`;
+      scope.querySelectorAll(selector).forEach((node) => {
+        if (node instanceof HTMLInputElement) group.push(node);
+      });
+    } catch {
+    }
+  }
+  if (group.length === 0) group.push(el);
+  return group.map((radio) => ({
+    value: radio.value,
+    label: radioLabel(radio) || radio.value
+  }));
+}
+function controlLabelText(el) {
+  try {
+    const labels = el.labels;
+    if (labels && labels.length > 0) {
+      return (labels[0]?.textContent ?? "").trim();
+    }
+  } catch {
+  }
+  try {
+    const closest = el.closest("label");
+    if (closest) return (closest.textContent ?? "").trim();
+  } catch {
+  }
+  return "";
+}
+function radioLabel(el) {
+  return controlLabelText(el);
+}
+function readFillSpec(el, authored, doc) {
+  let kind = "custom";
+  let options = null;
+  let required = false;
+  let min = null;
+  let max = null;
+  let step = null;
+  let maxLength = null;
+  let pattern = null;
+  if (el instanceof HTMLSelectElement) {
+    kind = "select";
+    options = selectOptions(el);
+    required = el.required || !el.querySelector('option[value=""]');
+  } else if (el instanceof HTMLTextAreaElement) {
+    kind = "textarea";
+    required = el.required;
+    if (el.maxLength > 0) maxLength = el.maxLength;
+  } else if (el instanceof HTMLInputElement) {
+    const type = (readAttr(el, "type") ?? "text").toLowerCase();
+    kind = INPUT_TYPE_TO_KIND[type] ?? "text";
+    required = el.required;
+    min = readAttr(el, "min");
+    max = readAttr(el, "max");
+    step = readAttr(el, "step");
+    pattern = readAttr(el, "pattern");
+    if (el.maxLength > 0) maxLength = el.maxLength;
+    if (kind === "radio") options = radioOptions(el, doc);
+    if (kind === "checkbox") {
+      options = [{ value: "true", label: controlLabelText(el) }];
+    }
+  }
+  if (authored && authored !== "text" && (kind === "text" || kind === "custom" || kind === "textarea")) {
+    kind = authored;
+  }
+  return { kind, required, options, min, max, step, maxLength, pattern };
+}
+function findEditable(el) {
+  if (el instanceof HTMLInputElement || el instanceof HTMLTextAreaElement || el instanceof HTMLSelectElement) {
+    return el;
+  }
+  if (el instanceof HTMLElement && el.isContentEditable) return el;
+  try {
+    const inner = el.querySelector(
+      'input:not([type="hidden"]), textarea, select, [contenteditable="true"], [contenteditable=""]'
+    );
+    return inner instanceof HTMLElement ? inner : null;
+  } catch {
+    return null;
+  }
+}
+function dispatchKeyboardShadow(el, doc) {
+  const win = doc.defaultView;
+  const Ctor = win?.KeyboardEvent;
+  if (typeof Ctor !== "function") return;
+  for (const type of ["keydown", "keyup"]) {
+    try {
+      el.dispatchEvent(new Ctor(type, { bubbles: true, cancelable: true }));
+    } catch {
+    }
+  }
+}
+function applyFillReply(el, reply, kind, doc) {
+  if (kind === "checkbox" && el instanceof HTMLInputElement) {
+    const desired = reply === "true";
+    if (el.checked !== desired) dispatchClickSequence(el, doc);
+    if (el.checked !== desired) {
+      el.checked = desired;
+      dispatchInputChange(el, doc);
+    }
+    return true;
+  }
+  if (kind === "radio" && el instanceof HTMLInputElement) {
+    const scope = el.form ?? doc;
+    const name = el.getAttribute("name");
+    let chosen = null;
+    if (name) {
+      try {
+        const selector = `input[type="radio"][name="${CSS.escape(name)}"]`;
+        scope.querySelectorAll(selector).forEach((node) => {
+          if (node instanceof HTMLInputElement && node.value === reply) {
+            chosen = node;
+          }
+        });
+      } catch {
+      }
+    }
+    const target = chosen ?? (el.value === reply ? el : null);
+    if (!target) return false;
+    dispatchClickSequence(target, doc);
+    const settled = target;
+    if (!settled.checked) {
+      settled.checked = true;
+      dispatchInputChange(settled, doc);
+    }
+    return true;
+  }
+  const editable = findEditable(el);
+  if (!editable) return false;
+  if (editable instanceof HTMLElement && editable.isContentEditable) {
+    try {
+      editable.focus();
+    } catch {
+    }
+    try {
+      editable.textContent = reply;
+    } catch {
+      return false;
+    }
+    dispatchInputChange(editable, doc);
+    return true;
+  }
+  try {
+    editable.focus();
+  } catch {
+  }
+  if (!setNativeValue(editable, reply)) return false;
+  dispatchKeyboardShadow(editable, doc);
+  dispatchInputChange(editable, doc);
+  return true;
+}
+async function dispatchFillStep(step, ctx, options) {
+  if (!isTargetFingerprint(step.target)) {
+    return { status: "error", reason: "invalid_target" };
+  }
+  if (!options.promptFill) {
+    return { status: "wait" };
+  }
+  const result = await ctx.waitForElement(step.target);
+  if (result.status !== "matched" || !result.element.isConnected) {
+    return { status: "error", reason: "element_not_found" };
+  }
+  const spec = readFillSpec(
+    result.element,
+    readAuthoredInputType(step.fillInputType),
+    ctx.doc
+  );
+  const question = (step.fillDescription ?? "").trim() || step.label || "";
+  let errorCode = null;
+  let lastInvalid = null;
+  let reply;
+  for (; ; ) {
+    let answer;
+    ctx.setInputPending(true);
+    try {
+      answer = await options.promptFill({ ...spec, question, errorCode });
+    } catch {
+      return { status: "error", reason: "prompt_failed" };
+    } finally {
+      ctx.setInputPending(false);
+    }
+    if (answer === null) {
+      return { status: "error", reason: "fill_cancelled" };
+    }
+    const normalized = spec.kind === "select" || spec.kind === "radio" ? normalizeOptionReply(answer, spec.options) : spec.kind === "password" ? (
+      // Never trimmed: a password's whitespace is the user's own.
+      answer
+    ) : answer.trim();
+    errorCode = validateFillReply(normalized, { ...spec, question, errorCode: null });
+    if (errorCode === null) {
+      reply = normalized;
+      break;
+    }
+    if (lastInvalid !== null && lastInvalid === normalized) {
+      return { status: "error", reason: "fill_invalid" };
+    }
+    lastInvalid = normalized;
+  }
+  const fresh = await ctx.waitForElement(step.target);
+  if (fresh.status !== "matched" || !fresh.element.isConnected) {
+    return { status: "error", reason: "element_not_found" };
+  }
+  const freshSpec = readFillSpec(
+    fresh.element,
+    readAuthoredInputType(step.fillInputType),
+    ctx.doc
+  );
+  if (freshSpec.kind !== spec.kind) {
+    return { status: "error", reason: "unfillable_target" };
+  }
+  scrollIntoViewAboveBar(fresh.element, ctx, options);
+  if (!applyFillReply(fresh.element, reply, freshSpec.kind, ctx.doc)) {
+    return { status: "error", reason: "unfillable_target" };
+  }
+  return { status: "advance" };
+}
+function isSafeNavigateUrl(url) {
+  if (url.startsWith("/") && !url.startsWith("//")) return true;
+  try {
+    const parsed = new URL(url);
+    return parsed.protocol === "http:" || parsed.protocol === "https:";
+  } catch {
+    return false;
+  }
+}
+async function dispatchNavigateStep(step, ctx) {
+  if (!step.navigateUrl || !step.navigateTarget) {
+    return { status: "error", reason: "invalid_navigate_step" };
+  }
+  if (!isSafeNavigateUrl(step.navigateUrl)) {
+    return { status: "error", reason: "invalid_navigate_step" };
+  }
+  try {
+    if (step.navigateTarget === "new_tab") {
+      ctx.win.open(step.navigateUrl, "_blank", "noopener,noreferrer");
+    } else {
+      ctx.win.location.assign(step.navigateUrl);
+    }
+  } catch {
+    return { status: "error", reason: "navigate_failed" };
+  }
+  return { status: "navigated", navigateTarget: step.navigateTarget };
+}
+function createDomExecutor(options = {}) {
+  return async (step, ctx) => {
+    try {
+      switch (step.type) {
+        case "click":
+          return await dispatchClickStep(step, ctx, options);
+        case "fill":
+          return await dispatchFillStep(step, ctx, options);
+        case "navigate":
+          return await dispatchNavigateStep(step, ctx);
+        default:
+          return { status: "error", reason: "unknown_step_type" };
+      }
+    } catch {
+      return { status: "error", reason: "executor_threw" };
+    }
+  };
+}
+
+// src/flow/index.ts
+function mount(context) {
+  try {
+    const executor = createDomExecutor({
+      promptFill: context.promptFill,
+      // 26.4: the bar covers the bottom of the screen, so a target under it
+      // is scrolled into view before it is clicked or filled.
+      getBottomOcclusion: context.getBottomOcclusion
+    });
+    return createFlowRuntime({ context, executor });
+  } catch {
+    return null;
+  }
+}
+var registration = { contract: FLOW_CONTRACT, mount };
+if (typeof window !== "undefined") {
+  try {
+    ;
+    window[FLOW_GLOBAL] = registration;
+  } catch {
+  }
+}