@devrev/airsync-sdk 2.0.0-beta.2 → 2.0.0-beta.4

package/dist/state/extraction-state.d.ts

@@ -0,0 +1,29 @@
+import { BaseState } from './base-state';
+import { StateInterface } from './state.interfaces';
+/**
+ * ExtractionState is the per-mode state for extraction workers. It seeds the
+ * extraction SDK state (extraction boundaries + attachments bookkeeping) on top
+ * of the shared lifecycle provided by `BaseState` and adds extraction-window
+ * resolution.
+ */
+export declare class ExtractionState<ConnectorState> extends BaseState<ConnectorState> {
+    constructor(params: StateInterface<ConnectorState>);
+    /**
+     * Resolves the extraction window onto the event context.
+     *
+     * On StartExtractingMetadata: resolve fresh from the TimeValue objects in the
+     * event context and cache them as pending boundaries (always overwrite).
+     * On all other events: reuse the pending boundaries cached during
+     * StartExtractingMetadata. Finally, validate that extract_from < extract_to.
+     */
+    resolveExtractionWindow(): void;
+}
+/**
+ * Creates and initializes an `ExtractionState` for an extraction worker.
+ *
+ * For non-stateless events this fetches persisted state, installs the initial
+ * domain mapping if the snap-in version changed, then resolves the extraction
+ * window (time-value resolution + pending boundary reuse) and validates it.
+ */
+export declare function createExtractionState<ConnectorState>({ event, initialState, initialDomainMapping, options, }: StateInterface<ConnectorState>): Promise<ExtractionState<ConnectorState>>;
+//# sourceMappingURL=extraction-state.d.ts.map

package/dist/state/extraction-state.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"extraction-state.d.ts","sourceRoot":"","sources":["../../src/state/extraction-state.ts"],"names":[],"mappings":"AAQA,OAAO,EAAE,SAAS,EAAE,MAAM,cAAc,CAAC;AACzC,OAAO,EAAsB,cAAc,EAAE,MAAM,oBAAoB,CAAC;AAExE;;;;;GAKG;AACH,qBAAa,eAAe,CAAC,cAAc,CAAE,SAAQ,SAAS,CAAC,cAAc,CAAC;gBAChE,MAAM,EAAE,cAAc,CAAC,cAAc,CAAC;IAIlD;;;;;;;OAOG;IACH,uBAAuB,IAAI,IAAI;CA+EhC;AAED;;;;;;GAMG;AACH,wBAAsB,qBAAqB,CAAC,cAAc,EAAE,EAC1D,KAAK,EACL,YAAY,EACZ,oBAAoB,EACpB,OAAO,GACR,EAAE,cAAc,CAAC,cAAc,CAAC,GAAG,OAAO,CAAC,eAAe,CAAC,cAAc,CAAC,CAAC,CAkB3E"}

package/dist/state/extraction-state.js

