@funnelsgrove/cli 0.1.14 → 0.1.18

package/dist/analyticsOutput.d.ts

@@ -23,6 +23,26 @@ export type AnalyticsOverviewResponse = {
         chargedRevenueMinor: number;
     }>;
 };
+export type AnalyticsFunnelFlow = {
+    steps: Array<{
+        stepId: string;
+        stepName: string | null;
+        stepPath: string | null;
+        stepTitle: string | null;
+        stepType: string | null;
+        stepKind: string | null;
+        stepOrder: number;
+    }>;
+    experiments: unknown[];
+    branches: unknown[];
+};
+export type PublishedFunnelFlowResponse = {
+    funnelId: string;
+    publishedVersionId: string | null;
+    status: 'ready' | 'syncing' | 'unpublished';
+    flow: AnalyticsFunnelFlow | null;
+    updatedAt: string | null;
+};
 export type AnalyticsStepDropoffResponse = {
     generatedAt: string;
     from: string | null;
@@ -61,19 +81,7 @@ export type AnalyticsStepDropoffResponse = {
         chartPoints: unknown[];
     }>;
     steps: AnalyticsStepTransition[];
-    flow: {
-        steps: Array<{
-            stepId: string;
-            stepName: string | null;
-            stepPath: string | null;
-            stepTitle: string | null;
-            stepType: string | null;
-            stepKind: string | null;
-            stepOrder: number;
-        }>;
-        experiments: unknown[];
-        branches: unknown[];
-    } | null;
+    flow: AnalyticsFunnelFlow | null;
 };
 export type AnalyticsStepTransition = {
     stepId: string;
@@ -97,6 +105,9 @@ export type MarketingCohortPerformanceRow = {
     subscribersAlive: number;
     subscribersAlivePercent: number | null;
     revenue: number;
+    revenueDay3: number;
+    revenueDay90: number;
+    revenueDay180: number;
     pLtv: number | null;
     pLtvPredictedNetRevenueDay365Minor: number;
     pLtvPredictedCustomerCount: number;
@@ -130,7 +141,7 @@ export declare const parseAnalyticsDate: (value: string) => ParsedAnalyticsDate;
 export declare const normalizeAnalyticsOutputFormat: (value: string | undefined) => AnalyticsOutputFormat;
 export declare const assertHasConversionData: (date: string, overview: AnalyticsOverviewResponse, stepDropoff: AnalyticsStepDropoffResponse) => void;
 export declare const assertHasTransitionData: (date: string, stepDropoff: AnalyticsStepDropoffResponse) => void;
-export declare const assertHasFunnelPathData: (date: string, stepDropoff: AnalyticsStepDropoffResponse) => void;
+export declare const assertHasFunnelPathData: (date: string, stepDropoff: AnalyticsStepDropoffResponse, publishedFunnelFlow: PublishedFunnelFlowResponse) => void;
 export declare const assertHasCohortData: (date: string, report: MarketingCohortPerformanceReport) => void;
 export declare const buildTransitionRows: (stepDropoff: AnalyticsStepDropoffResponse) => {
     stepId: string;
@@ -141,7 +152,7 @@ export declare const buildTransitionRows: (stepDropoff: AnalyticsStepDropoffResp
     dropoffs: number;
     dropoffRate: number;
 }[];
-export declare const buildFunnelPathRows: (stepDropoff: AnalyticsStepDropoffResponse) => {
+export declare const buildFunnelPathRows: (stepDropoff: AnalyticsStepDropoffResponse, publishedFunnelFlow: PublishedFunnelFlowResponse) => {
     stepId: string;
     path: string;
     label: string;
@@ -154,6 +165,7 @@ export declare const buildFunnelPathRows: (stepDropoff: AnalyticsStepDropoffResp
 export declare const buildConversionReportPayload: (input: ReportContext & {
     overview: AnalyticsOverviewResponse;
     stepDropoff: AnalyticsStepDropoffResponse;
+    publishedFunnelFlow: PublishedFunnelFlowResponse;
 }) => {
     generatedAt: string;
     date: string;
@@ -199,6 +211,7 @@ export declare const buildConversionReportPayload: (input: ReportContext & {
 };
 export declare const buildFunnelPathReportPayload: (input: ReportContext & {
     stepDropoff: AnalyticsStepDropoffResponse;
+    publishedFunnelFlow: PublishedFunnelFlowResponse;
 }) => {
     generatedAt: string;
     date: string;
@@ -263,11 +276,13 @@ export declare const formatTransitionsTable: (input: {
 export declare const formatFunnelPathTable: (input: {
     date: string;
     stepDropoff: AnalyticsStepDropoffResponse;
+    publishedFunnelFlow: PublishedFunnelFlowResponse;
 }) => string;
 export declare const formatConversionsTable: (input: {
     date: string;
     overview: AnalyticsOverviewResponse;
     stepDropoff: AnalyticsStepDropoffResponse;
+    publishedFunnelFlow: PublishedFunnelFlowResponse;
 }) => string;
 export declare const formatCohortTable: (input: {
     date: string;

package/dist/analyticsOutput.js

@@ -55,8 +55,8 @@ export const assertHasTransitionData = (date, stepDropoff) => {
     }
     throw new Error(`No synced step transition data found for ${date}. Analytics may not have synced yet, or the funnel had no tracked step traffic that day.`);
 };
-export const assertHasFunnelPathData = (date, stepDropoff) => {
-    if (buildFunnelPathRows(stepDropoff).length > 0 && hasPositiveNumber(stepDropoff.steps)) {
+export const assertHasFunnelPathData = (date, stepDropoff, publishedFunnelFlow) => {
+    if (buildFunnelPathRows(stepDropoff, publishedFunnelFlow).length > 0) {
         return;
     }
     throw new Error(`No synced full funnel path data found for ${date}. Analytics may not have synced yet, or the funnel had no tracked path traffic that day.`);
@@ -85,13 +85,6 @@ const formatCurrency = (value) => new Intl.NumberFormat('en-US', {
 }).format(value);
 const formatMinorCurrency = (value) => formatCurrency((Number(value) || 0) / 100);
 const stepDisplayName = (step) => step.stepName || step.stepId;
-const flowStepDisplay = (stepDropoff, step) => {
-    const flowStep = stepDropoff.flow?.steps.find((candidate) => candidate.stepId === step.stepId);
-    return {
-        label: flowStep?.stepTitle || step.stepName || flowStep?.stepName || step.stepId,
-        path: flowStep?.stepPath || step.stepId,
-    };
-};
 export const buildTransitionRows = (stepDropoff) => [...stepDropoff.steps]
     .sort((left, right) => left.stepOrder - right.stepOrder || left.stepId.localeCompare(right.stepId))
     .map((step) => ({
@@ -103,20 +96,28 @@ export const buildTransitionRows = (stepDropoff) => [...stepDropoff.steps]
     dropoffs: step.dropoffs,
     dropoffRate: step.dropoffRate,
 }));
-export const buildFunnelPathRows = (stepDropoff) => buildTransitionRows(stepDropoff).map((row) => {
-    const step = stepDropoff.steps.find((candidate) => candidate.stepId === row.stepId);
-    const display = flowStepDisplay(stepDropoff, step);
-    return {
-        stepId: row.stepId,
-        path: display.path,
-        label: display.label,
-        users: row.entrants,
-        advancedToNextStep: row.advancedToNextStep,
-        conversionToNextStep: row.entrants > 0 ? row.advancedToNextStep / row.entrants : 0,
-        dropoffs: row.dropoffs,
-        dropoffRate: row.dropoffRate,
-    };
-});
+export const buildFunnelPathRows = (stepDropoff, publishedFunnelFlow) => {
+    if (publishedFunnelFlow.status !== 'ready' || !publishedFunnelFlow.flow) {
+        return [];
+    }
+    const transitionsByStepId = new Map(stepDropoff.steps.map((step) => [step.stepId, step]));
+    return [...publishedFunnelFlow.flow.steps]
+        .sort((left, right) => left.stepOrder - right.stepOrder || left.stepId.localeCompare(right.stepId))
+        .map((flowStep) => {
+        const step = transitionsByStepId.get(flowStep.stepId);
+        const entrants = step?.entrants ?? 0;
+        return {
+            stepId: flowStep.stepId,
+            path: flowStep.stepPath || flowStep.stepId,
+            label: flowStep.stepTitle || flowStep.stepName || flowStep.stepId,
+            users: entrants,
+            advancedToNextStep: step?.advancedToNextStep ?? 0,
+            conversionToNextStep: entrants > 0 ? (step?.advancedToNextStep ?? 0) / entrants : 0,
+            dropoffs: step?.dropoffs ?? 0,
+            dropoffRate: step?.dropoffRate ?? 0,
+        };
+    });
+};
 export const buildConversionReportPayload = (input) => ({
     generatedAt: new Date().toISOString(),
     date: input.date,
@@ -126,7 +127,7 @@ export const buildConversionReportPayload = (input) => ({
     overview: input.overview,
     totals: input.stepDropoff.totals,
     metrics: input.stepDropoff.metrics,
-    funnelPath: buildFunnelPathRows(input.stepDropoff),
+    funnelPath: buildFunnelPathRows(input.stepDropoff, input.publishedFunnelFlow),
     transitions: buildTransitionRows(input.stepDropoff),
 });
 export const buildFunnelPathReportPayload = (input) => ({
@@ -135,7 +136,7 @@ export const buildFunnelPathReportPayload = (input) => ({
     workspaceId: input.workspaceId,
     project: input.project,
     funnel: input.stepDropoff.funnel,
-    funnelPath: buildFunnelPathRows(input.stepDropoff),
+    funnelPath: buildFunnelPathRows(input.stepDropoff, input.publishedFunnelFlow),
 });
 export const buildTransitionReportPayload = (input) => ({
     generatedAt: new Date().toISOString(),
@@ -176,7 +177,7 @@ export const formatFunnelPathTable = (input) => {
         `Full funnel path\t${input.date}\t${input.stepDropoff.funnel.name}`,
         'step\tpath\tusers\tadvanced\tconversionToNext\tdropoffs\tdropoffRate',
     ];
-    for (const row of buildFunnelPathRows(input.stepDropoff)) {
+    for (const row of buildFunnelPathRows(input.stepDropoff, input.publishedFunnelFlow)) {
         lines.push([
             row.label,
             row.path,
@@ -219,6 +220,7 @@ export const formatConversionsTable = (input) => {
     lines.push('', formatFunnelPathTable({
         date: input.date,
         stepDropoff: input.stepDropoff,
+        publishedFunnelFlow: input.publishedFunnelFlow,
     }).trimEnd());
     return `${lines.join('\n')}\n`;
 };
@@ -229,14 +231,24 @@ const predictedAverageLtv = (row) => {
     }
     return Number(row.pLtv) || 0;
 };
+const ratioToSpend = (value, spend) => (Number.isFinite(value) && Number.isFinite(spend) && spend !== 0 ? value / spend : null);
+const formatRoi = (profit, spend) => {
+    const ratio = ratioToSpend(profit, spend);
+    return ratio === null ? '' : `${(ratio * 100).toFixed(2)}%`;
+};
+const formatRoas = (revenue, spend) => {
+    const ratio = ratioToSpend(revenue, spend);
+    return ratio === null ? '' : `${ratio.toFixed(2)}x`;
+};
 export const formatCohortTable = (input) => {
     const lines = [
         `Cohort\t${input.date}`,
-        'cohort\tmediaSource\tfunnelUrl\tspend\tsubscribers\taliveRate\trevenue\tpLtv\tcpa\tpredictedProfit',
+        'cohort\tmediaSource\tfunnelUrl\tspend\tsubscribers\taliveRate\trevenue\tpLtv\tcpa\tpredictedProfit\tpROI\tROAS\tROAS d3\tROAS d90\tROAS d180',
     ];
     for (const row of flattenCohortRows(input.cohort.rows)) {
         const cpa = row.subscribers > 0 ? row.spend / row.subscribers : 0;
         const predictedRevenue = predictedAverageLtv(row) * row.subscribers;
+        const predictedProfit = predictedRevenue - row.spend;
         lines.push([
             row.cohortDate,
             row.mediaSource,
@@ -247,7 +259,12 @@ export const formatCohortTable = (input) => {
             formatCurrency(row.revenue),
             row.pLtv === null ? '' : formatCurrency(row.pLtv),
             row.subscribers > 0 ? formatCurrency(cpa) : '',
-            formatCurrency(predictedRevenue - row.spend),
+            formatCurrency(predictedProfit),
+            formatRoi(predictedProfit, row.spend),
+            formatRoas(row.revenue, row.spend),
+            formatRoas(row.revenueDay3, row.spend),
+            formatRoas(row.revenueDay90, row.spend),
+            formatRoas(row.revenueDay180, row.spend),
         ].join('\t'));
     }
     return `${lines.join('\n')}\n`;

package/dist/apiClient.d.ts

@@ -1,3 +1,5 @@
+import { type FunnelContractDiagnosticCode } from '@funnelsgrove/runtime';
+import type { SourceCandidateOperation } from './localSync.js';
 type FetchFn = typeof fetch;
 type TrpcProcedureType = 'query' | 'mutation';
 export type TrpcCallInput = {
@@ -7,7 +9,90 @@ export type TrpcCallInput = {
     input?: unknown;
     token?: string | null;
     fetchFn?: FetchFn;
+    signal?: AbortSignal;
 };
+export type FunnelSourceCandidateApiContext = {
+    apiUrl: string;
+    token?: string | null;
+    fetchFn?: FetchFn;
+    signal?: AbortSignal;
+};
+export type FunnelSourceCandidateStatus = 'staging' | 'validating' | 'committed' | 'aborted' | 'expired' | 'failed';
+export type BeginFunnelSourceCandidateInput = {
+    workspaceId: string;
+    funnelId: string;
+    baseDraftVersionId: string | null;
+    idempotencyKey: string;
+};
+export type StageFunnelSourceCandidateInput = {
+    workspaceId: string;
+    candidateId: string;
+    idempotencyKey: string;
+    operations: SourceCandidateOperation[];
+};
+export type FinishFunnelSourceCandidateInput = {
+    workspaceId: string;
+    candidateId: string;
+};
+export type FinalizeFunnelSourceCandidateInput = FinishFunnelSourceCandidateInput & {
+    message?: string;
+};
+export type FunnelSourceCandidateSummary = {
+    candidateId: string;
+    status: FunnelSourceCandidateStatus;
+    baseDraftVersionId: string | null;
+    fileCount?: number;
+    byteCount?: number;
+    batchCount?: number;
+};
+export type StageFunnelSourceCandidateResult = {
+    candidateId: string;
+    stageId: string;
+    batchIndex: number;
+    operationCount: number;
+    fileCount: number;
+    byteCount: number;
+    totalOperationCount: number;
+    idempotent: boolean;
+};
+export type FinalizeFunnelSourceCandidateResult = {
+    candidateId: string;
+    projectId: string;
+    funnelId: string;
+    versionId: string;
+    status: 'committed';
+    idempotent: boolean;
+    diagnostics: readonly FunnelContractApiDiagnostic[];
+};
+export declare const FUNNEL_CONTRACT_API_INGRESSES: readonly ["agent-transaction", "cli-sync", "github-sync", "builder-authoring", "preview-publish", "production-publish", "published-artifact-serving"];
+export type FunnelContractApiIngress = (typeof FUNNEL_CONTRACT_API_INGRESSES)[number];
+export type FunnelContractApiDiagnostic = {
+    code: FunnelContractDiagnosticCode;
+    severity: 'error';
+    ingress: FunnelContractApiIngress;
+    file: string | null;
+    stepId: string | null;
+    expected: unknown;
+    received: unknown;
+    reason: string;
+    guide: string;
+    repair: string;
+};
+export type FunnelContractApiErrorData = {
+    schemaVersion: 1;
+    contractVersion: number;
+    ingress: FunnelContractApiIngress;
+    diagnostics: readonly FunnelContractApiDiagnostic[];
+};
+export declare class FunnelContractApiError extends Error {
+    readonly funnelContract: FunnelContractApiErrorData;
+    constructor(message: string, funnelContract: FunnelContractApiErrorData);
+}
+export declare const parseFunnelContractApiErrorData: (value: unknown) => FunnelContractApiErrorData | null;
 export declare function parseTrpcJsonResponse<T = unknown>(response: unknown): T;
 export declare function callTrpcProcedure<T = unknown>(input: TrpcCallInput): Promise<T>;
+export declare const beginFunnelSourceCandidate: (context: FunnelSourceCandidateApiContext, input: BeginFunnelSourceCandidateInput) => Promise<FunnelSourceCandidateSummary>;
+export declare const stageFunnelSourceCandidate: (context: FunnelSourceCandidateApiContext, input: StageFunnelSourceCandidateInput) => Promise<StageFunnelSourceCandidateResult>;
+export declare const finalizeFunnelSourceCandidate: (context: FunnelSourceCandidateApiContext, input: FinalizeFunnelSourceCandidateInput) => Promise<FinalizeFunnelSourceCandidateResult>;
+export declare const abortFunnelSourceCandidate: (context: FunnelSourceCandidateApiContext, input: FinishFunnelSourceCandidateInput) => Promise<FunnelSourceCandidateSummary>;
 export {};

package/dist/apiClient.js

@@ -1,22 +1,227 @@
+import { CURRENT_STEP_CONTRACT_VERSION, FUNNEL_CONTRACT_DIAGNOSTIC_CODES, } from '@funnelsgrove/runtime';
+export const FUNNEL_CONTRACT_API_INGRESSES = Object.freeze([
+    'agent-transaction',
+    'cli-sync',
+    'github-sync',
+    'builder-authoring',
+    'preview-publish',
+    'production-publish',
+    'published-artifact-serving',
+]);
+export class FunnelContractApiError extends Error {
+    funnelContract;
+    constructor(message, funnelContract) {
+        super(`tRPC request failed: ${message}`);
+        this.name = 'FunnelContractApiError';
+        this.funnelContract = funnelContract;
+    }
+}
+const ENVELOPE_KEYS = Object.freeze([
+    'schemaVersion',
+    'contractVersion',
+    'ingress',
+    'diagnostics',
+]);
+const DIAGNOSTIC_KEYS = Object.freeze([
+    'code',
+    'severity',
+    'ingress',
+    'file',
+    'stepId',
+    'expected',
+    'received',
+    'reason',
+    'guide',
+    'repair',
+]);
+const DIAGNOSTIC_CODE_SET = new Set(FUNNEL_CONTRACT_DIAGNOSTIC_CODES);
+const INGRESS_SET = new Set(FUNNEL_CONTRACT_API_INGRESSES);
+const MAX_DIAGNOSTICS = 256;
+const MAX_JSON_DEPTH = 8;
+const MAX_JSON_ITEMS = 256;
+const MAX_TRANSPORT_STRING_LENGTH = 4_096;
+const UNSAFE_JSON_KEYS = new Set(['__proto__', 'constructor', 'prototype']);
 function isObject(value) {
-    return typeof value === 'object' && value !== null && !Array.isArray(value);
+    if (typeof value !== 'object' || value === null || Array.isArray(value))
+        return false;
+    try {
+        const prototype = Object.getPrototypeOf(value);
+        return prototype === Object.prototype || prototype === null;
+    }
+    catch {
+        return false;
+    }
 }
+const ownDataValue = (value, key) => {
+    const descriptor = Object.getOwnPropertyDescriptor(value, key);
+    return descriptor && Object.hasOwn(descriptor, 'value') ? descriptor.value : undefined;
+};
+const hasExactDataProperties = (value, keys) => {
+    if (!isObject(value)) {
+        return false;
+    }
+    let ownKeys;
+    try {
+        ownKeys = Reflect.ownKeys(value);
+    }
+    catch {
+        return false;
+    }
+    if (ownKeys.length !== keys.length || ownKeys.some((key) => typeof key !== 'string')) {
+        return false;
+    }
+    const expectedKeys = new Set(keys);
+    return ownKeys.every((key) => {
+        if (typeof key !== 'string' || !expectedKeys.has(key)) {
+            return false;
+        }
+        const descriptor = Object.getOwnPropertyDescriptor(value, key);
+        return descriptor?.enumerable === true && Object.hasOwn(descriptor, 'value');
+    });
+};
+const readDenseDataArray = (value, maximum) => {
+    if (!Array.isArray(value))
+        return null;
+    const descriptors = (() => {
+        try {
+            return Object.getOwnPropertyDescriptors(value);
+        }
+        catch {
+            return null;
+        }
+    })();
+    if (descriptors === null)
+        return null;
+    const length = descriptors.length?.value;
+    if (typeof length !== 'number' || !Number.isSafeInteger(length) || length < 0 || length > maximum) {
+        return null;
+    }
+    const keys = Reflect.ownKeys(descriptors);
+    if (keys.length !== length + 1
+        || keys.some((key) => (typeof key !== 'string'
+            || (key !== 'length' && !/^(?:0|[1-9]\d*)$/.test(key)))))
+        return null;
+    const result = [];
+    for (let index = 0; index < length; index += 1) {
+        const descriptor = descriptors[String(index)];
+        if (!descriptor?.enumerable || !Object.hasOwn(descriptor, 'value'))
+            return null;
+        result.push(descriptor.value);
+    }
+    return result;
+};
+const isJsonValue = (value, seen = new Set(), depth = 0) => {
+    if (value === null
+        || typeof value === 'boolean') {
+        return true;
+    }
+    if (typeof value === 'string')
+        return value.length <= MAX_TRANSPORT_STRING_LENGTH;
+    if (typeof value === 'number') {
+        return Number.isFinite(value);
+    }
+    if (typeof value !== 'object' || seen.has(value) || depth >= MAX_JSON_DEPTH) {
+        return false;
+    }
+    seen.add(value);
+    try {
+        if (Array.isArray(value)) {
+            const items = readDenseDataArray(value, MAX_JSON_ITEMS);
+            return items !== null && items.every((item) => isJsonValue(item, seen, depth + 1));
+        }
+        const prototype = Object.getPrototypeOf(value);
+        if (prototype !== Object.prototype && prototype !== null) {
+            return false;
+        }
+        const keys = Reflect.ownKeys(value);
+        return keys.length <= MAX_JSON_ITEMS && keys.every((key) => {
+            if (typeof key !== 'string') {
+                return false;
+            }
+            if (UNSAFE_JSON_KEYS.has(key))
+                return false;
+            const descriptor = Object.getOwnPropertyDescriptor(value, key);
+            return descriptor?.enumerable === true
+                && Object.hasOwn(descriptor, 'value')
+                && isJsonValue(descriptor.value, seen, depth + 1);
+        });
+    }
+    finally {
+        seen.delete(value);
+    }
+};
+const isNullableString = (value) => (value === null
+    || (typeof value === 'string' && value.length <= MAX_TRANSPORT_STRING_LENGTH));
+const isBoundedString = (value) => (typeof value === 'string' && value.length <= MAX_TRANSPORT_STRING_LENGTH);
+const isFunnelContractApiDiagnostic = (value, ingress) => {
+    if (!hasExactDataProperties(value, DIAGNOSTIC_KEYS))
+        return false;
+    const code = ownDataValue(value, 'code');
+    return typeof code === 'string'
+        && DIAGNOSTIC_CODE_SET.has(code)
+        && ownDataValue(value, 'severity') === 'error'
+        && ownDataValue(value, 'ingress') === ingress
+        && isNullableString(ownDataValue(value, 'file'))
+        && isNullableString(ownDataValue(value, 'stepId'))
+        && isJsonValue(ownDataValue(value, 'expected'))
+        && isJsonValue(ownDataValue(value, 'received'))
+        && isBoundedString(ownDataValue(value, 'reason'))
+        && isBoundedString(ownDataValue(value, 'guide'))
+        && isBoundedString(ownDataValue(value, 'repair'));
+};
+export const parseFunnelContractApiErrorData = (value) => {
+    if (!hasExactDataProperties(value, ENVELOPE_KEYS)
+        || ownDataValue(value, 'schemaVersion') !== 1
+        || ownDataValue(value, 'contractVersion') !== CURRENT_STEP_CONTRACT_VERSION) {
+        return null;
+    }
+    const ingressValue = ownDataValue(value, 'ingress');
+    if (typeof ingressValue !== 'string' || !INGRESS_SET.has(ingressValue))
+        return null;
+    const diagnostics = readDenseDataArray(ownDataValue(value, 'diagnostics'), MAX_DIAGNOSTICS);
+    if (diagnostics === null)
+        return null;
+    const ingress = ingressValue;
+    return diagnostics.every((diagnostic) => (isFunnelContractApiDiagnostic(diagnostic, ingress))) ? value : null;
+};
+const readFunnelContractApiErrorData = (error) => {
+    const data = ownDataValue(error, 'data');
+    if (!isObject(data)) {
+        return null;
+    }
+    const descriptor = Object.getOwnPropertyDescriptor(data, 'funnelContract');
+    return descriptor && Object.hasOwn(descriptor, 'value')
+        ? parseFunnelContractApiErrorData(descriptor.value)
+        : null;
+};
 export function parseTrpcJsonResponse(response) {
     if (!isObject(response)) {
         throw new Error('Invalid tRPC response');
     }
-    if (isObject(response.error)) {
-        const message = typeof response.error.message === 'string' ? response.error.message : 'Unknown error';
+    const errorValue = ownDataValue(response, 'error');
+    if (isObject(errorValue)) {
+        const messageValue = ownDataValue(errorValue, 'message');
+        const message = typeof messageValue === 'string' ? messageValue : 'Unknown error';
+        const funnelContract = readFunnelContractApiErrorData(errorValue);
+        if (funnelContract) {
+            throw new FunnelContractApiError(message, funnelContract);
+        }
         throw new Error(`tRPC request failed: ${message}`);
     }
-    const result = response.result;
-    if (!isObject(result) || !('data' in result)) {
+    const result = ownDataValue(response, 'result');
+    if (!isObject(result)) {
         throw new Error('Invalid tRPC response');
     }
-    if (isObject(result.data) && 'json' in result.data) {
-        return result.data.json;
+    const dataDescriptor = Object.getOwnPropertyDescriptor(result, 'data');
+    if (!dataDescriptor || !Object.hasOwn(dataDescriptor, 'value'))
+        throw new Error('Invalid tRPC response');
+    const data = dataDescriptor.value;
+    if (isObject(data)) {
+        const jsonDescriptor = Object.getOwnPropertyDescriptor(data, 'json');
+        if (jsonDescriptor && Object.hasOwn(jsonDescriptor, 'value'))
+            return jsonDescriptor.value;
     }
-    return result.data;
+    return data;
 }
 const trimTrailingSlash = (value) => value.trim().replace(/\/+$/, '');
 const buildHeaders = (input) => {
@@ -36,11 +241,13 @@ export async function callTrpcProcedure(input) {
         ? {
             method: 'GET',
             headers: buildHeaders({ token: input.token }),
+            signal: input.signal,
         }
         : {
             method: 'POST',
             headers: buildHeaders({ token: input.token, contentType: 'application/json' }),
             body: JSON.stringify(input.input ?? {}),
+            signal: input.signal,
         };
     const url = input.type === 'query' && input.input !== undefined
         ? `${baseUrl}?input=${encodeURIComponent(JSON.stringify(input.input))}`
@@ -59,3 +266,13 @@ export async function callTrpcProcedure(input) {
     }
     return parseTrpcJsonResponse(json);
 }
+const callFunnelSourceCandidateMutation = (context, path, input) => callTrpcProcedure({
+    ...context,
+    path,
+    type: 'mutation',
+    input,
+});
+export const beginFunnelSourceCandidate = (context, input) => callFunnelSourceCandidateMutation(context, 'funnels.beginSourceCandidate', input);
+export const stageFunnelSourceCandidate = (context, input) => callFunnelSourceCandidateMutation(context, 'funnels.stageSourceCandidate', input);
+export const finalizeFunnelSourceCandidate = (context, input) => callFunnelSourceCandidateMutation(context, 'funnels.finalizeSourceCandidate', input);
+export const abortFunnelSourceCandidate = (context, input) => callFunnelSourceCandidateMutation(context, 'funnels.abortSourceCandidate', input);