@funnelsgrove/runtime 0.1.0

package/dist/runtime/funnel-flow.js

@@ -0,0 +1,66 @@
+import { canUseDom } from './browser-helpers';
+import { chooseAssignedVariantId, getExperimentAssignmentStorageKey, } from './experiment-assignment';
+export const isPreviewStepLockRequested = () => {
+    if (!canUseDom()) {
+        return false;
+    }
+    try {
+        return new URLSearchParams(window.location.search).get('previewStepLock') === '1';
+    }
+    catch (_a) {
+        return false;
+    }
+};
+export const getRequestedEntryPointId = () => {
+    var _a, _b;
+    if (!canUseDom()) {
+        return null;
+    }
+    try {
+        const searchParams = new URLSearchParams(window.location.search);
+        return ((_a = searchParams.get('entryPoint')) === null || _a === void 0 ? void 0 : _a.trim()) || ((_b = searchParams.get('entry')) === null || _b === void 0 ? void 0 : _b.trim()) || null;
+    }
+    catch (_c) {
+        return null;
+    }
+};
+export const getRuntimeFunnelIdentity = () => {
+    var _a;
+    if (!canUseDom()) {
+        return 'default';
+    }
+    try {
+        const searchParams = new URLSearchParams(window.location.search);
+        return ((_a = searchParams.get('funnelId')) === null || _a === void 0 ? void 0 : _a.trim()) || 'default';
+    }
+    catch (_b) {
+        return 'default';
+    }
+};
+export const getAssignedVariantId = (experiment, userId, storage) => {
+    if (!userId.trim()) {
+        return null;
+    }
+    const storageKey = getExperimentAssignmentStorageKey(getRuntimeFunnelIdentity(), userId, experiment.experimentId);
+    const storedVariantId = storage.read(storageKey);
+    const selectedVariantId = chooseAssignedVariantId(experiment, userId, storedVariantId);
+    if (!selectedVariantId) {
+        return null;
+    }
+    if (storedVariantId !== selectedVariantId) {
+        storage.write(storageKey, selectedVariantId);
+    }
+    return selectedVariantId;
+};
+export const resolveNextStepFromContext = (input) => {
+    var _a, _b;
+    const configuredStepId = input.getConfiguredNextStepId(input.stepId, {
+        attributes: input.attributes,
+        userId: input.userId,
+        getAssignedVariantId: (experiment) => input.getAssignedVariantId(experiment, input.userId),
+    });
+    if (configuredStepId) {
+        return (_a = input.resolveRenderableStepId(configuredStepId)) !== null && _a !== void 0 ? _a : input.safeInitialStepId;
+    }
+    return (_b = input.resolveRenderableStepId(input.getSequentialNextStepId(input.stepId))) !== null && _b !== void 0 ? _b : input.safeInitialStepId;
+};

package/dist/runtime/funnel-manifest.validation.d.ts

@@ -0,0 +1,2 @@
+import type { FunnelManifest } from '../config/funnel.manifest.types';
+export declare const validateFunnelManifest: <T extends FunnelManifest>(manifest: T) => T;

package/dist/runtime/funnel-manifest.validation.js

