@appright/funnelshift 0.0.0-stage → 0.16.0

package/dist/funnel.js

@@ -0,0 +1,433 @@
+import { jsx as _jsx } from "react/jsx-runtime";
+import { createContext, useContext, useEffect, useLayoutEffect, useMemo, useRef, useState } from 'react';
+import { createRoot, hydrateRoot } from 'react-dom/client';
+import { nextIndex, prevIndex } from './nav.js';
+import { readBootstrap, readCreator } from './bootstrap.js';
+import { setContent, keyOfText } from './content.js';
+import { installClicks } from './clicks.js';
+import { Tracker, validUserId } from './tracker.js';
+import { autoOn } from './autotrack.js';
+import { installStepSignals, sectionName } from './signals.js';
+import { installVitals } from './vitals.js';
+import { installBackNav } from './backnav.js';
+import { installAnchors, scrollToInitialHash } from './anchors.js';
+import { installErrors } from './errors.js';
+import { batchContext } from './context.js';
+import { emailHash } from './sha256.js';
+import { visit } from './server.js';
+import { exposeVariants } from './exposure.js';
+import { attribution } from './attribution.js';
+import { encodeAnswer, packAnswers } from './answers.js';
+import { LabelCtx, sameValue } from './offer.js';
+import { funnelSlug, setHandoff, visitorId } from './handoff.js';
+import { installPixel, metaCookies, readPixel, revokePixel, setPixel } from './pixel.js';
+export const defineStep = (s) => s;
+export const defineFunnel = (f) => f;
+export const FunnelCtx = createContext(null);
+export function useFunnel() {
+    const c = useContext(FunnelCtx);
+    if (!c)
+        throw new Error('useFunnel() outside <FunnelApp>');
+    return c;
+}
+// The answers of a step: every key that was last set() on this step, except skipAnswers, value and label (answers.ts).
+// More than MAX_PROPS props are split: the first part is the $step_complete props, the rest go as $step_answers.
+// trackAnswers (kit 0.3) and sensitive filter nothing any more.
+// extra (active_ms) is counted in the first event's props like an answer, so it never pushes an answer out of the 128.
+function stepAnswers(step, asked, a, labels, extra) {
+    const skip = new Set(step.skipAnswers ?? []);
+    const keys = Object.keys(asked).filter(k => asked[k] === step.id && !skip.has(k));
+    return packAnswers([...(extra ? [extra] : []), ...keys.map(k => encodeAnswer(k, a[k], labels[k]))]);
+}
+// load/save: a JSON object in sessionStorage. Storage can be blocked or hold junk: the funnel must still work.
+function load(key) {
+    try {
+        const v = JSON.parse(sessionStorage.getItem(key) ?? '{}');
+        return (v && typeof v === 'object' && !Array.isArray(v) ? v : {});
+    }
+    catch {
+        return {};
+    }
+}
+function save(key, v) { try {
+    sessionStorage.setItem(key, JSON.stringify(v));
+}
+catch { /* storage unavailable */ } }
+// $lead: the visitor left a contact. Sent at most once per session (a sessionStorage flag per funnel; a blocked storage falls back
+// to memory), by identify() or by completing a step with role 'lead'.
+const leadSent = new Set();
+function leadAlreadySent(funnelId) {
+    const key = `af_lead:${funnelId}`;
+    try {
+        if (sessionStorage.getItem(key))
+            return true;
+        sessionStorage.setItem(key, '1');
+        return false;
+    }
+    catch {
+        if (leadSent.has(key))
+            return true;
+        leadSent.add(key);
+        return false;
+    }
+}
+// af_known=1, set by the product's app on the parent domain after login (not HttpOnly: the kit reads it).
+function knownCookie() {
+    try {
+        return /(?:^|;\s*)af_known=1(?:;|$)/.test(document.cookie);
+    }
+    catch {
+        return false;
+    }
+}
+// The funnel that is running now: identify() reports through it. Not set in shot mode, where nothing is ever sent.
+let live = null;
+const TRAIT_KEY = /^[a-z][a-z0-9_]{0,56}$/;
+export function identify(userId, opts = {}) {
+    if (userId === undefined) {
+        if (live && !leadAlreadySent(live.funnelId))
+            live.track('$lead', {}, live.stepId);
+        return;
+    }
+    if (!validUserId(userId)) {
+        console.warn('funnel-kit: identify() needs the product\'s user id: up to 128 characters, no "@" (an email is not an id), no control characters; not sent');
+        return;
+    }
+    const tr = current;
+    if (!tr || tr.stopped())
+        return; // a thumbnail, vite dev, or the visitor must not be tracked
+    tr.setUser(userId);
+    const props = { user_id: userId };
+    const email = typeof opts.email === 'string' ? opts.email.trim() : '';
+    const hash = email ? emailHash(email) : '';
+    if (hash)
+        props.email_hash = hash;
+    if (hash && opts.sendEmail === true)
+        props.email = email;
+    for (const [k, v] of Object.entries(opts.traits ?? {})) {
+        const key = k.toLowerCase();
+        if (!TRAIT_KEY.test(key) || key.includes('email'))
+            continue;
+        if (typeof v === 'string' && v.includes('@'))
+            continue; // contacts go through email, hashed
+        if (typeof v === 'string' || typeof v === 'number' || typeof v === 'boolean')
+            props['trait_' + key] = v;
+    }
+    tr.track('$identify', props, live?.stepId ?? '');
+    if (hash && live && !leadAlreadySent(live.funnelId))
+        live.track('$lead', {}, live.stepId);
+}
+// reset(): the visitor is nobody's again (the product's logout): later events carry no user id. The visitor id stays.
+export function reset() {
+    current?.clearUser();
+    if (current)
+        return;
+    try {
+        const b = window.__FUNNEL__;
+        if (b?.project)
+            localStorage.removeItem('af_user:' + b.project);
+    }
+    catch { /* storage unavailable */ }
+}
+export function shotRequest(search) {
+    const q = new URLSearchParams(search);
+    const step = q.get('__step');
+    return q.get('__shot') === '1' && step ? { step } : null;
+}
+// One screen, in the same layout as in the funnel, with the sample answers of the step. It is a picture: nothing is tracked,
+// nothing is stored, and the buttons do nothing. `fk-shot` turns the animations off (blocks.css).
+function ShotView({ funnel, stepId }) {
+    const found = funnel.steps.findIndex(s => s.id === stepId);
+    const index = found < 0 ? 0 : found;
+    const step = funnel.steps[index];
+    const ctx = useMemo(() => {
+        const none = () => { };
+        return { answers: { ...step.sample?.answers }, set: none, next: none, back: none, skip: none, track: none,
+            stepId: step.id, index, total: funnel.steps.length, progress: 0, shot: true, stopTracking: async () => { }, creator: null,
+            visitorId: '', funnelId: funnelSlug() || funnel.id, userId: '', knownUser: false };
+    }, [funnel, step, index]);
+    const C = step.component;
+    return _jsx(FunnelCtx.Provider, { value: ctx, children: _jsx("div", { className: "fk-shot", children: _jsx(C, {}) }) });
+}
+// root: the element the funnel is drawn into. With it, every click on a button, link or option inside goes as $click (clicks.ts);
+// mount() passes its element. A thumbnail never tracks clicks.
+// browserBack: handle the browser's Back with the history (backnav.ts); mount() turns it on for a real visit.
+export function FunnelApp({ funnel, track, shot, root, browserBack }) {
+    if (shot)
+        return _jsx(ShotView, { funnel: funnel, stepId: shot.step });
+    return _jsx(LiveFunnel, { funnel: funnel, track: track, root: root ?? null, browserBack: browserBack === true });
+}
+// Answers, their labels and the step each answer was last set on live in sessionStorage per funnel (af_answers, af_labels,
+// af_asked), so after a reload a step completed again still sends its answers with their texts.
+function LiveFunnel({ funnel, track, root, browserBack }) {
+    const store = `af_answers:${funnel.id}`;
+    const labelStore = `af_labels:${funnel.id}`;
+    const askedStore = `af_asked:${funnel.id}`;
+    const [answers, setAnswers] = useState(() => load(store));
+    const [index, setIndex] = useState(() => nextIndex(funnel.steps, answers, -1) ?? 0);
+    const labels = useRef(load(labelStore));
+    const asked = useRef(load(askedStore));
+    // The label a Choice/MultiChoice offers while its onChange runs (offer.ts).
+    const offered = useRef(null);
+    const withLabel = useMemo(() => (value, label, fn) => {
+        const prev = offered.current;
+        offered.current = { value, label };
+        try {
+            fn();
+        }
+        finally {
+            offered.current = prev;
+        }
+    }, []);
+    const started = useRef(false);
+    // Read once: the bootstrap does not change while the page lives.
+    const [creator] = useState(() => readCreator());
+    const step = funnel.steps[index];
+    // The step on screen and the track function for a click: read when the click happens, before the button's own handler can move
+    // on, so one listener serves the whole funnel.
+    const onScreen = useRef({ step: step.id, track });
+    onScreen.current = { step: step.id, track };
+    // server() sends the step on screen. Set while rendering, like onScreen: a step that calls its function in its own effect runs
+    // that effect before any effect of the funnel would.
+    visit.step = step.id;
+    // A layout effect, not a plain one: the listener is on the root before the first paint, so a click right after the screen
+    // appears is never missed (a plain effect can run after the browser has already delivered that click).
+    useLayoutEffect(() => {
+        if (!root)
+            return;
+        const offClicks = installClicks(root, { stepId: () => onScreen.current.step, track: (n, p, s) => onScreen.current.track(n, p, s), keyOf: keyOfText });
+        const offAnchors = installAnchors(root);
+        return () => { offClicks(); offAnchors(); };
+    }, [root]);
+    // A link with a hash in the address (a shared link to a section): scroll to it once the first step is drawn.
+    useEffect(() => (root ? scrollToInitialHash() : undefined), [root]);
+    // Scroll depth, sections, field errors and the active clock of the step on screen (signals.ts). Without a root they watch the page.
+    const signals = useRef(null);
+    useLayoutEffect(() => {
+        const at = funnel.autoTrack;
+        const s = installStepSignals(root ?? document.body, { stepId: () => onScreen.current.step, track: (n, p, st) => onScreen.current.track(n, p, st),
+            scroll: autoOn(at, 'scroll'), sections: autoOn(at, 'sections'), fieldErrors: autoOn(at, 'fieldErrors'), activeTime: autoOn(at, 'activeTime') });
+        signals.current = s;
+        return () => { s.off(); if (signals.current === s)
+            signals.current = null; };
+    }, [root, funnel]);
+    // The browser's Back (backnav.ts): reads the screen and the answers as they are when it happens.
+    const now = useRef({ index, answers, reached: index });
+    now.current = { index, answers, reached: Math.max(now.current.reached, index) };
+    const backNav = useRef(null);
+    // The time on the step for the events that leave it (undefined: the clock is off).
+    const activeProps = () => {
+        const ms = signals.current?.activeMs();
+        return ms === undefined ? undefined : { active_ms: String(ms) };
+    };
+    useEffect(() => {
+        if (!browserBack)
+            return;
+        const b = installBackNav({
+            index: () => now.current.index, stepId: i => funnel.steps[i].id,
+            prev: () => prevIndex(funnel.steps, now.current.answers, now.current.index),
+            next: () => nextIndex(funnel.steps, now.current.answers, now.current.index),
+            reached: () => now.current.reached,
+            back: p => { onScreen.current.track('$back', { ...activeProps(), via: 'browser' }, funnel.steps[now.current.index].id); setIndex(p); },
+            forward: n => setIndex(n),
+        });
+        backNav.current = b;
+        return () => { b.off(); if (backNav.current === b)
+            backNav.current = null; };
+    }, [browserBack, funnel]);
+    useEffect(() => {
+        live = { funnelId: funnel.id, track, stepId: step.id };
+        return () => { if (live?.track === track)
+            live = null; };
+    }, [funnel.id, track, step.id]);
+    useEffect(() => {
+        if (!started.current) {
+            started.current = true;
+            track('$funnel_start');
+            exposeVariants(funnel.id, readBootstrap().variants, track);
+        }
+        track('$step_view', {}, step.id);
+        signals.current?.newView();
+    }, [step.id]);
+    const ctx = useMemo(() => {
+        const set = (k, v, label) => {
+            const o = offered.current;
+            if (label === undefined && o && sameValue(o.value, v))
+                label = o.label;
+            // A set() without a label replaces the old one too: a stale text must not describe a new value.
+            if (label === undefined)
+                delete labels.current[k];
+            else
+                labels.current[k] = label;
+            asked.current[k] = step.id;
+            save(labelStore, labels.current);
+            save(askedStore, asked.current);
+            setAnswers(prev => { const n = { ...prev, [k]: v }; save(store, n); return n; });
+            answers[k] = v; // next() called right after set() in one handler must see the fresh answer; React applies setAnswers later
+        };
+        const active = activeProps;
+        const go = (kind) => {
+            if (kind === '$step_complete') {
+                const [first, ...rest] = stepAnswers(step, asked.current, answers, labels.current, active());
+                track(kind, first, step.id);
+                for (const more of rest)
+                    track('$step_answers', more, step.id);
+            }
+            else
+                track(kind, active() ?? {}, step.id);
+            if (kind === '$step_complete' && step.role === 'lead' && !leadAlreadySent(funnel.id))
+                track('$lead', {}, step.id);
+            const n = nextIndex(funnel.steps, answers, index);
+            if (n === null)
+                track('$funnel_complete', {}, step.id);
+            else {
+                setIndex(n);
+                backNav.current?.push(n);
+            }
+        };
+        const visible = funnel.steps.filter(s => !s.when || s.when(answers)).length;
+        const pos = funnel.steps.slice(0, index + 1).filter(s => !s.when || s.when(answers)).length;
+        const funnelId = funnelSlug() || funnel.id;
+        return {
+            answers, set, track, stepId: step.id, index, total: visible, progress: visible ? pos / visible : 0, shot: false, stopTracking, creator,
+            // a getter: '' right after stopTracking(), without a new render
+            get visitorId() { return visitorId(); }, funnelId,
+            // getters too: identify() or the app's login can change them without a new render
+            get userId() { return current?.user() ?? ''; }, get knownUser() { return knownCookie(); },
+            next: () => go('$step_complete'), skip: () => go('$step_skip'),
+            back: () => { const p = prevIndex(funnel.steps, answers, index); if (p !== null) {
+                track('$back', { ...active(), via: 'button' }, step.id);
+                setIndex(p);
+                backNav.current?.syncBack();
+            } },
+        };
+    }, [answers, index, step, funnel, track, creator]);
+    const C = step.component;
+    return _jsx(LabelCtx.Provider, { value: withLabel, children: _jsx(FunnelCtx.Provider, { value: ctx, children: _jsx(C, {}) }) });
+}
+let current = null;
+export function track(name, props) { current?.track(name, props); }
+// fieldError(field, code) (kit 0.13.0): a field of your own showed a validation error. The kit already reports a field that the browser
+// rejects (a native `invalid`) or that gets aria-invalid="true"; call this when the error shows some other way (a message under
+// a custom input). Sends $field_error with the step on screen. field: the name of the field ([a-z0-9_-], at most 64 characters),
+// code: a short word ([a-z][a-z0-9_]{0,31}: required, email_invalid, too_short, …). Never pass what the person typed.
+export function fieldError(field, code) {
+    const f = sectionName(field);
+    if (!f || !/^[a-z][a-z0-9_]{0,31}$/.test(code))
+        return;
+    live?.track('$field_error', { field: f, code }, live.stepId);
+}
+// stopTracking(): the person must not be tracked (under 13 at an age gate, an opt-out). Clears the funnel's queue and sends
+// nothing more from this tab until it closes, reloads included (sessionStorage af_stop:<funnel>): no $funnel_start or
+// $step_view on the next load, and server() stops sending X-Session/X-Step, so function calls are not tied to the visit.
+// scope 'project' keeps the stop for every funnel of the project in this browser (localStorage af_stop_project:<project>).
+// final, given, is sent once, right away, as an event nobody can tie to this person: a fresh random visitor and session, no
+// attribution, no step, no answers, only its own props (say { name: 'age_gate_blocked' }). Outside a mounted funnel: nothing.
+export async function stopTracking(opts) {
+    if (current)
+        revokePixel();
+    await current?.halt(opts?.final, opts?.scope ?? 'tab');
+}
+// mount: read the bootstrap the router injected, set content, start the tracker, render the funnel.
+// In shot mode (see shotRequest) no Tracker is made at all: a thumbnail in the admin must not count as a visit.
+export function mount(funnel, el = document.getElementById('root')) {
+    const b = readBootstrap();
+    setContent(b.content ?? {}, b.content_overrides ?? {});
+    const shot = shotRequest(location.search);
+    visit.step = '';
+    visit.session = () => '';
+    visit.off = () => false;
+    if (shot) {
+        setPixel(null);
+        setHandoff({ visitor: () => '', funnel: b.funnel });
+        createRoot(el).render(_jsx(FunnelApp, { funnel: funnel, track: () => { }, shot: shot }));
+        return;
+    }
+    // On a project's own domain (the bootstrap names the functions' prefix) the funnel is mounted at "/<funnel>/" or "/", not at
+    // "/<project>/<funnel>/": the link's creator segments are read after the router's <base href>.
+    const own = typeof b.fn_base === 'string';
+    const mountPath = own ? basePath() : undefined;
+    // Meta's cookies first, so the landing read below carries them (pixel.ts).
+    if (readPixel(b.meta_pixel) && b.env === 'prod') {
+        try {
+            metaCookies();
+        }
+        catch { /* cookies blocked */ }
+    }
+    current = new Tracker({ ingestUrl: b.ingest_url, fallbackUrl: b.ingest_fallback_url ?? null, project: b.project, key: b.ingest_key,
+        attribution: attribution(location, document, sessionStorage, { project: b.project, funnel: b.funnel, mountPath, own }),
+        base: { funnel_id: b.funnel, build_id: b.build_id, release_id: b.release_id, env: b.env, visitor_id: b.visitor_id, url_path: location.pathname },
+        variants: b.variants ?? {}, geo: typeof b.geo === 'string' ? b.geo : '', context: () => batchContext({ net: autoOn(funnel.autoTrack, 'network') }) });
+    const tr = current;
+    setHandoff({ visitor: () => tr.stopped() ? '' : b.visitor_id, funnel: b.funnel });
+    // After stopTracking() (this page or before a reload) the tracker stays silent, and so does its timer.
+    if (!tr.stopped())
+        tr.start();
+    visit.session = () => tr.session();
+    visit.off = () => tr.stopped();
+    // JS errors and page performance are the page's, not a step's: errors carry the step on screen (visit.step, set by the funnel).
+    if (!tr.stopped()) {
+        if (autoOn(funnel.autoTrack, 'errors'))
+            installErrors({ track: (n, p, s) => tr.track(n, p, s), stepId: () => visit.step });
+        if (autoOn(funnel.autoTrack, 'perf'))
+            installVitals({ send: p => { tr.track('$perf', p); void tr.flush(true); } });
+    }
+    // The page runs: tell ingest which router $request it answers (the share of requests without this is «ушли до загрузки»).
+    if (typeof b.request_id === 'string' && b.request_id && !tr.stopped()) {
+        tr.track('$page_loaded', { request_id: b.request_id, ms: typeof performance !== 'undefined' ? Math.round(performance.now()) : undefined });
+        void tr.flush();
+    }
+    // The browser's Back moves a step back, except in the admin's preview and inside a frame (the admin's thumbnails and previews).
+    let framed = false;
+    try {
+        framed = window.self !== window.top;
+    }
+    catch {
+        framed = true;
+    }
+    const browserBack = funnel.browserBack !== false && b.env !== 'preview' && !framed;
+    // Meta Pixel (pixel.ts): only on a real visit of a published funnel whose project switched Meta on.
+    const px = readPixel(b.meta_pixel);
+    let pixel = null;
+    if (px && b.env === 'prod' && !tr.stopped()) {
+        try {
+            pixel = installPixel(px, { funnel: b.funnel, steps: funnel.steps, visitorId: b.visitor_id, session: () => tr.session(), stopped: () => tr.stopped() });
+        }
+        catch (e) {
+            console.warn('funnel-kit: the Meta pixel did not start', e);
+        }
+    }
+    setPixel(pixel);
+    const app = _jsx(FunnelApp, { funnel: funnel, track: (n, p, s) => { tr.track(n, p, s ?? ''); pixel?.after(n, s ?? ''); }, root: el, browserBack: browserBack });
+    // A landing the build drew into index.html (`prerender: true`, prerender.tsx) is hydrated when this visit starts on it — the
+    // first step is the landing and no saved answers move the funnel on; otherwise the page is drawn again from scratch.
+    if (el.dataset?.prerendered === 'landing' && el.hasChildNodes() && startsOnFirstStep(funnel)) {
+        // A text edited in the admin, an A/B arm or the creator's greeting differ from what the build drew: React then draws that part
+        // again on the client (the page is right, the text changes after the script loads). That is expected, not an error to report.
+        hydrateRoot(el, app, { onRecoverableError: e => console.debug('funnel-kit: the prerendered landing differs from this visit, drawn again', e) });
+    }
+    else
+        createRoot(el).render(app);
+}
+// The path of the document's <base href>, the funnel's root as the router mounted it.
+function basePath() {
+    try {
+        return new URL(document.baseURI).pathname;
+    }
+    catch {
+        return undefined;
+    }
+}
+function startsOnFirstStep(funnel) {
+    return (nextIndex(funnel.steps, load(`af_answers:${funnel.id}`), -1) ?? 0) === 0;
+}
+// What the landing step sees on the server, at build time (prerender.tsx): an anonymous first visit that has answered nothing.
+// It is the context the client builds on a first visit, minus what only a browser knows (the creator, the visitor id).
+export function landingContext(funnel) {
+    const none = () => { };
+    const step = funnel.steps[0];
+    const visible = funnel.steps.filter(s => !s.when || s.when({})).length;
+    return { answers: {}, set: none, next: none, back: none, skip: none, track: none, stepId: step.id, index: 0, total: visible,
+        progress: visible ? 1 / visible : 0, shot: false, stopTracking: async () => { }, creator: null, visitorId: '', funnelId: funnel.id,
+        userId: '', knownUser: false };
+}

