@launchdarkly/js-client-sdk-common 1.22.0 → 1.24.0

package/dist/cjs/index.cjs

@@ -293,10 +293,18 @@ function validateOptions(input, validatorMap, defaults, logger, prefix) {
  * Creates a validator for nested objects. When used in a validator map,
  * `validateOptions` will recursively validate the nested object's properties.
  * Defaults for nested fields are passed through from the parent.
+ *
+ * @param validators - Validator map for the nested object's fields.
+ * @param options - Optional configuration.
+ * @param options.defaults - Built-in defaults for nested fields.
+ * @param options.is - Custom `is` predicate. When provided, replaces the
+ *   default "is object" check. Use this to discriminate between object shapes
+ *   in an `anyOf` (e.g., matching on a `type` discriminant field).
  */
-function validatorOf(validators, builtInDefaults) {
+function validatorOf(validators, options) {
+    const builtInDefaults = options?.defaults;
     return {
-        is: (u) => jsSdkCommon.TypeValidators.Object.is(u),
+        is: options?.is ?? ((u) => jsSdkCommon.TypeValidators.Object.is(u)),
         getType: () => 'object',
         validate(value, name, logger, defaults) {
             if (!jsSdkCommon.TypeValidators.Object.is(value)) {
@@ -310,6 +318,62 @@ function validatorOf(validators, builtInDefaults) {
         },
     };
 }
+/**
+ * Creates a validator for arrays of discriminated objects. Each item in the
+ * array must be an object containing a `discriminant` field whose value
+ * selects which validator map to apply. The valid discriminant values are
+ * the keys of `validatorsByType`. Items that are not objects, or whose
+ * discriminant value is missing or unrecognized, are filtered out with a
+ * warning.
+ *
+ * @param discriminant - The field name used to determine each item's type.
+ * @param validatorsByType - A mapping from discriminant values to the
+ *   validator maps used to validate items of that type. Each validator map
+ *   should include a validator for the discriminant field itself.
+ *
+ * @example
+ * ```ts
+ * // Validates an array like:
+ * //   [{ type: 'polling', pollInterval: 60 }, { type: 'cache' }]
+ *
+ * const validator = arrayOf('type', {
+ *   cache: { type: TypeValidators.String },
+ *   polling: { type: TypeValidators.String, pollInterval: TypeValidators.numberWithMin(30) },
+ *   streaming: { type: TypeValidators.String, initialReconnectDelay: TypeValidators.numberWithMin(1) },
+ * });
+ * ```
+ */
+function arrayOf(discriminant, validatorsByType) {
+    return {
+        is: (u) => Array.isArray(u),
+        getType: () => 'array',
+        validate(value, name, logger) {
+            if (!Array.isArray(value)) {
+                logger?.warn(jsSdkCommon.OptionMessages.wrongOptionType(name, 'array', typeof value));
+                return undefined;
+            }
+            const results = [];
+            value.forEach((item, i) => {
+                const itemPath = `${name}[${i}]`;
+                if (jsSdkCommon.isNullish(item) || !jsSdkCommon.TypeValidators.Object.is(item)) {
+                    logger?.warn(jsSdkCommon.OptionMessages.wrongOptionType(itemPath, 'object', typeof item));
+                    return;
+                }
+                const obj = item;
+                const typeValue = obj[discriminant];
+                const validators = typeof typeValue === 'string' ? validatorsByType[typeValue] : undefined;
+                if (!validators) {
+                    const expected = Object.keys(validatorsByType).join(' | ');
+                    const received = typeof typeValue === 'string' ? typeValue : typeof typeValue;
+                    logger?.warn(jsSdkCommon.OptionMessages.wrongOptionType(`${itemPath}.${discriminant}`, expected, received));
+                    return;
+                }
+                results.push(validateOptions(obj, validators, {}, logger, itemPath));
+            });
+            return { value: results };
+        },
+    };
+}
 /**
  * Creates a validator that tries each provided validator in order and uses the
  * first one whose `is()` check passes. For compound validators the value is
@@ -339,38 +403,151 @@ function anyOf(...validators) {
         },
     };
 }
+/**
+ * Creates a validator for objects with dynamic keys. Each key in the input
+ * object is checked against `keyValidator`; unrecognized keys produce a
+ * warning. Each value is validated by `valueValidator`. Defaults for
+ * individual entries are passed through from the parent so partial overrides
+ * preserve non-overridden entries.
+ *
+ * @param keyValidator - Validates that each key is an allowed value.
+ * @param valueValidator - Validates each value in the record.
+ * @param options - Optional configuration.
+ * @param options.defaults - Built-in defaults for the record entries. When
+ *   provided, takes priority over defaults passed from the parent at
+ *   validation time (same precedence as {@link validatorOf}).
+ *
+ * @example
+ * ```ts
+ * // Validates a record like { streaming: { ... }, polling: { ... } }
+ * // where keys must be valid connection modes:
+ * recordOf(
+ *   TypeValidators.oneOf('streaming', 'polling', 'offline'),
+ *   validatorOf({ initializers: arrayValidator, synchronizers: arrayValidator }),
+ * )
+ * ```
+ */
+function recordOf(keyValidator, valueValidator, options) {
+    const builtInDefaults = options?.defaults;
+    return {
+        is: (u) => jsSdkCommon.TypeValidators.Object.is(u),
+        getType: () => 'object',
+        validate(value, name, logger, defaults) {
+            if (jsSdkCommon.isNullish(value)) {
+                return undefined;
+            }
+            if (!jsSdkCommon.TypeValidators.Object.is(value)) {
+                logger?.warn(jsSdkCommon.OptionMessages.wrongOptionType(name, 'object', typeof value));
+                return undefined;
+            }
+            // Filter invalid keys, then delegate to validateOptions.
+            const obj = value;
+            const filtered = {};
+            const validatorMap = {};
+            Object.keys(obj).forEach((key) => {
+                if (keyValidator.is(key)) {
+                    filtered[key] = obj[key];
+                    validatorMap[key] = valueValidator;
+                }
+                else {
+                    logger?.warn(jsSdkCommon.OptionMessages.wrongOptionType(name, keyValidator.getType(), key));
+                }
+            });
+            const recordDefaults = builtInDefaults ??
+                (jsSdkCommon.TypeValidators.Object.is(defaults) ? defaults : {});
+            return { value: validateOptions(filtered, validatorMap, recordDefaults, logger, name) };
+        },
+    };
+}
 
+const DEFAULT_FDV1_FALLBACK_POLL_INTERVAL_SECONDS = 300;
+const BACKGROUND_POLL_INTERVAL_SECONDS = 3600;
 const dataSourceTypeValidator = jsSdkCommon.TypeValidators.oneOf('cache', 'polling', 'streaming');
 const connectionModeValidator = jsSdkCommon.TypeValidators.oneOf('streaming', 'polling', 'offline', 'one-shot', 'background');
 const endpointValidators = {
     pollingBaseUri: jsSdkCommon.TypeValidators.String,
     streamingBaseUri: jsSdkCommon.TypeValidators.String,
 };
-({
+const cacheEntryValidators = {
+    type: dataSourceTypeValidator,
+};
+const pollingEntryValidators = {
     type: dataSourceTypeValidator,
     pollInterval: jsSdkCommon.TypeValidators.numberWithMin(30),
     endpoints: validatorOf(endpointValidators),
-});
-({
+};
+const streamingEntryValidators = {
     type: dataSourceTypeValidator,
     initialReconnectDelay: jsSdkCommon.TypeValidators.numberWithMin(1),
     endpoints: validatorOf(endpointValidators),
+};
+const initializerEntryArrayValidator = arrayOf('type', {
+    cache: cacheEntryValidators,
+    polling: pollingEntryValidators,
+    streaming: streamingEntryValidators,
+});
+const synchronizerEntryArrayValidator = arrayOf('type', {
+    polling: pollingEntryValidators,
+    streaming: streamingEntryValidators,
 });
+const fdv1FallbackValidators = {
+    pollInterval: jsSdkCommon.TypeValidators.numberWithMin(30),
+    endpoints: validatorOf(endpointValidators),
+};
+const modeDefinitionValidators = {
+    initializers: initializerEntryArrayValidator,
+    synchronizers: synchronizerEntryArrayValidator,
+    fdv1Fallback: validatorOf(fdv1FallbackValidators),
+};
+const MODE_TABLE = {
+    streaming: {
+        initializers: [{ type: 'cache' }, { type: 'polling' }],
+        synchronizers: [{ type: 'streaming' }, { type: 'polling' }],
+        fdv1Fallback: { pollInterval: DEFAULT_FDV1_FALLBACK_POLL_INTERVAL_SECONDS },
+    },
+    polling: {
+        initializers: [{ type: 'cache' }],
+        synchronizers: [{ type: 'polling' }],
+        fdv1Fallback: { pollInterval: DEFAULT_FDV1_FALLBACK_POLL_INTERVAL_SECONDS },
+    },
+    offline: {
+        initializers: [{ type: 'cache' }],
+        synchronizers: [],
+    },
+    'one-shot': {
+        initializers: [{ type: 'cache' }, { type: 'polling' }, { type: 'streaming' }],
+        synchronizers: [],
+    },
+    background: {
+        initializers: [{ type: 'cache' }],
+        synchronizers: [{ type: 'polling', pollInterval: BACKGROUND_POLL_INTERVAL_SECONDS }],
+        fdv1Fallback: { pollInterval: BACKGROUND_POLL_INTERVAL_SECONDS },
+    },
+};
+const connectionModesValidator = recordOf(connectionModeValidator, validatorOf(modeDefinitionValidators));
 
-const modeSwitchingValidators = {
+function hasType(u, type) {
+    return jsSdkCommon.TypeValidators.Object.is(u) && u.type === type;
+}
+const automaticModeValidators = {
+    type: jsSdkCommon.TypeValidators.oneOf('automatic'),
     lifecycle: jsSdkCommon.TypeValidators.Boolean,
     network: jsSdkCommon.TypeValidators.Boolean,
 };
-const dataSystemValidators = {
+const manualModeValidators = {
+    type: jsSdkCommon.TypeValidators.oneOf('manual'),
     initialConnectionMode: connectionModeValidator,
+};
+const dataSystemValidators = {
     backgroundConnectionMode: connectionModeValidator,
-    automaticModeSwitching: anyOf(jsSdkCommon.TypeValidators.Boolean, validatorOf(modeSwitchingValidators)),
+    automaticModeSwitching: anyOf(jsSdkCommon.TypeValidators.Boolean, validatorOf(automaticModeValidators, { is: (u) => hasType(u, 'automatic') }), validatorOf(manualModeValidators, { is: (u) => hasType(u, 'manual') })),
+    connectionModes: connectionModesValidator,
 };
 /**
  * Default FDv2 data system configuration for browser SDKs.
  */
 const BROWSER_DATA_SYSTEM_DEFAULTS = {
-    initialConnectionMode: 'one-shot',
+    foregroundConnectionMode: 'one-shot',
     backgroundConnectionMode: undefined,
     automaticModeSwitching: false,
 };
@@ -378,7 +555,7 @@ const BROWSER_DATA_SYSTEM_DEFAULTS = {
  * Default FDv2 data system configuration for mobile (React Native) SDKs.
  */
 const MOBILE_DATA_SYSTEM_DEFAULTS = {
-    initialConnectionMode: 'streaming',
+    foregroundConnectionMode: 'streaming',
     backgroundConnectionMode: 'background',
     automaticModeSwitching: true,
 };
@@ -386,10 +563,24 @@ const MOBILE_DATA_SYSTEM_DEFAULTS = {
  * Default FDv2 data system configuration for desktop SDKs (Electron, etc.).
  */
 const DESKTOP_DATA_SYSTEM_DEFAULTS = {
-    initialConnectionMode: 'streaming',
+    foregroundConnectionMode: 'streaming',
     backgroundConnectionMode: undefined,
     automaticModeSwitching: false,
 };
+function isManualModeSwitching(value) {
+    return typeof value === 'object' && value !== null && 'type' in value && value.type === 'manual';
+}
+/**
+ * Resolve the foreground connection mode from a validated data system config
+ * and platform defaults. Uses the mode from `ManualModeSwitching` when present,
+ * otherwise falls back to the platform default.
+ */
+function resolveForegroundMode(dataSystem, defaults) {
+    if (isManualModeSwitching(dataSystem.automaticModeSwitching)) {
+        return dataSystem.automaticModeSwitching.initialConnectionMode;
+    }
+    return dataSystem.foregroundConnectionMode ?? defaults.foregroundConnectionMode;
+}
 
 function createValidators(options) {
     return {
@@ -419,7 +610,12 @@ function createValidators(options) {
         inspectors: jsSdkCommon.TypeValidators.createTypeArray('LDInspection', {}),
         cleanOldPersistentData: jsSdkCommon.TypeValidators.Boolean,
         dataSystem: options?.dataSystemDefaults
-            ? validatorOf(dataSystemValidators, options.dataSystemDefaults)
+            ? validatorOf(dataSystemValidators, {
+                defaults: {
+                    ...options.dataSystemDefaults,
+                    connectionModes: MODE_TABLE,
+                },
+            })
             : jsSdkCommon.TypeValidators.Object,
     };
 }
@@ -836,6 +1032,33 @@ async function hashContext(crypto, context) {
     }
     return digest(crypto.createHash('sha256').update(json), 'base64');
 }
+/**
+ * Reads the freshness timestamp from storage for the given context.
+ *
+ * Returns `undefined` if no freshness record exists, the data is corrupt,
+ * or the context attributes have changed since the freshness was recorded.
+ */
+async function readFreshness(storage, crypto, environmentNamespace, context, logger) {
+    const contextStorageKey = await namespaceForContextData(crypto, environmentNamespace, context);
+    const json = await storage.get(`${contextStorageKey}${FRESHNESS_SUFFIX}`);
+    if (json === null || json === undefined) {
+        return undefined;
+    }
+    try {
+        const record = JSON.parse(json);
+        const currentHash = await hashContext(crypto, context);
+        if (currentHash === undefined || record.contextHash !== currentHash) {
+            return undefined;
+        }
+        return typeof record.timestamp === 'number' && !Number.isNaN(record.timestamp)
+            ? record.timestamp
+            : undefined;
+    }
+    catch (e) {
+        logger?.warn(`Could not read freshness data from persistent storage: ${e.message}`);
+        return undefined;
+    }
+}
 
 function isValidFlag(value) {
     return value !== null && typeof value === 'object' && typeof value.version === 'number';
@@ -989,6 +1212,19 @@ class FlagPersistence {
         }
         return false;
     }
+    /**
+     * Applies a changeset to the flag store.
+     * - `'full'`: replaces all flags via {@link FlagUpdater.init}.
+     * - `'partial'`: upserts individual flags via {@link FlagUpdater.upsert}.
+     * - `'none'`: no flag changes, only persists cache to update freshness.
+     *
+     * Always persists to cache afterwards, which updates the freshness timestamp
+     * even when no flags change (e.g., transfer-none).
+     */
+    async applyChanges(context, updates, type) {
+        this._flagUpdater.applyChanges(context, updates, type);
+        await this._storeCache(context);
+    }
     /**
      * Loads the flags from persistence for the provided context and gives those to the
      * {@link FlagUpdater} this {@link FlagPersistence} was constructed with.
@@ -1112,6 +1348,16 @@ function createDefaultFlagStore() {
         getAll() {
             return flags;
         },
+        applyChanges(updates, type) {
+            if (type === 'full') {
+                this.init(updates);
+            }
+            else if (type === 'partial') {
+                Object.entries(updates).forEach(([key, descriptor]) => {
+                    flags[key] = descriptor;
+                });
+            }
+        },
     };
 }
 
@@ -1169,6 +1415,24 @@ function createFlagUpdater(_flagStore, _logger) {
             }
             this.init(context, newFlags);
         },
+        applyChanges(context, updates, type) {
+            activeContext = context;
+            const oldFlags = flagStore.getAll();
+            flagStore.applyChanges(updates, type);
+            if (type === 'full') {
+                const changed = calculateChangedKeys(oldFlags, updates);
+                if (changed.length > 0) {
+                    this.handleFlagChanges(changed, 'init');
+                }
+            }
+            else if (type === 'partial') {
+                const keys = Object.keys(updates);
+                if (keys.length > 0) {
+                    this.handleFlagChanges(keys, 'patch');
+                }
+            }
+            // 'none' — no flag changes, caller handles freshness.
+        },
         upsert(context, key, item) {
             if (activeContext?.canonicalKey !== context.canonicalKey) {
                 logger.warn('Received an update for an inactive context.');
@@ -1248,6 +1512,9 @@ class DefaultFlagManager {
     async loadCached(context) {
         return (await this._flagPersistencePromise).loadCached(context);
     }
+    async applyChanges(context, updates, type) {
+        return (await this._flagPersistencePromise).applyChanges(context, updates, type);
+    }
     on(callback) {
         this._flagUpdater.on(callback);
     }
@@ -2844,6 +3111,1992 @@ const DESKTOP_TRANSITION_TABLE = [
     { conditions: {}, mode: { configured: 'foreground' } },
 ];
 
+/**
+ * Creates a change set result containing processed flag data.
+ */
+function changeSet(payload, fdv1Fallback, environmentId, freshness) {
+    return { type: 'changeSet', payload, fdv1Fallback, environmentId, freshness };
+}
+/**
+ * Creates an interrupted status result. Indicates a transient error; the
+ * synchronizer will attempt to recover automatically.
+ *
+ * When used with an initializer, this is still a terminal state.
+ */
+function interrupted(errorInfo, fdv1Fallback) {
+    return { type: 'status', state: 'interrupted', errorInfo, fdv1Fallback };
+}
+/**
+ * Creates a shutdown status result. Indicates the data source was closed
+ * gracefully and will not produce any further results.
+ */
+function shutdown() {
+    return { type: 'status', state: 'shutdown', fdv1Fallback: false };
+}
+/**
+ * Creates a terminal error status result. Indicates an unrecoverable error;
+ * the data source will not produce any further results.
+ */
+function terminalError(errorInfo, fdv1Fallback) {
+    return { type: 'status', state: 'terminal_error', errorInfo, fdv1Fallback };
+}
+/**
+ * Creates a goodbye status result. Indicates the server has instructed the
+ * client to disconnect.
+ */
+function goodbye(reason, fdv1Fallback) {
+    return { type: 'status', state: 'goodbye', reason, fdv1Fallback };
+}
+/**
+ * Helper to create a {@link DataSourceStatusErrorInfo} from an HTTP status code.
+ */
+function errorInfoFromHttpError(statusCode) {
+    return {
+        kind: jsSdkCommon.DataSourceErrorKind.ErrorResponse,
+        message: `Unexpected status code: ${statusCode}`,
+        statusCode,
+        time: Date.now(),
+    };
+}
+/**
+ * Helper to create a {@link DataSourceStatusErrorInfo} from a network error.
+ */
+function errorInfoFromNetworkError(message) {
+    return {
+        kind: jsSdkCommon.DataSourceErrorKind.NetworkError,
+        message,
+        time: Date.now(),
+    };
+}
+/**
+ * Helper to create a {@link DataSourceStatusErrorInfo} from invalid data.
+ */
+function errorInfoFromInvalidData(message) {
+    return {
+        kind: jsSdkCommon.DataSourceErrorKind.InvalidData,
+        message,
+        time: Date.now(),
+    };
+}
+/**
+ * Helper to create a {@link DataSourceStatusErrorInfo} for unknown errors.
+ */
+function errorInfoFromUnknown(message) {
+    return {
+        kind: jsSdkCommon.DataSourceErrorKind.Unknown,
+        message,
+        time: Date.now(),
+    };
+}
+
+/**
+ * Strips the `version` field from a stored {@link Flag} to produce the
+ * `FlagEvaluationResult` shape expected in an FDv2 `Update.object`.
+ *
+ * The version is carried on the `Update` envelope, not on the object itself.
+ */
+function flagToEvaluationResult(flag) {
+    // eslint-disable-next-line @typescript-eslint/no-unused-vars
+    const { version, ...evalResult } = flag;
+    return evalResult;
+}
+/**
+ * Reads cached flag data and freshness from platform storage and returns
+ * them as an {@link FDv2SourceResult}.
+ */
+async function loadFromCache(config) {
+    const { storage, crypto, environmentNamespace, context, logger } = config;
+    if (!storage) {
+        logger?.debug('No storage available for cache initializer');
+        return interrupted(errorInfoFromUnknown('No storage available'), false);
+    }
+    const cached = await loadCachedFlags(storage, crypto, environmentNamespace, context, logger);
+    if (!cached) {
+        logger?.debug('Cache miss for context');
+        return interrupted(errorInfoFromUnknown('Cache miss'), false);
+    }
+    const updates = Object.entries(cached.flags).map(([key, flag]) => ({
+        kind: 'flag-eval',
+        key,
+        version: flag.version,
+        object: flagToEvaluationResult(flag),
+    }));
+    const payload = {
+        version: 0,
+        // No `state` field. The orchestrator sees a changeSet without a selector,
+        // records dataReceived=true, and continues to the next initializer.
+        type: 'full',
+        updates,
+    };
+    const freshness = await readFreshness(storage, crypto, environmentNamespace, context, logger);
+    logger?.debug('Loaded cached flag evaluations via cache initializer');
+    return changeSet(payload, false, undefined, freshness);
+}
+/**
+ * Creates an {@link InitializerFactory} that produces cache initializers.
+ *
+ * The cache initializer reads flag data and freshness from persistent storage
+ * for the given context and returns them as a changeSet without a selector.
+ * This allows the orchestrator to provide cached data immediately while
+ * continuing to the next initializer for network-verified data.
+ *
+ * Per spec Requirement 4.1.2, the payload has `persist=false` semantics
+ * (no selector) so the consuming layer should not re-persist it.
+ *
+ * @internal
+ */
+function createCacheInitializerFactory(config) {
+    // The selectorGetter is ignored — cache data has no selector.
+    return (_selectorGetter) => {
+        let shutdownResolve;
+        const shutdownPromise = new Promise((resolve) => {
+            shutdownResolve = resolve;
+        });
+        return {
+            async run() {
+                return Promise.race([shutdownPromise, loadFromCache(config)]);
+            },
+            close() {
+                shutdownResolve?.(shutdown());
+                shutdownResolve = undefined;
+            },
+        };
+    };
+}
+
+/**
+ * Creates an {@link FDv2Requestor} for client-side FDv2 polling.
+ *
+ * @param plainContextString The JSON-serialized evaluation context.
+ * @param serviceEndpoints Service endpoint configuration.
+ * @param paths FDv2 polling endpoint paths.
+ * @param requests Platform HTTP abstraction.
+ * @param encoding Platform encoding abstraction.
+ * @param baseHeaders Default HTTP headers (e.g. authorization).
+ * @param baseQueryParams Additional query parameters to include on every request.
+ * @param usePost If true, use POST with context in body instead of GET with
+ *   context in URL path.
+ */
+function makeFDv2Requestor(plainContextString, serviceEndpoints, paths, requests, encoding, baseHeaders, baseQueryParams, usePost) {
+    const headers = { ...baseHeaders };
+    let body;
+    let method = 'GET';
+    let path;
+    if (usePost) {
+        method = 'POST';
+        headers['content-type'] = 'application/json';
+        body = plainContextString;
+        path = paths.pathPost(encoding, plainContextString);
+    }
+    else {
+        path = paths.pathGet(encoding, plainContextString);
+    }
+    return {
+        async poll(basis) {
+            const parameters = [...(baseQueryParams ?? [])];
+            // Intentionally falsy check: an empty string basis must not be sent as
+            // a query parameter, since it does not represent a valid selector.
+            if (basis) {
+                parameters.push({ key: 'basis', value: basis });
+            }
+            const uri = jsSdkCommon.getPollingUri(serviceEndpoints, path, parameters);
+            const res = await requests.fetch(uri, {
+                method,
+                headers,
+                body,
+            });
+            const responseBody = res.status === 304 ? null : await res.text();
+            return {
+                status: res.status,
+                headers: res.headers,
+                body: responseBody,
+            };
+        },
+    };
+}
+
+/**
+ * ObjProcessor for the `flag-eval` object kind. Used by the protocol handler to
+ * process objects received in `put-object` events.
+ *
+ * Client-side evaluation results are already in their final form (pre-evaluated
+ * by the server), so no transformation is needed — this is a passthrough.
+ */
+function processFlagEval(object) {
+    return object;
+}
+/**
+ * Converts an FDv2 {@link internal.Update} with `kind: 'flag-eval'` into an
+ * {@link ItemDescriptor} suitable for {@link FlagManager}.
+ *
+ * For put updates the envelope `version` is used as the {@link ItemDescriptor.version}
+ * and as {@link Flag.version}. The rest of the fields are spread from the
+ * {@link FlagEvaluationResult} object.
+ *
+ * For delete updates a tombstone descriptor is created with `deleted: true`.
+ */
+function flagEvalUpdateToItemDescriptor(update) {
+    if (update.deleted) {
+        return {
+            version: update.version,
+            flag: {
+                version: update.version,
+                deleted: true,
+                value: undefined,
+                trackEvents: false,
+            },
+        };
+    }
+    const evalResult = update.object;
+    return {
+        version: update.version,
+        flag: {
+            ...evalResult,
+            version: update.version,
+        },
+    };
+}
+/**
+ * Converts an array of FDv2 payload updates into a map of flag key to
+ * {@link ItemDescriptor}. Only `flag-eval` kind updates are processed;
+ * unrecognized kinds are silently ignored.
+ */
+function flagEvalPayloadToItemDescriptors(updates) {
+    const descriptors = {};
+    updates.forEach((update) => {
+        if (update.kind === 'flag-eval') {
+            descriptors[update.key] = flagEvalUpdateToItemDescriptor(update);
+        }
+    });
+    return descriptors;
+}
+
+function getFallback(headers) {
+    const value = headers.get('x-ld-fd-fallback');
+    return value !== null && value.toLowerCase() === 'true';
+}
+function getEnvironmentId(headers) {
+    return headers.get('x-ld-envid') ?? undefined;
+}
+/**
+ * Process FDv2 events using the protocol handler directly.
+ *
+ * We use `createProtocolHandler` rather than `PayloadProcessor` because
+ * the PayloadProcessor does not surface goodbye/serverError actions —
+ * it only forwards payloads and actionable errors. For polling results,
+ * we need full control over all protocol action types.
+ */
+function processEvents(events, fdv1Fallback, environmentId, logger) {
+    const handler = jsSdkCommon.internal.createProtocolHandler({
+        'flag-eval': processFlagEval,
+    }, logger);
+    let earlyResult;
+    events.forEach((event) => {
+        if (earlyResult) {
+            return;
+        }
+        const action = handler.processEvent(event);
+        switch (action.type) {
+            case 'payload':
+                earlyResult = changeSet(action.payload, fdv1Fallback, environmentId);
+                break;
+            case 'goodbye':
+                earlyResult = goodbye(action.reason, fdv1Fallback);
+                break;
+            case 'serverError': {
+                const errorInfo = errorInfoFromUnknown(action.reason);
+                logger?.error(`Server error during polling: ${action.reason}`);
+                earlyResult = interrupted(errorInfo, fdv1Fallback);
+                break;
+            }
+            case 'error': {
+                // Actionable protocol errors (MISSING_PAYLOAD, PROTOCOL_ERROR)
+                if (action.kind === 'MISSING_PAYLOAD' || action.kind === 'PROTOCOL_ERROR') {
+                    const errorInfo = errorInfoFromInvalidData(action.message);
+                    logger?.warn(`Protocol error during polling: ${action.message}`);
+                    earlyResult = interrupted(errorInfo, fdv1Fallback);
+                }
+                else {
+                    // Non-actionable errors (UNKNOWN_EVENT) are logged but don't stop processing
+                    logger?.warn(action.message);
+                }
+                break;
+            }
+        }
+    });
+    if (earlyResult) {
+        return earlyResult;
+    }
+    // Events didn't produce a result
+    const errorInfo = errorInfoFromUnknown('Unexpected end of polling response');
+    logger?.error('Unexpected end of polling response');
+    return interrupted(errorInfo, fdv1Fallback);
+}
+/**
+ * Performs a single FDv2 poll request, processes the protocol response, and
+ * returns an {@link FDv2SourceResult}.
+ *
+ * Recoverable errors produce interrupted results; unrecoverable HTTP errors
+ * produce terminal errors.
+ *
+ * @internal
+ */
+async function poll(requestor, basis, logger) {
+    let fdv1Fallback = false;
+    let environmentId;
+    try {
+        const response = await requestor.poll(basis);
+        fdv1Fallback = getFallback(response.headers);
+        environmentId = getEnvironmentId(response.headers);
+        // 304 Not Modified: treat as server-intent with intentCode 'none'
+        // (Spec Requirement 10.1.2)
+        if (response.status === 304) {
+            const nonePayload = {
+                version: 0,
+                type: 'none',
+                updates: [],
+            };
+            return changeSet(nonePayload, fdv1Fallback, environmentId);
+        }
+        // Non-success HTTP status
+        if (response.status < 200 || response.status >= 300) {
+            const errorInfo = errorInfoFromHttpError(response.status);
+            logger?.error(`Polling request failed with HTTP error: ${response.status}`);
+            const recoverable = response.status <= 0 || jsSdkCommon.isHttpRecoverable(response.status);
+            return recoverable
+                ? interrupted(errorInfo, fdv1Fallback)
+                : terminalError(errorInfo, fdv1Fallback);
+        }
+        // Successful response — process FDv2 events
+        if (!response.body) {
+            const errorInfo = errorInfoFromInvalidData('Empty response body');
+            logger?.error('Polling request received empty response body');
+            return interrupted(errorInfo, fdv1Fallback);
+        }
+        let parsed;
+        try {
+            parsed = JSON.parse(response.body);
+        }
+        catch {
+            const errorInfo = errorInfoFromInvalidData('Malformed JSON data in polling response');
+            logger?.error('Polling request received malformed data');
+            return interrupted(errorInfo, fdv1Fallback);
+        }
+        if (!Array.isArray(parsed.events)) {
+            const errorInfo = errorInfoFromInvalidData('Invalid polling response: missing or invalid events array');
+            logger?.error('Polling response does not contain a valid events array');
+            return interrupted(errorInfo, fdv1Fallback);
+        }
+        return processEvents(parsed.events, fdv1Fallback, environmentId, logger);
+    }
+    catch (err) {
+        // Network or other I/O error from the fetch itself
+        const message = err?.message ?? String(err);
+        logger?.error(`Polling request failed with network error: ${message}`);
+        const errorInfo = errorInfoFromNetworkError(message);
+        return interrupted(errorInfo, fdv1Fallback);
+    }
+}
+
+const SHUTDOWN = Symbol('shutdown');
+/**
+ * Creates a polling initializer that performs an FDv2 poll request with
+ * retry logic. Retries up to 3 times on recoverable errors with a 1-second
+ * delay between attempts.
+ *
+ * Unrecoverable errors (401, 403, etc.) are returned immediately as terminal
+ * errors. After exhausting retries on recoverable errors, the result is
+ * converted to a terminal error.
+ *
+ * If `close()` is called during a poll or retry delay, the result will be
+ * a shutdown status.
+ *
+ * @internal
+ */
+function createPollingInitializer(requestor, logger, selectorGetter) {
+    let shutdownResolve;
+    const shutdownPromise = new Promise((resolve) => {
+        shutdownResolve = resolve;
+    });
+    return {
+        async run() {
+            const maxRetries = 3;
+            const retryDelayMs = 1000;
+            const selector = selectorGetter();
+            let lastResult;
+            for (let attempt = 0; attempt <= maxRetries; attempt += 1) {
+                // eslint-disable-next-line no-await-in-loop
+                const result = await Promise.race([shutdownPromise, poll(requestor, selector, logger)]);
+                if (result === SHUTDOWN) {
+                    return shutdown();
+                }
+                if (result.type === 'changeSet') {
+                    return result;
+                }
+                // Non-retryable status (terminal_error, goodbye) -> return immediately
+                if (result.state !== 'interrupted') {
+                    return result;
+                }
+                // Recoverable error — save and potentially retry
+                lastResult = result;
+                if (attempt < maxRetries) {
+                    logger?.warn(`Recoverable polling error (attempt ${attempt + 1}/${maxRetries + 1}), retrying in ${retryDelayMs}ms...`);
+                    // eslint-disable-next-line no-await-in-loop
+                    const sleepResult = await Promise.race([shutdownPromise, jsSdkCommon.sleep(retryDelayMs)]);
+                    if (sleepResult === SHUTDOWN) {
+                        return shutdown();
+                    }
+                }
+            }
+            // Convert final interrupted -> terminal_error
+            const status = lastResult;
+            return terminalError(status.errorInfo, status.fdv1Fallback);
+        },
+        close() {
+            shutdownResolve?.(SHUTDOWN);
+            shutdownResolve = undefined;
+        },
+    };
+}
+
+/**
+ * Creates a new {@link AsyncQueue}.
+ *
+ * @internal
+ */
+function createAsyncQueue() {
+    const items = [];
+    const waiters = [];
+    return {
+        put(item) {
+            const waiter = waiters.shift();
+            if (waiter) {
+                waiter(item);
+            }
+            else {
+                items.push(item);
+            }
+        },
+        take() {
+            if (items.length > 0) {
+                return Promise.resolve(items.shift());
+            }
+            return new Promise((resolve) => {
+                waiters.push(resolve);
+            });
+        },
+    };
+}
+
+/**
+ * Creates a continuous polling synchronizer that periodically polls for FDv2
+ * data and yields results via successive calls to `next()`.
+ *
+ * The first poll fires immediately. Subsequent polls are scheduled using
+ * `setTimeout` after each poll completes, ensuring sequential execution and
+ * preventing overlapping requests on slow networks.
+ *
+ * Results are buffered in an async queue. On terminal errors, polling stops
+ * and the shutdown future is resolved. On `close()`, polling stops and the
+ * next `next()` call returns a shutdown result.
+ *
+ * @internal
+ */
+function createPollingSynchronizer(requestor, logger, selectorGetter, pollIntervalMs) {
+    const resultQueue = createAsyncQueue();
+    let shutdownResolve;
+    const shutdownPromise = new Promise((resolve) => {
+        shutdownResolve = resolve;
+    });
+    let timeoutHandle;
+    let stopped = false;
+    async function doPoll() {
+        if (stopped) {
+            return;
+        }
+        const startTime = Date.now();
+        try {
+            const result = await poll(requestor, selectorGetter(), logger);
+            if (stopped) {
+                return;
+            }
+            let shouldShutdown = false;
+            if (result.type === 'status') {
+                switch (result.state) {
+                    case 'terminal_error':
+                        stopped = true;
+                        shouldShutdown = true;
+                        break;
+                    case 'interrupted':
+                    case 'goodbye':
+                        // Continue polling on transient errors and goodbyes
+                        break;
+                    case 'shutdown':
+                        // The base poll function doesn't emit shutdown; we handle it
+                        // at this level via close().
+                        break;
+                    default:
+                        break;
+                }
+            }
+            if (shouldShutdown) {
+                shutdownResolve?.(result);
+                shutdownResolve = undefined;
+            }
+            else {
+                resultQueue.put(result);
+            }
+        }
+        catch (err) {
+            logger?.debug(`Polling error: ${err}`);
+        }
+        // Schedule next poll after completion, accounting for elapsed time.
+        // This ensures sequential execution — no overlapping requests.
+        if (!stopped) {
+            const elapsed = Date.now() - startTime;
+            const sleepFor = Math.min(Math.max(pollIntervalMs - elapsed, 0), pollIntervalMs);
+            timeoutHandle = setTimeout(() => {
+                doPoll();
+            }, sleepFor);
+        }
+    }
+    // Start polling immediately
+    doPoll();
+    return {
+        async next() {
+            return Promise.race([shutdownPromise, resultQueue.take()]);
+        },
+        close() {
+            stopped = true;
+            if (timeoutHandle !== undefined) {
+                clearTimeout(timeoutHandle);
+                timeoutHandle = undefined;
+            }
+            shutdownResolve?.(shutdown());
+            shutdownResolve = undefined;
+        },
+    };
+}
+
+/**
+ * Creates a {@link SynchronizerSlot}.
+ *
+ * @param factory The synchronizer factory function.
+ * @param options Optional configuration.
+ * @param options.isFDv1Fallback Whether this slot is the FDv1 fallback adapter.
+ *   FDv1 slots start `'blocked'` by default.
+ * @param options.initialState Override the initial state (defaults to
+ *   `'blocked'` for FDv1 slots, `'available'` otherwise).
+ */
+function createSynchronizerSlot(factory, options) {
+    const isFDv1Fallback = options?.isFDv1Fallback ?? false;
+    const state = options?.initialState ?? (isFDv1Fallback ? 'blocked' : 'available');
+    return { factory, isFDv1Fallback, state };
+}
+/**
+ * Creates a {@link SourceManager} that coordinates initializer and
+ * synchronizer lifecycle.
+ *
+ * @param initializerFactories Ordered list of initializer factories.
+ * @param synchronizerSlots Ordered list of synchronizer slots with state.
+ * @param selectorGetter Closure that returns the current selector string.
+ */
+function createSourceManager(initializerFactories, synchronizerSlots, selectorGetter) {
+    let activeSource;
+    let initializerIndex = -1;
+    let synchronizerIndex = -1;
+    let isShutdown = false;
+    function closeActiveSource() {
+        if (activeSource) {
+            activeSource.close();
+            activeSource = undefined;
+        }
+    }
+    function findFirstAvailableIndex() {
+        return synchronizerSlots.findIndex((slot) => slot.state === 'available');
+    }
+    return {
+        get isShutdown() {
+            return isShutdown;
+        },
+        getNextInitializerAndSetActive() {
+            if (isShutdown) {
+                return undefined;
+            }
+            initializerIndex += 1;
+            if (initializerIndex >= initializerFactories.length) {
+                return undefined;
+            }
+            closeActiveSource();
+            const initializer = initializerFactories[initializerIndex](selectorGetter);
+            activeSource = initializer;
+            return initializer;
+        },
+        getNextAvailableSynchronizerAndSetActive() {
+            if (isShutdown || synchronizerSlots.length === 0) {
+                return undefined;
+            }
+            // Scan all slots starting from the position after the current one,
+            // wrapping around to the beginning if needed. This matches the Java
+            // SourceManager behavior where synchronizers cycle rather than exhausting.
+            let visited = 0;
+            while (visited < synchronizerSlots.length) {
+                synchronizerIndex += 1;
+                if (synchronizerIndex >= synchronizerSlots.length) {
+                    synchronizerIndex = 0;
+                }
+                const candidate = synchronizerSlots[synchronizerIndex];
+                if (candidate.state === 'available') {
+                    closeActiveSource();
+                    const synchronizer = candidate.factory(selectorGetter);
+                    activeSource = synchronizer;
+                    return synchronizer;
+                }
+                visited += 1;
+            }
+            return undefined;
+        },
+        blockCurrentSynchronizer() {
+            if (synchronizerIndex >= 0 && synchronizerIndex < synchronizerSlots.length) {
+                // eslint-disable-next-line no-param-reassign
+                synchronizerSlots[synchronizerIndex].state = 'blocked';
+            }
+        },
+        resetSourceIndex() {
+            synchronizerIndex = -1;
+        },
+        fdv1Fallback() {
+            synchronizerSlots.forEach((slot) => {
+                // eslint-disable-next-line no-param-reassign
+                slot.state = slot.isFDv1Fallback ? 'available' : 'blocked';
+            });
+            synchronizerIndex = -1;
+        },
+        isPrimeSynchronizer() {
+            return synchronizerIndex === findFirstAvailableIndex();
+        },
+        getAvailableSynchronizerCount() {
+            return synchronizerSlots.filter((slot) => slot.state === 'available').length;
+        },
+        hasFDv1Fallback() {
+            return synchronizerSlots.some((slot) => slot.isFDv1Fallback);
+        },
+        close() {
+            isShutdown = true;
+            closeActiveSource();
+        },
+    };
+}
+
+/**
+ * FDv2 event names to listen for on the EventSource. This must stay in sync
+ * with the `EventType` union defined in `@launchdarkly/js-sdk-common`'s
+ * `internal/fdv2/proto.ts`.
+ */
+const FDV2_EVENT_NAMES = [
+    'server-intent',
+    'put-object',
+    'delete-object',
+    'payload-transferred',
+    'goodbye',
+    'error',
+    'heart-beat',
+];
+/**
+ * Creates the core streaming base for FDv2 client-side data sources.
+ *
+ * Manages an EventSource connection, processes FDv2 protocol events using
+ * a protocol handler from the common package, detects FDv1 fallback signals,
+ * handles legacy ping events, and queues results for consumption by
+ * {@link createStreamingInitializer} or {@link createStreamingSynchronizer}.
+ *
+ * @internal
+ */
+function createStreamingBase(config) {
+    const resultQueue = createAsyncQueue();
+    const protocolHandler = jsSdkCommon.internal.createProtocolHandler({ 'flag-eval': processFlagEval }, config.logger);
+    const headers = { ...config.headers };
+    function buildStreamUri() {
+        const params = [...config.parameters];
+        const basis = config.selectorGetter?.();
+        if (basis) {
+            params.push({ key: 'basis', value: encodeURIComponent(basis) });
+        }
+        return jsSdkCommon.getStreamingUri(config.serviceEndpoints, config.streamUriPath, params);
+    }
+    let eventSource;
+    let connectionAttemptStartTime;
+    let fdv1Fallback = false;
+    let started = false;
+    let stopped = false;
+    function logConnectionAttempt() {
+        connectionAttemptStartTime = Date.now();
+    }
+    function logConnectionResult(success) {
+        if (connectionAttemptStartTime && config.diagnosticsManager) {
+            config.diagnosticsManager.recordStreamInit(connectionAttemptStartTime, !success, Date.now() - connectionAttemptStartTime);
+        }
+        connectionAttemptStartTime = undefined;
+    }
+    function handleAction(action) {
+        switch (action.type) {
+            case 'payload':
+                logConnectionResult(true);
+                resultQueue.put(changeSet(action.payload, fdv1Fallback));
+                break;
+            case 'goodbye':
+                resultQueue.put(goodbye(action.reason, fdv1Fallback));
+                break;
+            case 'serverError':
+                resultQueue.put(interrupted(errorInfoFromUnknown(action.reason), fdv1Fallback));
+                break;
+            case 'error':
+                // Only actionable errors are queued; informational ones (UNKNOWN_EVENT)
+                // are logged by the protocol handler.
+                if (action.kind === 'MISSING_PAYLOAD' || action.kind === 'PROTOCOL_ERROR') {
+                    resultQueue.put(interrupted(errorInfoFromInvalidData(action.message), fdv1Fallback));
+                }
+                break;
+        }
+    }
+    function handleError(err) {
+        // Check for FDv1 fallback header.
+        if (err.headers?.['x-ld-fd-fallback'] === 'true') {
+            fdv1Fallback = true;
+            logConnectionResult(false);
+            resultQueue.put(terminalError(errorInfoFromHttpError(err.status ?? 0), true));
+            return false;
+        }
+        if (!jsSdkCommon.shouldRetry(err)) {
+            config.logger?.error(jsSdkCommon.httpErrorMessage(err, 'streaming request'));
+            logConnectionResult(false);
+            resultQueue.put(terminalError(errorInfoFromHttpError(err.status ?? 0), fdv1Fallback));
+            return false;
+        }
+        config.logger?.warn(jsSdkCommon.httpErrorMessage(err, 'streaming request', 'will retry'));
+        logConnectionResult(false);
+        logConnectionAttempt();
+        resultQueue.put(interrupted(errorInfoFromHttpError(err.status ?? 0), fdv1Fallback));
+        return true;
+    }
+    function attachFDv2Listeners(es) {
+        FDV2_EVENT_NAMES.forEach((eventName) => {
+            es.addEventListener(eventName, (event) => {
+                if (stopped) {
+                    config.logger?.debug(`Received ${eventName} event after processor was closed. Skipping.`);
+                    return;
+                }
+                if (!event?.data) {
+                    // Some events (e.g. 'error') may legitimately arrive without a body.
+                    if (eventName !== 'error') {
+                        config.logger?.warn(`Event from EventStream missing data for "${eventName}".`);
+                    }
+                    return;
+                }
+                config.logger?.debug(`Received ${eventName} event`);
+                let parsed;
+                try {
+                    parsed = JSON.parse(event.data);
+                }
+                catch {
+                    config.logger?.error(`Stream received data that was unable to be parsed in "${eventName}" message`);
+                    config.logger?.debug(`Data follows: ${event.data}`);
+                    resultQueue.put(interrupted(errorInfoFromInvalidData('Malformed JSON in EventStream'), fdv1Fallback));
+                    return;
+                }
+                const action = protocolHandler.processEvent({ event: eventName, data: parsed });
+                handleAction(action);
+            });
+        });
+    }
+    function attachPingListener(es) {
+        es.addEventListener('ping', async () => {
+            if (stopped) {
+                config.logger?.debug('Ping received after processor was closed. Skipping.');
+                return;
+            }
+            config.logger?.debug('Got PING, going to poll LaunchDarkly for feature flag updates');
+            if (!config.pingHandler) {
+                config.logger?.warn('Ping event received but no ping handler configured.');
+                return;
+            }
+            try {
+                const result = await config.pingHandler.handlePing();
+                if (stopped) {
+                    config.logger?.debug('Ping completed after processor was closed. Skipping processing.');
+                    return;
+                }
+                resultQueue.put(result);
+            }
+            catch (err) {
+                if (stopped) {
+                    return;
+                }
+                config.logger?.error(`Error handling ping: ${err?.message ?? err}`);
+                resultQueue.put(interrupted(errorInfoFromNetworkError(err?.message ?? 'Error during ping poll'), fdv1Fallback));
+            }
+        });
+    }
+    return {
+        start() {
+            if (started || stopped) {
+                return;
+            }
+            started = true;
+            logConnectionAttempt();
+            const es = config.requests.createEventSource(buildStreamUri(), {
+                headers,
+                errorFilter: (error) => handleError(error),
+                initialRetryDelayMillis: config.initialRetryDelayMillis,
+                readTimeoutMillis: 5 * 60 * 1000,
+                retryResetIntervalMillis: 60 * 1000,
+                urlBuilder: buildStreamUri,
+            });
+            eventSource = es;
+            attachFDv2Listeners(es);
+            attachPingListener(es);
+            es.onclose = () => {
+                config.logger?.info('Closed LaunchDarkly stream connection');
+            };
+            es.onerror = (err) => {
+                if (stopped) {
+                    return;
+                }
+                if (err && typeof err.status === 'number') {
+                    // This condition will be handled by the error filter.
+                    return;
+                }
+                resultQueue.put(interrupted(errorInfoFromNetworkError(err?.message ?? 'IO Error'), fdv1Fallback));
+            };
+            es.onopen = () => {
+                config.logger?.info('Opened LaunchDarkly stream connection');
+                protocolHandler.reset();
+            };
+            es.onretrying = (e) => {
+                config.logger?.info(`Will retry stream connection in ${e.delayMillis} milliseconds`);
+            };
+        },
+        close() {
+            if (stopped) {
+                return;
+            }
+            stopped = true;
+            eventSource?.close();
+            eventSource = undefined;
+            resultQueue.put(shutdown());
+        },
+        takeResult() {
+            return resultQueue.take();
+        },
+    };
+}
+
+/**
+ * Creates a one-shot streaming initializer for FDv2.
+ *
+ * Connects to the FDv2 streaming endpoint, waits for the first result
+ * (a change set or an error status), then disconnects. Used in browser
+ * `one-shot` mode where a persistent connection is not desired.
+ *
+ * If `close()` is called before a result arrives, the returned promise
+ * resolves with a shutdown result.
+ *
+ * @param base - The streaming base that manages the EventSource connection.
+ * @internal
+ */
+function createStreamingInitializer(base) {
+    let closed = false;
+    let shutdownResolve;
+    const shutdownPromise = new Promise((resolve) => {
+        shutdownResolve = resolve;
+    });
+    return {
+        run() {
+            if (closed) {
+                return Promise.resolve(shutdown());
+            }
+            base.start();
+            return Promise.race([
+                base.takeResult().then((result) => {
+                    // Got our first result — close the connection.
+                    base.close();
+                    return result;
+                }),
+                shutdownPromise,
+            ]);
+        },
+        close() {
+            if (closed) {
+                return;
+            }
+            closed = true;
+            base.close();
+            shutdownResolve?.(shutdown());
+            shutdownResolve = undefined;
+        },
+    };
+}
+
+/**
+ * Creates a long-lived streaming synchronizer for FDv2.
+ *
+ * Maintains a persistent EventSource connection to the FDv2 streaming
+ * endpoint and produces a stream of results via the pull-based `next()`
+ * method. Used in streaming connection mode.
+ *
+ * The connection is started lazily on the first call to `next()`.
+ * On `close()`, the next call to `next()` returns a shutdown result.
+ *
+ * @param base - The streaming base that manages the EventSource connection.
+ * @internal
+ */
+function createStreamingSynchronizer(base) {
+    let started = false;
+    let closed = false;
+    let shutdownResolve;
+    const shutdownPromise = new Promise((resolve) => {
+        shutdownResolve = resolve;
+    });
+    return {
+        next() {
+            if (closed) {
+                return Promise.resolve(shutdown());
+            }
+            if (!started) {
+                started = true;
+                base.start();
+            }
+            return Promise.race([base.takeResult(), shutdownPromise]);
+        },
+        close() {
+            if (closed) {
+                return;
+            }
+            closed = true;
+            base.close();
+            shutdownResolve?.(shutdown());
+            shutdownResolve = undefined;
+        },
+    };
+}
+
+function createPingHandler(requestor, selectorGetter, logger) {
+    return {
+        handlePing: () => poll(requestor, selectorGetter(), logger),
+    };
+}
+/**
+ * Create a {@link ServiceEndpoints} with per-entry endpoint overrides applied.
+ * Returns the original endpoints if no overrides are specified.
+ */
+function resolveEndpoints(ctx, endpoints) {
+    if (!endpoints?.pollingBaseUri && !endpoints?.streamingBaseUri) {
+        return ctx.serviceEndpoints;
+    }
+    return new jsSdkCommon.ServiceEndpoints(endpoints.streamingBaseUri ?? ctx.serviceEndpoints.streaming, endpoints.pollingBaseUri ?? ctx.serviceEndpoints.polling, ctx.serviceEndpoints.events, ctx.serviceEndpoints.analyticsEventPath, ctx.serviceEndpoints.diagnosticEventPath, ctx.serviceEndpoints.includeAuthorizationHeader, ctx.serviceEndpoints.payloadFilterKey);
+}
+/**
+ * Get the FDv2 requestor for a polling entry. If the entry has custom
+ * endpoints, creates a new requestor targeting those endpoints. Otherwise
+ * returns the shared requestor from the context.
+ */
+function resolvePollingRequestor(ctx, endpoints) {
+    if (!endpoints?.pollingBaseUri) {
+        return ctx.requestor;
+    }
+    const overriddenEndpoints = resolveEndpoints(ctx, endpoints);
+    return makeFDv2Requestor(ctx.plainContextString, overriddenEndpoints, ctx.polling.paths, ctx.requests, ctx.encoding, ctx.baseHeaders, ctx.queryParams);
+}
+/**
+ * Build a streaming base instance using per-entry config with context defaults
+ * as fallbacks. The `sg` selector getter is the canonical source of truth for
+ * the current selector — both the stream and its ping handler use it.
+ */
+function buildStreamingBase(entry, ctx, sg) {
+    const entryEndpoints = resolveEndpoints(ctx, entry.endpoints);
+    const requestor = resolvePollingRequestor(ctx, entry.endpoints);
+    const streamUriPath = ctx.streaming.paths.pathGet(ctx.encoding, ctx.plainContextString);
+    return createStreamingBase({
+        requests: ctx.requests,
+        serviceEndpoints: entryEndpoints,
+        streamUriPath,
+        parameters: ctx.queryParams,
+        selectorGetter: sg,
+        headers: ctx.baseHeaders,
+        initialRetryDelayMillis: (entry.initialReconnectDelay ?? ctx.streaming.initialReconnectDelaySeconds) * 1000,
+        logger: ctx.logger,
+        pingHandler: createPingHandler(requestor, sg, ctx.logger),
+    });
+}
+/**
+ * Creates a {@link SourceFactoryProvider} that handles `cache`, `polling`,
+ * and `streaming` data source entries.
+ */
+function createDefaultSourceFactoryProvider() {
+    return {
+        createInitializerFactory(entry, ctx) {
+            switch (entry.type) {
+                case 'polling': {
+                    const requestor = resolvePollingRequestor(ctx, entry.endpoints);
+                    return (sg) => createPollingInitializer(requestor, ctx.logger, sg);
+                }
+                case 'streaming':
+                    return (sg) => createStreamingInitializer(buildStreamingBase(entry, ctx, sg));
+                case 'cache':
+                    return createCacheInitializerFactory({
+                        storage: ctx.storage,
+                        crypto: ctx.crypto,
+                        environmentNamespace: ctx.environmentNamespace,
+                        context: ctx.context,
+                        logger: ctx.logger,
+                    });
+                default:
+                    return undefined;
+            }
+        },
+        createSynchronizerSlot(entry, ctx) {
+            switch (entry.type) {
+                case 'polling': {
+                    const intervalMs = (entry.pollInterval ?? ctx.polling.intervalSeconds) * 1000;
+                    const requestor = resolvePollingRequestor(ctx, entry.endpoints);
+                    const factory = (sg) => createPollingSynchronizer(requestor, ctx.logger, sg, intervalMs);
+                    return createSynchronizerSlot(factory);
+                }
+                case 'streaming': {
+                    const factory = (sg) => createStreamingSynchronizer(buildStreamingBase(entry, ctx, sg));
+                    return createSynchronizerSlot(factory);
+                }
+                default:
+                    return undefined;
+            }
+        },
+    };
+}
+
+function flagsToPayload(flags) {
+    const updates = Object.entries(flags).map(([key, flag]) => ({
+        kind: 'flag',
+        key,
+        version: flag.version ?? 1,
+        object: flag,
+    }));
+    return {
+        version: 1,
+        type: 'full',
+        updates,
+    };
+}
+/**
+ * Creates a polling synchronizer that polls an FDv1 endpoint and produces
+ * results in the FDv2 {@link Synchronizer} pull model.
+ *
+ * This is a standalone implementation (not a wrapper around the existing FDv1
+ * `PollingProcessor`) because the FDv1 fallback is temporary and will be
+ * removed in the next major version. A focused implementation is simpler than
+ * an adapter layer.
+ *
+ * Polling starts lazily on the first call to `next()`. Each poll returns the
+ * complete flag set as a `changeSet` result with `type: 'full'` and an empty
+ * selector.
+ *
+ * @param requestor FDv1 requestor configured with the appropriate endpoint.
+ * @param pollIntervalMs Interval between polls in milliseconds.
+ * @param logger Optional logger.
+ * @internal
+ */
+function createFDv1PollingSynchronizer(requestor, pollIntervalMs, logger) {
+    const resultQueue = createAsyncQueue();
+    let shutdownResolve;
+    const shutdownPromise = new Promise((resolve) => {
+        shutdownResolve = resolve;
+    });
+    let timeoutHandle;
+    let stopped = false;
+    let started = false;
+    function scheduleNextPoll(startTime) {
+        if (!stopped) {
+            const elapsed = Date.now() - startTime;
+            const sleepFor = Math.min(Math.max(pollIntervalMs - elapsed, 0), pollIntervalMs);
+            // eslint-disable-next-line @typescript-eslint/no-use-before-define
+            timeoutHandle = setTimeout(doPoll, sleepFor);
+        }
+    }
+    async function doPoll() {
+        if (stopped) {
+            return;
+        }
+        logger?.debug('Polling FDv1 endpoint for feature flag updates');
+        const startTime = Date.now();
+        try {
+            const body = await requestor.requestPayload();
+            if (stopped) {
+                return;
+            }
+            let payload;
+            try {
+                const flags = JSON.parse(body);
+                payload = flagsToPayload(flags);
+            }
+            catch {
+                logger?.error('FDv1 polling received malformed data');
+                resultQueue.put({
+                    type: 'status',
+                    state: 'interrupted',
+                    errorInfo: errorInfoFromInvalidData('Malformed data in FDv1 polling response'),
+                    fdv1Fallback: false,
+                });
+                scheduleNextPoll(startTime);
+                return;
+            }
+            resultQueue.put(changeSet(payload, false));
+        }
+        catch (err) {
+            if (stopped) {
+                return;
+            }
+            const requestError = err;
+            if (requestError.status !== undefined) {
+                if (!jsSdkCommon.isHttpRecoverable(requestError.status)) {
+                    logger?.error(jsSdkCommon.httpErrorMessage(err, 'FDv1 polling request'));
+                    stopped = true;
+                    shutdownResolve?.(terminalError(errorInfoFromHttpError(requestError.status), false));
+                    shutdownResolve = undefined;
+                    return;
+                }
+            }
+            logger?.warn(jsSdkCommon.httpErrorMessage(err, 'FDv1 polling request', 'will retry'));
+            resultQueue.put({
+                type: 'status',
+                state: 'interrupted',
+                errorInfo: requestError.status
+                    ? errorInfoFromHttpError(requestError.status)
+                    : errorInfoFromNetworkError(requestError.message),
+                fdv1Fallback: false,
+            });
+        }
+        scheduleNextPoll(startTime);
+    }
+    return {
+        next() {
+            if (!started) {
+                started = true;
+                doPoll();
+            }
+            return Promise.race([shutdownPromise, resultQueue.take()]);
+        },
+        close() {
+            stopped = true;
+            if (timeoutHandle !== undefined) {
+                clearTimeout(timeoutHandle);
+                timeoutHandle = undefined;
+            }
+            shutdownResolve?.(shutdown());
+            shutdownResolve = undefined;
+        },
+    };
+}
+
+const DEFAULT_FALLBACK_TIMEOUT_MS = 2 * 60 * 1000; // 120 seconds
+const DEFAULT_RECOVERY_TIMEOUT_MS = 5 * 60 * 1000; // 300 seconds
+/**
+ * Creates a cancelable timer that resolves with the given {@link ConditionType}
+ * when it fires. Wraps {@link cancelableTimedPromise} to convert its
+ * reject-on-timeout semantics into resolve-with-type semantics.
+ */
+function conditionTimer(timeoutMs, type, taskName) {
+    const timed = jsSdkCommon.cancelableTimedPromise(timeoutMs / 1000, taskName);
+    return {
+        promise: timed.promise.then(() => new Promise(() => { }), // cancelled — never settle
+        () => type),
+        cancel: timed.cancel,
+    };
+}
+/**
+ * Creates a timed {@link Condition}.
+ *
+ * @param timeoutMs Time in milliseconds before the condition fires.
+ * @param type The {@link ConditionType} to resolve with when the timer fires.
+ * @param informHandler Optional callback invoked on each `inform()` call.
+ *   When omitted, the timer starts immediately and `inform()` is a no-op.
+ *   When provided, the timer must be started explicitly via `controls.start()`.
+ */
+function createCondition(timeoutMs, type, informHandler) {
+    let resolve;
+    let timer;
+    let closed = false;
+    const promise = new Promise((res) => {
+        resolve = res;
+    });
+    function startTimer() {
+        if (!timer && !closed) {
+            timer = conditionTimer(timeoutMs, type, `${type} condition`);
+            timer.promise.then((t) => {
+                timer = undefined;
+                resolve?.(t);
+            });
+        }
+    }
+    function cancelTimer() {
+        timer?.cancel();
+        timer = undefined;
+    }
+    // No inform handler — start immediately (recovery behavior).
+    if (!informHandler) {
+        startTimer();
+    }
+    return {
+        promise,
+        inform(result) {
+            if (closed) {
+                return;
+            }
+            informHandler?.(result, { start: startTimer, cancel: cancelTimer });
+        },
+        close() {
+            closed = true;
+            cancelTimer();
+        },
+    };
+}
+/**
+ * Creates a fallback condition. The condition starts a timer when an
+ * `interrupted` status is received and cancels it when a `changeSet` is
+ * received. If the timer fires, the condition resolves with `'fallback'`.
+ */
+function createFallbackCondition(timeoutMs) {
+    return createCondition(timeoutMs, 'fallback', (result, { start, cancel }) => {
+        if (result.type === 'changeSet') {
+            cancel();
+        }
+        else if (result.type === 'status' && result.state === 'interrupted') {
+            start();
+        }
+    });
+}
+/**
+ * Creates a recovery condition. The condition starts a timer immediately
+ * and resolves with `'recovery'` when it fires. It ignores all `inform()`
+ * calls.
+ */
+function createRecoveryCondition(timeoutMs) {
+    return createCondition(timeoutMs, 'recovery');
+}
+/**
+ * Creates a group of conditions that are managed together.
+ *
+ * @param conditions The conditions to group.
+ */
+function createConditionGroup(conditions) {
+    return {
+        promise: conditions.length === 0 ? undefined : Promise.race(conditions.map((c) => c.promise)),
+        inform(result) {
+            conditions.forEach((condition) => condition.inform(result));
+        },
+        close() {
+            conditions.forEach((condition) => condition.close());
+        },
+    };
+}
+/**
+ * Determines which conditions to create based on the synchronizer's position
+ * and availability.
+ *
+ * - If there is only one available synchronizer, no conditions are needed
+ *   (there is nowhere to fall back to).
+ * - If the current synchronizer is the primary (first available), only a
+ *   fallback condition is created.
+ * - If the current synchronizer is non-primary, both fallback and recovery
+ *   conditions are created.
+ *
+ * @param availableSyncCount Number of available (non-blocked) synchronizers.
+ * @param isPrime Whether the current synchronizer is the primary.
+ * @param fallbackTimeoutMs Fallback condition timeout.
+ * @param recoveryTimeoutMs Recovery condition timeout.
+ */
+function getConditions(availableSyncCount, isPrime, fallbackTimeoutMs = DEFAULT_FALLBACK_TIMEOUT_MS, recoveryTimeoutMs = DEFAULT_RECOVERY_TIMEOUT_MS) {
+    if (availableSyncCount <= 1) {
+        return createConditionGroup([]);
+    }
+    if (isPrime) {
+        return createConditionGroup([createFallbackCondition(fallbackTimeoutMs)]);
+    }
+    return createConditionGroup([
+        createFallbackCondition(fallbackTimeoutMs),
+        createRecoveryCondition(recoveryTimeoutMs),
+    ]);
+}
+
+/**
+ * Creates an {@link FDv2DataSource} orchestrator.
+ */
+function createFDv2DataSource(config) {
+    const { initializerFactories, synchronizerSlots, dataCallback, statusManager, selectorGetter, logger, fallbackTimeoutMs = DEFAULT_FALLBACK_TIMEOUT_MS, recoveryTimeoutMs = DEFAULT_RECOVERY_TIMEOUT_MS, } = config;
+    let initialized = false;
+    let closed = false;
+    let dataReceived = false;
+    let initResolve;
+    let initReject;
+    const sourceManager = createSourceManager(initializerFactories, synchronizerSlots, selectorGetter);
+    function markInitialized() {
+        if (!initialized) {
+            initialized = true;
+            initResolve?.();
+            initResolve = undefined;
+            initReject = undefined;
+        }
+    }
+    function applyChangeSet(result) {
+        dataCallback(result.payload);
+        statusManager.requestStateUpdate('VALID');
+    }
+    function reportStatusError(result) {
+        if (result.errorInfo) {
+            statusManager.reportError(result.errorInfo.kind, result.errorInfo.message, result.errorInfo.statusCode, result.state === 'interrupted');
+        }
+    }
+    function handleFdv1Fallback(result) {
+        if (result.fdv1Fallback && sourceManager.hasFDv1Fallback()) {
+            sourceManager.fdv1Fallback();
+            return true;
+        }
+        return false;
+    }
+    /* eslint-disable no-await-in-loop */
+    // The orchestration loops intentionally use await-in-loop for sequential
+    // state machine processing — one result at a time.
+    async function runInitializers() {
+        while (!closed) {
+            const initializer = sourceManager.getNextInitializerAndSetActive();
+            if (initializer === undefined) {
+                break;
+            }
+            const result = await initializer.run();
+            if (closed) {
+                return;
+            }
+            if (result.type === 'changeSet') {
+                applyChangeSet(result);
+                if (handleFdv1Fallback(result)) {
+                    // FDv1 fallback triggered during initialization — data was received
+                    // but we should move to synchronizers where the FDv1 adapter will run.
+                    dataReceived = true;
+                    break;
+                }
+                if (result.payload.state) {
+                    // Got basis data with a selector — initialization is complete.
+                    markInitialized();
+                    return;
+                }
+                // Got data but no selector (e.g., cache). Record that data was
+                // received and continue to the next initializer.
+                dataReceived = true;
+            }
+            else if (result.type === 'status') {
+                switch (result.state) {
+                    case 'interrupted':
+                    case 'terminal_error':
+                        logger?.warn(`Initializer failed: ${result.errorInfo?.message ?? 'unknown error'}`);
+                        reportStatusError(result);
+                        break;
+                    case 'shutdown':
+                        return;
+                }
+                handleFdv1Fallback(result);
+            }
+        }
+        // All initializers exhausted.
+        if (dataReceived) {
+            markInitialized();
+        }
+    }
+    async function runSynchronizers() {
+        while (!closed) {
+            const synchronizer = sourceManager.getNextAvailableSynchronizerAndSetActive();
+            if (synchronizer === undefined) {
+                if (!initialized) {
+                    initReject?.(new Error('All data sources exhausted without receiving data.'));
+                    initResolve = undefined;
+                    initReject = undefined;
+                }
+                return;
+            }
+            const conditions = getConditions(sourceManager.getAvailableSynchronizerCount(), sourceManager.isPrimeSynchronizer(), fallbackTimeoutMs, recoveryTimeoutMs);
+            if (conditions.promise) {
+                logger?.debug('Fallback condition active for current synchronizer.');
+            }
+            // try/finally ensures conditions are closed on all code paths.
+            let synchronizerRunning = true;
+            try {
+                while (!closed && synchronizerRunning) {
+                    const syncPromise = synchronizer
+                        .next()
+                        .then((value) => ({ source: 'sync', value }));
+                    const racers = [syncPromise];
+                    if (conditions.promise !== undefined) {
+                        racers.push(conditions.promise.then((value) => ({ source: 'condition', value })));
+                    }
+                    const winner = await Promise.race(racers);
+                    if (closed) {
+                        return;
+                    }
+                    if (winner.source === 'condition') {
+                        const conditionType = winner.value;
+                        if (conditionType === 'fallback') {
+                            logger?.warn('Fallback condition fired, moving to next synchronizer.');
+                        }
+                        else if (conditionType === 'recovery') {
+                            logger?.info('Recovery condition fired, resetting to primary synchronizer.');
+                            sourceManager.resetSourceIndex();
+                        }
+                        synchronizerRunning = false;
+                    }
+                    else {
+                        // Synchronizer produced a result.
+                        const syncResult = winner.value;
+                        conditions.inform(syncResult);
+                        if (syncResult.type === 'changeSet') {
+                            applyChangeSet(syncResult);
+                            if (!initialized) {
+                                markInitialized();
+                            }
+                        }
+                        else if (syncResult.type === 'status') {
+                            switch (syncResult.state) {
+                                case 'interrupted':
+                                    logger?.warn(`Synchronizer interrupted: ${syncResult.errorInfo?.message ?? 'unknown error'}`);
+                                    reportStatusError(syncResult);
+                                    break;
+                                case 'terminal_error':
+                                    logger?.error(`Synchronizer terminal error: ${syncResult.errorInfo?.message ?? 'unknown error'}`);
+                                    reportStatusError(syncResult);
+                                    sourceManager.blockCurrentSynchronizer();
+                                    synchronizerRunning = false;
+                                    break;
+                                case 'shutdown':
+                                    return;
+                                case 'goodbye':
+                                    // The synchronizer will handle reconnection internally.
+                                    break;
+                                default:
+                                    break;
+                            }
+                        }
+                        // Check for FDv1 fallback after all result handling — single location.
+                        if (handleFdv1Fallback(syncResult)) {
+                            synchronizerRunning = false;
+                        }
+                    }
+                }
+            }
+            finally {
+                conditions.close();
+            }
+        }
+    }
+    /* eslint-enable no-await-in-loop */
+    async function runOrchestration() {
+        // No sources configured at all — nothing to wait for, immediately valid.
+        if (initializerFactories.length === 0 && synchronizerSlots.length === 0) {
+            statusManager.requestStateUpdate('VALID');
+            markInitialized();
+            return;
+        }
+        await runInitializers();
+        if (!closed) {
+            await runSynchronizers();
+        }
+    }
+    return {
+        start() {
+            return new Promise((resolve, reject) => {
+                initResolve = resolve;
+                initReject = reject;
+                statusManager.requestStateUpdate('INITIALIZING');
+                runOrchestration()
+                    .then(() => {
+                    // Orchestration completed without error. If the init promise was
+                    // never resolved (e.g., close() called during init, or all sources
+                    // exhausted without data and no synchronizers), resolve it now.
+                    // This prevents the start() promise from hanging forever.
+                    if (!initialized) {
+                        initReject?.(new Error('Data source closed before initialization completed.'));
+                        initResolve = undefined;
+                        initReject = undefined;
+                    }
+                })
+                    .catch((err) => {
+                    if (!initialized) {
+                        initReject?.(err instanceof Error ? err : new Error(String(err)));
+                        initResolve = undefined;
+                        initReject = undefined;
+                    }
+                    else {
+                        logger?.error(`Orchestration error: ${err}`);
+                    }
+                });
+            });
+        },
+        close() {
+            closed = true;
+            sourceManager.close();
+        },
+    };
+}
+
+/** Default debounce window duration in milliseconds. */
+const DEFAULT_DEBOUNCE_MS = 1000;
+/**
+ * Creates a {@link StateDebounceManager}.
+ *
+ * The manager accumulates state changes from network, lifecycle, and
+ * connection mode events. Each event updates the relevant component
+ * of the pending state and resets the debounce timer. When the timer
+ * fires, the reconciliation callback receives the final combined state.
+ *
+ * @param config Configuration for the debounce manager.
+ */
+function createStateDebounceManager(config) {
+    const { initialState, onReconcile, debounceMs = DEFAULT_DEBOUNCE_MS } = config;
+    let { networkState, lifecycleState, requestedMode } = initialState;
+    let timer;
+    let closed = false;
+    function getPendingState() {
+        return { networkState, lifecycleState, requestedMode };
+    }
+    function resetTimer() {
+        if (closed) {
+            return;
+        }
+        if (timer !== undefined) {
+            clearTimeout(timer);
+        }
+        timer = setTimeout(() => {
+            timer = undefined;
+            if (!closed) {
+                onReconcile(getPendingState());
+            }
+        }, debounceMs);
+    }
+    return {
+        setNetworkState(state) {
+            if (networkState === state) {
+                return;
+            }
+            networkState = state;
+            resetTimer();
+        },
+        setLifecycleState(state) {
+            if (lifecycleState === state) {
+                return;
+            }
+            lifecycleState = state;
+            resetTimer();
+        },
+        setRequestedMode(mode) {
+            if (requestedMode === mode) {
+                return;
+            }
+            requestedMode = mode;
+            resetTimer();
+        },
+        close() {
+            closed = true;
+            if (timer !== undefined) {
+                clearTimeout(timer);
+                timer = undefined;
+            }
+        },
+    };
+}
+
+const logTag = '[FDv2DataManagerBase]';
+/**
+ * Creates a shared FDv2 data manager that owns mode resolution, debouncing,
+ * selector state, and FDv2DataSource lifecycle. Platform SDKs (browser, RN)
+ * wrap this with platform-specific config and event wiring.
+ */
+function createFDv2DataManagerBase(baseConfig) {
+    const { platform, flagManager, config, baseHeaders, emitter, transitionTable, foregroundMode: configuredForegroundMode, backgroundMode, modeTable, sourceFactoryProvider, buildQueryParams, fdv1Endpoints, fallbackTimeoutMs, recoveryTimeoutMs, } = baseConfig;
+    const { logger } = config;
+    const statusManager = createDataSourceStatusManager(emitter);
+    const endpoints = fdv2Endpoints();
+    // Merge user-provided connection mode overrides into the mode table.
+    const effectiveModeTable = config.dataSystem?.connectionModes
+        ? { ...modeTable, ...config.dataSystem.connectionModes }
+        : modeTable;
+    // --- Mutable state ---
+    let selector;
+    let currentResolvedMode = configuredForegroundMode;
+    let foregroundMode = configuredForegroundMode;
+    let dataSource;
+    let debounceManager;
+    let identifiedContext;
+    let factoryContext;
+    let initialized = false;
+    let bootstrapped = false;
+    let closed = false;
+    let flushCallback;
+    // Explicit connection mode override — bypasses transition table entirely.
+    let connectionModeOverride;
+    // Forced/automatic streaming state for browser listener-driven streaming.
+    let forcedStreaming;
+    let automaticStreamingState = false;
+    // Outstanding identify promise callbacks — needed so that mode switches
+    // during identify can wire the new data source's completion to the
+    // original identify promise.
+    let pendingIdentifyResolve;
+    let pendingIdentifyReject;
+    // Current debounce input state.
+    let networkState = 'available';
+    let lifecycleState = 'foreground';
+    // --- Helpers ---
+    function getModeDefinition(mode) {
+        return effectiveModeTable[mode];
+    }
+    function buildModeState() {
+        return {
+            lifecycle: lifecycleState,
+            networkAvailable: networkState === 'available',
+            foregroundMode,
+            backgroundMode: backgroundMode ?? 'offline',
+        };
+    }
+    /**
+     * Resolve the current effective connection mode.
+     *
+     * Priority:
+     * 1. connectionModeOverride (set via setConnectionMode) — bypasses everything
+     * 2. Transition table (network/lifecycle state + foreground/background modes)
+     */
+    function resolveMode() {
+        if (connectionModeOverride !== undefined) {
+            return connectionModeOverride;
+        }
+        return resolveConnectionMode(transitionTable, buildModeState());
+    }
+    /**
+     * Resolve the foreground mode input for the transition table based on
+     * forced/automatic streaming state.
+     *
+     * Priority: forcedStreaming > automaticStreaming > configuredForegroundMode
+     */
+    function resolveStreamingForeground() {
+        if (forcedStreaming === true) {
+            return 'streaming';
+        }
+        if (forcedStreaming === false) {
+            return configuredForegroundMode === 'streaming' ? 'one-shot' : configuredForegroundMode;
+        }
+        return automaticStreamingState ? 'streaming' : configuredForegroundMode;
+    }
+    /**
+     * Compute the effective foreground mode from streaming state and push it
+     * through the debounce manager. Used by setForcedStreaming and
+     * setAutomaticStreamingState.
+     */
+    function pushForegroundMode() {
+        foregroundMode = resolveStreamingForeground();
+        debounceManager?.setRequestedMode(foregroundMode);
+    }
+    /**
+     * Convert a ModeDefinition's entries into concrete InitializerFactory[]
+     * and SynchronizerSlot[] using the source factory provider.
+     */
+    function buildFactories(modeDef, ctx, includeInitializers) {
+        const initializerFactories = [];
+        if (includeInitializers) {
+            modeDef.initializers
+                // Skip cache when bootstrapped — bootstrap data was applied to the
+                // flag store before identify, so the cache would only load older data.
+                .filter((entry) => !(bootstrapped && entry.type === 'cache'))
+                .forEach((entry) => {
+                const factory = sourceFactoryProvider.createInitializerFactory(entry, ctx);
+                if (factory) {
+                    initializerFactories.push(factory);
+                }
+                else {
+                    logger.warn(`${logTag} Unsupported initializer type '${entry.type}'. It will be skipped.`);
+                }
+            });
+        }
+        const synchronizerSlots = [];
+        modeDef.synchronizers.forEach((entry) => {
+            const slot = sourceFactoryProvider.createSynchronizerSlot(entry, ctx);
+            if (slot) {
+                synchronizerSlots.push(slot);
+            }
+            else {
+                logger.warn(`${logTag} Unsupported synchronizer type '${entry.type}'. It will be skipped.`);
+            }
+        });
+        // Append a blocked FDv1 fallback synchronizer when configured and
+        // when there are FDv2 synchronizers to fall back from.
+        if (fdv1Endpoints && synchronizerSlots.length > 0) {
+            const fallbackConfig = modeDef.fdv1Fallback;
+            const fallbackPollIntervalMs = (fallbackConfig?.pollInterval ?? config.pollInterval) * 1000;
+            const fallbackServiceEndpoints = fallbackConfig?.endpoints?.pollingBaseUri || fallbackConfig?.endpoints?.streamingBaseUri
+                ? new jsSdkCommon.ServiceEndpoints(fallbackConfig.endpoints.streamingBaseUri ?? ctx.serviceEndpoints.streaming, fallbackConfig.endpoints.pollingBaseUri ?? ctx.serviceEndpoints.polling, ctx.serviceEndpoints.events, ctx.serviceEndpoints.analyticsEventPath, ctx.serviceEndpoints.diagnosticEventPath, ctx.serviceEndpoints.includeAuthorizationHeader, ctx.serviceEndpoints.payloadFilterKey)
+                : ctx.serviceEndpoints;
+            const fdv1RequestorFactory = () => makeRequestor(ctx.plainContextString, fallbackServiceEndpoints, fdv1Endpoints.polling(), ctx.requests, ctx.encoding, ctx.baseHeaders, ctx.queryParams, config.withReasons, config.useReport);
+            const fdv1SyncFactory = () => createFDv1PollingSynchronizer(fdv1RequestorFactory(), fallbackPollIntervalMs, logger);
+            synchronizerSlots.push(createSynchronizerSlot(fdv1SyncFactory, { isFDv1Fallback: true }));
+        }
+        return { initializerFactories, synchronizerSlots };
+    }
+    /**
+     * The data callback shared across all FDv2DataSource instances for
+     * the current identify. Handles selector tracking and flag updates.
+     */
+    function dataCallback(payload) {
+        logger.debug(`${logTag} dataCallback: type=${payload.type}, updates=${payload.updates.length}, state=${payload.state}`);
+        selector = payload.state;
+        const context = identifiedContext;
+        if (!context) {
+            logger.warn(`${logTag} dataCallback called without an identified context.`);
+            return;
+        }
+        const descriptors = flagEvalPayloadToItemDescriptors(payload.updates ?? []);
+        // Flag updates and change events happen synchronously inside applyChanges.
+        // The returned promise is only for async cache persistence — we intentionally
+        // do not await it so the data source pipeline is not blocked by storage I/O.
+        flagManager.applyChanges(context, descriptors, payload.type).catch((e) => {
+            logger.warn(`${logTag} Failed to persist flag cache: ${e}`);
+        });
+    }
+    /**
+     * Create and start a new FDv2DataSource for the given mode.
+     *
+     * @param mode The connection mode to use.
+     * @param includeInitializers Whether to include initializers (true on
+     *   first identify, false on mode switch after initialization).
+     */
+    function createAndStartDataSource(mode, includeInitializers) {
+        if (!factoryContext) {
+            logger.warn(`${logTag} Cannot create data source without factory context.`);
+            return;
+        }
+        const modeDef = getModeDefinition(mode);
+        const { initializerFactories, synchronizerSlots } = buildFactories(modeDef, factoryContext, includeInitializers);
+        currentResolvedMode = mode;
+        // If there are no sources at all (e.g., offline or one-shot mode
+        // post-initialization), don't create a data source.
+        if (initializerFactories.length === 0 && synchronizerSlots.length === 0) {
+            logger.debug(`${logTag} Mode '${mode}' has no sources. No data source created.`);
+            if (!initialized && pendingIdentifyResolve) {
+                // Offline mode during initial identify — resolve immediately.
+                // The SDK will use cached data if any.
+                initialized = true;
+                pendingIdentifyResolve();
+                pendingIdentifyResolve = undefined;
+                pendingIdentifyReject = undefined;
+            }
+            return;
+        }
+        const selectorGetter = () => selector;
+        dataSource = createFDv2DataSource({
+            initializerFactories,
+            synchronizerSlots,
+            dataCallback,
+            statusManager,
+            selectorGetter,
+            logger,
+            fallbackTimeoutMs,
+            recoveryTimeoutMs,
+        });
+        dataSource
+            .start()
+            .then(() => {
+            initialized = true;
+            if (pendingIdentifyResolve) {
+                pendingIdentifyResolve();
+                pendingIdentifyResolve = undefined;
+                pendingIdentifyReject = undefined;
+            }
+        })
+            .catch((err) => {
+            if (pendingIdentifyReject) {
+                pendingIdentifyReject(err instanceof Error ? err : new Error(String(err)));
+                pendingIdentifyResolve = undefined;
+                pendingIdentifyReject = undefined;
+            }
+        });
+    }
+    /**
+     * Reconciliation callback invoked when the debounce timer fires.
+     * Resolves the new mode and switches data sources if needed.
+     */
+    function onReconcile(pendingState) {
+        if (closed || !factoryContext) {
+            return;
+        }
+        // Update local state from the debounced pending state.
+        networkState = pendingState.networkState;
+        lifecycleState = pendingState.lifecycleState;
+        foregroundMode = pendingState.requestedMode;
+        const newMode = resolveMode();
+        if (newMode === currentResolvedMode) {
+            logger.debug(`${logTag} Reconcile: mode unchanged (${newMode}). No action.`);
+            return;
+        }
+        logger.debug(`${logTag} Reconcile: mode switching from '${currentResolvedMode}' to '${newMode}'.`);
+        // Close the current data source.
+        dataSource?.close();
+        dataSource = undefined;
+        // Include initializers if we don't have a selector yet. This covers:
+        // - Not yet initialized (normal case)
+        // - Initialized from bootstrap (no selector) — need initializers to
+        //   get a full payload via poll before starting synchronizers
+        // When we have a selector, only synchronizers change (spec 5.3.8).
+        const includeInitializers = !selector;
+        createAndStartDataSource(newMode, includeInitializers);
+    }
+    // --- Public interface ---
+    return {
+        get configuredForegroundMode() {
+            return configuredForegroundMode;
+        },
+        async identify(identifyResolve, identifyReject, context, identifyOptions) {
+            if (closed) {
+                logger.debug(`${logTag} Identify called after close.`);
+                return;
+            }
+            // Tear down previous state.
+            dataSource?.close();
+            dataSource = undefined;
+            debounceManager?.close();
+            debounceManager = undefined;
+            selector = undefined;
+            initialized = false;
+            bootstrapped = false;
+            identifiedContext = context;
+            pendingIdentifyResolve = identifyResolve;
+            pendingIdentifyReject = identifyReject;
+            const plainContextString = JSON.stringify(jsSdkCommon.Context.toLDContext(context));
+            const queryParams = buildQueryParams(identifyOptions);
+            if (config.withReasons) {
+                queryParams.push({ key: 'withReasons', value: 'true' });
+            }
+            const streamingEndpoints = endpoints.streaming();
+            const pollingEndpoints = endpoints.polling();
+            const requestor = makeFDv2Requestor(plainContextString, config.serviceEndpoints, pollingEndpoints, platform.requests, platform.encoding, baseHeaders, queryParams);
+            const environmentNamespace = await namespaceForEnvironment(platform.crypto, baseConfig.credential);
+            // Re-check after the await — close() may have been called while
+            // namespaceForEnvironment was pending.
+            if (closed) {
+                logger.debug(`${logTag} Identify aborted: closed during async setup.`);
+                return;
+            }
+            factoryContext = {
+                requestor,
+                requests: platform.requests,
+                encoding: platform.encoding,
+                serviceEndpoints: config.serviceEndpoints,
+                baseHeaders,
+                queryParams,
+                plainContextString,
+                logger,
+                polling: {
+                    paths: pollingEndpoints,
+                    intervalSeconds: config.pollInterval,
+                },
+                streaming: {
+                    paths: streamingEndpoints,
+                    initialReconnectDelaySeconds: config.streamInitialReconnectDelay,
+                },
+                storage: platform.storage,
+                crypto: platform.crypto,
+                environmentNamespace,
+                context,
+            };
+            // Ensure foreground mode reflects current streaming state before resolving.
+            foregroundMode = resolveStreamingForeground();
+            // Resolve the initial mode.
+            const mode = resolveMode();
+            logger.debug(`${logTag} Identify: initial mode resolved to '${mode}'.`);
+            bootstrapped = identifyOptions?.bootstrap !== undefined;
+            if (bootstrapped) {
+                // Bootstrap data was already applied to the flag store by the
+                // caller (BrowserClient.start → presetFlags) before identify
+                // was called. Resolve immediately — flag evaluations will use
+                // the bootstrap data synchronously.
+                initialized = true;
+                statusManager.requestStateUpdate('VALID');
+                // selector remains undefined — bootstrap data has no selector.
+                pendingIdentifyResolve?.();
+                pendingIdentifyResolve = undefined;
+                pendingIdentifyReject = undefined;
+                // Only create a data source if the mode has synchronizers.
+                // For one-shot (no synchronizers), there's nothing more to do.
+                const modeDef = getModeDefinition(mode);
+                if (modeDef.synchronizers.length > 0) {
+                    // Start synchronizers without initializers — we already have
+                    // data from bootstrap. Initializers will run on mode switches
+                    // if selector is still undefined (see onReconcile).
+                    createAndStartDataSource(mode, false);
+                }
+            }
+            else {
+                // Normal identify — create and start the data source with full pipeline.
+                createAndStartDataSource(mode, true);
+            }
+            // Set up debouncing for subsequent state changes.
+            debounceManager = createStateDebounceManager({
+                initialState: {
+                    networkState,
+                    lifecycleState,
+                    requestedMode: foregroundMode,
+                },
+                onReconcile,
+            });
+        },
+        close() {
+            closed = true;
+            dataSource?.close();
+            dataSource = undefined;
+            debounceManager?.close();
+            debounceManager = undefined;
+            pendingIdentifyResolve = undefined;
+            pendingIdentifyReject = undefined;
+        },
+        setNetworkState(state) {
+            networkState = state;
+            debounceManager?.setNetworkState(state);
+        },
+        setLifecycleState(state) {
+            // Flush immediately when going to background — the app may be
+            // about to close. This is not debounced (CONNMODE spec 3.3.1).
+            if (state === 'background' && lifecycleState !== 'background') {
+                flushCallback?.();
+            }
+            lifecycleState = state;
+            debounceManager?.setLifecycleState(state);
+        },
+        setConnectionMode(mode) {
+            connectionModeOverride = mode;
+            if (mode !== undefined) {
+                debounceManager?.setRequestedMode(mode);
+            }
+            else {
+                pushForegroundMode();
+            }
+        },
+        getCurrentMode() {
+            return currentResolvedMode;
+        },
+        setFlushCallback(callback) {
+            flushCallback = callback;
+        },
+        setForcedStreaming(streaming) {
+            forcedStreaming = streaming;
+            pushForegroundMode();
+        },
+        setAutomaticStreamingState(streaming) {
+            automaticStreamingState = streaming;
+            pushForegroundMode();
+        },
+    };
+}
+
 exports.platform = jsSdkCommon__namespace;
 exports.BROWSER_DATA_SYSTEM_DEFAULTS = BROWSER_DATA_SYSTEM_DEFAULTS;
 exports.BROWSER_TRANSITION_TABLE = BROWSER_TRANSITION_TABLE;
@@ -2854,13 +5107,19 @@ exports.DataSourceState = DataSourceState;
 exports.LDClientImpl = LDClientImpl;
 exports.MOBILE_DATA_SYSTEM_DEFAULTS = MOBILE_DATA_SYSTEM_DEFAULTS;
 exports.MOBILE_TRANSITION_TABLE = MOBILE_TRANSITION_TABLE;
+exports.MODE_TABLE = MODE_TABLE;
 exports.browserFdv1Endpoints = browserFdv1Endpoints;
+exports.createDataSourceStatusManager = createDataSourceStatusManager;
+exports.createDefaultSourceFactoryProvider = createDefaultSourceFactoryProvider;
+exports.createFDv2DataManagerBase = createFDv2DataManagerBase;
+exports.createStateDebounceManager = createStateDebounceManager;
 exports.dataSystemValidators = dataSystemValidators;
 exports.fdv2Endpoints = fdv2Endpoints;
 exports.makeRequestor = makeRequestor;
 exports.mobileFdv1Endpoints = mobileFdv1Endpoints;
 exports.readFlagsFromBootstrap = readFlagsFromBootstrap;
 exports.resolveConnectionMode = resolveConnectionMode;
+exports.resolveForegroundMode = resolveForegroundMode;
 exports.safeRegisterDebugOverridePlugins = safeRegisterDebugOverridePlugins;
 exports.validateOptions = validateOptions;
 Object.keys(jsSdkCommon).forEach(function (k) {