@funnelsgrove/runtime 0.1.0 → 0.1.2

package/dist/runtime/preview-bridge.js

@@ -1,11 +1,45 @@
 'use client';
 import { useEffect, useRef } from 'react';
-import { BUILDER_PREVIEW_ACTIVE_STEP_CHANGED, BUILDER_PREVIEW_GO_TO_STEP, BUILDER_PREVIEW_READY, BUILDER_PREVIEW_RUNTIME_MODE_CHANGED, } from '../config/builder-preview.protocol';
-import { isPreviewFrameRuntime } from '../services/preview-frame.service';
-import { logger } from '../services/logger';
+import { BUILDER_PREVIEW_ACTIVE_STEP_CHANGED, BUILDER_PREVIEW_DEFINITION_PATCH, BUILDER_PREVIEW_GO_TO_STEP, BUILDER_PREVIEW_PAYWALL_PLANS_CHANGED, BUILDER_PREVIEW_READY, BUILDER_PREVIEW_RUNTIME_MODE_CHANGED, BUILDER_PREVIEW_VARIABLE_VALUES_CHANGED, } from '../config/builder-preview.protocol.js';
+import { isPreviewFrameRuntime } from '../services/preview-frame.service.js';
+import { logger } from '../services/logger.js';
+import { applyPreviewDefinitionPatch, applyPreviewPaywallPlansPatch } from './preview-definition-overrides.js';
 const isRecord = (value) => {
     return Boolean(value) && typeof value === 'object' && !Array.isArray(value);
 };
+const parsePreviewDefinitionPatch = (value) => {
+    if (!isRecord(value)) {
+        return null;
+    }
+    const kind = typeof value.kind === 'string' ? value.kind : '';
+    const stepId = typeof value.stepId === 'string' ? value.stepId.trim() : '';
+    if (!kind || !stepId) {
+        return null;
+    }
+    if (kind === 'content') {
+        const locale = typeof value.locale === 'string' ? value.locale.trim() : '';
+        if (!locale || !isRecord(value.content)) {
+            return null;
+        }
+        return {
+            kind,
+            stepId,
+            locale,
+            content: value.content,
+        };
+    }
+    if (kind === 'pricing') {
+        if (!isRecord(value.pricing)) {
+            return null;
+        }
+        return {
+            kind,
+            stepId,
+            pricing: value.pricing,
+        };
+    }
+    return null;
+};
 const isPositiveIndex = (value) => {
     return typeof value === 'number' && Number.isInteger(value) && value >= 1;
 };
@@ -85,12 +119,36 @@ export const parsePreviewBridgeMessage = (value) => {
         const patch = parsePreviewQuickEditPatch(value.patch);
         return patch ? { kind: 'quickEditPatch', patch } : null;
     }
+    if (messageType === BUILDER_PREVIEW_DEFINITION_PATCH) {
+        const patch = parsePreviewDefinitionPatch(value.patch);
+        return patch ? { kind: 'definitionPatch', patch } : null;
+    }
     if (messageType === BUILDER_PREVIEW_RUNTIME_MODE_CHANGED) {
         return {
             kind: 'runtimeModeChanged',
             mode: value.mode === 'live' ? 'live' : 'test',
         };
     }
+    if (messageType === BUILDER_PREVIEW_PAYWALL_PLANS_CHANGED) {
+        const stepId = typeof value.stepId === 'string' ? value.stepId.trim() : '';
+        const plans = Array.isArray(value.plans)
+            ? value.plans.filter((plan) => isRecord(plan) &&
+                typeof plan.id === 'string' &&
+                typeof plan.title === 'string' &&
+                typeof plan.priceLabel === 'string' &&
+                typeof plan.perDayAmount === 'string' &&
+                typeof plan.perDayLabel === 'string' &&
+                typeof plan.amountCents === 'number' &&
+                (plan.source === 'stripe' || plan.source === 'config'))
+            : [];
+        return stepId
+            ? {
+                kind: 'paywallPlansChanged',
+                stepId,
+                plans,
+            }
+            : null;
+    }
     if (messageType === BUILDER_PREVIEW_GO_TO_STEP) {
         const stepId = typeof value.stepId === 'string' ? value.stepId.trim() : '';
         return stepId ? { kind: 'goToStep', stepId } : null;
@@ -181,6 +239,25 @@ function emitPreviewReady(stepId) {
         stepId,
     }, '*');
 }