package/dist/handoff.d.ts

@@ -0,0 +1,8 @@
+export declare function setHandoff(m: {
+    visitor: () => string;
+    funnel: string;
+} | null): void;
+export declare function visitorId(): string;
+export declare function funnelSlug(): string;
+export declare function paywallUrl(base: string, extra?: Record<string, string>): string;
+export declare function appUrl(base: string, extra?: Record<string, string>): string;

package/dist/handoff.js

@@ -0,0 +1,66 @@
+// Set by mount(): the visitor while the tracker runs ('' once stopped or in shot mode) and the funnel of the bootstrap.
+let mounted = null;
+export function setHandoff(m) { mounted = m; }
+const boot = () => typeof window === 'undefined' ? undefined : window.__FUNNEL__;
+// visitorId(): the visitor_id of this page's events, usable outside React. Before mount() it is read from the router's bootstrap
+// (window.__FUNNEL__); without one (vite dev, no mount) it is ''.
+export function visitorId() {
+    if (mounted)
+        return mounted.visitor();
+    const v = boot()?.visitor_id;
+    return typeof v === 'string' ? v : '';
+}
+// The funnel slug of the bootstrap (the funnel_id of the events), '' when unknown.
+export function funnelSlug() {
+    if (mounted)
+        return mounted.funnel;
+    const f = boot()?.funnel;
+    return typeof f === 'string' ? f : '';
+}
+// paywallUrl(base, extra?): base with extra and then fv=<visitor>&ff=<funnel slug> set in its query (other params and the hash
+// kept). A Stripe Payment Link (buy.stripe.com) also gets client_reference_id=<visitor>, which Stripe puts on the Checkout
+// Session. A RevenueCat Web Purchase Link (kit 0.10.0) (pay.rev.cat/<token>, or pay.rev.cat/sandbox/<token>) without an app user id gets
+// the visitor as one (…/<token>/<visitor>): RevenueCat drops unknown query params, its webhook brings app_user_id back. With no visitor known (thumbnail, stopped, no bootstrap) or a base that is not a URL, base comes back unchanged.
+export function paywallUrl(base, extra) {
+    const u = withVisit(base, extra);
+    if (!u)
+        return base;
+    const visitor = visitorId();
+    if (u.hostname === 'buy.stripe.com')
+        u.searchParams.set('client_reference_id', visitor);
+    if (u.hostname === 'pay.rev.cat') {
+        const seg = u.pathname.split('/').filter(Boolean);
+        if (seg.length === (seg[0] === 'sandbox' ? 2 : 1))
+            u.pathname = `/${seg.join('/')}/${encodeURIComponent(visitor)}`;
+    }
+    return u.toString();
+}
+// base with extra and then fv=<visitor>&ff=<funnel slug> set in its query (other params and the hash kept); null when there is no
+// visitor to hand over (thumbnail, stopped, no bootstrap) or base is not a URL.
+function withVisit(base, extra) {
+    const visitor = visitorId();
+    if (!visitor)
+        return null;
+    let u;
+    try {
+        u = typeof location === 'undefined' ? new URL(base) : new URL(base, location.href);
+    }
+    catch {
+        return null;
+    }
+    for (const [k, v] of Object.entries(extra ?? {}))
+        u.searchParams.set(k, v);
+    u.searchParams.set('fv', visitor);
+    const funnel = funnelSlug();
+    if (funnel)
+        u.searchParams.set('ff', funnel);
+    return u;
+}
+// appUrl(base, extra?): the address of the product's app (kit 0.11.0, «Из воронки в кабинет» in the guide) with what the app needs
+// to recognize the person: fv=<visitor> (the value of the af_vid cookie, which the app's backend reads itself on a shared parent
+// domain; fv is the fallback for a browser that lost it) and ff=<funnel slug>, after extra (the one-time token, session_id…).
+// Secrets never belong here beyond the one-time login token the product made. No visitor known: base comes back unchanged.
+export function appUrl(base, extra) {
+    const u = withVisit(base, extra);
+    return u ? u.toString() : base;
+}