@@ -0,0 +1,122 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.ExtractionState = void 0;
+exports.createExtractionState = createExtractionState;
+const node_worker_threads_1 = require("node:worker_threads");
+const constants_1 = require("../common/constants");
+const time_value_resolver_1 = require("./time-value-resolver");
+const logger_1 = require("../logger/logger");
+const extraction_1 = require("../types/extraction");
+const workers_1 = require("../types/workers");
+const base_state_1 = require("./base-state");
+const state_interfaces_1 = require("./state.interfaces");
+/**
+ * ExtractionState is the per-mode state for extraction workers. It seeds the
+ * extraction SDK state (extraction boundaries + attachments bookkeeping) on top
+ * of the shared lifecycle provided by `BaseState` and adds extraction-window
+ * resolution.
+ */
+class ExtractionState extends base_state_1.BaseState {
+    constructor(params) {
+        super(params, state_interfaces_1.extractionSdkState);
+    }
+    /**
+     * Resolves the extraction window onto the event context.
+     *
+     * On StartExtractingMetadata: resolve fresh from the TimeValue objects in the
+     * event context and cache them as pending boundaries (always overwrite).
+     * On all other events: reuse the pending boundaries cached during
+     * StartExtractingMetadata. Finally, validate that extract_from < extract_to.
+     */
+    resolveExtractionWindow() {
+        const sdkState = this.sdkState;
+        const eventContext = this.event.payload.event_context;
+        if (this.event.payload.event_type === extraction_1.EventType.StartExtractingMetadata) {
+            const timeFields = [
+                {
+                    source: 'extraction_start_time',
+                    target: 'extract_from',
+                    pending: 'pendingWorkersOldest',
+                },
+                {
+                    source: 'extraction_end_time',
+                    target: 'extract_to',
+                    pending: 'pendingWorkersNewest',
+                },
+            ];
+            for (const { source, target, pending } of timeFields) {
+                const timeValue = eventContext[source];
+                if (timeValue && timeValue.type) {
+                    try {
+                        const resolved = (0, time_value_resolver_1.resolveTimeValue)(timeValue, sdkState);
+                        eventContext[target] = resolved;
+                        sdkState[pending] = resolved;
+                        console.log(`Resolved ${target} to ${resolved}. Stored in ${pending}.`);
+                    }
+                    catch (error) {
+                        const errorMessage = `Failed to resolve ${source}: ${(0, logger_1.serializeError)(error)}`;
+                        console.error(errorMessage);
+                        node_worker_threads_1.parentPort === null || node_worker_threads_1.parentPort === void 0 ? void 0 : node_worker_threads_1.parentPort.postMessage({
+                            subject: workers_1.WorkerMessageSubject.WorkerMessageFailed,
+                            payload: { message: errorMessage },
+                        });
+                        process.exit(1);
+                    }
+                }
+            }
+        }
+        else {
+            // Non-StartExtractingMetadata events: reuse pending values from state
+            if (sdkState.pendingWorkersOldest) {
+                eventContext.extract_from = sdkState.pendingWorkersOldest;
+                console.log(`Reusing pendingWorkersOldest as extract_from: ${sdkState.pendingWorkersOldest}.`);
+            }
+            else {
+                console.log('pendingWorkersOldest is not set in state. extract_from will not be populated for this invocation.');
+            }
+            if (sdkState.pendingWorkersNewest) {
+                eventContext.extract_to = sdkState.pendingWorkersNewest;
+                console.log(`Reusing pendingWorkersNewest as extract_to: ${sdkState.pendingWorkersNewest}.`);
+            }
+            else {
+                console.log('pendingWorkersNewest is not set in state. extract_to will not be populated for this invocation.');
+            }
+        }
+        // Validate that extract_from is before extract_to
+        if (eventContext.extract_from && eventContext.extract_to) {
+            if (eventContext.extract_from >= eventContext.extract_to) {
+                const errorMessage = `Invalid extraction window: extract_from (${eventContext.extract_from}) must be older than extract_to (${eventContext.extract_to}). This indicates an error in the platform.`;
+                console.error(errorMessage);
+                node_worker_threads_1.parentPort === null || node_worker_threads_1.parentPort === void 0 ? void 0 : node_worker_threads_1.parentPort.postMessage({
+                    subject: workers_1.WorkerMessageSubject.WorkerMessageFailed,
+                    payload: { message: errorMessage },
+                });
+                process.exit(1);
+            }
+        }
+    }
+}
+exports.ExtractionState = ExtractionState;
+/**
+ * Creates and initializes an `ExtractionState` for an extraction worker.
+ *
+ * For non-stateless events this fetches persisted state, installs the initial
+ * domain mapping if the snap-in version changed, then resolves the extraction
+ * window (time-value resolution + pending boundary reuse) and validates it.
+ */
+async function createExtractionState({ event, initialState, initialDomainMapping, options, }) {
+    // Deep clone the initial state to avoid mutating the original state
+    const deepCloneInitialState = structuredClone(initialState);
+    const state = new ExtractionState({
+        event,
+        initialState: deepCloneInitialState,
+        initialDomainMapping,
+        options,
+    });
+    if (!constants_1.STATELESS_EVENT_TYPES.includes(event.payload.event_type)) {
+        await state.init(deepCloneInitialState);
+        await state.installInitialDomainMappingIfNeeded(initialDomainMapping);
+        state.resolveExtractionWindow();
+    }
+    return state;
+}