+export function emitPreviewVariableValues(stepId, values) {
+    if (typeof window === 'undefined' || window.parent === window) {
+        return;
+    }
+    window.parent.postMessage({
+        type: BUILDER_PREVIEW_VARIABLE_VALUES_CHANGED,
+        stepId,
+        values,
+    }, '*');
+}
+export function usePreviewVariableValues(stepId, values) {
+    const serializedValues = JSON.stringify(values);
+    useEffect(() => {
+        if (!isPreviewFrameRuntime()) {
+            return;
+        }
+        emitPreviewVariableValues(stepId, values);
+    }, [serializedValues, stepId, values]);
+}
 export function usePreviewBridge({ activeStepId, onGoToStep, resolveRenderableStepId, setRuntimeMode, shouldLockToInitialStep, }) {
     const previewReadySentRef = useRef(false);
     useEffect(() => {
@@ -209,6 +286,14 @@ export function usePreviewBridge({ activeStepId, onGoToStep, resolveRenderableSt
                 applyPreviewQuickEditPatch(action.patch);
                 return;
             }
+            if (action.kind === 'definitionPatch') {
+                applyPreviewDefinitionPatch(action.patch);
+                return;
+            }
+            if (action.kind === 'paywallPlansChanged') {
+                applyPreviewPaywallPlansPatch(action.stepId, action.plans);
+                return;
+            }
             if (action.kind === 'runtimeModeChanged') {
                 setRuntimeMode(action.mode);
                 return;
@@ -226,5 +311,11 @@ export function usePreviewBridge({ activeStepId, onGoToStep, resolveRenderableSt
         return () => {
             window.removeEventListener('message', handlePreviewMessage);
         };
-    }, [activeStepId, onGoToStep, resolveRenderableStepId, setRuntimeMode, shouldLockToInitialStep]);
+    }, [
+        activeStepId,
+        onGoToStep,
+        resolveRenderableStepId,
+        setRuntimeMode,
+        shouldLockToInitialStep,
+    ]);
 }

package/dist/runtime/preview-definition-overrides.d.ts

@@ -0,0 +1,20 @@
+import { type CountryPricingProfile, type LocalizedStepContent, type ResolvedCountryPricing, type StepEditorSection } from '../content/step-content.js';
+import type { BuilderPreviewDefinitionPatch } from '../config/builder-preview.protocol.js';
+export declare const usePreviewDefinitionOverrideRevision: () => number;
+export declare const clearPreviewDefinitionPatches: () => void;
+export declare const applyPreviewDefinitionPatch: (patch: BuilderPreviewDefinitionPatch) => void;
+export declare const applyPreviewPaywallPlansPatch: (stepId: string, plans: readonly unknown[]) => void;
+export declare const resolvePreviewStepLocalizedContent: <TLocaleContent>(stepId: string, definition: LocalizedStepContent<TLocaleContent>, requestedLocale?: string | null, options?: {
+    editorSections?: readonly StepEditorSection[];
+    variableValues?: Record<string, string>;
+    universalVariables?: Record<string, string>;
+}) => TLocaleContent;
+export declare const resolvePreviewStepCountryPricing: <TOfferKey extends string>(stepId: string, pricingProfile: CountryPricingProfile<TOfferKey>, requestedCountryCode?: string | null) => ResolvedCountryPricing<TOfferKey>;
+export declare const usePreviewStepLocalizedContent: <TLocaleContent>(stepId: string, definition: LocalizedStepContent<TLocaleContent>, requestedLocale?: string | null, options?: {
+    editorSections?: readonly StepEditorSection[];
+    variableValues?: Record<string, string>;
+    universalVariables?: Record<string, string>;
+}) => TLocaleContent;
+export declare const usePreviewStepCountryPricing: <TOfferKey extends string>(stepId: string, pricingProfile: CountryPricingProfile<TOfferKey>, requestedCountryCode?: string | null) => ResolvedCountryPricing<TOfferKey>;
+export declare const resolvePreviewStepPaywallPlans: <TPlan>(stepId: string) => readonly TPlan[] | null;
+export declare const usePreviewStepPaywallPlans: <TPlan>(stepId: string) => readonly TPlan[] | null;

package/dist/runtime/preview-definition-overrides.js

@@ -0,0 +1,148 @@
+'use client';
+import { useMemo, useSyncExternalStore } from 'react';
+import { resolveStepContentVariables, resolveUniversalContentVariables, resolveCountryPricing, resolveLocalizedStepContent, } from '../content/step-content.js';
+import { useOptionalFunnel } from '../components/FunnelContext.js';
+import { apiService } from '../services/api.service.js';
+const PREVIEW_DEFINITION_OVERRIDE_STORE_KEY = '__funnelsgrovePreviewDefinitionOverrides';
+const getPreviewDefinitionOverrideStore = () => {
+    const globalState = globalThis;
+    const existingStore = globalState[PREVIEW_DEFINITION_OVERRIDE_STORE_KEY];
+    if (existingStore) {
+        return existingStore;
+    }
+    const nextStore = {
+        listeners: new Set(),
+        state: {
+            revision: 0,
+            contentByStepId: {},
+            pricingByStepId: {},
+            paywallPlansByStepId: {},
+        },
+    };
+    globalState[PREVIEW_DEFINITION_OVERRIDE_STORE_KEY] = nextStore;
+    return nextStore;
+};
+const normalizeStepId = (value) => {
+    return value.trim();
+};
+const normalizeLocale = (value) => {
+    return value.trim().toLowerCase();
+};
+const subscribePreviewDefinitionOverrides = (listener) => {
+    const store = getPreviewDefinitionOverrideStore();
+    store.listeners.add(listener);
+    return () => {
+        store.listeners.delete(listener);
+    };
+};
+const emitPreviewDefinitionOverrideChange = () => {
+    for (const listener of getPreviewDefinitionOverrideStore().listeners) {
+        listener();
+    }
+};
+const getPreviewDefinitionOverrideRevision = () => {
+    return getPreviewDefinitionOverrideStore().state.revision;
+};
+export const usePreviewDefinitionOverrideRevision = () => {
+    return useSyncExternalStore(subscribePreviewDefinitionOverrides, getPreviewDefinitionOverrideRevision, () => 0);
+};
+const buildMergedLocalizedContentDefinition = (stepId, definition) => {
+    const stepOverrides = getPreviewDefinitionOverrideStore().state.contentByStepId[normalizeStepId(stepId)];
+    if (!stepOverrides) {
+        return definition;
+    }
+    const mergedLocales = Object.assign({}, definition.locales);
+    for (const [locale, localeOverride] of Object.entries(stepOverrides)) {
+        const currentLocaleValue = definition.locales[locale];
+        if (currentLocaleValue && typeof currentLocaleValue === 'object' && localeOverride) {
+            mergedLocales[locale] = Object.assign(Object.assign({}, currentLocaleValue), localeOverride);
+            continue;
+        }
+        mergedLocales[locale] = localeOverride;
+    }
+    return Object.assign(Object.assign({}, definition), { locales: mergedLocales });
+};
+export const clearPreviewDefinitionPatches = () => {
+    const store = getPreviewDefinitionOverrideStore();
+    store.state = {
+        revision: store.state.revision + 1,
+        contentByStepId: {},
+        pricingByStepId: {},
+        paywallPlansByStepId: {},
+    };
+    emitPreviewDefinitionOverrideChange();
+};
+export const applyPreviewDefinitionPatch = (patch) => {
+    const store = getPreviewDefinitionOverrideStore();
+    const stepId = normalizeStepId(patch.stepId);
+    if (!stepId) {
+        return;
+    }
+    if (patch.kind === 'content') {
+        const locale = normalizeLocale(patch.locale);
+        if (!locale) {
+            return;
+        }
+        store.state = Object.assign(Object.assign({}, store.state), { revision: store.state.revision + 1, contentByStepId: Object.assign(Object.assign({}, store.state.contentByStepId), { [stepId]: Object.assign(Object.assign({}, (store.state.contentByStepId[stepId] || {})), { [locale]: patch.content }) }) });
+        emitPreviewDefinitionOverrideChange();
+        return;
+    }
+    store.state = Object.assign(Object.assign({}, store.state), { revision: store.state.revision + 1, pricingByStepId: Object.assign(Object.assign({}, store.state.pricingByStepId), { [stepId]: patch.pricing }) });
+    emitPreviewDefinitionOverrideChange();
+};
+export const applyPreviewPaywallPlansPatch = (stepId, plans) => {
+    const normalizedStepId = normalizeStepId(stepId);
+    if (!normalizedStepId) {
+        return;
+    }
+    const store = getPreviewDefinitionOverrideStore();
+    store.state = Object.assign(Object.assign({}, store.state), { revision: store.state.revision + 1, paywallPlansByStepId: Object.assign(Object.assign({}, store.state.paywallPlansByStepId), { [normalizedStepId]: [...plans] }) });
+    emitPreviewDefinitionOverrideChange();
+};
+export const resolvePreviewStepLocalizedContent = (stepId, definition, requestedLocale, options) => {
+    var _a;
+    const localizedContent = resolveLocalizedStepContent(buildMergedLocalizedContentDefinition(stepId, definition), requestedLocale);
+    if (!((_a = options === null || options === void 0 ? void 0 : options.editorSections) === null || _a === void 0 ? void 0 : _a.length) || !options.variableValues) {
+        if (!(options === null || options === void 0 ? void 0 : options.universalVariables)) {
+            return localizedContent;
+        }
+        return resolveUniversalContentVariables(localizedContent, options.universalVariables);
+    }
+    const contentWithEditorVariables = resolveStepContentVariables(localizedContent, options.editorSections, options.variableValues);
+    if (!options.universalVariables) {
+        return contentWithEditorVariables;
+    }
+    return resolveUniversalContentVariables(contentWithEditorVariables, options.universalVariables);
+};
+export const resolvePreviewStepCountryPricing = (stepId, pricingProfile, requestedCountryCode) => {
+    const pricingOverride = getPreviewDefinitionOverrideStore().state.pricingByStepId[normalizeStepId(stepId)];
+    return resolveCountryPricing(pricingOverride || pricingProfile, requestedCountryCode);
+};
+export const usePreviewStepLocalizedContent = (stepId, definition, requestedLocale, options) => {
+    const revision = usePreviewDefinitionOverrideRevision();
+    const funnel = useOptionalFunnel();
+    const currentUserId = (funnel === null || funnel === void 0 ? void 0 : funnel.user.id) || apiService.getOrCreateClientUserId();
+    return useMemo(() => {
+        var _a;
+        void revision;
+        return resolvePreviewStepLocalizedContent(stepId, definition, requestedLocale, Object.assign(Object.assign({}, options), { universalVariables: Object.assign(Object.assign({}, ((_a = options === null || options === void 0 ? void 0 : options.universalVariables) !== null && _a !== void 0 ? _a : {})), { user_id: currentUserId }) }));
+    }, [currentUserId, definition, options, requestedLocale, revision, stepId]);
+};
+export const usePreviewStepCountryPricing = (stepId, pricingProfile, requestedCountryCode) => {
+    const revision = usePreviewDefinitionOverrideRevision();
+    return useMemo(() => {
+        void revision;
+        return resolvePreviewStepCountryPricing(stepId, pricingProfile, requestedCountryCode);
+    }, [pricingProfile, requestedCountryCode, revision, stepId]);
+};
+export const resolvePreviewStepPaywallPlans = (stepId) => {
+    const plans = getPreviewDefinitionOverrideStore().state.paywallPlansByStepId[normalizeStepId(stepId)];
+    return Array.isArray(plans) ? plans : null;
+};
+export const usePreviewStepPaywallPlans = (stepId) => {
+    const revision = usePreviewDefinitionOverrideRevision();
+    return useMemo(() => {
+        void revision;
+        return resolvePreviewStepPaywallPlans(stepId);
+    }, [revision, stepId]);
+};

package/dist/runtime/route-resolver.d.ts

@@ -1,4 +1,4 @@
-import type { FunnelManifest, FunnelManifestExperiment } from '../config/funnel.manifest.types';
+import type { FunnelManifest, FunnelManifestExperiment } from '../config/funnel.manifest.types.js';
 export declare const getChoiceTargetsFromEdges: (manifest: FunnelManifest, stepId: string) => {
     yes?: string;
     no?: string;
@@ -8,11 +8,10 @@ export declare const getPathForStep: (manifest: FunnelManifest, stepId: string)
 export declare const resolveInitialStepId: (input: {
     manifest: FunnelManifest;
     requestedStepId?: string | null;
-    entryPointId?: string | null;
 }) => string;
 export declare const resolveNextStepId: (input: {
     manifest: FunnelManifest;
     currentStepId: string;
     attributes: Record<string, unknown>;
-    getAssignedVariantId: (experiment: FunnelManifestExperiment) => string | null;
+    resolveExperimentVariantKey: (experiment: FunnelManifestExperiment) => string | null;
 }) => string | null;

package/dist/runtime/route-resolver.js

@@ -4,21 +4,12 @@ const getStepById = (manifest, stepId) => {
     }
     return manifest.steps.find((step) => step.id === stepId) || null;
 };
-const getEntryPointStepId = (manifest, entryPointId) => {
+const getDefaultManifestStepId = (manifest) => {
     var _a;
-    if (!entryPointId) {
-        return null;
-    }
-    return ((_a = manifest.entryPoints.find((entryPoint) => entryPoint.id === entryPointId)) === null || _a === void 0 ? void 0 : _a.stepId) || null;
+    return ((_a = manifest.steps[0]) === null || _a === void 0 ? void 0 : _a.id) || '';
 };
-const getDefaultEntryPointStepId = (manifest) => {
-    var _a, _b;
-    return (((_a = manifest.entryPoints.find((entryPoint) => 'isDefault' in entryPoint && entryPoint.isDefault)) === null || _a === void 0 ? void 0 : _a.stepId) ||
-        ((_b = manifest.steps[0]) === null || _b === void 0 ? void 0 : _b.id) ||
-        '');
-};
-const getActiveExperimentForStep = (manifest, stepId) => {
-    return (manifest.experiments.find((experiment) => experiment.stepId === stepId && experiment.status === 'active') || null);
+const getExperimentForStep = (manifest, stepId) => {
+    return manifest.experiments.find((experiment) => experiment.stepId === stepId) || null;
 };
 const resolveNextStepFromEdges = (edges, attributes) => {
     var _a;
@@ -69,23 +60,21 @@ export const resolveInitialStepId = (input) => {
     if (requestedStep) {
         return requestedStep.id;
     }
-    const entryPointStepId = getEntryPointStepId(input.manifest, input.entryPointId);
-    const entryPointStep = getStepById(input.manifest, entryPointStepId);
-    if (entryPointStep) {
-        return entryPointStep.id;
-    }
-    return getDefaultEntryPointStepId(input.manifest);
+    return getDefaultManifestStepId(input.manifest);
 };
 export const resolveNextStepId = (input) => {
     var _a;
-    const activeExperiment = getActiveExperimentForStep(input.manifest, input.currentStepId);
-    if (activeExperiment) {
-        const assignedVariantId = input.getAssignedVariantId(activeExperiment);
-        const assignedVariant = activeExperiment.variants.find((variant) => variant.id === assignedVariantId);
-        if (assignedVariant) {
-            return assignedVariant.routeToStepId;
+    const experiment = getExperimentForStep(input.manifest, input.currentStepId);
+    if (experiment) {
+        const variantKey = input.resolveExperimentVariantKey(experiment);
+        const matchedVariant = variantKey
+            ? experiment.variants.find((variant) => variant.variantKey === variantKey)
+            : undefined;
+        if (matchedVariant) {
+            return matchedVariant.routeToStepId;
         }
-        return ((_a = activeExperiment.variants[0]) === null || _a === void 0 ? void 0 : _a.routeToStepId) || null;
+        const controlVariant = (_a = experiment.variants.find((variant) => variant.variantKey === 'control')) !== null && _a !== void 0 ? _a : experiment.variants[0];
+        return (controlVariant === null || controlVariant === void 0 ? void 0 : controlVariant.routeToStepId) || null;
     }
     return resolveNextStepFromEdges(input.manifest.edgesByStepId[input.currentStepId], input.attributes);
 };

package/dist/runtime/subscription-handoff.d.ts

@@ -0,0 +1,32 @@
+import type { FunnelUserAttribution } from './funnel-attribution.js';
+export type SubscriptionHandoffPlatform = 'ios' | 'android' | 'desktop';
+export type SubscriptionHandoffConfig = {
+    iosAppStoreUrl: string | null;
+    androidPlayStoreUrl: string | null;
+    universalLink: string | null;
+    iosDeepLink: string | null;
+    androidDeepLink: string | null;
+};
+export type ResolvedSubscriptionHandoff = {
+    platform: SubscriptionHandoffPlatform;
+    iosStoreUrl: string | null;
+    androidStoreUrl: string | null;
+    iosDeepLinkUrl: string | null;
+    androidDeepLinkUrl: string | null;
+    openAppUrl: string | null;
+    webLinkUrl: string | null;
+    emailOpenAppUrl: string | null;
+    emailIosDeepLinkUrl: string | null;
+    emailAndroidDeepLinkUrl: string | null;
+    emailIosStoreUrl: string | null;
+    emailAndroidStoreUrl: string | null;
+    qrConfirmationUrl: string | null;
+};
+export declare const resolveSubscriptionHandoff: (input: {
+    userId: string | null | undefined;
+    email?: string | null;
+    confirmationUrl: string | null | undefined;
+    userAgent?: string | null;
+    attribution?: FunnelUserAttribution | null;
+    config: SubscriptionHandoffConfig;
+}) => ResolvedSubscriptionHandoff;

package/dist/runtime/subscription-handoff.js

@@ -0,0 +1,113 @@
+const asTrimmedString = (value) => {
+    if (typeof value !== 'string') {
+        return null;
+    }
+    const trimmed = value.trim();
+    return trimmed || null;
+};
+const resolvePlatform = (userAgent) => {
+    var _a;
+    const normalized = ((_a = asTrimmedString(userAgent)) === null || _a === void 0 ? void 0 : _a.toLowerCase()) || '';
+    if (/iphone|ipad|ipod/.test(normalized)) {
+        return 'ios';
+    }
+    if (/android/.test(normalized)) {
+        return 'android';
+    }
+    return 'desktop';
+};
+const applyLinkTemplates = (value, variables) => {
+    return value
+        .replace(/\{user_id\}/g, encodeURIComponent(variables.userId))
+        .replace(/\{email\}/g, variables.email ? encodeURIComponent(variables.email) : '');
+};
+const resolveUrl = (value, variables, firstTouch) => {
+    const normalized = asTrimmedString(value);
+    if (!normalized) {
+        return null;
+    }
+    try {
+        const url = new URL(applyLinkTemplates(normalized, variables));
+        if (!url.searchParams.has('user_id')) {
+            url.searchParams.set('user_id', variables.userId);
+        }
+        for (const [key, rawValue] of Object.entries(firstTouch)) {
+            const nextKey = key.trim();
+            const nextValue = rawValue.trim();
+            if (!nextKey || !nextValue || url.searchParams.has(nextKey)) {
+                continue;
+            }
+            url.searchParams.set(nextKey, nextValue);
+        }
+        return url.toString();
+    }
+    catch (_a) {
+        return applyLinkTemplates(normalized, variables);
+    }
+};
+const buildQrConfirmationUrl = (confirmationUrl, userId) => {
+    const normalized = asTrimmedString(confirmationUrl);
+    if (!normalized) {
+        return null;
+    }
+    try {
+        const url = new URL(normalized);
+        url.search = '';
+        url.hash = '';
+        url.searchParams.set('user_id', userId);
+        return url.toString();
+    }
+    catch (_a) {
+        return null;
+    }
+};
+export const resolveSubscriptionHandoff = (input) => {
+    var _a, _b;
+    const userId = asTrimmedString(input.userId);
+    const email = asTrimmedString(input.email);
+    const platform = resolvePlatform(input.userAgent);
+    const firstTouch = (_b = (_a = input.attribution) === null || _a === void 0 ? void 0 : _a.firstTouch) !== null && _b !== void 0 ? _b : {};
+    if (!userId) {
+        return {
+            platform,
+            iosStoreUrl: null,
+            androidStoreUrl: null,
+            iosDeepLinkUrl: null,
+            androidDeepLinkUrl: null,
+            openAppUrl: null,
+            webLinkUrl: null,
+            emailOpenAppUrl: null,
+            emailIosDeepLinkUrl: null,
+            emailAndroidDeepLinkUrl: null,
+            emailIosStoreUrl: null,
+            emailAndroidStoreUrl: null,
+            qrConfirmationUrl: null,
+        };
+    }
+    const variables = { userId, email };
+    const iosStoreUrl = resolveUrl(input.config.iosAppStoreUrl, variables, firstTouch);
+    const androidStoreUrl = resolveUrl(input.config.androidPlayStoreUrl, variables, firstTouch);
+    const iosDeepLink = resolveUrl(input.config.iosDeepLink, variables, firstTouch);
+    const androidDeepLink = resolveUrl(input.config.androidDeepLink, variables, firstTouch);
+    const universalLink = resolveUrl(input.config.universalLink, variables, firstTouch);
+    const openAppUrl = platform === 'ios'
+        ? iosDeepLink || universalLink || iosStoreUrl
+        : platform === 'android'
+            ? androidDeepLink || universalLink || androidStoreUrl
+            : null;
+    return {
+        platform,
+        iosStoreUrl,
+        androidStoreUrl,
+        iosDeepLinkUrl: iosDeepLink,
+        androidDeepLinkUrl: androidDeepLink,
+        openAppUrl,
+        webLinkUrl: universalLink,
+        emailOpenAppUrl: universalLink || iosDeepLink || androidDeepLink,
+        emailIosDeepLinkUrl: iosDeepLink,
+        emailAndroidDeepLinkUrl: androidDeepLink,
+        emailIosStoreUrl: iosStoreUrl,
+        emailAndroidStoreUrl: androidStoreUrl,
+        qrConfirmationUrl: buildQrConfirmationUrl(input.confirmationUrl, userId),
+    };
+};

package/dist/runtime/use-funnel-flow-controller.d.ts

@@ -1,20 +1,21 @@
-import { type Dispatch, type SetStateAction, type ComponentType } from 'react';
-import type { FunnelContextValue } from '../components/FunnelContext';
-import type { FunnelManifestExperiment } from '../config/funnel.manifest.types';
-import type { FunnelStepMeta } from '../steps/types';
+import { type Dispatch, type SetStateAction } from 'react';
+import type { FunnelContextValue } from '../components/FunnelContext.js';
+import type { FunnelManifestExperiment } from '../config/funnel.manifest.types.js';
+import type { FunnelStepMeta } from '../steps/types.js';
 export type FunnelFlowControllerExperiment<StepId extends string> = FunnelManifestExperiment & {
     stepId: StepId;
     variants: readonly (FunnelManifestExperiment['variants'][number] & {
         routeToStepId: StepId;
     })[];
 };
+type StepComponentRegistry = Record<string, unknown>;
 type UseFunnelFlowControllerInput<StepId extends string> = {
     initialStepId?: StepId;
     lockToInitialStep?: boolean;
     defaultStepId: StepId;
     stepSequence: readonly StepId[];
     stepById: Record<string, FunnelStepMeta>;
-    stepComponentById: Record<string, ComponentType>;
+    stepComponentById: StepComponentRegistry;
     funnelExperiments: readonly FunnelFlowControllerExperiment<StepId>[];
     getPathForStep: (stepId: StepId) => string;
     getStepIdFromPath: (pathname: string) => StepId | null;
@@ -26,16 +27,14 @@ type UseFunnelFlowControllerInput<StepId extends string> = {
     isFunnelStepId: (value: string) => value is StepId;
     resolveConfiguredNextStep: (stepId: StepId, context: {
         attributes: Record<string, unknown>;
-        userId: string;
-        getAssignedVariantId: (experiment: FunnelManifestExperiment) => string | null;
+        resolveExperimentVariantKey: (experiment: FunnelManifestExperiment) => string | null;
     }) => StepId | null;
     resolveRuntimeInitialStepId: (input: {
         requestedStepId?: string | null;
-        entryPointId?: string | null;
     }) => StepId;
 };
 type UseFunnelFlowControllerResult<StepId extends string> = {
-    activeStepComponent: ComponentType | undefined;
+    activeStepComponent: unknown;
     activeStepId: StepId;
     activeStepMeta: FunnelStepMeta | undefined;
     buttonText: string;
@@ -46,13 +45,23 @@ type UseFunnelFlowControllerResult<StepId extends string> = {
     experimentAssignmentForEditor: (experiment: FunnelFlowControllerExperiment<StepId>) => string;
     funnelExperiments: readonly FunnelFlowControllerExperiment<StepId>[];
     handleContinue: () => void;
+    postHogReady: boolean;
+    renderSuspended: boolean;
     renderedStepId: StepId;
     renderedStepMeta: FunnelStepMeta | undefined;
     runtimeMode: 'test' | 'live';
     setEditorPanelExpanded: Dispatch<SetStateAction<boolean>>;
-    setEditorVariantSelection: (experiment: FunnelFlowControllerExperiment<StepId>, variantId: string) => void;
+    setEditorVariantSelection: (experiment: FunnelFlowControllerExperiment<StepId>, variantKey: string) => void;
     setRuntimeMode: (mode: 'test' | 'live') => void;
     showShellContinue: boolean;
 };
+export declare function computeRenderSuspended(input: {
+    activeStepId: string;
+    postHogReady: boolean;
+    experiments: ReadonlyArray<{
+        stepId: string;
+    }>;
+    isPreviewRuntime?: boolean;
+}): boolean;
 export declare function useFunnelFlowController<StepId extends string>({ initialStepId, lockToInitialStep, defaultStepId, stepSequence, stepById, stepComponentById, funnelExperiments, getPathForStep, getStepIdFromPath, getSequentialNextStepId, getChoiceTargetsForStep, isFunnelStepId, resolveConfiguredNextStep, resolveRuntimeInitialStepId, }: UseFunnelFlowControllerInput<StepId>): UseFunnelFlowControllerResult<StepId>;
 export {};