@coframe/sdk 1.1.59 → 1.1.60

package/README.md

@@ -145,7 +145,11 @@ Pass `projectData` into `<CoframeProvider>` to avoid the extra client-side proje
 
 Use `getExperimentAssignment()` when the server must know one experiment's
 variant before rendering or calling an upstream service. Edge performs the full
-assignment; the package never falls back to local bucketing.
+assignment; the package never falls back to local bucketing. Use
+`getAssignments()` with the same options minus `experimentId` to get every
+experiment the visitor is assigned on `currentUrl` in one call; the result's
+`variants` lists them in the order the browser applies them and `variant` is
+`null` with reason `no_target_experiment`.
 
 ```ts
 import {
@@ -273,14 +277,21 @@ kinds of input only exist in the page, so Edge cannot evaluate them:
     on experiments you resolve on the server.
   - Experiments in the same frame are evaluated in order and the first match
     wins. If a JavaScript-targeted experiment sits **ahead of the target in
-    the same frame**, Edge skips it and assigns the target, while the browser
-    can match it and skip the target. Keep JavaScript-targeted experiments out
-    of the target experiment's frame, or place them after the target.
+    the same frame**, Edge cannot tell whether the browser would match it and
+    skip the target, so it leaves the whole frame to the browser: the result is
+    `variant: null` with reason `not_assigned` (logged on Edge as
+    `undecidable_audience`) and the browser renders the frame's pick. Keep
+    JavaScript-targeted experiments out of the target experiment's frame, or
+    place them after the target.
   - The same applies to a JavaScript-targeted experiment that shares a
     **lane** with the target, wherever it sits: lane winners are drawn from
     the experiments the visitor can reach, and Edge cannot tell whether that
-    one is reachable. Keep JavaScript-targeted experiments out of the target's
-    lane.
+    one is reachable, so it leaves every frame holding a member of that lane
+    to the browser (`variant: null`, reason `not_assigned`, logged as
+    `undecidable_lane`) unless an earlier visit already claimed the lane; a
+    lane member in a frame whose own activation needs the page counts the
+    same way. Keep
+    JavaScript-targeted experiments out of the target's lane.
 - **CMAB experiments.** A target CMAB experiment returns `variant: null` with
   reason `unsupported_experiment_type`.
 - **URL fragments.** A server never sees the `#fragment` of the page URL, and
@@ -601,6 +612,22 @@ If your app uses an older TypeScript module resolution mode, prefer moving to on
 
 Modern resolution modes handle package subpath exports more reliably.
 
+## SDK development
+
+When building this SDK from source, use the Node.js version pinned in `.nvmrc`.
+SDK CI reads the same `.nvmrc` file through `actions/setup-node`.
+
+From `sdk/sdk-js`, run:
+
+```sh
+nvm install
+nvm use
+yarn install --frozen-lockfile
+yarn build:stage
+```
+
+SDK Tools use their own `sdk/tools/.nvmrc`.
+
 ## API overview
 
 ### `@coframe/sdk`
@@ -627,6 +654,7 @@ Modern resolution modes handle package subpath exports more reliably.
 
 - `getProjectData(options)`
 - `getExperimentAssignment(options)`
+- `getAssignments(options)`
 - `generateUserToken()`
 - `evaluateFlags(options)`
 - `getFeatureFlag(key, options)` / `isFeatureEnabled(key, options)`

package/dist/pkg/cf.cjs.js

@@ -1663,6 +1663,60 @@ const executeTags = (tags, logger, nonce) => {
     }
 };
 