package/dist/state/install-initial-domain-mapping.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"install-initial-domain-mapping.d.ts","sourceRoot":"","sources":["../../src/state/install-initial-domain-mapping.ts"],"names":[],"mappings":"AACA,OAAO,EAAE,YAAY,EAAE,MAAM,qBAAqB,CAAC;AAGnD,OAAO,EAAE,oBAAoB,EAAE,MAAM,iBAAiB,CAAC;AAEvD,wBAAsB,2BAA2B,CAC/C,KAAK,EAAE,YAAY,EACnB,wBAAwB,EAAE,oBAAoB,GAC7C,OAAO,CAAC,IAAI,CAAC,CA0Ff"}

package/dist/{common → state}/install-initial-domain-mapping.js

@@ -1,7 +1,7 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.installInitialDomainMapping = installInitialDomainMapping;
-const axios_client_internal_1 = require("../http/axios-client-internal");
+const client_1 = require("../http/client");
 const logger_1 = require("../logger/logger");
 async function installInitialDomainMapping(event, initialDomainMappingJson) {
     var _a, _b, _c, _d, _e, _f, _g;
@@ -13,7 +13,7 @@ async function installInitialDomainMapping(event, initialDomainMappingJson) {
         return;
     }
     // Get snap-in details
-    const snapInResponse = await axios_client_internal_1.axiosClient.get(devrevEndpoint + '/internal/snap-ins.get', {
+    const snapInResponse = await client_1.axiosClient.get(devrevEndpoint + '/internal/snap-ins.get', {
         headers: {
             Authorization: devrevToken,
         },
@@ -33,7 +33,7 @@ async function installInitialDomainMapping(event, initialDomainMappingJson) {
     if (startingRecipeBlueprint &&
         Object.keys(startingRecipeBlueprint).length !== 0) {
         try {
-            const recipeBlueprintResponse = await axios_client_internal_1.axiosClient.post(`${devrevEndpoint}/internal/airdrop.recipe.blueprints.create`, Object.assign({}, startingRecipeBlueprint), {
+            const recipeBlueprintResponse = await client_1.axiosClient.post(`${devrevEndpoint}/internal/airdrop.recipe.blueprints.create`, Object.assign({}, startingRecipeBlueprint), {
                 headers: {
                     Authorization: devrevToken,
                 },
@@ -47,7 +47,7 @@ async function installInitialDomainMapping(event, initialDomainMappingJson) {
     }
     // Install the initial domain mappings
     const additionalMappings = initialDomainMappingJson.additional_mappings || {};
-    const initialDomainMappingInstallResponse = await axios_client_internal_1.axiosClient.post(`${devrevEndpoint}/internal/airdrop.recipe.initial-domain-mappings.install`, Object.assign(Object.assign({ external_system_type: 'ADaaS', import_slug: importSlug, snap_in_slug: snapInSlug }, (recipeBlueprintId && {
+    const initialDomainMappingInstallResponse = await client_1.axiosClient.post(`${devrevEndpoint}/internal/airdrop.recipe.initial-domain-mappings.install`, Object.assign(Object.assign({ external_system_type: 'ADaaS', import_slug: importSlug, snap_in_slug: snapInSlug }, (recipeBlueprintId && {
         starting_recipe_blueprint: recipeBlueprintId,
     })), additionalMappings), {
         headers: {

package/dist/state/loading-state.d.ts

@@ -0,0 +1,18 @@
+import { BaseState } from './base-state';
+import { StateInterface } from './state.interfaces';
+/**
+ * LoadingState is the per-mode state for loading workers. It seeds the loading
+ * SDK state (files-to-load bookkeeping) on top of the shared lifecycle provided
+ * by `BaseState`. Loading has no extraction-window resolution.
+ */
+export declare class LoadingState<ConnectorState> extends BaseState<ConnectorState> {
+    constructor(params: StateInterface<ConnectorState>);
+}
+/**
+ * Creates and initializes a `LoadingState` for a loading worker.
+ *
+ * For non-stateless events this fetches persisted state and installs the
+ * initial domain mapping if the snap-in version changed.
+ */
+export declare function createLoadingState<ConnectorState>({ event, initialState, initialDomainMapping, options, }: StateInterface<ConnectorState>): Promise<LoadingState<ConnectorState>>;
+//# sourceMappingURL=loading-state.d.ts.map

package/dist/state/loading-state.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"loading-state.d.ts","sourceRoot":"","sources":["../../src/state/loading-state.ts"],"names":[],"mappings":"AAEA,OAAO,EAAE,SAAS,EAAE,MAAM,cAAc,CAAC;AACzC,OAAO,EAAmB,cAAc,EAAE,MAAM,oBAAoB,CAAC;AAErE;;;;GAIG;AACH,qBAAa,YAAY,CAAC,cAAc,CAAE,SAAQ,SAAS,CAAC,cAAc,CAAC;gBAC7D,MAAM,EAAE,cAAc,CAAC,cAAc,CAAC;CAGnD;AAED;;;;;GAKG;AACH,wBAAsB,kBAAkB,CAAC,cAAc,EAAE,EACvD,KAAK,EACL,YAAY,EACZ,oBAAoB,EACpB,OAAO,GACR,EAAE,cAAc,CAAC,cAAc,CAAC,GAAG,OAAO,CAAC,YAAY,CAAC,cAAc,CAAC,CAAC,CAiBxE"}

package/dist/state/loading-state.js

@@ -0,0 +1,39 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.LoadingState = void 0;
+exports.createLoadingState = createLoadingState;
+const constants_1 = require("../common/constants");
+const base_state_1 = require("./base-state");
+const state_interfaces_1 = require("./state.interfaces");
+/**
+ * LoadingState is the per-mode state for loading workers. It seeds the loading
+ * SDK state (files-to-load bookkeeping) on top of the shared lifecycle provided
+ * by `BaseState`. Loading has no extraction-window resolution.
+ */
+class LoadingState extends base_state_1.BaseState {
+    constructor(params) {
+        super(params, state_interfaces_1.loadingSdkState);
+    }
+}
+exports.LoadingState = LoadingState;
+/**
+ * Creates and initializes a `LoadingState` for a loading worker.
+ *
+ * For non-stateless events this fetches persisted state and installs the
+ * initial domain mapping if the snap-in version changed.
+ */
+async function createLoadingState({ event, initialState, initialDomainMapping, options, }) {
+    // Deep clone the initial state to avoid mutating the original state
+    const deepCloneInitialState = structuredClone(initialState);
+    const state = new LoadingState({
+        event,
+        initialState: deepCloneInitialState,
+        initialDomainMapping,
+        options,
+    });
+    if (!constants_1.STATELESS_EVENT_TYPES.includes(event.payload.event_type)) {
+        await state.init(deepCloneInitialState);
+        await state.installInitialDomainMappingIfNeeded(initialDomainMapping);
+    }
+    return state;
+}

package/dist/state/state.d.ts

@@ -1,36 +1,4 @@
-import { AdapterState, StateInterface } from './state.interfaces';
-import { ExtractionScope } from '../types/workers';
-export declare function createAdapterState<ConnectorState>({ event, initialState, initialDomainMapping, options, }: StateInterface<ConnectorState>): Promise<State<ConnectorState>>;
-export declare class State<ConnectorState> {
-    private _state;
-    private _extractionScope;
-    private initialSdkState;
-    private workerUrl;
-    private devrevToken;
-    private syncUnitId;
-    private requestId;
-    constructor({ event, initialState }: StateInterface<ConnectorState>);
-    get state(): AdapterState<ConnectorState>;
-    set state(value: AdapterState<ConnectorState>);
-    get extractionScope(): ExtractionScope;
-    /**
-     * Initializes the state for this adapter instance by fetching from API
-     * or creating an initial state if none exists (404).
-     * @param initialState The initial connector state provided by the spawn function
-     */
-    init(initialState: ConnectorState): Promise<void>;
-    /**
-     *  Updates the state of the adapter by posting to API.
-     * @param {object} state - The state to be updated
-     */
-    postState(state?: AdapterState<ConnectorState>): Promise<void>;
-    /**
-     *  Fetches the state of the adapter from API.
-     * @return  The raw state data from API
-     */
-    fetchState(): Promise<{
-        state: string;
-        objects?: string;
-    }>;
-}
+export { BaseState } from './base-state';
+export { ExtractionState, createExtractionState } from './extraction-state';
+export { LoadingState, createLoadingState } from './loading-state';
 //# sourceMappingURL=state.d.ts.map

package/dist/state/state.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"state.d.ts","sourceRoot":"","sources":["../../src/state/state.ts"],"names":[],"mappings":"AAYA,OAAO,EACL,YAAY,EAIZ,cAAc,EACf,MAAM,oBAAoB,CAAC;AAC5B,OAAO,EAAE,eAAe,EAAE,MAAM,kBAAkB,CAAC;AAEnD,wBAAsB,kBAAkB,CAAC,cAAc,EAAE,EACvD,KAAK,EACL,YAAY,EACZ,oBAAoB,EACpB,OAAO,GACR,EAAE,cAAc,CAAC,cAAc,CAAC,GAAG,OAAO,CAAC,KAAK,CAAC,cAAc,CAAC,CAAC,CAoIjE;AAED,qBAAa,KAAK,CAAC,cAAc;IAC/B,OAAO,CAAC,MAAM,CAA+B;IAC7C,OAAO,CAAC,gBAAgB,CAAuB;IAC/C,OAAO,CAAC,eAAe,CAAW;IAClC,OAAO,CAAC,SAAS,CAAS;IAC1B,OAAO,CAAC,WAAW,CAAS;IAC5B,OAAO,CAAC,UAAU,CAAS;IAC3B,OAAO,CAAC,SAAS,CAAS;gBAEd,EAAE,KAAK,EAAE,YAAY,EAAE,EAAE,cAAc,CAAC,cAAc,CAAC;IAenE,IAAI,KAAK,IAAI,YAAY,CAAC,cAAc,CAAC,CAExC;IAED,IAAI,KAAK,CAAC,KAAK,EAAE,YAAY,CAAC,cAAc,CAAC,EAE5C;IAED,IAAI,eAAe,IAAI,eAAe,CAErC;IAED;;;;OAIG;IACG,IAAI,CAAC,YAAY,EAAE,cAAc,GAAG,OAAO,CAAC,IAAI,CAAC;IAiDvD;;;OAGG;IACG,SAAS,CAAC,KAAK,CAAC,EAAE,YAAY,CAAC,cAAc,CAAC;IAqDpD;;;OAGG;IACG,UAAU,IAAI,OAAO,CAAC;QAAE,KAAK,EAAE,MAAM,CAAC;QAAC,OAAO,CAAC,EAAE,MAAM,CAAA;KAAE,CAAC;CAqBjE"}
+{"version":3,"file":"state.d.ts","sourceRoot":"","sources":["../../src/state/state.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,SAAS,EAAE,MAAM,cAAc,CAAC;AACzC,OAAO,EAAE,eAAe,EAAE,qBAAqB,EAAE,MAAM,oBAAoB,CAAC;AAC5E,OAAO,EAAE,YAAY,EAAE,kBAAkB,EAAE,MAAM,iBAAiB,CAAC"}

package/dist/state/state.interfaces.d.ts

@@ -18,10 +18,14 @@ export interface SdkState {
     snapInVersionId?: string;
 }
 /**
- * AdapterState is an interface that defines the structure of the adapter state that is used by the external extractor.
- * It extends the connector state with additional fields including snapInVersionId and attachmentsMetadata.
+ * AdapterStateEnvelope is the v2 on-disk state shape: connector state and SDK
+ * bookkeeping are stored as disjoint sub-objects so SDK internals stay
+ * encapsulated and never collide with connector keys.
  */
-export type AdapterState<ConnectorState> = ConnectorState & SdkState;
+export interface AdapterStateEnvelope<ConnectorState> {
+    connectorState: ConnectorState;
+    sdkState: SdkState;
+}
 export interface ToDevRev {
     attachmentsMetadata: {
         artifactIds: string[];
@@ -65,4 +69,17 @@ export declare const loadingSdkState: {
         filesToLoad: never[];
     };
 };
+/**
+ * The set of top-level state keys owned by the SDK. Derived from the initial
+ * SDK state constants so it auto-updates whenever a new SDK field is added.
+ * Used by the migration shim to split a flat v1 state blob into the
+ * `{ connectorState, sdkState }` envelope: keys in this set go to `sdkState`,
+ * everything else is connector state.
+ *
+ * `lastSyncStarted` / `lastSuccessfulSyncStarted` are retained here even though
+ * they are no longer fields on `SdkState`: a flat v1 blob may still carry them,
+ * and they must be recognized as SDK-owned so they are stripped out rather than
+ * leaking into connector state during migration.
+ */
+export declare const V1_SDK_STATE_KEYS: ReadonlySet<string>;
 //# sourceMappingURL=state.interfaces.d.ts.map

package/dist/state/state.interfaces.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"state.interfaces.d.ts","sourceRoot":"","sources":["../../src/state/state.interfaces.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,oBAAoB,EAAE,MAAM,iBAAiB,CAAC;AACvD,OAAO,EAAE,YAAY,EAAE,MAAM,qBAAqB,CAAC;AACnD,OAAO,EAAE,UAAU,EAAE,MAAM,kBAAkB,CAAC;AAC9C,OAAO,EAAE,oBAAoB,EAAE,MAAM,kBAAkB,CAAC;AAExD,MAAM,WAAW,QAAQ;IACvB;gHAC4G;IAC5G,oBAAoB,CAAC,EAAE,MAAM,CAAC;IAC9B;gHAC4G;IAC5G,oBAAoB,CAAC,EAAE,MAAM,CAAC;IAC9B,2DAA2D;IAC3D,aAAa,CAAC,EAAE,MAAM,CAAC;IACvB,2DAA2D;IAC3D,aAAa,CAAC,EAAE,MAAM,CAAC;IACvB,QAAQ,CAAC,EAAE,QAAQ,CAAC;IACpB,UAAU,CAAC,EAAE,UAAU,CAAC;IACxB,eAAe,CAAC,EAAE,MAAM,CAAC;CAC1B;AAED;;;GAGG;AACH,MAAM,MAAM,YAAY,CAAC,cAAc,IAAI,cAAc,GAAG,QAAQ,CAAC;AAErE,MAAM,WAAW,QAAQ;IACvB,mBAAmB,EAAE;QACnB,WAAW,EAAE,MAAM,EAAE,CAAC;QACtB,aAAa,EAAE,MAAM,CAAC;QACtB,+BAA+B,CAAC,EAAE,mBAAmB,EAAE,CAAC;KACzD,CAAC;CACH;AAED;;GAEG;AACH,MAAM,WAAW,mBAAmB;IAClC,EAAE,EAAE,MAAM,CAAC;IACX,SAAS,EAAE,MAAM,CAAC;CACnB;AAED,MAAM,WAAW,UAAU;IACzB,WAAW,EAAE,UAAU,EAAE,CAAC;CAC3B;AAED,MAAM,WAAW,cAAc,CAAC,cAAc;IAC5C,KAAK,EAAE,YAAY,CAAC;IACpB,YAAY,EAAE,cAAc,CAAC;IAC7B,oBAAoB,CAAC,EAAE,oBAAoB,CAAC;IAC5C,OAAO,CAAC,EAAE,oBAAoB,CAAC;CAChC;AAED,eAAO,MAAM,kBAAkB;;;;;;;;;;;;;CAa9B,CAAC;AAEF,eAAO,MAAM,eAAe;;;;;CAK3B,CAAC"}
+{"version":3,"file":"state.interfaces.d.ts","sourceRoot":"","sources":["../../src/state/state.interfaces.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,oBAAoB,EAAE,MAAM,iBAAiB,CAAC;AACvD,OAAO,EAAE,YAAY,EAAE,MAAM,qBAAqB,CAAC;AACnD,OAAO,EAAE,UAAU,EAAE,MAAM,kBAAkB,CAAC;AAC9C,OAAO,EAAE,oBAAoB,EAAE,MAAM,kBAAkB,CAAC;AAExD,MAAM,WAAW,QAAQ;IACvB;gHAC4G;IAC5G,oBAAoB,CAAC,EAAE,MAAM,CAAC;IAC9B;gHAC4G;IAC5G,oBAAoB,CAAC,EAAE,MAAM,CAAC;IAC9B,2DAA2D;IAC3D,aAAa,CAAC,EAAE,MAAM,CAAC;IACvB,2DAA2D;IAC3D,aAAa,CAAC,EAAE,MAAM,CAAC;IACvB,QAAQ,CAAC,EAAE,QAAQ,CAAC;IACpB,UAAU,CAAC,EAAE,UAAU,CAAC;IACxB,eAAe,CAAC,EAAE,MAAM,CAAC;CAC1B;AAED;;;;GAIG;AACH,MAAM,WAAW,oBAAoB,CAAC,cAAc;IAClD,cAAc,EAAE,cAAc,CAAC;IAC/B,QAAQ,EAAE,QAAQ,CAAC;CACpB;AAED,MAAM,WAAW,QAAQ;IACvB,mBAAmB,EAAE;QACnB,WAAW,EAAE,MAAM,EAAE,CAAC;QACtB,aAAa,EAAE,MAAM,CAAC;QACtB,+BAA+B,CAAC,EAAE,mBAAmB,EAAE,CAAC;KACzD,CAAC;CACH;AAED;;GAEG;AACH,MAAM,WAAW,mBAAmB;IAClC,EAAE,EAAE,MAAM,CAAC;IACX,SAAS,EAAE,MAAM,CAAC;CACnB;AAED,MAAM,WAAW,UAAU;IACzB,WAAW,EAAE,UAAU,EAAE,CAAC;CAC3B;AAED,MAAM,WAAW,cAAc,CAAC,cAAc;IAC5C,KAAK,EAAE,YAAY,CAAC;IACpB,YAAY,EAAE,cAAc,CAAC;IAC7B,oBAAoB,CAAC,EAAE,oBAAoB,CAAC;IAC5C,OAAO,CAAC,EAAE,oBAAoB,CAAC;CAChC;AAED,eAAO,MAAM,kBAAkB;;;;;;;;;;;;;CAa9B,CAAC;AAEF,eAAO,MAAM,eAAe;;;;;CAK3B,CAAC;AAEF;;;;;;;;;;;GAWG;AACH,eAAO,MAAM,iBAAiB,EAAE,WAAW,CAAC,MAAM,CAKhD,CAAC"}

package/dist/state/state.interfaces.js

@@ -1,6 +1,6 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.loadingSdkState = exports.extractionSdkState = void 0;
+exports.V1_SDK_STATE_KEYS = exports.loadingSdkState = exports.extractionSdkState = void 0;
 exports.extractionSdkState = {
     pendingWorkersOldest: '',
     pendingWorkersNewest: '',
@@ -21,3 +21,21 @@ exports.loadingSdkState = {
         filesToLoad: [],
     },
 };
+/**
+ * The set of top-level state keys owned by the SDK. Derived from the initial
+ * SDK state constants so it auto-updates whenever a new SDK field is added.
+ * Used by the migration shim to split a flat v1 state blob into the
+ * `{ connectorState, sdkState }` envelope: keys in this set go to `sdkState`,
+ * everything else is connector state.
+ *
+ * `lastSyncStarted` / `lastSuccessfulSyncStarted` are retained here even though
+ * they are no longer fields on `SdkState`: a flat v1 blob may still carry them,
+ * and they must be recognized as SDK-owned so they are stripped out rather than
+ * leaking into connector state during migration.
+ */
+exports.V1_SDK_STATE_KEYS = new Set([
+    ...Object.keys(exports.extractionSdkState),
+    ...Object.keys(exports.loadingSdkState),
+    'lastSyncStarted',
+    'lastSuccessfulSyncStarted',
+]);