@appright/funnelshift 0.0.0-stage → 0.16.0

package/dist/tracker.js

@@ -0,0 +1,446 @@
+import { uuidv7 } from './uuid.js';
+import { capParams, CLICK_IDS, MAX_PARAM_KEY, MAX_PARAM_VALUE } from './attribution.js';
+import { PROP_KEY, MAX_PROPS, cut } from './answers.js';
+import { batchContext } from './context.js';
+const SESSION_GAP = 30 * 60 * 1000;
+const MAX_QUEUE = 1000;
+const MAX_BATCH = 100; // the server rejects bigger batches
+const MAX_BODY = 48 * 1024; // keepalive/sendBeacon bodies are limited to 64 KB, and 100 fat events can exceed the server's 256 KB
+const MAX_AGE = 7 * 24 * 3600 * 1000; // the server would replace a timestamp this far off anyway; such events are just dropped
+const BACKOFF_BASE = 5000;
+const BACKOFF_MAX = 60000;
+const enc = new TextEncoder();
+const VARIANT_KEY = /^[a-z][a-z0-9_]{0,31}$/;
+const NAME = /^\$?[a-z][a-z0-9_]{0,63}$/;
+const STEP = /^[a-z0-9_-]{0,64}$/;
+const ARM = /^[a-z0-9_-]{1,32}$/;
+const HOST = /^[a-z0-9]([a-z0-9.-]{0,252})?$/;
+// The user id of the product (identify(), kit 0.11.0): what ingest accepts for the event's user_id (128 characters, no '@' — an
+// email is not an id — no control characters). Mirrored by server/internal/ingest ValidUserID.
+export const MAX_USER_ID = 128;
+export function validUserId(u) {
+    return typeof u === 'string' && u !== '' && [...u].length <= MAX_USER_ID && !u.includes('@') && !/[\u0000-\u001f\u007f-\u009f]/.test(u);
+}
+const UTM_KEYS = ['source', 'medium', 'campaign', 'content', 'term'];
+const CLICK_TYPES = ['', ...new Set(CLICK_IDS.map(([p]) => p.toLowerCase()))];
+const NETWORKS = new Set(CLICK_IDS.map(([, n]) => n));
+const SEG = /^[a-z0-9._-]{1,64}$/;
+// The server answers these for good: 202 accepted, 400 malformed (a retry cannot fix it), 401 unknown key,
+// 403 bad origin, 413 too large. Everything else (503, other 5xx, 429, network errors) is retried later.
+const FINAL = new Set([202, 400, 401, 403, 413]);
+// An outage of ingest, not a refusal: these send the same batch to the fallback ingest.
+const OUTAGE = (status) => status === 0 || status === 429 || status >= 500;
+// Degraded mode (after a fallback 202: ingest is likely down): ingest is probed at most once a minute, batches go to the fallback
+// every 30 s or when maxBatch events wait, and at most 20 per page load; the first 202 from ingest ends it.
+const PRIMARY_TIMEOUT = 8000;
+const PROBE_EVERY = 60_000;
+const DEGRADED_EVERY = 30_000;
+const MAX_FALLBACK_SENDS = 20;
+// Shared by every tab and reload of this browser (localStorage): until this time (ms) ingest is taken for down, so a new page
+// load starts degraded instead of waiting up to 8 s on ingest first. Set for a minute on each fallback 202, cleared by any
+// answer of ingest that is not an outage.
+const DEGRADED_KEY = 'af_degraded_until';
+// Props in the shape the server accepts (spec "all events" §4): at most 128, the name [a-z][a-z0-9_]{0,63}, the value a string
+// of at most 1000 characters (a longer one is cut, not lost), a number or a boolean. Answers may be free text, emails and
+// phones: the owner collects them on purpose, so nothing is filtered by content. Anything else is dropped here, because the
+// server would reject the whole event for it.
+export function safeProps(p) {
+    const out = {};
+    let n = 0;
+    for (const [k, v] of Object.entries(p ?? {})) {
+        if (n >= MAX_PROPS)
+            break;
+        if (!PROP_KEY.test(k))
+            continue;
+        if (typeof v === 'number' || typeof v === 'boolean')
+            out[k] = String(v);
+        else if (typeof v === 'string')
+            out[k] = cut(v).text;
+        else
+            continue;
+        n++;
+    }
+    return out;
+}
+// The server rejects only an event with a bad field (it answers 202 with accepted/rejected counts), but such an event is lost,
+// so attribution is cleaned to what the server accepts. The landing fields (kit 0.7) are cut or emptied one by one, as the
+// server does with them: a bad one never costs the event.
+function cleanAttribution(a) {
+    const utm = {};
+    for (const k of UTM_KEYS) {
+        const v = a?.utm?.[k];
+        if (typeof v === 'string' && v && v.length <= 128 && !v.includes('@'))
+            utm[k] = v;
+    }
+    const type = a && typeof a.click_id_type === 'string' && CLICK_TYPES.includes(a.click_id_type) ? a.click_id_type : '';
+    const id = type && typeof a?.click_id === 'string' && a.click_id.length <= 256 && !a.click_id.includes('@') ? a.click_id : '';
+    const host = (a?.referrer_host ?? '').toLowerCase();
+    const seg = (v) => (typeof v === 'string' && SEG.test(v.toLowerCase()) ? v.toLowerCase() : '');
+    const path = typeof a?.landing_path === 'string' && a.landing_path.startsWith('/') && [...a.landing_path].length <= 512 && !a.landing_path.includes('@') ? a.landing_path : '';
+    const fit = [];
+    for (const [k, v] of Object.entries(a?.landing_params ?? {})) {
+        if (!k || [...k].length > MAX_PARAM_KEY || typeof v !== 'string')
+            continue;
+        fit.push([k, [...v].length > MAX_PARAM_VALUE ? [...v].slice(0, MAX_PARAM_VALUE).join('') : v]);
+    }
+    const params = capParams(fit); // 50 keys and 6 KB, the rest counted in $dropped
+    const segs = Array.isArray(a?.path_segs) ? a.path_segs.map(seg).filter(Boolean).slice(0, 16) : [];
+    const creator = seg(a?.creator), entry = seg(a?.entry_creator);
+    const referrer = typeof a?.referrer === 'string' && /^(https?|android-app):\/\/[^/?#@\s]+(\/[^?#\s]*)?$/.test(a.referrer) && [...a.referrer].length <= 1024 ? a.referrer : '';
+    const landing = { landing_path: path, landing_params: params, path_segs: segs, referrer,
+        click_network: typeof a?.click_network === 'string' && NETWORKS.has(a.click_network) ? a.click_network : '',
+        creator, channel: creator ? seg(a?.channel) : '', entry_creator: entry, entry_channel: entry ? seg(a?.entry_channel) : '' };
+    // An empty landing field is left out (the server reads a missing one as empty): a batch of 100 plain events stays as small
+    // as before kit 0.7.
+    for (const [k, v] of Object.entries(landing))
+        if (v === '' || (Array.isArray(v) ? !v.length : typeof v === 'object' && !Object.keys(v).length))
+            delete landing[k];
+    return { utm, click_id_type: id ? type : '', click_id: id, referrer_host: HOST.test(host) && host.length <= 255 ? host : '', ...landing };
+}
+function cleanVariants(v) {
+    const out = {};
+    if (!v || typeof v !== 'object')
+        return out;
+    for (const [k, arm] of Object.entries(v))
+        if (typeof arm === 'string' && (Object.keys(out).length < 16 && VARIANT_KEY.test(k) && ARM.test(arm)))
+            out[k] = arm;
+    return out;
+}
+// unmark is the event as sent: without the queue's own _b mark.
+function unmark(e) {
+    if (!('_b' in e))
+        return e;
+    const { _b, ...rest } = e;
+    void _b;
+    return rest;
+}
+export class Tracker {
+    o;
+    qkey;
+    stopKey;
+    projectStopKey;
+    userKey;
+    memUser = ''; // the user id of this page when storage is blocked
+    halted = false; // stopTracking() in this tab, also when sessionStorage is blocked
+    isDegraded = false;
+    nextProbe = 0; // degraded: no request to ingest before this
+    lastFallback = 0; // degraded: when the last batch went to the fallback
+    fallbackSends = 0; // this page load
+    timer;
+    inflight = Promise.resolve();
+    failures = 0;
+    retryAt = 0;
+    onHide = () => { void this.flush(true); };
+    onVisibility = () => { if (document.visibilityState === 'hidden')
+        void this.flush(true); };
+    constructor(o) {
+        this.o = {
+            storage: localStorage, session: sessionStorage, fetchImpl: fetch.bind(globalThis),
+            beacon: (u, b) => navigator.sendBeacon?.(u, new Blob([b], { type: 'text/plain' })) ?? false,
+            maxBatch: 20, intervalMs: 5000, now: Date.now, fallbackUrl: null, project: '', primaryTimeoutMs: PRIMARY_TIMEOUT, variants: {}, context: batchContext, geo: '', ...o,
+        };
+        this.qkey = 'af_q:' + o.base.funnel_id;
+        this.stopKey = 'af_stop:' + o.base.funnel_id;
+        this.projectStopKey = 'af_stop_project:' + this.o.project;
+        this.userKey = 'af_user:' + (this.o.project || o.base.funnel_id);
+        // A later visit after a project-wide stop: what this funnel still had queued from before is not sent either.
+        if (this.projectStopped())
+            this.save([]);
+        const until = this.sharedDegradedUntil();
+        if (until > this.o.now()) {
+            this.isDegraded = true;
+            this.nextProbe = until;
+        }
+    }
+    sharedDegradedUntil() {
+        try {
+            const v = Number(this.o.storage.getItem(DEGRADED_KEY));
+            return Number.isFinite(v) ? v : 0;
+        }
+        catch {
+            return 0;
+        }
+    }
+    shareDegraded(until) {
+        try {
+            if (until === null)
+                this.o.storage.removeItem(DEGRADED_KEY);
+            else
+                this.o.storage.setItem(DEGRADED_KEY, String(until));
+        }
+        catch { /* storage unavailable: this page only */ }
+    }
+    projectStopped() {
+        if (!this.o.project)
+            return false;
+        try {
+            return this.o.storage.getItem(this.projectStopKey) === '1';
+        }
+        catch {
+            return false;
+        }
+    }
+    // stopTracking() was called for this funnel in this tab (this page or one before a reload), or for the whole project in
+    // this browser: nothing is sent any more.
+    stopped() {
+        if (this.halted)
+            return true;
+        try {
+            if (this.o.session.getItem(this.stopKey) === '1')
+                return true;
+        }
+        catch { /* storage blocked */ }
+        return this.projectStopped();
+    }
+    // The user id of the product this browser was identified as (localStorage per project, so every funnel and later visit of the
+    // project carries it), '' for an anonymous visitor.
+    user() {
+        try {
+            const v = this.o.storage.getItem(this.userKey);
+            if (v !== null)
+                return validUserId(v) ? v : '';
+        }
+        catch { /* storage blocked: this page's memory */ }
+        return this.memUser;
+    }
+    setUser(id) {
+        if (!validUserId(id))
+            return;
+        this.memUser = id;
+        try {
+            this.o.storage.setItem(this.userKey, id);
+        }
+        catch { /* storage unavailable: this page only */ }
+    }
+    clearUser() {
+        this.memUser = '';
+        try {
+            this.o.storage.removeItem(this.userKey);
+        }
+        catch { /* storage unavailable */ }
+    }
+    // Degraded mode: the last batch went through the fallback and ingest has not answered 202 since.
+    degraded() { return this.isDegraded; }
+    // Stops this funnel's tracking in this tab for good (until the tab closes): clears its queue, sends nothing more, and gives
+    // server() no session any more. final, given, is sent once, right now, as an event nobody can tie to this visitor: a fresh
+    // random visitor_id and session_id, no attribution, no step, no answers, only its own props. A second stop sends nothing.
+    // scope 'project' also keeps the stop in localStorage for every funnel of the project in this browser.
+    async halt(final, scope = 'tab') {
+        const already = this.stopped();
+        this.halted = true;
+        try {
+            this.o.session.setItem(this.stopKey, '1');
+        }
+        catch { /* storage unavailable: held in memory for this page */ }
+        if (scope === 'project' && this.o.project) {
+            try {
+                this.o.storage.setItem(this.projectStopKey, '1');
+            }
+            catch { /* storage unavailable: this tab only */ }
+        }
+        this.stop();
+        this.save([]);
+        if (!final || already)
+            return;
+        if (!NAME.test(final.name)) {
+            console.warn(`funnel-kit: final event "${final.name}" has an invalid name, not sent`);
+            return;
+        }
+        const { ingestUrl, key, base } = this.o;
+        if (!ingestUrl)
+            return;
+        const now = this.o.now();
+        const ev = { funnel_id: base.funnel_id, build_id: base.build_id, release_id: base.release_id, env: base.env,
+            url_path: base.url_path.startsWith('/') ? base.url_path.slice(0, 512) : '', visitor_id: crypto.randomUUID(),
+            session_id: crypto.randomUUID(), event_id: uuidv7(now), name: final.name, step_id: '', props: safeProps(final.props),
+            variants: {}, ts_client: now, user_id: '', ...cleanAttribution() };
+        // keepalive: an age gate may close or leave the page right after; one small event fits its 64 KB. It is the one send
+        // allowed after the stop, and it is not counted against the fallback's limit.
+        const body = JSON.stringify({ key, events: [ev], sent_at: now });
+        const status = await this.post(ingestUrl, body, true, true);
+        if (!FINAL.has(status) && OUTAGE(status) && this.o.fallbackUrl)
+            await this.post(this.o.fallbackUrl, body, false, true);
+    }
+    // The device's ctx for this batch; a failing reader gives none, it never costs the batch.
+    context() { try {
+        return this.o.context();
+    }
+    catch {
+        return {};
+    } }
+    // One POST; its status, 0 for no answer. Ingest (primary) is given up after primaryTimeoutMs; the fallback has no timeout.
+    async post(url, body, primary, keepalive = false) {
+        const init = { method: 'POST', body, headers: { 'Content-Type': 'text/plain' } };
+        if (keepalive)
+            init.keepalive = true;
+        if (primary && typeof AbortSignal.timeout === 'function')
+            init.signal = AbortSignal.timeout(this.o.primaryTimeoutMs);
+        try {
+            return (await this.o.fetchImpl(url, init)).status;
+        }
+        catch {
+            return 0;
+        }
+    }
+    queue() { try {
+        return JSON.parse(this.o.storage.getItem(this.qkey) ?? '[]');
+    }
+    catch {
+        return [];
+    } }
+    // Storage can be full or blocked (private mode): analytics must never break the funnel, so a failed save is dropped.
+    save(q) { try {
+        this.o.storage.setItem(this.qkey, JSON.stringify(q.slice(-MAX_QUEUE)));
+    }
+    catch { /* storage unavailable */ } }
+    sessionId() {
+        const now = this.o.now();
+        let s = null;
+        try {
+            s = JSON.parse(this.o.session.getItem('af_sid') ?? 'null');
+        }
+        catch { /* corrupt */ }
+        if (!s || now - s.last > SESSION_GAP)
+            s = { id: uuidv7(now), last: now };
+        s.last = now;
+        try {
+            this.o.session.setItem('af_sid', JSON.stringify(s));
+        }
+        catch { /* storage unavailable */ }
+        return s.id;
+    }
+    // The current session id (the one the next event will carry); server() sends it as X-Session. Asking counts as activity.
+    // After stopTracking() there is none: the router then records no $fn_call for this tab.
+    session() { return this.stopped() ? '' : this.sessionId(); }
+    // The event's event_id, '' when it was not tracked (stopped, an invalid name).
+    track(name, props, stepId = '', variants = this.o.variants) {
+        if (this.stopped())
+            return '';
+        // The server would reject an event with an invalid name or step id (counted as rejected), so it never enters the queue.
+        if (!NAME.test(name) || !STEP.test(stepId)) {
+            console.warn(`funnel-kit: event "${name}" (step "${stepId}") has an invalid name, not tracked`);
+            return '';
+        }
+        const base = this.o.base;
+        const ev = { ...base, url_path: base.url_path.startsWith('/') ? base.url_path.slice(0, 512) : '',
+            event_id: uuidv7(this.o.now()), name, step_id: stepId, props: safeProps(props), variants: cleanVariants(variants),
+            ts_client: this.o.now(), session_id: this.sessionId(), user_id: this.user(), ...cleanAttribution(this.o.attribution) };
+        const q = this.queue();
+        q.push(ev);
+        this.save(q);
+        if (q.length >= this.o.maxBatch)
+            this.inflight = this.inflight.then(() => this.flush());
+        return ev.event_id;
+    }
+    // Sends what waits now (in the background, after any send already on its way).
+    flushSoon() { this.inflight = this.inflight.then(() => this.flush()); }
+    // The head of the queue that fits one request: at most 100 events and 48 KB serialized (always at least one event).
+    takeBatch(q, key) {
+        let size = enc.encode(JSON.stringify({ key, events: [], sent_at: this.o.now() })).length;
+        let n = 0;
+        for (; n < Math.min(q.length, MAX_BATCH); n++) {
+            size += enc.encode(JSON.stringify(unmark(q[n]))).length + 1;
+            if (n > 0 && size > MAX_BODY)
+                break;
+        }
+        return q.slice(0, n);
+    }
+    // Failed sends back off min(5s * 2^(failures-1), 60s) so a down server is not hit by every track(); the unload beacon ignores it.
+    async flush(useBeacon = false) {
+        const { ingestUrl, key, fallbackUrl } = this.o;
+        if (this.stopped())
+            return;
+        if (!useBeacon && this.o.now() < this.retryAt)
+            return;
+        const cutoff = this.o.now() - MAX_AGE;
+        const all = this.queue();
+        const q = all.filter(e => typeof e.ts_client === 'number' && e.ts_client >= cutoff);
+        if (q.length !== all.length)
+            this.save(q);
+        if (!q.length)
+            return;
+        if (!ingestUrl) {
+            this.save([]);
+            return;
+        }
+        // A beacon gets no answer (the server may have refused it), so beaconed events stay queued, marked _b: the next beacon
+        // skips them, the next normal send sends them again and drops them on its answer. A copy within the same day collapses.
+        const candidates = useBeacon ? q.filter(e => !e._b) : q;
+        if (!candidates.length)
+            return;
+        const batch = this.takeBatch(candidates, key);
+        // sent_at: the device clock at this very send (a retry gets a new one). The server compares it with its own clock and,
+        // when they differ by more than 2 s, moves the batch's ts_client by the difference (a phone with a wrong clock).
+        const body = JSON.stringify({ key, events: batch.map(unmark), sent_at: this.o.now(), ctx: { ...this.context(), ...(this.o.geo ? { geo: this.o.geo } : {}) } });
+        const ids = new Set(batch.map(e => e.event_id));
+        const fallback = fallbackUrl && this.fallbackSends < MAX_FALLBACK_SENDS ? fallbackUrl : null;
+        if (useBeacon) {
+            // A beacon the browser refuses (queue full, too big) is tried on the other address; neither gives an answer. Degraded:
+            // the fallback first.
+            const order = this.isDegraded ? [fallback, ingestUrl] : [ingestUrl, fallback];
+            for (const u of order) {
+                if (!u || !this.o.beacon(u, body))
+                    continue;
+                if (u === fallback)
+                    this.fallbackSends++;
+                this.save(this.queue().map(e => ids.has(e.event_id) ? { ...e, _b: 1 } : e));
+                break;
+            }
+            return;
+        }
+        // ingest first; after no answer (or none within 8 s), a 5xx or a 429 the same batch (same sent_at) goes to the fallback
+        // at once, and its 202 settles it too and makes the tracker degraded. Degraded, ingest is only probed once a minute, and
+        // between probes batches go straight to the fallback every 30 s or when maxBatch events wait. Otherwise the batch stays
+        // and the backoff grows.
+        const now = this.o.now();
+        let probe = true;
+        if (this.isDegraded) {
+            probe = now >= this.nextProbe;
+            if (!probe && (!fallback || (q.length < this.o.maxBatch && now < this.lastFallback + DEGRADED_EVERY)))
+                return;
+            if (probe)
+                this.nextProbe = now + PROBE_EVERY;
+        }
+        const status = probe ? await this.post(ingestUrl, body, true) : -1;
+        // Any answer that is not an outage means ingest is up (a 4xx is about the batch, not the server): back to normal.
+        if (status > 0 && !OUTAGE(status)) {
+            if (this.isDegraded || this.sharedDegradedUntil())
+                this.shareDegraded(null);
+            this.isDegraded = false;
+        }
+        let done = FINAL.has(status);
+        // stopTracking() may have run while ingest was tried: then the batch goes nowhere else.
+        if (!done && (status === -1 || OUTAGE(status)) && fallback && !this.stopped()) {
+            this.fallbackSends++;
+            this.lastFallback = this.o.now();
+            if (await this.post(fallback, body, false) === 202) {
+                done = true;
+                if (!this.isDegraded) {
+                    this.isDegraded = true;
+                    this.nextProbe = this.o.now() + PROBE_EVERY;
+                }
+                this.shareDegraded(this.nextProbe);
+            }
+        }
+        if (done)
+            this.failures = 0;
+        else
+            this.retryAt = this.o.now() + Math.min(BACKOFF_BASE * 2 ** this.failures++, BACKOFF_MAX);
+        if (done)
+            this.save(this.queue().filter(e => !ids.has(e.event_id)));
+    }
+    idle() { return this.inflight; }
+    start() {
+        this.stop();
+        this.timer = setInterval(() => { this.inflight = this.inflight.then(() => this.flush()); }, this.o.intervalMs);
+        addEventListener('pagehide', this.onHide);
+        document.addEventListener('visibilitychange', this.onVisibility);
+    }
+    stop() {
+        if (this.timer)
+            clearInterval(this.timer);
+        this.timer = undefined;
+        removeEventListener('pagehide', this.onHide);
+        document.removeEventListener('visibilitychange', this.onVisibility);
+    }
+}

package/dist/uuid.d.ts

@@ -0,0 +1 @@
+export declare function uuidv7(now?: number): string;

package/dist/uuid.js

@@ -0,0 +1,12 @@
+// UUIDv7: time-ordered, so events sort by creation; used for event_id and session_id.
+export function uuidv7(now = Date.now()) {
+    const b = new Uint8Array(16);
+    crypto.getRandomValues(b);
+    const ms = BigInt(now);
+    for (let i = 0; i < 6; i++)
+        b[i] = Number((ms >> BigInt(8 * (5 - i))) & 0xffn);
+    b[6] = (b[6] & 0x0f) | 0x70;
+    b[8] = (b[8] & 0x3f) | 0x80;
+    const h = [...b].map(x => x.toString(16).padStart(2, '0')).join('');
+    return `${h.slice(0, 8)}-${h.slice(8, 12)}-${h.slice(12, 16)}-${h.slice(16, 20)}-${h.slice(20)}`;
+}

package/dist/vitals.d.ts

@@ -0,0 +1,4 @@
+export type VitalsOptions = {
+    send: (props: Record<string, number | string>) => void;
+};
+export declare function installVitals(o: VitalsOptions): () => void;

package/dist/vitals.js

@@ -0,0 +1,104 @@
+// $perf (kit 0.13.0): how the page loaded and how it felt, once per page load. Sent when the page first goes to the background or
+// is left (visibilitychange to hidden, pagehide), through the tracker's beacon path, because the numbers that matter most
+// (largest paint, layout shift, interaction delay) are only final then. A tab that is killed without ever going hidden sends nothing.
+//
+// Props (all whole numbers, a metric the browser cannot give is left out):
+//   ttfb_ms  the first byte of the document (navigation responseStart)
+//   fcp_ms   first contentful paint
+//   lcp_ms   largest contentful paint, the last candidate before the page was hidden
+//   load_ms  the load event (loadEventEnd); left out when the page went hidden before it
+//   cls      cumulative layout shift x 1000 (0.1 is 100), the worst session window of the Core Web Vitals definition
+//   inp_ms   interaction to next paint, the slow end of the interactions of the visit (Chrome and Safari only)
+//   nav      navigate, reload, back_forward or prerender
+// Positions on the page, URLs and element names are never read: only the times.
+const NAV = new Set(['navigate', 'reload', 'back_forward', 'prerender']);
+const whole = (v) => (typeof v === 'number' && Number.isFinite(v) && v >= 0 ? Math.round(v) : undefined);
+export function installVitals(o) {
+    if (typeof PerformanceObserver === 'undefined')
+        return () => { };
+    let fcp;
+    let lcp;
+    let cls = 0;
+    let session = { value: 0, first: 0, last: 0 };
+    const interactions = new Map();
+    const observers = [];
+    const watch = (type, take, extra = {}) => {
+        try {
+            const po = new PerformanceObserver(list => { try {
+                take(list.getEntries());
+            }
+            catch { /* ignore */ } });
+            po.observe({ type, buffered: true, ...extra });
+            observers.push({ po, take });
+        }
+        catch { /* the browser does not know this entry type */ }
+    };
+    watch('paint', es => { for (const e of es)
+        if (e.name === 'first-contentful-paint')
+            fcp = e.startTime; });
+    watch('largest-contentful-paint', es => { const last = es[es.length - 1]; if (last)
+        lcp = last.startTime; });
+    watch('layout-shift', es => {
+        for (const e of es) {
+            if (e.hadRecentInput)
+                continue;
+            if (session.value === 0 || e.startTime - session.last > 1000 || e.startTime - session.first > 5000)
+                session = { value: 0, first: e.startTime, last: e.startTime };
+            session.value += e.value ?? 0;
+            session.last = e.startTime;
+            if (session.value > cls)
+                cls = session.value;
+        }
+    });
+    watch('event', es => {
+        for (const e of es) {
+            if (typeof e.interactionId !== 'number' || e.interactionId <= 0)
+                continue;
+            interactions.set(e.interactionId, Math.max(interactions.get(e.interactionId) ?? 0, e.duration));
+        }
+    }, { durationThreshold: 40 });
+    let done = false;
+    const report = () => {
+        if (done)
+            return;
+        done = true;
+        off();
+        for (const { po, take } of observers) {
+            try {
+                take(po.takeRecords());
+            }
+            catch { /* ignore */ }
+            po.disconnect();
+        }
+        const props = {};
+        const put = (k, v) => { if (v !== undefined)
+            props[k] = v; };
+        let nav;
+        try {
+            nav = performance.getEntriesByType('navigation')[0];
+        }
+        catch { /* ignore */ }
+        put('ttfb_ms', nav && nav.responseStart > 0 ? whole(nav.responseStart) : undefined);
+        put('fcp_ms', whole(fcp));
+        put('lcp_ms', lcp ? whole(lcp) : undefined);
+        put('load_ms', nav && nav.loadEventEnd > 0 ? whole(nav.loadEventEnd) : undefined);
+        if (observers.length)
+            put('cls', whole(cls * 1000));
+        if (interactions.size) {
+            const slow = [...interactions.values()].sort((a, b) => b - a);
+            put('inp_ms', whole(slow[Math.min(slow.length - 1, Math.floor(slow.length / 50))]));
+        }
+        if (nav && NAV.has(nav.type))
+            props.nav = nav.type;
+        if (Object.keys(props).length === 0 || (Object.keys(props).length === 1 && 'nav' in props))
+            return;
+        o.send(props);
+    };
+    const onVisibility = () => { if (document.visibilityState === 'hidden')
+        report(); };
+    const off = () => { removeEventListener('pagehide', report); document.removeEventListener('visibilitychange', onVisibility); };
+    addEventListener('pagehide', report);
+    document.addEventListener('visibilitychange', onVisibility);
+    return () => { done = true; off(); for (const { po } of observers)
+        po.disconnect(); };
+}

package/package.json

@@ -1,6 +1,31 @@
 {
   "name": "@appright/funnelshift",
-  "version": "0.0.0-stage",
-  "stub": true,
-  "description": "Temporary package placeholder for staged publishing"
-}
+  "version": "0.16.0",
+  "type": "module",
+  "main": "dist/index.js",
+  "types": "dist/index.d.ts",
+  "exports": {
+    ".": { "types": "./dist/index.d.ts", "import": "./dist/index.js" },
+    "./functions": { "types": "./dist/functions.d.ts", "import": "./dist/functions.js" },
+    "./prerender": { "types": "./dist/prerender.d.ts", "import": "./dist/prerender.js" },
+    "./blocks.css": "./src/blocks/blocks.css",
+    "./package.json": "./package.json"
+  },
+  "bin": { "funnelshift": "bin/funnel-kit.js", "funnel-kit": "bin/funnel-kit.js" },
+  "files": ["dist", "bin", "src/blocks/blocks.css", "templates"],
+  "license": "UNLICENSED",
+  "repository": { "type": "git", "url": "git+https://github.com/appright-org/funnelshift.git", "directory": "kit" },
+  "publishConfig": { "access": "public" },
+  "scripts": {
+    "build": "tsc -p tsconfig.json",
+    "typecheck": "tsc -p tsconfig.json --noEmit",
+    "test": "vitest run",
+    "prepare": "tsc -p tsconfig.json"
+  },
+  "peerDependencies": { "react": "^19", "react-dom": "^19" },
+  "dependencies": { "@babel/parser": "^7", "@vitejs/plugin-react": "^6", "tar": "^7", "vite": "^8" },
+  "devDependencies": {
+    "@testing-library/dom": "^10", "@testing-library/react": "^16", "@types/node": "^22", "@types/react": "^19", "@types/react-dom": "^19",
+    "jsdom": "^30", "react": "^19", "react-dom": "^19", "typescript": "^7", "vitest": "^5"
+  }
+}