package/dist/index.d.ts

@@ -0,0 +1,17 @@
+export { defineFunnel, defineStep, FunnelApp, useFunnel, mount, track, identify, reset, stopTracking, fieldError, shotRequest, type FunnelDef, type IdentifyOptions, type ShotRequest, type StopOptions } from './funnel.js';
+export { appUrl, paywallUrl, visitorId } from './handoff.js';
+export { purchased, type PurchaseInfo } from './pixel.js';
+export { t, param, setContent } from './content.js';
+export { experiment, useExperiment, rule, useRule } from './experiments.js';
+export { bucketOf, pickArm } from './bucket.js';
+export { readBootstrap, readCreator, type Bootstrap, type Creator } from './bootstrap.js';
+export { server, ServerFnError } from './server.js';
+export { autoOn, SERVICE_SIGNALS, type AutoTrack, type AutoTrackKey } from './autotrack.js';
+export { Tracker, safeProps, type FinalEvent, type StopScope } from './tracker.js';
+export { nextIndex, prevIndex, type StepDef, type StepRole, type Answers } from './nav.js';
+export { uuidv7 } from './uuid.js';
+export { Hero } from './blocks/Hero.js';
+export { Choice } from './blocks/Choice.js';
+export { MultiChoice } from './blocks/MultiChoice.js';
+export { Cta } from './blocks/Cta.js';
+export { Section, type SectionProps } from './blocks/Section.js';