@@ -0,0 +1,63 @@
+const isDefinedString = (value) => {
+    return typeof value === 'string' && value.trim().length > 0;
+};
+const pushDuplicateErrors = (label, values, errors) => {
+    const seen = new Set();
+    const duplicates = new Set();
+    for (const value of values) {
+        if (seen.has(value)) {
+            duplicates.add(value);
+            continue;
+        }
+        seen.add(value);
+    }
+    if (duplicates.size > 0) {
+        errors.push(`duplicate ${label}: ${Array.from(duplicates).join(', ')}`);
+    }
+};
+const assertValidReference = (label, value, validIds, errors) => {
+    if (!isDefinedString(value) || !validIds.has(value)) {
+        errors.push(`${label} references missing step "${value || ''}"`);
+    }
+};
+export const validateFunnelManifest = (manifest) => {
+    const errors = [];
+    if (!Number.isInteger(manifest.templateArchitectureVersion) || manifest.templateArchitectureVersion < 1) {
+        errors.push('templateArchitectureVersion must be a positive integer');
+    }
+    if (manifest.steps.length === 0) {
+        errors.push('manifest must declare at least one step');
+    }
+    const stepIds = manifest.steps.map((step) => step.id);
+    const stepPaths = manifest.steps.map((step) => step.path);
+    const filePaths = manifest.steps.map((step) => step.filePath);
+    const componentKeys = manifest.steps.map((step) => step.componentKey);
+    const validStepIds = new Set(stepIds);
+    pushDuplicateErrors('step ids', stepIds, errors);
+    pushDuplicateErrors('step paths', stepPaths, errors);
+    pushDuplicateErrors('step file paths', filePaths, errors);
+    pushDuplicateErrors('step component keys', componentKeys, errors);
+    const defaultEntryPoints = manifest.entryPoints.filter((entryPoint) => entryPoint.isDefault === true);
+    if (defaultEntryPoints.length !== 1) {
+        errors.push(`manifest must declare exactly one default entry point, found ${defaultEntryPoints.length}`);
+    }
+    for (const entryPoint of manifest.entryPoints) {
+        assertValidReference(`entry point "${entryPoint.id}"`, entryPoint.stepId, validStepIds, errors);
+    }
+    for (const [stepId, edges] of Object.entries(manifest.edgesByStepId)) {
+        assertValidReference(`edge source "${stepId}"`, stepId, validStepIds, errors);
+        for (const edge of edges || []) {
+            assertValidReference(`edge from "${stepId}"`, edge.toStepId, validStepIds, errors);
+        }
+    }
+    for (const experiment of manifest.experiments) {
+        assertValidReference(`experiment "${experiment.experimentId}"`, experiment.stepId, validStepIds, errors);
+        for (const variant of experiment.variants) {
+            assertValidReference(`experiment variant "${experiment.experimentId}:${variant.id}"`, variant.routeToStepId, validStepIds, errors);
+        }
+    }
+    if (errors.length > 0) {
+        throw new Error(`Invalid funnel manifest:\n- ${errors.join('\n- ')}`);
+    }
+    return manifest;
+};

package/dist/runtime/funnel-runtime.d.ts

@@ -0,0 +1,34 @@
+import type { FunnelManifest, FunnelManifestExperiment } from '../config/funnel.manifest.types';
+export type FunnelStepId = string;
+export declare const getFunnelStepSequence: (manifest: FunnelManifest) => FunnelStepId[];
+export declare const getFunnelEntryPoints: (manifest: FunnelManifest) => {
+    stepId: FunnelStepId;
+    id: string;
+    isDefault?: boolean;
+}[];
+export type FunnelExperimentConfig = FunnelManifestExperiment & {
+    stepId: FunnelStepId;
+    variants: Array<FunnelManifestExperiment['variants'][number] & {
+        routeToStepId: FunnelStepId;
+    }>;
+};
+export declare const getFunnelExperiments: (manifest: FunnelManifest) => FunnelExperimentConfig[];
+export declare const getDefaultFunnelStepId: (manifest: FunnelManifest) => FunnelStepId;
+export declare const getIsFunnelStepId: (manifest: FunnelManifest, value: string) => value is FunnelStepId;
+export declare const getStepIdFromPath: (manifest: FunnelManifest, pathname: string) => FunnelStepId | null;
+export declare const getDefaultEntryPointStepId: (manifest: FunnelManifest) => FunnelStepId;
+export declare const getEntryPointStepId: (manifest: FunnelManifest, entryPointId: string | null | undefined) => FunnelStepId | null;
+export declare const getSequentialNextStepId: (manifest: FunnelManifest, stepId: FunnelStepId) => FunnelStepId | null;
+export declare const getChoiceTargetsForStep: (manifest: FunnelManifest, stepId: FunnelStepId) => {
+    yes?: FunnelStepId;
+    no?: FunnelStepId;
+} | null;
+export declare const resolveRuntimeInitialStepId: (input: {
+    manifest: FunnelManifest;
+    requestedStepId?: string | null;
+    entryPointId?: string | null;
+}) => FunnelStepId;
+export declare const resolveConfiguredNextStep: (manifest: FunnelManifest, stepId: FunnelStepId, context: {
+    attributes: Record<string, unknown>;
+    getAssignedVariantId: (experiment: FunnelManifestExperiment) => string | null;
+}) => FunnelStepId | null;

package/dist/runtime/funnel-runtime.js

