@appright/funnelshift 0.0.0-stage → 0.15.0

package/dist/clicks.js

@@ -0,0 +1,102 @@
+import { collapse } from './content.js';
+const TARGET = 'button, a, [role=button], [role=radio], [role=checkbox], [role=option], [data-track]';
+const FIELD = 'input, textarea, select';
+const IGNORE = '[data-track-ignore]';
+const REPEAT_MS = 400;
+const MAX_LABEL = 200;
+const MAX_NAME = 200;
+const SKIP_TEXT = new Set(['SCRIPT', 'STYLE', 'TEMPLATE', 'NOSCRIPT']);
+export function installClicks(root, o) {
+    const now = o.now ?? Date.now;
+    const last = new Map();
+    const onClick = (e) => {
+        try {
+            const props = describe(root, e.target, o.keyOf);
+            if (!props)
+                return;
+            const step = o.stepId();
+            const key = step + '\u0000' + props.target;
+            const t = now();
+            const prev = last.get(key);
+            if (prev !== undefined && t - prev < REPEAT_MS)
+                return;
+            if (last.size > 200)
+                for (const [k, v] of last)
+                    if (t - v >= REPEAT_MS)
+                        last.delete(k);
+            last.set(key, t);
+            o.track('$click', props, step);
+        }
+        catch { /* analytics must never break a click */ }
+    };
+    root.addEventListener('click', onClick, { capture: true, passive: true });
+    return () => root.removeEventListener('click', onClick, { capture: true });
+}
+function describe(root, from, keyOf) {
+    const el = from instanceof Element ? from : from instanceof Node ? from.parentElement : null;
+    if (!el || !root.contains(el) || el.closest(FIELD))
+        return null;
+    const target = el.closest(TARGET);
+    if (!target || !root.contains(target) || target.closest(IGNORE))
+        return null;
+    const text = collapse(visibleText(target)) || collapse(target.getAttribute('aria-label') ?? '') || collapse(imageAlt(target))
+        || collapse(target.getAttribute('title') ?? '');
+    const props = { target: nameOf(root, target, text, keyOf), label: Array.from(text).slice(0, MAX_LABEL).join(''), kind: kindOf(target) };
+    const host = target.tagName === 'A' ? outsideHost(target.getAttribute('href')) : null;
+    if (host)
+        props.href_host = host;
+    return props;
+}
+function nameOf(root, target, text, keyOf) {
+    const own = collapse(target.getAttribute('data-track') ?? '');
+    if (own)
+        return Array.from(own).slice(0, MAX_NAME).join('');
+    const key = text ? keyOf(text) : null;
+    if (key)
+        return key;
+    const all = Array.from(root.querySelectorAll(TARGET)).filter(n => !n.closest(IGNORE));
+    return `${target.tagName.toLowerCase()}#${all.indexOf(target) + 1}`;
+}
+function kindOf(el) {
+    const role = el.getAttribute('role');
+    if (role === 'radio' || role === 'checkbox' || role === 'option')
+        return 'option';
+    if (role === 'button')
+        return 'button';
+    return el.tagName === 'A' ? 'link' : 'button';
+}
+const shown = (n) => !SKIP_TEXT.has(n.tagName) && n.getAttribute('aria-hidden') !== 'true' && !n.hasAttribute('hidden');
+// The text a person sees: text nodes, without aria-hidden or hidden parts (an icon's emoji, a check mark). Each child element's
+// text is set off by spaces (<span>Pay</span><span>now</span> → "Pay now"); text nodes next to each other stay joined ("5" "%" →
+// "5%", "Hello, " "Ann" "!" → "Hello, Ann!"). The caller collapses the spaces.
+function visibleText(el) {
+    let out = '';
+    for (const n of Array.from(el.childNodes)) {
+        if (n.nodeType === Node.TEXT_NODE)
+            out += n.textContent ?? '';
+        else if (n instanceof Element && shown(n))
+            out += ' ' + visibleText(n) + ' ';
+    }
+    return out;
+}
+// The alt texts of the images in a button or link that has no text of its own (a logo link, an image button).
+function imageAlt(el) {
+    return Array.from(el.querySelectorAll('img[alt]')).filter(img => {
+        for (let n = img; n && n !== el; n = n.parentElement)
+            if (!shown(n))
+                return false;
+        return true;
+    }).map(img => img.getAttribute('alt')).join(' ');
+}
+// The host of a link that leaves the page's site (http/https only), else null. The path and query are never sent.
+function outsideHost(href) {
+    if (!href)
+        return null;
+    try {
+        const u = new URL(href, location.href);
+        return (u.protocol === 'http:' || u.protocol === 'https:') && u.host !== location.host ? u.hostname.toLowerCase() : null;
+    }
+    catch {
+        return null;
+    }
+}