package/dist/index.js

@@ -0,0 +1,17 @@
+export { defineFunnel, defineStep, FunnelApp, useFunnel, mount, track, identify, reset, stopTracking, fieldError, shotRequest } from './funnel.js';
+export { appUrl, paywallUrl, visitorId } from './handoff.js';
+export { purchased } from './pixel.js';
+export { t, param, setContent } from './content.js';
+export { experiment, useExperiment, rule, useRule } from './experiments.js';
+export { bucketOf, pickArm } from './bucket.js';
+export { readBootstrap, readCreator } from './bootstrap.js';
+export { server, ServerFnError } from './server.js';
+export { autoOn, SERVICE_SIGNALS } from './autotrack.js';
+export { Tracker, safeProps } from './tracker.js';
+export { nextIndex, prevIndex } from './nav.js';
+export { uuidv7 } from './uuid.js';
+export { Hero } from './blocks/Hero.js';
+export { Choice } from './blocks/Choice.js';
+export { MultiChoice } from './blocks/MultiChoice.js';
+export { Cta } from './blocks/Cta.js';
+export { Section } from './blocks/Section.js';

package/dist/nav.d.ts

@@ -0,0 +1,19 @@
+import type { ComponentType } from 'react';
+export type Answers = Record<string, unknown>;
+export type StepRole = 'lead' | 'paywall' | 'landing';
+export declare const STEP_ROLES: readonly StepRole[];
+export type StepDef = {
+    id: string;
+    component: ComponentType;
+    when?: (a: Answers) => boolean;
+    role?: StepRole;
+    sensitive?: boolean;
+    sample?: {
+        answers?: Answers;
+    };
+    skipAnswers?: string[];
+    /** @deprecated Since kit 0.4 every answer is sent; this list filters nothing. Use skipAnswers to leave a key out. */
+    trackAnswers?: string[];
+};
+export declare function nextIndex(steps: StepDef[], a: Answers, from: number): number | null;
+export declare function prevIndex(steps: StepDef[], a: Answers, from: number): number | null;