@@ -0,0 +1,75 @@
+import { getChoiceTargetsFromEdges, isManifestStepId, resolveInitialStepId, resolveNextStepId, } from './route-resolver';
+export const getFunnelStepSequence = (manifest) => manifest.steps.map((step) => step.id);
+export const getFunnelEntryPoints = (manifest) => manifest.entryPoints.map((entryPoint) => (Object.assign(Object.assign({}, entryPoint), { stepId: entryPoint.stepId })));
+export const getFunnelExperiments = (manifest) => manifest.experiments.map((experiment) => (Object.assign(Object.assign({}, experiment), { stepId: experiment.stepId, variants: experiment.variants.map((variant) => (Object.assign(Object.assign({}, variant), { routeToStepId: variant.routeToStepId }))) })));
+export const getDefaultFunnelStepId = (manifest) => {
+    var _a;
+    return ((_a = manifest.entryPoints.find((entryPoint) => {
+        return 'isDefault' in entryPoint && entryPoint.isDefault;
+    })) === null || _a === void 0 ? void 0 : _a.stepId) ||
+        getFunnelStepSequence(manifest)[0];
+};
+export const getIsFunnelStepId = (manifest, value) => {
+    return new Set(getFunnelStepSequence(manifest)).has(value);
+};
+export const getStepIdFromPath = (manifest, pathname) => {
+    const segment = pathname
+        .split('?')[0]
+        .split('#')[0]
+        .split('/')
+        .map((part) => part.trim())
+        .filter(Boolean)[0];
+    if (!segment || !getIsFunnelStepId(manifest, segment)) {
+        return null;
+    }
+    return segment;
+};
+export const getDefaultEntryPointStepId = (manifest) => {
+    return getDefaultFunnelStepId(manifest);
+};
+export const getEntryPointStepId = (manifest, entryPointId) => {
+    var _a;
+    if (!entryPointId) {
+        return null;
+    }
+    const stepId = (_a = manifest.entryPoints.find((entryPoint) => entryPoint.id === entryPointId)) === null || _a === void 0 ? void 0 : _a.stepId;
+    return stepId && getIsFunnelStepId(manifest, stepId) ? stepId : null;
+};
+export const getSequentialNextStepId = (manifest, stepId) => {
+    var _a;
+    const stepSequence = getFunnelStepSequence(manifest);
+    const stepIndex = stepSequence.indexOf(stepId);
+    if (stepIndex < 0) {
+        return null;
+    }
+    return (_a = stepSequence[stepIndex + 1]) !== null && _a !== void 0 ? _a : null;
+};
+export const getChoiceTargetsForStep = (manifest, stepId) => {
+    const choiceTargets = getChoiceTargetsFromEdges(manifest, stepId);
+    if (!choiceTargets) {
+        return null;
+    }
+    return {
+        yes: choiceTargets.yes && getIsFunnelStepId(manifest, choiceTargets.yes) ? choiceTargets.yes : undefined,
+        no: choiceTargets.no && getIsFunnelStepId(manifest, choiceTargets.no) ? choiceTargets.no : undefined,
+    };
+};
+export const resolveRuntimeInitialStepId = (input) => {
+    const stepId = resolveInitialStepId({
+        manifest: input.manifest,
+        requestedStepId: input.requestedStepId,
+        entryPointId: input.entryPointId,
+    });
+    return getIsFunnelStepId(input.manifest, stepId) ? stepId : getDefaultFunnelStepId(input.manifest);
+};
+export const resolveConfiguredNextStep = (manifest, stepId, context) => {
+    const nextStepId = resolveNextStepId({
+        manifest,
+        currentStepId: stepId,
+        attributes: context.attributes,
+        getAssignedVariantId: context.getAssignedVariantId,
+    });
+    return nextStepId && isManifestStepId(manifest, nextStepId) && getIsFunnelStepId(manifest, nextStepId)
+        ? nextStepId
+        : null;
+};

package/dist/runtime/preview-bridge.d.ts