package/dist/content.d.ts

@@ -0,0 +1,7 @@
+type Value = string | number | boolean;
+export declare function setContent(c: Record<string, string>, o?: Record<string, Value>): void;
+export declare const collapse: (s: string) => string;
+export declare function t(key: string, def: string, vars?: Record<string, string | number>): string;
+export declare function param<T extends Value>(key: string, def: T): T;
+export declare function keyOfText(text: string): string | null;
+export {};

package/dist/content.js

@@ -0,0 +1,60 @@
+let content = {};
+let overrides = {};
+// The reverse dictionary for $click names (clicks.ts): every text t() has produced on this page, whitespace collapsed → its key.
+// Two keys with one text give the key that comes first in the manifest (keys sorted with localeCompare, cli/extract.ts), so the
+// name does not depend on what was drawn first. Texts with vars ("Hi Ann") count too; past MAX_TEXTS new texts are not added, so a
+// t() with a ticking var cannot grow it for ever.
+let texts = new Map();
+const MAX_TEXTS = 2000;
+export function setContent(c, o = {}) {
+    content = c && typeof c === 'object' ? c : {};
+    overrides = o && typeof o === 'object' ? o : {};
+    texts = new Map();
+}
+const own = (o, k) => Object.prototype.hasOwnProperty.call(o, k);
+// The value for key: the arm's override, else the admin's edit; undefined for neither.
+function valueOf(key) {
+    if (own(overrides, key)) {
+        const v = overrides[key];
+        if (typeof v === 'string' || typeof v === 'number' || typeof v === 'boolean')
+            return v;
+    }
+    if (own(content, key) && typeof content[key] === 'string')
+        return content[key];
+    return undefined;
+}
+export const collapse = (s) => s.replace(/\s+/g, ' ').trim();
+// t(key, default): the published text for key, else the default written in code. The build collects every
+// t() call with its default into the manifest, so all texts are editable in the admin.
+export function t(key, def, vars) {
+    const v = valueOf(key);
+    const s = v === undefined ? def : String(v);
+    const out = vars ? s.replace(/\{\{(\w+)\}\}/g, (m, k) => (k in vars ? String(vars[k]) : m)) : s;
+    remember(collapse(out), key);
+    return out;
+}
+// param(key, default): a number, string or boolean the admin (or an A/B arm) may change, of the default's type. A value that does
+// not read as that type ("abc" for a number) gives the default.
+export function param(key, def) {
+    const v = valueOf(key);
+    if (v === undefined)
+        return def;
+    if (typeof def === 'number') {
+        const n = typeof v === 'number' ? v : typeof v === 'string' && v.trim() !== '' ? Number(v) : NaN;
+        return (Number.isFinite(n) ? n : def);
+    }
+    if (typeof def === 'boolean')
+        return (typeof v === 'boolean' ? v : v === 'true' ? true : v === 'false' ? false : def);
+    return String(v);
+}
+function remember(text, key) {
+    if (!text)
+        return;
+    const prev = texts.get(text);
+    if (prev === undefined ? texts.size < MAX_TEXTS : key.localeCompare(prev) < 0)
+        texts.set(text, key);
+}
+// keyOfText: the t() key whose text, as shown on this page, is exactly this one (whitespace collapsed), or null.
+export function keyOfText(text) {
+    return texts.get(collapse(text)) ?? null;
+}

package/dist/context.d.ts

@@ -0,0 +1,12 @@
+export type BatchContext = {
+    lang?: string;
+    tz?: string;
+    screen?: string;
+    viewport?: string;
+    dpr?: number;
+    net?: string;
+    save_data?: boolean;
+};
+export declare function batchContext(o?: {
+    net?: boolean;
+}): BatchContext;

package/dist/context.js