package/dist/nav.js

@@ -0,0 +1,14 @@
+export const STEP_ROLES = ['lead', 'paywall', 'landing'];
+const shown = (s, a) => !s.when || s.when(a);
+export function nextIndex(steps, a, from) {
+    for (let i = from + 1; i < steps.length; i++)
+        if (shown(steps[i], a))
+            return i;
+    return null;
+}
+export function prevIndex(steps, a, from) {
+    for (let i = from - 1; i >= 0; i--)
+        if (shown(steps[i], a))
+            return i;
+    return null;
+}

package/dist/offer.d.ts

@@ -0,0 +1,3 @@
+export type WithLabel = (value: unknown, label: string | string[], fn: () => void) => void;
+export declare const LabelCtx: import("react").Context<WithLabel>;
+export declare function sameValue(a: unknown, b: unknown): boolean;

package/dist/offer.js

@@ -0,0 +1,7 @@
+import { createContext } from 'react';
+export const LabelCtx = createContext((_v, _l, fn) => fn());
+export function sameValue(a, b) {
+    if (Array.isArray(a) && Array.isArray(b))
+        return a.length === b.length && a.every((x, i) => x === b[i]);
+    return a === b;
+}

package/dist/pixel.d.ts

@@ -0,0 +1,36 @@
+import type { StepDef } from './nav.js';
+export type MetaPixel = {
+    id: string;
+    lead_step?: string;
+    checkout_step?: string;
+};
+export type PixelDeps = {
+    funnel: string;
+    steps: StepDef[];
+    visitorId: string;
+    session: () => string;
+    stopped: () => boolean;
+    win?: Window;
+    doc?: Document;
+    now?: () => number;
+};
+export type Pixel = {
+    after: (name: string, stepId: string) => void;
+    purchased: (p: PurchaseInfo) => void;
+};
+export type PurchaseInfo = {
+    value: number;
+    currency: string;
+    trial?: boolean;
+    subscription?: boolean;
+};
+export declare function readPixel(v: unknown): MetaPixel | null;
+export declare function readCookie(doc: Document, name: string): string;
+export declare function setTopCookie(doc: Document, loc: Location, name: string, make: (index: number) => string): string;
+export declare function ensureFbp(doc: Document, loc: Location, now: number): string;
+export declare function ensureFbc(doc: Document, loc: Location, now: number): string;
+export declare function metaCookies(doc?: Document, loc?: Location, now?: number): void;
+export declare function installPixel(cfg: MetaPixel, d: PixelDeps): Pixel;
+export declare function setPixel(p: Pixel | null): void;
+export declare function revokePixel(win?: Window): void;
+export declare function purchased(p: PurchaseInfo): void;