fix: FDv2 -- cache initializer returns transfer-none on cache miss (#1275)

<!-- CURSOR_SUMMARY -->
> [!NOTE]
> **Medium Risk**
> Changes FDv2 initialization semantics so cache misses/no-storage now
produce a `changeSet` with payload `type: 'none'` instead of an
`interrupted` status, which can affect whether `start()` considers data
received and when it rejects.
> 
> **Overview**
> Cache initialization now reports cache miss / missing storage /
corrupt cache as a **transfer-none** result (`changeSet` with
`payload.type: 'none'` and no updates) rather than returning an
`interrupted` status.
> 
> The FDv2 orchestrator is updated to *skip* `changeSet` results with
`payload.type: 'none'` during initialization (no `dataCallback`, and
they don’t count as “data received”), with tests and helpers adjusted to
cover the new behavior.
> 
> <sup>Reviewed by [Cursor Bugbot](https://cursor.com/bugbot) for commit
ba3d456. Bugbot is set up for automated
code reviews on this repo. Configure
[here](https://www.cursor.com/dashboard/bugbot).</sup>
<!-- /CURSOR_SUMMARY -->

Author: kinyoklion

packages/shared/sdk-client/__tests__/datasource/fdv2/CacheInitializer.test.ts

@@ -135,41 +135,44 @@ describe('CacheInitializer', () => {
     }
   });
 
-  it('returns interrupted on cache miss', async () => {
+  it('returns transfer-none on cache miss', async () => {
     const storage = makeMemoryStorage();
 
     const initializer = createInitializer(storage, crypto, context);
     const result = await initializer.run();
 
-    expect(result.type).toBe('status');
-    if (result.type === 'status') {
-      expect(result.state).toBe('interrupted');
+    expect(result.type).toBe('changeSet');
+    if (result.type === 'changeSet') {
+      expect(result.payload.type).toBe('none');
+      expect(result.payload.updates).toHaveLength(0);
     }
   });
 
-  it('returns interrupted when storage is undefined', async () => {
+  it('returns transfer-none when storage is undefined', async () => {
     const logger = makeMockLogger();
     const initializer = createInitializer(undefined, crypto, context, logger);
     const result = await initializer.run();
 
-    expect(result.type).toBe('status');
-    if (result.type === 'status') {
-      expect(result.state).toBe('interrupted');
+    expect(result.type).toBe('changeSet');
+    if (result.type === 'changeSet') {
+      expect(result.payload.type).toBe('none');
+      expect(result.payload.updates).toHaveLength(0);
     }
     expect(logger.debug).toHaveBeenCalledWith('No storage available for cache initializer');
   });
 
-  it('returns interrupted on corrupt JSON (treated as cache miss)', async () => {
+  it('returns transfer-none on corrupt JSON (treated as cache miss)', async () => {
     const storage = makeMemoryStorage();
     const storageKey = await namespaceForContextData(crypto, TEST_NAMESPACE, context);
     await storage.set(storageKey, 'not valid json!!!');
 
     const initializer = createInitializer(storage, crypto, context);
     const result = await initializer.run();
 
-    expect(result.type).toBe('status');
-    if (result.type === 'status') {
-      expect(result.state).toBe('interrupted');
+    expect(result.type).toBe('changeSet');
+    if (result.type === 'changeSet') {
+      expect(result.payload.type).toBe('none');
+      expect(result.payload.updates).toHaveLength(0);
     }
   });
 

packages/shared/sdk-client/__tests__/datasource/fdv2/FDv2DataSource.test.ts

@@ -92,6 +92,48 @@ it('resolves start() when all initializers exhausted but data was received', asy
   ds.close();
 });
 
+it('skips transfer-none initializer results without calling dataCallback', async () => {
+  const dataCallback = jest.fn();
+  const statusManager = makeStatusManager();
+  const nonePayload = makePayload({ type: 'none' });
+  const fullPayload = makePayload({ state: 'selector' });
+
+  const ds = createFDv2DataSource({
+    initializerFactories: [
+      makeInitFactory(makeMockInitializer(changeSet(nonePayload, false))),
+      makeInitFactory(makeMockInitializer(changeSet(fullPayload, false))),
+    ],
+    synchronizerSlots: [],
+    dataCallback,
+    statusManager,
+    selectorGetter: noSelector,
+  });
+
+  await ds.start();
+
+  expect(dataCallback).toHaveBeenCalledTimes(1);
+  expect(dataCallback).toHaveBeenCalledWith(fullPayload);
+  ds.close();
+});
+
+it('does not mark data received for transfer-none initializer results', async () => {
+  const dataCallback = jest.fn();
+  const statusManager = makeStatusManager();
+  const nonePayload = makePayload({ type: 'none' });
+
+  const ds = createFDv2DataSource({
+    initializerFactories: [makeInitFactory(makeMockInitializer(changeSet(nonePayload, false)))],
+    synchronizerSlots: [],
+    dataCallback,
+    statusManager,
+    selectorGetter: noSelector,
+  });
+
+  await expect(ds.start()).rejects.toThrow('All data sources exhausted');
+  expect(dataCallback).not.toHaveBeenCalled();
+  ds.close();
+});
+
 it('continues past initializer errors', async () => {
   const dataCallback = jest.fn();
   const statusManager = makeStatusManager();

packages/shared/sdk-client/__tests__/datasource/fdv2/orchestrationTestHelpers.ts

@@ -76,7 +76,7 @@ export function makePayload(
 ): internal.Payload {
   return {
     version: 1,
-    state: opts.state ?? 'test-selector',
+    ...('state' in opts ? { state: opts.state } : { state: 'test-selector' }),
     type: opts.type ?? 'full',
     updates: [],
   };

packages/shared/sdk-client/src/datasource/fdv2/CacheInitializer.ts

@@ -3,13 +3,7 @@ import { Context, Crypto, internal, LDLogger, Storage } from '@launchdarkly/js-s
 import { readFreshness } from '../../storage/freshness';
 import { loadCachedFlags } from '../../storage/loadCachedFlags';
 import { Flag } from '../../types';
-import {
-  changeSet,
-  errorInfoFromUnknown,
-  FDv2SourceResult,
-  interrupted,
-  shutdown,
-} from './FDv2SourceResult';
+import { changeSet, FDv2SourceResult, shutdown } from './FDv2SourceResult';
 import { Initializer } from './Initializer';
 import { InitializerFactory } from './SourceManager';
 
@@ -50,13 +44,13 @@ async function loadFromCache(config: CacheInitializerConfig): Promise<FDv2Source
 
   if (!storage) {
     logger?.debug('No storage available for cache initializer');
-    return interrupted(errorInfoFromUnknown('No storage available'), false);
+    return changeSet({ version: 0, type: 'none', updates: [] }, false);
   }
 
   const cached = await loadCachedFlags(storage, crypto, environmentNamespace, context, logger);
   if (!cached) {
     logger?.debug('Cache miss for context');
-    return interrupted(errorInfoFromUnknown('Cache miss'), false);
+    return changeSet({ version: 0, type: 'none', updates: [] }, false);
   }
 
   const updates: internal.Update[] = Object.entries(cached.flags).map(

packages/shared/sdk-client/src/datasource/fdv2/FDv2DataSource.ts

@@ -145,18 +145,18 @@ export function createFDv2DataSource(config: FDv2DataSourceConfig): FDv2DataSour
         return;
       }
 
-      if (result.type === 'changeSet') {
+      if (result.type === 'changeSet' && result.payload.type !== 'none') {
         applyChangeSet(result);
 
         if (handleFdv1Fallback(result)) {
-          // FDv1 fallback triggered during initialization — data was received
+          // 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.
+          // Got basis data with a selector -- initialization is complete.
           markInitialized();
           return;
         }