@@ -0,0 +1,52 @@
+// What the device tells about itself, sent once per batch as `ctx` (spec v2 §2): the language, the time zone, the screen and the
+// viewport in CSS pixels, the device pixel ratio, and (kit 0.13.0) the connection type and data saver. The server stamps it on every event of the batch and drops what does not
+// look right, so each value here is only read and shaped, never trusted. Anything unavailable is left out; reading must never
+// throw (a private mode, an old browser, a test without a screen).
+const NET = new Set(['slow-2g', '2g', '3g', '4g']);
+const LANG = /^[A-Za-z]{2,8}(?:[-_][A-Za-z0-9]{1,8}){0,3}$/;
+const ZONE = /^[A-Za-z][A-Za-z0-9_+/-]{0,63}$/;
+function size(w, h) {
+    const a = Math.round(Number(w)), b = Math.round(Number(h));
+    return Number.isFinite(a) && Number.isFinite(b) && a >= 1 && b >= 1 && a <= 20000 && b <= 20000 ? `${a}x${b}` : undefined;
+}
+function attempt(read) {
+    try {
+        return read();
+    }
+    catch {
+        return undefined;
+    }
+}
+// The screen of a touch device is its portrait size whatever way it is held (Android reports the current one, iOS the portrait
+// one), so a rotation does not split one visitor into two screens; a desktop keeps width x height as it is.
+function screenSize() {
+    const w = screen.width, h = screen.height;
+    const touch = attempt(() => matchMedia('(pointer: coarse)').matches) === true;
+    return touch && w > h ? size(h, w) : size(w, h);
+}
+export function batchContext(o = {}) {
+    const ctx = {};
+    const lang = attempt(() => navigator.language);
+    if (typeof lang === 'string' && lang.length <= 16 && LANG.test(lang))
+        ctx.lang = lang;
+    const tz = attempt(() => Intl.DateTimeFormat().resolvedOptions().timeZone);
+    if (typeof tz === 'string' && ZONE.test(tz))
+        ctx.tz = tz;
+    const scr = attempt(screenSize);
+    if (scr)
+        ctx.screen = scr;
+    const vp = attempt(() => size(innerWidth, innerHeight));
+    if (vp)
+        ctx.viewport = vp;
+    const dpr = attempt(() => Number(devicePixelRatio));
+    if (dpr !== undefined && Number.isFinite(dpr) && dpr >= 0.5 && dpr <= 10)
+        ctx.dpr = Math.round(dpr * 10) / 10;
+    if (o.net !== false) {
+        const conn = attempt(() => navigator.connection);
+        if (conn && typeof conn.effectiveType === 'string' && NET.has(conn.effectiveType))
+            ctx.net = conn.effectiveType;
+        if (conn && conn.saveData === true)
+            ctx.save_data = true;
+    }
+    return ctx;
+}

package/dist/errors.d.ts

@@ -0,0 +1,7 @@
+export declare const MAX_ERRORS = 5;
+export declare function scrub(text: string): string;
+export type ErrorOptions = {
+    track: (name: string, props: Record<string, unknown>, stepId: string) => void;
+    stepId: () => string;
+};
+export declare function installErrors(o: ErrorOptions): () => void;

package/dist/errors.js