+function isRecord(value) {
+    return !!value && typeof value === 'object' && !Array.isArray(value);
+}
+
+const SCOPED = new Set(['update', 'delete', 'insert_into', 'insert_by']);
+const ADDED = new Set(['add_modal', 'add_banner']);
+function safeSelector(css) {
+    return css.trim() !== '' && !/[<{}]/.test(css) && !css.includes('/*');
+}
+function modificationScope(modifications, elements) {
+    const selectors = [];
+    if (!isRecord(modifications) || !isRecord(elements))
+        return { kind: 'page', reason: 'invalid_variant' };
+    for (const [id, changes] of Object.entries(modifications)) {
+        if (!Array.isArray(changes))
+            return { kind: 'page', reason: 'invalid_variant' };
+        let scoped = false;
+        for (const change of changes) {
+            const type = isRecord(change) ? change.type : undefined;
+            if (typeof type === 'string' && SCOPED.has(type))
+                scoped = true;
+            else if (type === 'execute_js' &&
+                isRecord(change) &&
+                change.css !== undefined) {
+                const { css: list } = change;
+                const declared = Array.isArray(list) ? list : [list];
+                if (declared.length === 0)
+                    return { kind: 'page', reason: `unscoped_change:${type}` };
+                for (const css of declared) {
+                    if (typeof css !== 'string' || !safeSelector(css))
+                        return { kind: 'page', reason: `unscoped_selector:${id}` };
+                    selectors.push(css.trim());
+                }
+            }
+            else if (typeof type !== 'string' || !ADDED.has(type))
+                return { kind: 'page', reason: `unscoped_change:${String(type)}` };
+        }
+        if (!scoped)
+            continue;
+        const conditions = elements[id];
+        if (!Array.isArray(conditions) || conditions.length === 0)
+            return { kind: 'page', reason: 'invalid_variant' };
+        const css = [];
+        for (const condition of conditions) {
+            const value = isRecord(condition) ? condition.css : undefined;
+            if (typeof value !== 'string' || !safeSelector(value))
+                return { kind: 'page', reason: `unscoped_selector:${id}` };
+            css.push(value.trim());
+        }
+        selectors.push(css.join(', '));
+    }
+    return selectors.length ? { kind: 'elements', selectors } : { kind: 'none' };
+}
+
 function getLogCallback() {
     const queue = window.CFQ;
     if (!queue) {
@@ -1974,6 +2028,75 @@ function subscribeToCmd(predicate, callback, queueName = QueueName.CFQ) {
     return __addListener(predicate, callback, queueName);
 }
 
+function scopeOwners(variants, selectors) {
+    const matches = new Map();
+    const select = (css) => {
+        if (!matches.has(css)) {
+            try {
+                matches.set(css, document.querySelectorAll(css));
+            }
+            catch (_a) {
+                matches.set(css, null);
+            }
+        }
+        return matches.get(css);
+    };
+    const overlaps = (hidden, changed) => {
+        if (hidden === changed)
+            return true;
+        const left = select(hidden);
+        const right = select(changed);
+        if (!(left === null || left === void 0 ? void 0 : left.length) || !(right === null || right === void 0 ? void 0 : right.length))
+            return true;
+        for (let i = 0; i < left.length; i++) {
+            for (let j = 0; j < right.length; j++) {
+                if (left[i].contains(right[j]) || right[j].contains(left[i]))
+                    return true;
+            }
+        }
+        return false;
+    };
+    const scopes = variants.map(({ variant, elements }) => modificationScope(variant.modifications, elements));
+    return selectors.map((selector) => {
+        const owners = [];
+        scopes.forEach((scope, index) => {
+            if (scope.kind === 'page' ||
+                (scope.kind === 'elements' &&
+                    scope.selectors.some((changed) => overlaps(selector, changed)))) {
+                owners.push(index);
+            }
+        });
+        return owners;
+    });
+}
+function beginProxyBatch(variants) {
+    const request = findLastCmd((cmd) => cmd.proxyReveal === true);
+    if (!request)
+        return undefined;
+    const queue = ensureQueueExists();
+    const batchId = queue.length + 1;
+    const keys = variants.map(({ variant }, index) => JSON.stringify([variant.experiment_id, variant.id, index]));
+    const owners = request.proxySelectors
+        ? scopeOwners(variants, request.proxySelectors)
+        : undefined;
+    queue.push({ proxyBatch: { batchId, keys, ...(owners ? { owners } : {}) } });
+    return (index) => {
+        let completed = false;
+        const complete = (() => {
+            if (completed)
+                return;
+            completed = true;
+            queue.push({ proxyVariantRendered: { batchId, key: keys[index] } });
+        });
+        complete.silent = () => {
+            if (completed)
+                return;
+            queue.push({ proxyVariantSilent: { batchId, key: keys[index] } });
+        };
+        return complete;
+    };
+}
+
 function describeError(error) {
     if (error && (typeof error === 'object' || typeof error === 'function')) {
         const stack = readString(() => error.stack);
@@ -2112,13 +2235,15 @@ function variantRendered() {
     const queue = ensureQueueExists();
     queue.push({
         emit: 'variantRendered',
+        sdkVariantRendered: true,
     });
 }
+const SIGNALS_COMPLETION = /variantRendered|variantSession/;
 function hasJavascriptModification(variantElements) {
     const modifications = variantElements.variant.modifications || {};
     return Object.keys(modifications).some((elementId) => (modifications[elementId] || []).some((modification) => modification.type === 'execute_js'));
 }
-const applyVariantChanges = (variantElements, currentUrl, logger, nonce, lifecycleContext) => {
+const applyVariantChanges = (variantElements, currentUrl, logger, nonce, lifecycleContext, proxyComplete) => {
     var _a;
     const { variant, elements } = variantElements;
     const variantMetadata = {
@@ -2126,6 +2251,35 @@ const applyVariantChanges = (variantElements, currentUrl, logger, nonce, lifecyc
         experiment_id: variant.experiment_id,
     };
     setApplyVariantChangesStarted(true);
+    const javascriptPending = [];
+    const javascriptSilent = [];
+    let applying = true;
+    const maybeComplete = () => {
+        if (applying)
+            return;
+        if (javascriptPending.every((pending) => !pending))
+            proxyComplete === null || proxyComplete === void 0 ? void 0 : proxyComplete();
+        else if (javascriptPending.every((pending, i) => !pending || javascriptSilent[i]))
+            proxyComplete === null || proxyComplete === void 0 ? void 0 : proxyComplete.silent();
+    };
+    const scriptCompletion = () => {
+        const index = javascriptPending.push(true) - 1;
+        javascriptSilent.push(false);
+        const complete = (() => {
+            var _a;
+            if (!javascriptPending[index])
+                return;
+            javascriptPending[index] = false;
+            (_a = complete.settled) === null || _a === void 0 ? void 0 : _a.call(complete);
+            complete.settled = undefined;
+            maybeComplete();
+        });
+        complete.silent = () => {
+            if (javascriptPending[index])
+                javascriptSilent[index] = true;
+        };
+        return complete;
+    };
     const session = lifecycleContext && hasJavascriptModification(variantElements)
         ? lifecycleContext.runtime.createVariantSession({
             batchId: lifecycleContext.batchId,
@@ -2136,6 +2290,7 @@ const applyVariantChanges = (variantElements, currentUrl, logger, nonce, lifecyc
     if (!variant.modifications ||
         Object.keys(variant.modifications).length === 0) {
         variantRendered();
+        proxyComplete === null || proxyComplete === void 0 ? void 0 : proxyComplete();
         return true;
     }
     for (const elementId of Object.keys(variant.modifications)) {
@@ -2159,7 +2314,7 @@ const applyVariantChanges = (variantElements, currentUrl, logger, nonce, lifecyc
             }
             continue;
         }
-        const edited = editElement(selectedElement, variant.modifications, elementId, logger, nonce, variantMetadata, session === null || session === void 0 ? void 0 : session.facade);
+        const edited = editElement(selectedElement, variant.modifications, elementId, logger, nonce, variantMetadata, session === null || session === void 0 ? void 0 : session.facade, proxyComplete ? scriptCompletion : undefined);
         if (!edited) {
             logger.error('element not edited', 'element_not_edited', {
                 ...variantMetadata,
@@ -2177,6 +2332,8 @@ const applyVariantChanges = (variantElements, currentUrl, logger, nonce, lifecyc
             }
         }
     }
+    applying = false;
+    maybeComplete();
     return true;
 };
 function describeElement(element) {
@@ -2188,7 +2345,7 @@ function describeElement(element) {
     const className = target.getAttribute('class');
     return `<${String(target.tagName).toLowerCase()}${id ? ` id=${JSON.stringify(id)}` : ''}${className ? ` class=${JSON.stringify(className)}` : ''}>`.slice(0, 200);
 }
-const editElement = (element, modifications, elementId, logger, nonce, logMetadata = {}, variantSession) => {
+const editElement = (element, modifications, elementId, logger, nonce, logMetadata = {}, variantSession, scriptCompletion) => {
     if (!modifications[elementId]) {
         logger.warn('no modifications for element', 'no_modifications_for_element', {
             ...logMetadata,
@@ -2199,13 +2356,37 @@ const editElement = (element, modifications, elementId, logger, nonce, logMetada
     }
     for (const content of modifications[elementId]) {
         switch (content.type) {
-            case 'execute_js':
-                if (!applyJavascriptModification(element, content, logger, nonce, logMetadata, variantSession ? { variantSession } : undefined) &&
-                    variantSession) {
+            case 'execute_js': {
+                const complete = scriptCompletion === null || scriptCompletion === void 0 ? void 0 : scriptCompletion();
+                const session = variantSession && complete
+                    ? {
+                        ...variantSession,
+                        complete() {
+                            variantSession.complete();
+                            complete();
+                        },
+                        error(error) {
+                            variantSession.error(error);
+                            complete();
+                        },
+                    }
+                    : variantSession;
+                const stop = complete &&
+                    subscribeToCmd((cmd) => !cmd.sdkVariantRendered &&
+                        (cmd.variantRendered === true || cmd.emit === 'variantRendered'), () => complete());
+                if (complete && stop)
+                    complete.settled = stop;
+                const applied = applyJavascriptModification(element, content, logger, nonce, logMetadata, session ? { variantSession: session } : undefined);
+                if (!applied)
+                    complete === null || complete === void 0 ? void 0 : complete();
+                if (applied && complete && !SIGNALS_COMPLETION.test(content.js))
+                    complete.silent();
+                if (!applied && variantSession) {
                     variantSession.error(new Error('JavaScript variant modification did not run'));
                     return false;
                 }
                 break;
+            }
             case 'update':
                 applyUpdateModification(element, content, logger, logMetadata);
                 variantRendered();
@@ -2264,13 +2445,14 @@ function revealPage() {
 async function replaceVariants(variants, orgId, logger, nonce, runtime) {
     const failedReplacements = [];
     let currentVariant;
+    const proxyCompletion = beginProxyBatch(variants);
     const batch = runtime === null || runtime === void 0 ? void 0 : runtime.beginBatch({
         expectedSessionCount: variants.filter(hasJavascriptModification).length,
     });
     try {
-        for (const v of variants) {
+        for (const [index, v] of variants.entries()) {
             currentVariant = v.variant;
-            if (!applyVariantChanges(v, getCurrentPageUrl(), logger, nonce, batch && runtime ? { runtime, batchId: batch.batchId } : undefined)) {
+            if (!applyVariantChanges(v, getCurrentPageUrl(), logger, nonce, batch && runtime ? { runtime, batchId: batch.batchId } : undefined, proxyCompletion === null || proxyCompletion === void 0 ? void 0 : proxyCompletion(index))) {
                 failedReplacements.push({
                     message: 'Original element not found',
                     metadata: {
@@ -2823,8 +3005,7 @@ function checkAllAudiences(metadata, ctx) {
     }
     return result;
 }
-function audiencesPass(metadata, ctx) {
-    const result = checkAllAudiences(metadata, ctx);
+function audiencesPass(result, ctx) {
     return ctx.unknownIsInactive ? result === true : result !== false;
 }
 async function getVariantsAndElements(personalizationHeaders, project, previewVariantId, userToken, currentPageUrl, languages, browserPlatform, logger, nonce, laneClaims = {}, silentFallback = false, chooseCmabVariants, userVisitCountOverride, runtime = {}) {
@@ -2906,57 +3087,89 @@ async function getVariantsAndElements(personalizationHeaders, project, previewVa
         experimentsInfo: [...experimentsInfo, ...assignment.experimentsInfo],
     });
 }
+function frameActivation(frame, ctx) {
+    return checkActivationCondition(frame.activation_condition, ctx.personalizationHeaders, ctx.currentPageUrl, ctx.languages, ctx.browserPlatform, ctx.userToken, ctx.userVisitCount, ctx.runJsFunction, ctx.logger);
+}
 function activateFrames(ctx) {
     return ctx.project.frames.filter((frame) => {
         if (!frame.experiments)
             return false;
-        const frameActivated = checkActivationCondition(frame.activation_condition, ctx.personalizationHeaders, ctx.currentPageUrl, ctx.languages, ctx.browserPlatform, ctx.userToken, ctx.userVisitCount, ctx.runJsFunction, ctx.logger);
+        const frameActivated = frameActivation(frame, ctx);
         return ctx.unknownIsInactive ? frameActivated === true : !!frameActivated;
     });
 }
+function undecidedFrames(ctx) {
+    if (!ctx.unknownIsInactive)
+        return [];
+    return ctx.project.frames.filter((frame) => {
+        if (!frame.experiments)
+            return false;
+        const activated = frameActivation(frame, ctx);
+        return activated !== true && activated !== false;
+    });
+}
 async function assignFrames(activeFrames, validatedClaims, ctx, chooseCmabVariants) {
-    var _a, _b, _c;
+    var _a, _b, _c, _d;
     const { project, userToken, logger } = ctx;
     const experimentsInfo = [];
     const variantsAndElements = [];
-    const audiencePass = new Map();
+    const audienceResult = new Map();
     const reachableByLane = {};
+    const undecidableLanes = new Set();
     for (const frame of activeFrames) {
         for (const experiment of (_a = frame.experiments) !== null && _a !== void 0 ? _a : []) {
             const metadata = experiment.metadata;
             const laneIds = experimentLaneIds(metadata);
             if (laneIds.length === 0)
                 continue;
-            const passes = audiencesPass(metadata, ctx);
-            audiencePass.set(metadata.experiment_id, passes);
-            if (passes) {
+            const result = checkAllAudiences(metadata, ctx);
+            audienceResult.set(metadata.experiment_id, result);
+            if (audiencesPass(result, ctx)) {
                 for (const laneId of laneIds) {
                     if (!reachableByLane[laneId])
                         reachableByLane[laneId] = [];
                     reachableByLane[laneId].push(metadata.experiment_id);
                 }
             }
+            else if (ctx.unknownIsInactive && result !== false) {
+                for (const laneId of laneIds)
+                    if (!validatedClaims[laneId])
+                        undecidableLanes.add(laneId);
+            }
         }
     }
+    for (const frame of undecidedFrames(ctx))
+        for (const experiment of (_b = frame.experiments) !== null && _b !== void 0 ? _b : [])
+            for (const laneId of experimentLaneIds(experiment.metadata))
+                if (!validatedClaims[laneId])
+                    undecidableLanes.add(laneId);
     const excludedExperimentIds = resolveLaneWinners(validatedClaims, reachableByLane, project.lanes, userToken);
     const updatedClaims = { ...validatedClaims };
     const assignmentEntries = [];
     let hasActivatedFrames = false;
     for (const frame of activeFrames) {
         let atLeastOneExperimentWasActivated = false;
-        for (const experiment of (_b = frame.experiments) !== null && _b !== void 0 ? _b : []) {
+        for (const experiment of (_c = frame.experiments) !== null && _c !== void 0 ? _c : []) {
             if (atLeastOneExperimentWasActivated)
                 break;
             const metadata = experiment.metadata;
             const variants = experiment.variants;
             const elements = frame.elements;
+            if (ctx.unknownIsInactive &&
+                experimentLaneIds(metadata).some((id) => undecidableLanes.has(id))) {
+                logger.warn('Leaving the frame to the browser: a lane member needs the page', 'undecidable_lane', { experiment_id: metadata.experiment_id });
+                break;
+            }
             if (excludedExperimentIds.has(metadata.experiment_id))
                 continue;
-            let activated = audiencePass.get(metadata.experiment_id);
-            if (activated === undefined) {
-                activated = audiencesPass(metadata, ctx);
+            let result = audienceResult.get(metadata.experiment_id);
+            if (result === undefined)
+                result = checkAllAudiences(metadata, ctx);
+            if (result !== true && result !== false && ctx.unknownIsInactive) {
+                logger.warn('Leaving the frame to the browser: an audience needs the page', 'undecidable_audience', { experiment_id: metadata.experiment_id });
+                break;
             }
-            if (!activated)
+            if (!audiencesPass(result, ctx))
                 continue;
             atLeastOneExperimentWasActivated = true;
             hasActivatedFrames = true;
@@ -3010,7 +3223,7 @@ async function assignFrames(activeFrames, validatedClaims, ctx, chooseCmabVarian
         try {
             mlVariantIds = await chooseCmabVariants(Array.from(cmabMetadataById.values()), userToken);
         }
-        catch (_d) {
+        catch (_e) {
             mlVariantIds = new Map();
         }
     }
@@ -3021,7 +3234,7 @@ async function assignFrames(activeFrames, validatedClaims, ctx, chooseCmabVarian
         }
         const { metadata, variants, elements } = entry;
         let mlVariantId = metadata.type === 'CMAB'
-            ? ((_c = mlVariantIds.get(metadata.experiment_id)) !== null && _c !== void 0 ? _c : null)
+            ? ((_d = mlVariantIds.get(metadata.experiment_id)) !== null && _d !== void 0 ? _d : null)
             : null;
         if (mlVariantId && !variants.some((v) => v.id === mlVariantId)) {
             logger.warn(`CMAB variant ${mlVariantId} not in experiment ${metadata.experiment_id}`, 'cmab_variant_not_found', { experiment_id: metadata.experiment_id });
@@ -3564,7 +3777,7 @@ function shouldSdkWaitForHydration(config) {
         !isVariantRuntimeLifecycleEnabled(config));
 }
 
-function createRevealCoordinator(revealPage, reportError = () => { }) {
+function createRevealCoordinator(revealPage, reportError = () => { }, onForced = () => { }) {
     const notify = (listener, reason) => {
         try {
             listener(reason);
@@ -3616,6 +3829,18 @@ function createRevealCoordinator(revealPage, reportError = () => { }) {
             reveal(reason);
         },
         forceReveal(reason) {
+            if (pageRevealed)
+                return;
+            try {
+                onForced(reason);
+            }
+            catch (error) {
+                try {
+                    reportError(error);
+                }
+                catch (_a) {
+                }
+            }
             reveal(reason);
         },
         block(batchId) {
@@ -3803,10 +4028,6 @@ function notifyEventsFlushed() {
     }
 }
 
-function isRecord(value) {
-    return !!value && typeof value === 'object' && !Array.isArray(value);
-}
-
 const OPT_IN_COUNTRIES = new Set(('AT BE BG HR CY CZ DK EE FI FR DE GR HU IE IT LV LT LU MT NL PL PT RO SK SI ES SE ' +
     'AX GF GP MF MQ RE YT ' +
     'IS LI NO ' +
@@ -5010,6 +5231,7 @@ function createApplyVariants(Coframe, config, previewVariantId, isSessionVariant
             Coframe.debug.laneClaims = laneClaims;
         }
         if (config.trackingOnly) {
+            beginProxyBatch([]);
             variantRendered();
         }
         else {
@@ -5032,7 +5254,7 @@ async function modifyPage(Coframe, configResult, projectResult, analytics, lifec
     var _a;
     const { config, timeoutMs, previewVariantId, isSessionVariant, integrationStartTime, executionStartTime, } = configResult;
     const { project: cdnProject, personalizationHeaders, assignmentContext, } = projectResult;
-    const revealCoordinator = (_a = lifecycle === null || lifecycle === void 0 ? void 0 : lifecycle.revealCoordinator) !== null && _a !== void 0 ? _a : createRevealCoordinator(revealPage, logRevealListenerError(() => Coframe.logger));
+    const revealCoordinator = (_a = lifecycle === null || lifecycle === void 0 ? void 0 : lifecycle.revealCoordinator) !== null && _a !== void 0 ? _a : createRevealCoordinator(revealPage, logRevealListenerError(() => Coframe.logger), () => beginProxyBatch([]));
     const runtime = lifecycle === null || lifecycle === void 0 ? void 0 : lifecycle.runtime;
     if (runtime && config.waitForHydration) {
         if (findLastCmd(isPageHydratedCmd)) {
@@ -5399,6 +5621,7 @@ async function resolveConfig(Coframe, revealActions) {
 }
 
 async function resolveIdentity(config, Coframe, timeoutMs, gracefulExit, previewVariantId) {
+    var _a;
     const logger = Coframe.logger;
     let userToken;
     if (config.waitForUserToken) {
@@ -5416,7 +5639,8 @@ async function resolveIdentity(config, Coframe, timeoutMs, gracefulExit, preview
         }
     }
     else {
-        userToken = getOrGenerateUserToken();
+        const proxied = (_a = findLastCmd((cmd) => typeof cmd.proxyUserToken === 'string' && !!cmd.proxyUserToken)) === null || _a === void 0 ? void 0 : _a.proxyUserToken;
+        userToken = proxied || getOrGenerateUserToken();
     }
     Coframe.userToken = userToken;
     const persistCookies = () => {
@@ -6409,7 +6633,7 @@ const Coframe = {
     },
 };
 Coframe.logger = createLogger(() => Coframe);
-const revealCoordinator = createRevealCoordinator(revealPage, logRevealListenerError(() => Coframe.logger));
+const revealCoordinator = createRevealCoordinator(revealPage, logRevealListenerError(() => Coframe.logger), () => beginProxyBatch([]));
 let activeRuntime = null;
 function clearActiveRuntime() {
     activeRuntime === null || activeRuntime === void 0 ? void 0 : activeRuntime.destroy();