@@ -0,0 +1,51 @@
+import type { RuntimeMode } from '../services/runtime-mode.service';
+import type { FunnelStepId } from './funnel-runtime';
+export type PreviewQuickEditPatch = {
+    kind: 'tagText';
+    stepId: string;
+    tag: string;
+    index: number;
+    value: string;
+} | {
+    kind: 'attribute';
+    stepId: string;
+    attribute: 'placeholder' | 'alt' | 'title' | 'aria-label';
+    index: number;
+    value: string;
+} | {
+    kind: 'imageSrc';
+    stepId: string;
+    index: number;
+    value: string;
+} | {
+    kind: 'cssUrl';
+    stepId: string;
+    index: number;
+    value: string;
+} | {
+    kind: 'cssText';
+    stepId: string;
+    value: string;
+};
+type PreviewBridgeMessage = {
+    kind: 'quickEditPatch';
+    patch: PreviewQuickEditPatch;
+} | {
+    kind: 'runtimeModeChanged';
+    mode: RuntimeMode;
+} | {
+    kind: 'goToStep';
+    stepId: string;
+};
+export declare const parsePreviewQuickEditPatch: (value: unknown) => PreviewQuickEditPatch | null;
+export declare const parsePreviewBridgeMessage: (value: unknown) => PreviewBridgeMessage | null;
+export declare const applyPreviewQuickEditPatch: (patch: PreviewQuickEditPatch) => void;
+export type PreviewBridgeOptions = {
+    activeStepId: FunnelStepId;
+    onGoToStep: (stepId: FunnelStepId) => void;
+    resolveRenderableStepId: (stepId: string) => FunnelStepId | null;
+    setRuntimeMode: (mode: RuntimeMode) => void;
+    shouldLockToInitialStep: boolean;
+};
+export declare function usePreviewBridge({ activeStepId, onGoToStep, resolveRenderableStepId, setRuntimeMode, shouldLockToInitialStep, }: PreviewBridgeOptions): void;
+export {};

package/dist/runtime/preview-bridge.js