@@ -0,0 +1,90 @@
+// $error (kit 0.13.0): an uncaught JS error (window error event) or an unhandled promise rejection on the funnel's page.
+//
+// Props:
+//   kind     error or rejection
+//   message  what the browser says, at most 300 characters
+//   source   the script's address without its query string and fragment (error only), at most 200 characters
+//   line, col the place in the script (error only)
+//   stack    the first 600 characters of the stack (when the error has one)
+// And the step id of the event is the step on screen. Nothing the visitor typed may reach this event, so every text goes through
+// scrub(): a query string or fragment of a URL is cut off, an address with an @ and a run of 9 or more digits are replaced.
+// At most 5 per page load, the same error (message and place) once. Errors of browser extensions and the harmless ResizeObserver
+// notice are not the funnel's and are left out.
+export const MAX_ERRORS = 5;
+const MAX_MESSAGE = 300;
+const MAX_SOURCE = 200;
+const MAX_STACK = 600;
+const URL_RE = /\b(?:https?|file|blob|wss?):\/\/[^\s'"<>()[\]{}]+/gi;
+// An address is word characters, @, then a domain with a dot. "fn@https://…" of a Firefox or Safari stack is no address.
+const EMAIL_RE = /[\w.+%-]+@(?![a-z-]+:)[\w-]+(?:\.[\w-]+)+/g;
+const DIGITS_RE = /\d{9,}/g;
+const EXTENSION_RE = /(?:chrome|moz|safari|safari-web|ms-browser)-extension:\/\/|webkit-masked-url:/i;
+const NOISE_RE = /ResizeObserver loop/i;
+// URL → origin and path, plus the line and column after a query-less script address ("a.js?v=1:10:5" → "a.js:10:5").
+function stripUrl(url) {
+    const pos = /(?::\d+){1,2}$/.exec(url)?.[0] ?? '';
+    const base = pos ? url.slice(0, -pos.length) : url;
+    const cutAt = base.search(/[?#]/);
+    return (cutAt < 0 ? base : base.slice(0, cutAt)) + pos;
+}
+export function scrub(text) {
+    return text.replace(URL_RE, stripUrl).replace(EMAIL_RE, '[email]').replace(DIGITS_RE, '#');
+}
+const cut = (s, n) => (s.length <= n ? s : Array.from(s).slice(0, n).join(''));
+export function installErrors(o) {
+    let sent = 0;
+    const seen = new Set();
+    const send = (props, key) => {
+        if (sent >= MAX_ERRORS || seen.has(key))
+            return;
+        seen.add(key);
+        sent++;
+        o.track('$error', props, o.stepId());
+    };
+    const onError = (e) => {
+        try {
+            const source = typeof e.filename === 'string' ? e.filename : '';
+            const message = typeof e.message === 'string' ? e.message : '';
+            if (NOISE_RE.test(message))
+                return;
+            const stack = e.error && typeof e.error.stack === 'string' ? e.error.stack : '';
+            if (EXTENSION_RE.test(source) || EXTENSION_RE.test(stack))
+                return;
+            const props = { kind: 'error', message: cut(scrub(message), MAX_MESSAGE) };
+            if (source)
+                props.source = cut(scrub(source), MAX_SOURCE);
+            if (Number.isFinite(e.lineno) && e.lineno > 0)
+                props.line = e.lineno;
+            if (Number.isFinite(e.colno) && e.colno > 0)
+                props.col = e.colno;
+            if (stack)
+                props.stack = cut(scrub(stack), MAX_STACK);
+            send(props, `${props.message}|${props.source ?? ''}|${props.line ?? ''}`);
+        }
+        catch { /* analytics must never break the page */ }
+    };
+    const onRejection = (e) => {
+        try {
+            const r = e.reason;
+            let message = 'non-error rejection', stack = '';
+            if (r instanceof Error || (r && typeof r === 'object' && typeof r.message === 'string')) {
+                const err = r;
+                message = (typeof err.name === 'string' && err.name ? err.name + ': ' : '') + err.message;
+                if (typeof err.stack === 'string')
+                    stack = err.stack;
+            }
+            else if (typeof r === 'string')
+                message = r;
+            if (NOISE_RE.test(message) || EXTENSION_RE.test(stack))
+                return;
+            const props = { kind: 'rejection', message: cut(scrub(message), MAX_MESSAGE) };
+            if (stack)
+                props.stack = cut(scrub(stack), MAX_STACK);
+            send(props, `${props.message}|r`);
+        }
+        catch { /* analytics must never break the page */ }
+    };
+    addEventListener('error', onError);
+    addEventListener('unhandledrejection', onRejection);
+    return () => { removeEventListener('error', onError); removeEventListener('unhandledrejection', onRejection); };
+}

package/dist/experiments.d.ts

@@ -0,0 +1,4 @@
+export declare function experiment(key: string): string | null;
+export declare function useExperiment(key: string): string | null;
+export declare function rule(): string | null;
+export declare function useRule(): string | null;

package/dist/experiments.js

@@ -0,0 +1,24 @@
+// A/B in the funnel's code (kit 0.9.0, spec «A/B» §3): the visitor's arm, as the router assigned it (bootstrap.variants).
+import { useMemo } from 'react';
+import { readBootstrap } from './bootstrap.js';
+// The arm key of experiment `key` for this visitor, or null: no such experiment running, vite dev, an old router.
+export function experiment(key) {
+    const v = readBootstrap().variants;
+    if (!v || typeof v !== 'object' || !Object.prototype.hasOwnProperty.call(v, key))
+        return null;
+    return typeof v[key] === 'string' ? v[key] : null;
+}
+// The same in a component; the bootstrap does not change while the page lives.
+export function useExperiment(key) {
+    return useMemo(() => experiment(key), [key]);
+}
+// The targeting rule the router matched for this visitor (v2 track D: «Правила» in the admin), or null: no rule matched, vite dev, an
+// old router. Rules decide the build and the t()/param() values before any experiment does; this is for code that wants to know which
+// one it got. It is the `rule` key of the variants, so experiment('rule') answers the same, but a rule is no experiment: no $exposure.
+export function rule() {
+    return experiment('rule');
+}
+// The same in a component; the bootstrap does not change while the page lives.
+export function useRule() {
+    return useMemo(() => rule(), []);
+}

package/dist/exposure.d.ts

@@ -0,0 +1,4 @@
+type Track = (name: string, props?: Record<string, unknown>) => void;
+export declare const RULE_KEY = "rule";
+export declare function exposeVariants(funnel: string, variants: Record<string, string> | undefined, track: Track): void;
+export {};

package/dist/exposure.js

@@ -0,0 +1,35 @@
+// $exposure (kit 0.9.0, spec «A/B» §3): at the funnel's start, one event per experiment of the bootstrap, props {experiment, arm},
+// once per session. The variants key `rule` is the targeting rule the router matched, not an experiment: it has no $exposure: sessionStorage af_exposed:<funnel> keeps the session id (the tracker's, visit.session) and the arms already sent.
+// A new session (30 min idle) or another arm sends it again. Blocked storage: once per page load.
+import { visit } from './server.js';
+// The variants key of the matched rule (v2 track D): it rides on every event as a variant, but a rule is no test and has no exposure.
+export const RULE_KEY = 'rule';
+export function exposeVariants(funnel, variants, track) {
+    if (!variants || typeof variants !== 'object')
+        return;
+    const entries = Object.entries(variants).filter(([experiment, arm]) => experiment !== RULE_KEY && typeof arm === 'string' && arm);
+    if (!entries.length)
+        return;
+    const key = `af_exposed:${funnel}`;
+    let sid = '';
+    try {
+        sid = visit.session();
+    }
+    catch { /* no session */ }
+    let seen = {};
+    try {
+        seen = JSON.parse(sessionStorage.getItem(key) ?? '{}') ?? {};
+    }
+    catch { /* blocked or junk */ }
+    const arms = seen.sid === sid && seen.arms && typeof seen.arms === 'object' ? { ...seen.arms } : {};
+    for (const [experiment, arm] of entries) {
+        if (arms[experiment] === arm)
+            continue;
+        track('$exposure', { experiment, arm });
+        arms[experiment] = arm;
+    }
+    try {
+        sessionStorage.setItem(key, JSON.stringify({ sid, arms }));
+    }
+    catch { /* storage unavailable */ }
+}

package/dist/functions.d.ts

@@ -0,0 +1,37 @@
+export declare const FUNCTION_NAME: RegExp;
+export declare const REPLY: unique symbol;
+export type Reply = {
+    readonly [REPLY]: true;
+    readonly status: number;
+    readonly body: unknown;
+};
+export type FunctionCtx = {
+    secrets: Readonly<Record<string, string>>;
+    cookies: {
+        get(name: string): string | undefined;
+        set(name: string, value: string, opts?: {
+            maxAgeSec?: number;
+        }): void;
+        clear(name: string): void;
+    };
+    ip: string;
+    env: 'prod' | 'preview';
+    project: string;
+    funnel: string;
+    visitor: string;
+    session: string;
+    build: string;
+    release: string;
+    variants: Readonly<Record<string, string>>;
+    params: Readonly<Record<string, string | number | boolean>>;
+    rule: string;
+    reply(status: number, body?: unknown): Reply;
+    track(name: string, props?: Record<string, unknown>): void;
+};
+export type FunctionHandler<P = any, R = unknown> = (payload: P, ctx: FunctionCtx) => R | Reply | Promise<R | Reply>;
+export type FunctionsModule<F extends Record<string, FunctionHandler> = Record<string, FunctionHandler>> = {
+    readonly __funnelFunctions: 1;
+    readonly functions: F;
+};
+export declare function reply(status: number, body?: unknown): Reply;
+export declare function defineFunctions<F extends Record<string, FunctionHandler>>(fns: F): FunctionsModule<F>;

package/dist/functions.js

@@ -0,0 +1,24 @@
+// `@appright/funnelshift/functions` (before 0.15.0 `@appright/funnel-kit/functions`): what functions/index.ts imports. It is bundled into _functions.js and runs in a Worker
+// isolate behind the router (spec §3), so nothing here may touch React, the DOM or node builtins.
+// The same rule as the router and server(): the name is a URL segment and a manifest entry.
+export const FUNCTION_NAME = /^[a-z][a-z0-9_]{0,63}$/;
+// The router's host builds replies with ctx.reply under this registry key; Symbol.for makes the host's symbol and this one the
+// same value although they live in different modules (host.js is router code, not part of the build).
+export const REPLY = Symbol.for('appright.funnel-kit.reply');
+// The same shape ctx.reply returns; for helpers that build a reply outside a handler.
+export function reply(status, body) {
+    return { [REPLY]: true, status, body };
+}
+// `export default defineFunctions({ ... })` is the only shape the build and the host accept: the marker tells them apart from
+// a module that forgot it. Bad names fail here, at build time, when funnel-kit imports the bundle to list them.
+export function defineFunctions(fns) {
+    if (!fns || typeof fns !== 'object')
+        throw new Error('defineFunctions expects an object of functions');
+    for (const [name, fn] of Object.entries(fns)) {
+        if (!FUNCTION_NAME.test(name))
+            throw new Error(`bad function name ${JSON.stringify(name)}: use ${FUNCTION_NAME.source}`);
+        if (typeof fn !== 'function')
+            throw new Error(`function ${name} is not a function`);
+    }
+    return { __funnelFunctions: 1, functions: fns };
+}

package/dist/funnel.d.ts

@@ -0,0 +1,64 @@
+import { type Answers, type StepDef } from './nav.js';
+import { type Creator } from './bootstrap.js';
+import { type FinalEvent, type StopScope } from './tracker.js';
+import { type AutoTrack } from './autotrack.js';
+export type FunnelDef = {
+    id: string;
+    steps: StepDef[];
+    prerender?: boolean;
+    autoTrack?: AutoTrack;
+    browserBack?: boolean;
+};
+export type TrackFn = (name: string, props?: Record<string, unknown>, stepId?: string) => void;
+type Ctx = {
+    answers: Answers;
+    set: (k: string, v: unknown, label?: string | string[]) => void;
+    next: () => void;
+    back: () => void;
+    skip: () => void;
+    stepId: string;
+    index: number;
+    total: number;
+    progress: number;
+    track: TrackFn;
+    shot: boolean;
+    stopTracking: (opts?: StopOptions) => Promise<void>;
+    creator: Creator | null;
+    visitorId: string;
+    funnelId: string;
+    userId: string;
+    knownUser: boolean;
+};
+export type StopOptions = {
+    final?: FinalEvent;
+    scope?: StopScope;
+};
+export declare const defineStep: (s: StepDef) => StepDef;
+export declare const defineFunnel: (f: FunnelDef) => FunnelDef;
+export declare const FunnelCtx: import("react").Context<Ctx | null>;
+export declare function useFunnel(): Ctx;
+export type IdentifyOptions = {
+    email?: string;
+    traits?: Record<string, unknown>;
+    sendEmail?: boolean;
+};
+export declare function identify(): void;
+export declare function identify(userId: string, opts?: IdentifyOptions): void;
+export declare function reset(): void;
+export type ShotRequest = {
+    step: string;
+};
+export declare function shotRequest(search: string): ShotRequest | null;
+export declare function FunnelApp({ funnel, track, shot, root, browserBack }: {
+    funnel: FunnelDef;
+    track: TrackFn;
+    shot?: ShotRequest | null;
+    root?: HTMLElement | null;
+    browserBack?: boolean;
+}): import("react").JSX.Element;
+export declare function track(name: string, props?: Record<string, unknown>): void;
+export declare function fieldError(field: string, code: string): void;
+export declare function stopTracking(opts?: StopOptions): Promise<void>;
+export declare function mount(funnel: FunnelDef, el?: HTMLElement): void;
+export declare function landingContext(funnel: FunnelDef): Ctx;
+export {};