@@ -0,0 +1,230 @@
+'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';
+const isRecord = (value) => {
+    return Boolean(value) && typeof value === 'object' && !Array.isArray(value);
+};
+const isPositiveIndex = (value) => {
+    return typeof value === 'number' && Number.isInteger(value) && value >= 1;
+};
+export const parsePreviewQuickEditPatch = (value) => {
+    if (!isRecord(value)) {
+        return null;
+    }
+    const kind = typeof value.kind === 'string' ? value.kind : '';
+    const stepId = typeof value.stepId === 'string' ? value.stepId.trim() : '';
+    const patchValue = typeof value.value === 'string' ? value.value : null;
+    if (!kind || !stepId || patchValue === null) {
+        return null;
+    }
+    if (kind === 'tagText') {
+        const tag = typeof value.tag === 'string' ? value.tag.trim().toLowerCase() : '';
+        const index = value.index;
+        if (!tag || !isPositiveIndex(index)) {
+            return null;
+        }
+        return {
+            kind,
+            stepId,
+            tag,
+            index,
+            value: patchValue,
+        };
+    }
+    if (kind === 'attribute') {
+        const attribute = value.attribute === 'placeholder' ||
+            value.attribute === 'alt' ||
+            value.attribute === 'title' ||
+            value.attribute === 'aria-label'
+            ? value.attribute
+            : null;
+        const index = value.index;
+        if (!attribute || !isPositiveIndex(index)) {
+            return null;
+        }
+        return {
+            kind,
+            stepId,
+            attribute,
+            index,
+            value: patchValue,
+        };
+    }
+    if (kind === 'imageSrc' || kind === 'cssUrl') {
+        const index = value.index;
+        if (!isPositiveIndex(index)) {
+            return null;
+        }
+        return {
+            kind,
+            stepId,
+            index,
+            value: patchValue,
+        };
+    }
+    if (kind === 'cssText') {
+        return {
+            kind,
+            stepId,
+            value: patchValue,
+        };
+    }
+    return null;
+};
+export const parsePreviewBridgeMessage = (value) => {
+    if (!isRecord(value)) {
+        return null;
+    }
+    const messageType = typeof value.type === 'string' ? value.type : '';
+    if (!messageType) {
+        return null;
+    }
+    if (messageType === 'builder.preview.quickEdit.patch') {
+        const patch = parsePreviewQuickEditPatch(value.patch);
+        return patch ? { kind: 'quickEditPatch', patch } : null;
+    }
+    if (messageType === BUILDER_PREVIEW_RUNTIME_MODE_CHANGED) {
+        return {
+            kind: 'runtimeModeChanged',
+            mode: value.mode === 'live' ? 'live' : 'test',
+        };
+    }
+    if (messageType === BUILDER_PREVIEW_GO_TO_STEP) {
+        const stepId = typeof value.stepId === 'string' ? value.stepId.trim() : '';
+        return stepId ? { kind: 'goToStep', stepId } : null;
+    }
+    return null;
+};
+export const applyPreviewQuickEditPatch = (patch) => {
+    if (typeof document === 'undefined') {
+        return;
+    }
+    const stageRoot = document.querySelector('.step-stage-transition');
+    if (!(stageRoot instanceof HTMLElement)) {
+        return;
+    }
+    if (patch.kind === 'tagText') {
+        const candidates = stageRoot.querySelectorAll(patch.tag);
+        const target = candidates.item(patch.index - 1);
+        if (target) {
+            target.textContent = patch.value;
+        }
+        return;
+    }
+    if (patch.kind === 'attribute') {
+        const candidates = stageRoot.querySelectorAll(`[${patch.attribute}]`);
+        const target = candidates.item(patch.index - 1);
+        if (target) {
+            target.setAttribute(patch.attribute, patch.value);
+        }
+        return;
+    }
+    if (patch.kind === 'imageSrc') {
+        const imageLikePathRegex = /\.(png|jpe?g|gif|webp|svg)(?:$|[?#])/i;
+        const candidates = Array.from(stageRoot.querySelectorAll('[src]')).filter((element) => {
+            const srcValue = element.getAttribute('src') || '';
+            return imageLikePathRegex.test(srcValue);
+        });
+        const target = candidates[patch.index - 1];
+        if (target) {
+            target.setAttribute('src', patch.value);
+        }
+        return;
+    }
+    if (patch.kind === 'cssUrl') {
+        const imageLikePathRegex = /(url\(\s*["']?)(\/[^"')]+\.(?:png|jpe?g|gif|webp|svg)(?:[?#][^"')]*)?)(["']?\s*\))/gi;
+        let globalMatchIndex = 0;
+        const styleElements = Array.from(stageRoot.querySelectorAll('style'));
+        for (const styleElement of styleElements) {
+            const source = styleElement.textContent || '';
+            let didReplace = false;
+            const nextContent = source.replace(imageLikePathRegex, (full, start, _pathPart, end) => {
+                globalMatchIndex += 1;
+                if (globalMatchIndex !== patch.index) {
+                    return full;
+                }
+                didReplace = true;
+                return `${start}${patch.value}${end}`;
+            });
+            if (didReplace && nextContent !== source) {
+                styleElement.textContent = nextContent;
+                return;
+            }
+        }
+        return;
+    }
+    if (patch.kind === 'cssText') {
+        const styleElements = stageRoot.querySelectorAll('style');
+        const target = styleElements.item(styleElements.length - 1);
+        if (target) {
+            target.textContent = patch.value;
+        }
+    }
+};
+function emitPreviewActiveStepChanged(stepId) {
+    if (typeof window === 'undefined' || window.parent === window) {
+        return;
+    }
+    window.parent.postMessage({
+        type: BUILDER_PREVIEW_ACTIVE_STEP_CHANGED,
+        stepId,
+    }, '*');
+}
+function emitPreviewReady(stepId) {
+    if (typeof window === 'undefined' || window.parent === window) {
+        return;
+    }
+    window.parent.postMessage({
+        type: BUILDER_PREVIEW_READY,
+        stepId,
+    }, '*');
+}
+export function usePreviewBridge({ activeStepId, onGoToStep, resolveRenderableStepId, setRuntimeMode, shouldLockToInitialStep, }) {
+    const previewReadySentRef = useRef(false);
+    useEffect(() => {
+        emitPreviewActiveStepChanged(activeStepId);
+    }, [activeStepId]);
+    useEffect(() => {
+        if (!isPreviewFrameRuntime() || previewReadySentRef.current) {
+            return;
+        }
+        previewReadySentRef.current = true;
+        emitPreviewReady(activeStepId);
+    }, [activeStepId]);
+    useEffect(() => {
+        if (shouldLockToInitialStep) {
+            return;
+        }
+        const handlePreviewMessage = (event) => {
+            const action = parsePreviewBridgeMessage(event.data);
+            if (!action) {
+                return;
+            }
+            if (action.kind === 'quickEditPatch') {
+                if (action.patch.stepId !== activeStepId) {
+                    return;
+                }
+                applyPreviewQuickEditPatch(action.patch);
+                return;
+            }
+            if (action.kind === 'runtimeModeChanged') {
+                setRuntimeMode(action.mode);
+                return;
+            }
+            const targetStepId = resolveRenderableStepId(action.stepId);
+            if (!targetStepId) {
+                logger.warn({
+                    stepId: action.stepId,
+                }, '[preview-bridge] Ignoring preview navigation to non-renderable step');
+                return;
+            }
+            onGoToStep(targetStepId);
+        };
+        window.addEventListener('message', handlePreviewMessage);
+        return () => {
+            window.removeEventListener('message', handlePreviewMessage);
+        };
+    }, [activeStepId, onGoToStep, resolveRenderableStepId, setRuntimeMode, shouldLockToInitialStep]);
+}

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

@@ -0,0 +1,18 @@
+import type { FunnelManifest, FunnelManifestExperiment } from '../config/funnel.manifest.types';
+export declare const getChoiceTargetsFromEdges: (manifest: FunnelManifest, stepId: string) => {
+    yes?: string;
+    no?: string;
+} | null;
+export declare const isManifestStepId: (manifest: FunnelManifest, stepId: string | null | undefined) => boolean;
+export declare const getPathForStep: (manifest: FunnelManifest, stepId: string) => 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;
+}) => string | null;

package/dist/runtime/route-resolver.js

@@ -0,0 +1,91 @@
+const getStepById = (manifest, stepId) => {
+    if (!stepId) {
+        return null;
+    }
+    return manifest.steps.find((step) => step.id === stepId) || null;
+};
+const getEntryPointStepId = (manifest, entryPointId) => {
+    var _a;
+    if (!entryPointId) {
+        return null;
+    }
+    return ((_a = manifest.entryPoints.find((entryPoint) => entryPoint.id === entryPointId)) === null || _a === void 0 ? void 0 : _a.stepId) || null;
+};
+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 resolveNextStepFromEdges = (edges, attributes) => {
+    var _a;
+    if (!edges || edges.length === 0) {
+        return null;
+    }
+    for (const edge of edges) {
+        if (!edge.conditionId) {
+            continue;
+        }
+        if (attributes[edge.conditionId] === true) {
+            return edge.toStepId;
+        }
+    }
+    return ((_a = edges.find((edge) => !edge.conditionId)) === null || _a === void 0 ? void 0 : _a.toStepId) || null;
+};
+export const getChoiceTargetsFromEdges = (manifest, stepId) => {
+    var _a;
+    const edges = manifest.edgesByStepId[stepId];
+    if (!edges || edges.length === 0) {
+        return null;
+    }
+    const targets = {};
+    for (const edge of edges) {
+        const conditionId = ((_a = edge.conditionId) === null || _a === void 0 ? void 0 : _a.trim()) || '';
+        const conditionMatch = conditionId.match(/:(yes|no)$/);
+        if (!(conditionMatch === null || conditionMatch === void 0 ? void 0 : conditionMatch[1])) {
+            continue;
+        }
+        if (conditionMatch[1] === 'yes') {
+            targets.yes = edge.toStepId;
+        }
+        if (conditionMatch[1] === 'no') {
+            targets.no = edge.toStepId;
+        }
+    }
+    return targets.yes || targets.no ? targets : null;
+};
+export const isManifestStepId = (manifest, stepId) => {
+    return Boolean(getStepById(manifest, stepId));
+};
+export const getPathForStep = (manifest, stepId) => {
+    var _a;
+    return ((_a = getStepById(manifest, stepId)) === null || _a === void 0 ? void 0 : _a.path) || `/${stepId}`;
+};
+export const resolveInitialStepId = (input) => {
+    const requestedStep = getStepById(input.manifest, input.requestedStepId);
+    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);
+};
+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;
+        }
+        return ((_a = activeExperiment.variants[0]) === null || _a === void 0 ? void 0 : _a.routeToStepId) || null;
+    }
+    return resolveNextStepFromEdges(input.manifest.edgesByStepId[input.currentStepId], input.attributes);
+};