@coveo/headless 3.28.4-pre.f345a65b79 → 3.28.4-pre.fe2dbcea63

package/dist/cjs/ssr-next/headless.cjs

@@ -1306,7 +1306,7 @@ var import_toolkit2 = require("@reduxjs/toolkit");
 var import_toolkit = require("@reduxjs/toolkit");
 
 // src/utils/version.ts
-var VERSION = "3.28.4-pre.f345a65b79";
+var VERSION = "3.28.4-pre.fe2dbcea63";
 var COVEO_FRAMEWORK = ["@coveo/atomic", "@coveo/quantic"];
 
 // src/api/analytics/analytics-selectors.ts

package/dist/definitions/api/commerce/common/product.d.ts

@@ -130,6 +130,10 @@ export interface BaseProduct {
      * The length and offset of each word to highlight in the product excerpt string.
      */
     excerptsHighlights?: HighlightKeyword[];
+    /**
+     * The ID of the response that returned the product.
+     */
+    responseId?: string;
 }
 export interface Product extends BaseProduct {
     /**

package/dist/definitions/ssr-commerce-next.index.d.ts

@@ -93,7 +93,7 @@ export type { InstantProducts, InstantProductsDefinition, InstantProductsOptions
 export { defineInstantProducts } from './ssr-next/commerce/controllers/instant-products/headless-instant-products.ssr.js';
 export type { CorePaginationOptions, Pagination, PaginationOptions, PaginationProps, PaginationState, } from './ssr-next/commerce/controllers/pagination/headless-core-commerce-pagination.ssr.js';
 export { definePagination } from './ssr-next/commerce/controllers/pagination/headless-core-commerce-pagination.ssr.js';
-export type { CommerceSearchParameters, ParameterManager, ParameterManagerProps, ParameterManagerState, Parameters, ProductListingParameters, SSRParameterManagerProps, } from './ssr-next/commerce/controllers/parameter-manager/headless-core-parameter-manager.ssr.js';
+export type { CommerceSearchParameters, ParameterManager, ParameterManagerDefinition, ParameterManagerProps, ParameterManagerState, Parameters, ProductListingParameters, SSRParameterManagerProps, } from './ssr-next/commerce/controllers/parameter-manager/headless-core-parameter-manager.ssr.js';
 export { defineParameterManager } from './ssr-next/commerce/controllers/parameter-manager/headless-core-parameter-manager.ssr.js';
 export type { ProductList, ProductListing, ProductListState, Search, } from './ssr-next/commerce/controllers/product-list/headless-product-list.ssr.js';
 export { defineProductList } from './ssr-next/commerce/controllers/product-list/headless-product-list.ssr.js';

package/dist/definitions/ssr-next/commerce/controller-utils.d.ts

@@ -1,19 +1,18 @@
 import type { UnknownAction } from '@reduxjs/toolkit';
 import type { Controller } from '../../controllers/controller/headless-controller.js';
-import type { ControllersMap } from '../common/types/controllers.js';
 import type { SSRCommerceEngine } from './factories/build-factory.js';
 import type { SolutionType } from './types/controller-constants.js';
-import type { ControllerDefinitionOption, ControllerDefinitionsMap, InferControllerStaticStateMapFromControllers } from './types/controller-definitions.js';
-import type { InferControllerPropsMapFromDefinitions, InferControllersMapFromDefinition } from './types/controller-inference.js';
+import type { ControllerDefinitionOption, ControllerDefinitionsMap } from './types/controller-definitions.js';
+import type { InferControllerPropsMapFromDefinitions, InferControllerStaticStateMapFromDefinitionsWithSolutionType, InferControllersMapFromDefinition } from './types/controller-inference.js';
 import type { EngineStaticState } from './types/engine.js';
-export declare function createStaticState<TSearchAction extends UnknownAction>({ searchActions, controllers, }: {
+export declare function createStaticState<TSearchAction extends UnknownAction, TControllerDefinitions extends ControllerDefinitionsMap<Controller>>({ searchActions, controllers, }: {
     searchActions: TSearchAction[];
-    controllers: ControllersMap;
-}): EngineStaticState<TSearchAction, InferControllerStaticStateMapFromControllers<ControllersMap>>;
+    controllers: InferControllersMapFromDefinition<TControllerDefinitions, SolutionType>;
+}): EngineStaticState<TSearchAction, InferControllerStaticStateMapFromDefinitionsWithSolutionType<TControllerDefinitions, SolutionType>>;
 export declare function buildControllerDefinitions<TControllerDefinitionsMap extends ControllerDefinitionsMap<Controller>, TSolutionType extends SolutionType>({ definitionsMap, engine, solutionType, propsMap, }: {
     definitionsMap: TControllerDefinitionsMap;
     engine: SSRCommerceEngine;
     solutionType: TSolutionType;
-    propsMap: InferControllerPropsMapFromDefinitions<TControllerDefinitionsMap>;
+    propsMap?: InferControllerPropsMapFromDefinitions<TControllerDefinitionsMap>;
 }): InferControllersMapFromDefinition<TControllerDefinitionsMap, TSolutionType>;
 export declare function ensureAtLeastOneSolutionType(options?: ControllerDefinitionOption): void;

package/dist/definitions/ssr-next/commerce/controllers/context/headless-context.ssr.d.ts

@@ -1,7 +1,9 @@
 import { type Context, type ContextOptions, type ContextProps, type ContextState, type UserLocation, type View } from '../../../../controllers/commerce/context/headless-context.js';
 import type { UniversalControllerDefinitionWithProps } from '../../types/controller-definitions.js';
 export type { Context, ContextProps, ContextState, View, UserLocation, ContextOptions, };
-export interface ContextDefinition extends UniversalControllerDefinitionWithProps<Context, ContextOptions> {
+export interface ContextDefinition extends UniversalControllerDefinitionWithProps<Context, {
+    initialState: ContextOptions;
+}> {
 }
 /**
  * Defines a `Context` controller instance.

package/dist/definitions/ssr-next/commerce/controllers/parameter-manager/headless-core-parameter-manager.ssr.d.ts

@@ -4,13 +4,14 @@ import type { ProductListingParameters } from '../../../../features/commerce/pro
 import type { CommerceSearchParameters } from '../../../../features/commerce/search-parameters/search-parameters-actions.js';
 import type { ControllerDefinitionOption, SubControllerDefinitionWithProps } from '../../types/controller-definitions.js';
 export type { ParameterManager, ParameterManagerProps, ParameterManagerState, Parameters, ProductListingParameters, CommerceSearchParameters, };
+export type ParameterManagerDefinition<TOptions extends ControllerDefinitionOption | undefined> = SubControllerDefinitionWithProps<ParameterManager<MappedParameterTypes<TOptions>>, TOptions, SSRParameterManagerProps<MappedParameterTypes<TOptions>>>;
 /**
  * Defines a `ParameterManager` controller instance.
  * @group Definers
  *
  * @returns The `ParameterManager` controller definition.
  */
-export declare function defineParameterManager<TOptions extends ControllerDefinitionOption | undefined>(options?: TOptions): SubControllerDefinitionWithProps<ParameterManager<MappedParameterTypes<TOptions>>, TOptions, SSRParameterManagerProps<MappedParameterTypes<TOptions>>>;
+export declare function defineParameterManager<TOptions extends ControllerDefinitionOption | undefined>(options?: TOptions): ParameterManagerDefinition<TOptions>;
 export interface SSRParameterManagerProps<T extends Parameters> extends Omit<ParameterManagerProps<T>, 'excludeDefaultParameters'> {
 }
 type MappedParameterTypes<TOptions extends ControllerDefinitionOption | undefined> = TOptions extends {

package/dist/definitions/ssr-next/commerce/engine/commerce-engine.ssr.d.ts

@@ -18,9 +18,34 @@ import type { CommerceEngineDefinition } from '../types/engine.js';
  *
  * @example
  * ```ts
- * const engineDefinition = defineCommerceEngine(engineConfig);
- * type SearchStaticState = InferStaticState<typeof engineDefinition>;
- * type SearchHydratedState = InferHydratedState<typeof engineDefinition>;
+ * const { listingEngineDefinition } = defineCommerceEngine(engineConfig);
+ *
+ * // Pass navigator context directly to fetchStaticState
+ * const staticState = await listingEngineDefinition.fetchStaticState({
+ *   navigatorContext: {
+ *     forwardedFor: req.ip,
+ *     referrer: req.headers.referer || null,
+ *     userAgent: req.headers['user-agent'] || null,
+ *     clientId: 'unique-session-id'
+ *   }
+ * });
+ *
+ * // Framework examples:
+ * // Express.js
+ * app.get('/api/listing', async (req, res) => {
+ *   const state = await listingEngineDefinition.fetchStaticState({
+ *     navigatorContext: {
+ *       forwardedFor: req.ip,
+ *       referrer: req.headers.referer || null,
+ *       userAgent: req.headers['user-agent'] || null,
+ *       clientId: req.sessionID
+ *     }
+ *   });
+ *   res.json(state);
+ * });
+ *
+ * type SearchStaticState = InferStaticState<typeof listingEngineDefinition>;
+ * type SearchHydratedState = InferHydratedState<typeof listingEngineDefinition>;
  * ```
  *
  * @group Engine

package/dist/definitions/ssr-next/commerce/types/controller-inference.d.ts

@@ -8,7 +8,7 @@ export type InferStaticState<T extends {
 export type InferHydratedState<T extends {
     hydrateStaticState(...args: unknown[]): Promise<unknown>;
 }> = Awaited<ReturnType<T['hydrateStaticState']>>;
-export type InferControllerPropsFromDefinition<TController extends ControllerDefinition<Controller>> = TController extends ControllerDefinitionWithProps<Controller, infer Props> ? HasKey<TController, typeof recommendationInternalOptionKey> extends never ? Props : Props & RecommendationControllerSettings : TController extends ControllerDefinitionWithoutProps<Controller> ? HasKey<TController, typeof recommendationInternalOptionKey> extends never ? {} : RecommendationControllerSettings : unknown;
+type InferControllerPropsFromDefinition<TController extends ControllerDefinition<Controller>> = TController extends ControllerDefinitionWithProps<Controller, infer Props> ? HasKey<TController, typeof recommendationInternalOptionKey> extends never ? Props : Props & RecommendationControllerSettings : TController extends ControllerDefinitionWithoutProps<Controller> ? HasKey<TController, typeof recommendationInternalOptionKey> extends never ? {} : RecommendationControllerSettings : unknown;
 export type InferControllerPropsMapFromDefinitions<TControllers extends ControllerDefinitionsMap<Controller>> = {
     [K in keyof TControllers as HasKeys<InferControllerPropsFromDefinition<TControllers[K]>> extends false ? never : K]: InferControllerPropsFromDefinition<TControllers[K]>;
 };
@@ -17,5 +17,6 @@ export type InferControllersMapFromDefinition<TControllers extends ControllerDef
     [K in keyof TControllers as HasKey<TControllers[K], TSolutionType> extends never ? never : K]: InferControllerFromDefinition<TControllers[K]>;
 };
 export type InferControllerStaticStateMapFromDefinitionsWithSolutionType<TControllers extends ControllerDefinitionsMap<Controller>, TSolutionType extends SolutionType> = {
-    [K in keyof TControllers as HasKey<TControllers[K], TSolutionType> extends never ? never : K]: InferControllerStaticStateFromController<InferControllerFromDefinition<TControllers[K]>>;
+    [K in keyof TControllers as HasKey<TControllers[K], TSolutionType> extends never ? never : K]: InferControllerStaticStateFromController<InferControllerFromDefinition<TControllers[K]>> & InferControllerPropsFromDefinition<TControllers[K]>;
 };
+export {};

package/dist/definitions/ssr-next/commerce/types/engine.d.ts

@@ -1,7 +1,6 @@
 import type { UnknownAction } from '@reduxjs/toolkit';
 import type { CommerceEngineOptions } from '../../../app/commerce-engine/commerce-engine.js';
 import type { EngineConfiguration } from '../../../app/engine-configuration.js';
-import type { NavigatorContextProvider } from '../../../app/navigator-context-provider.js';
 import type { Controller } from '../../../controllers/controller/headless-controller.js';
 import type { ControllerStaticStateMap } from '../../common/types/controllers.js';
 import type { SSRCommerceEngine } from '../factories/build-factory.js';
@@ -33,13 +32,6 @@ export interface CommerceEngineDefinition<TControllers extends ControllerDefinit
      * Fetches the hydrated state on the client side using your engine definition and the static state.
      */
     hydrateStaticState: HydrateStaticState<InferControllersMapFromDefinition<TControllers, TSolutionType>, UnknownAction, InferControllerPropsMapFromDefinitions<TControllers>, TControllers, TSolutionType>;
-    /**
-     * Sets the navigator context provider.
-     * This provider is essential for retrieving navigation-related data such as referrer, userAgent, location, and clientId, which are crucial for handling both server-side and client-side API requests effectively.
-     *
-     * Note: The implementation specifics of the navigator context provider depend on the Node.js framework being utilized. It is the developer's responsibility to appropriately define and implement the navigator context provider to ensure accurate navigation context is available throughout the application. If the user fails to provide a navigator context provider, a warning will be logged either on the server or the browser console.
-     */
-    setNavigatorContextProvider: (navigatorContextProvider: NavigatorContextProvider) => void;
     /**
      * Returns the access token.
      */

package/dist/definitions/ssr-next/commerce/types/fetch-static-state.d.ts

@@ -1,10 +1,31 @@
 import type { UnknownAction } from '@reduxjs/toolkit';
+import type { NavigatorContext } from '../../../app/navigator-context-provider.js';
 import type { Controller } from '../../../controllers/controller/headless-controller.js';
 import type { ControllerStaticStateMap, ControllersPropsMap } from '../../common/types/controllers.js';
 import type { SolutionType } from './controller-constants.js';
 import type { ControllerDefinitionsMap, EngineDefinitionControllersPropsOption, OptionsTuple } from './controller-definitions.js';
 import type { EngineStaticState } from './engine.js';
-export type FetchStaticStateOptions = {};
+export interface FetchStaticStateOptions {
+    /**
+     * The navigator context for this request.
+     *
+     * Used to pass required client information when making server-side requests.
+     *
+     * @example
+     * ```ts
+     * // In your server route handler
+     * const staticState = await listingEngineDefinition.fetchStaticState({
+     *   navigatorContext: {
+     *     forwardedFor: req.ip,
+     *     referrer: req.headers.referer || null,
+     *     userAgent: req.headers['user-agent'] || null,
+     *     clientId: req.sessionID || 'anonymous'
+     *   }
+     * });
+     * ```
+     */
+    navigatorContext?: NavigatorContext;
+}
 /**
  * Executes only the initial search for a given configuration, then returns a resumable snapshot of engine state along with the state of the controllers.
  *

package/dist/definitions/ssr-next/common/builders/controller-builder.d.ts

@@ -0,0 +1,17 @@
+import type { CoreEngine, CoreEngineNext } from '../../../app/engine.js';
+import type { Controller } from '../../../controllers/controller/headless-controller.js';
+import type { BaseControllerDefinitionWithoutProps, BaseControllerDefinitionWithProps } from '../types/controllers.js';
+/**
+ * Builder class for creating controllers from definitions
+ */
+export declare class ControllerBuilder<TDefinition extends Partial<BaseControllerDefinitionWithoutProps<TEngine, TController>> & Partial<BaseControllerDefinitionWithProps<TEngine, TController, TProps>>, TEngine extends CoreEngine | CoreEngineNext, TProps, TController extends Controller = Controller> {
+    private _definition;
+    private _engine;
+    private _props?;
+    private _additionalArgs;
+    constructor(definition: TDefinition, engine: TEngine, props?: TProps);
+    withAdditionalArgs(additionalArgs?: unknown[]): this;
+    build(): TController;
+    private buildWithoutProps;
+    private buildWithProps;
+}

package/dist/definitions/ssr-next/common/builders/static-controller-builder.d.ts

@@ -0,0 +1,24 @@
+import type { Controller } from '../../../controllers/controller/headless-controller.js';
+import type { ControllerWithKind } from '../../commerce/types/controller-definitions.js';
+import type { Kind } from '../../commerce/types/kind.js';
+export type StaticControllerState = {
+    initialState?: Controller['state'];
+    _kind?: Kind;
+} & Pick<ControllerWithKind, 'state'>;
+/**
+ * Builder class for creating static controller
+ */
+declare class StaticControllerBuilder {
+    private _state?;
+    private _kind?;
+    private _initialState?;
+    withState(state: StaticControllerState['state']): this;
+    withKind(kind: Kind): this;
+    withInitialState(initialState: StaticControllerState['initialState']): this;
+    /**
+     * Builds and returns the static controller state object
+     */
+    build(): StaticControllerState;
+}
+export declare function createStaticControllerBuilder<TController extends Controller>(controller: TController): StaticControllerBuilder;
+export {};

package/dist/definitions/ssr-next/common/controller-utils.d.ts

@@ -1,15 +1,15 @@
 import type { UnknownAction } from '@reduxjs/toolkit';
 import type { CoreEngine, CoreEngineNext } from '../../app/engine.js';
 import type { Controller } from '../../controllers/controller/headless-controller.js';
-import type { ControllerDefinitionsMap, ControllersMap } from './types/controllers.js';
+import type { ControllerDefinitionsMap } from './types/controllers.js';
 import type { EngineStaticState } from './types/engine.js';
-import type { InferControllerPropsMapFromDefinitions, InferControllerStaticStateMapFromControllers, InferControllersMapFromDefinition } from './types/inference.js';
+import type { InferControllerPropsMapFromDefinitions, InferControllerStaticStateMapFromDefinitions, InferControllersMapFromDefinition } from './types/inference.js';
 export declare function buildControllerDefinitions<TControllerDefinitionsMap extends ControllerDefinitionsMap<CoreEngine | CoreEngineNext, Controller>, TEngine extends CoreEngine | CoreEngineNext>({ definitionsMap, engine, propsMap, }: {
     definitionsMap: TControllerDefinitionsMap;
     engine: TEngine;
-    propsMap: InferControllerPropsMapFromDefinitions<TControllerDefinitionsMap>;
+    propsMap?: InferControllerPropsMapFromDefinitions<TControllerDefinitionsMap>;
 }): InferControllersMapFromDefinition<TControllerDefinitionsMap>;
-export declare function createStaticState<TSearchAction extends UnknownAction>({ searchAction, controllers, }: {
+export declare function createStaticState<TSearchAction extends UnknownAction, TControllerDefinitions extends ControllerDefinitionsMap<CoreEngine | CoreEngineNext, Controller>>({ searchAction, controllers, }: {
     searchAction: TSearchAction;
-    controllers: ControllersMap;
-}): EngineStaticState<TSearchAction, InferControllerStaticStateMapFromControllers<ControllersMap>>;
+    controllers: InferControllersMapFromDefinition<TControllerDefinitions>;
+}): EngineStaticState<TSearchAction, InferControllerStaticStateMapFromDefinitions<TControllerDefinitions>>;

package/dist/definitions/ssr-next/common/navigator-context-utils.d.ts

@@ -0,0 +1,16 @@
+import type { LoggerOptions } from '../../app/logger.js';
+import type { NavigatorContext } from '../../app/navigator-context-provider.js';
+/**
+ * Processes fetchStaticState parameters and returns enhanced engine options with navigator context.
+ * This is the single function that handles all navigator context logic for both commerce and search engines.
+ */
+export declare function processNavigatorContext<TOptions extends {
+    configuration: object;
+    loggerOptions?: LoggerOptions;
+}>(params: unknown[], baseOptions: TOptions): {
+    engineOptions: TOptions;
+    callOptions?: {
+        navigatorContext?: NavigatorContext;
+        controllers?: unknown;
+    };
+};

package/dist/definitions/ssr-next/common/navigator-context-utils.spec.d.ts

@@ -0,0 +1 @@
+export {};

package/dist/definitions/ssr-next/common/types/controllers.d.ts

@@ -9,6 +9,12 @@ export interface ControllerStaticState<TState> {
 export interface ControllerStaticStateMap {
     [customName: string]: ControllerStaticState<unknown>;
 }
+export interface BaseControllerDefinitionWithoutProps<TEngine, TController extends Controller> {
+    build(engine: TEngine, ...args: unknown[]): TController;
+}
+export interface BaseControllerDefinitionWithProps<TEngine, TController extends Controller, TProps> {
+    buildWithProps(engine: TEngine, props?: TProps, ...args: unknown[]): TController;
+}
 export interface ControllerDefinitionWithoutProps<TEngine extends CoreEngine | CoreEngineNext, TController extends Controller> {
     /**
      * Creates an instance of the given controller.

package/dist/definitions/ssr-next/common/types/engine.d.ts

@@ -1,7 +1,6 @@
 import type { AnyAction, UnknownAction } from '@reduxjs/toolkit';
 import type { CoreEngine, CoreEngineNext } from '../../../app/engine.js';
 import type { EngineConfiguration } from '../../../app/engine-configuration.js';
-import type { NavigatorContextProvider } from '../../../app/navigator-context-provider.js';
 import type { Controller } from '../../../controllers/controller/headless-controller.js';
 import type { Build } from './build.js';
 import type { ControllerDefinitionsMap, ControllerStaticStateMap, ControllersMap, ControllersPropsMap } from './controllers.js';
@@ -27,13 +26,6 @@ export interface EngineDefinition<TEngine extends CoreEngine | CoreEngineNext, T
      * Fetches the hydrated state on the client side using your engine definition and the static state.
      */
     hydrateStaticState: HydrateStaticState<TEngine, InferControllersMapFromDefinition<TControllers>, AnyAction, InferControllerPropsMapFromDefinitions<TControllers>>;
-    /**
-     * Sets the navigator context provider.
-     * This provider is essential for retrieving navigation-related data such as referrer, userAgent, location, and clientId, which are crucial for handling both server-side and client-side API requests effectively.
-     *
-     * Note: The implementation specifics of the navigator context provider depend on the Node.js framework being utilized. It is the developer's responsibility to appropriately define and implement the navigator context provider to ensure accurate navigation context is available throughout the application. If the user fails to provide a navigator context provider, a warning will be logged either on the server or the browser console.
-     */
-    setNavigatorContextProvider: (navigatorContextProvider: NavigatorContextProvider) => void;
 }
 export interface EngineDefinitionBuildResult<TEngine extends CoreEngine | CoreEngineNext, TControllers extends ControllersMap> {
     engine: TEngine;

package/dist/definitions/ssr-next/common/types/fetch-static-state.d.ts

@@ -1,8 +1,11 @@
 import type { UnknownAction } from '@reduxjs/toolkit';
+import type { NavigatorContext } from '../../../app/navigator-context-provider.js';
 import type { ControllerStaticStateMap, ControllersPropsMap } from './controllers.js';
 import type { EngineDefinitionControllersPropsOption, EngineStaticState } from './engine.js';
 import type { OptionsTuple } from './utilities.js';
-type FetchStaticStateOptions = {};
+type FetchStaticStateOptions = {
+    navigatorContext?: NavigatorContext;
+};
 /**
  * Executes only the initial search for a given configuration, then returns a resumable snapshot of engine state along with the state of the controllers.
  *

package/dist/definitions/ssr-next/common/types/inference.d.ts

@@ -2,7 +2,7 @@ import type { CoreEngine, CoreEngineNext } from '../../../app/engine.js';
 import type { Controller } from '../../../controllers/controller/headless-controller.js';
 import type { ControllerDefinition, ControllerDefinitionsMap, ControllerDefinitionWithoutProps, ControllerDefinitionWithProps, ControllerStaticState, ControllersMap } from './controllers.js';
 import type { HasKeys } from './utilities.js';
-export type InferControllerPropsFromDefinition<TController extends ControllerDefinition<CoreEngine | CoreEngineNext, Controller>> = TController extends ControllerDefinitionWithProps<CoreEngine | CoreEngineNext, Controller, infer Props> ? Props : TController extends ControllerDefinitionWithoutProps<CoreEngine | CoreEngineNext, Controller> ? {} : unknown;
+type InferControllerPropsFromDefinition<TController extends ControllerDefinition<CoreEngine | CoreEngineNext, Controller>> = TController extends ControllerDefinitionWithProps<CoreEngine | CoreEngineNext, Controller, infer Props> ? Props : TController extends ControllerDefinitionWithoutProps<CoreEngine | CoreEngineNext, Controller> ? {} : unknown;
 export type InferControllerPropsMapFromDefinitions<TControllers extends ControllerDefinitionsMap<CoreEngine | CoreEngineNext, Controller>> = {
     [K in keyof TControllers as HasKeys<InferControllerPropsFromDefinition<TControllers[K]>> extends false ? never : K]: InferControllerPropsFromDefinition<TControllers[K]>;
 };
@@ -12,8 +12,9 @@ export type InferControllersMapFromDefinition<TControllers extends ControllerDef
 };
 export type InferControllerStaticStateFromController<TController extends Controller> = ControllerStaticState<TController['state']>;
 export type InferControllerStaticStateMapFromDefinitions<TControllers extends ControllerDefinitionsMap<CoreEngine | CoreEngineNext, Controller>> = {
-    [K in keyof TControllers]: InferControllerStaticStateFromController<InferControllerFromDefinition<TControllers[K]>>;
+    [K in keyof TControllers]: InferControllerStaticStateFromController<InferControllerFromDefinition<TControllers[K]>> & InferControllerPropsFromDefinition<TControllers[K]>;
 };
 export type InferControllerStaticStateMapFromControllers<TControllers extends ControllersMap> = {
     [K in keyof TControllers]: InferControllerStaticStateFromController<TControllers[K]>;
 };
+export {};

package/dist/definitions/ssr-next/search/engine/search-engine.ssr.d.ts

@@ -1,40 +1,38 @@
-import type { NavigatorContextProvider } from '../../../app/navigator-context-provider.js';
 import { type SearchEngine, type SearchEngineOptions } from '../../../app/search-engine/search-engine.js';
 import type { Controller } from '../../../controllers/controller/headless-controller.js';
 import type { LegacySearchAction } from '../../../features/analytics/analytics-utils.js';
 import type { ControllerDefinitionsMap } from '../../common/types/controllers.js';
 import type { EngineDefinition, EngineDefinitionOptions } from '../../common/types/engine.js';
-import type { InferControllerPropsMapFromDefinitions, InferControllerStaticStateMapFromDefinitions } from '../../common/types/inference.js';
 /**
  * The SSR search engine.
- *
- * @group Engine
  */
 export interface SSRSearchEngine extends SearchEngine {
-    /**
-     * Waits for the search to be completed and returns a promise that resolves to a `SearchCompletedAction`.
-     */
     waitForSearchCompletedAction(): Promise<SearchCompletedAction>;
 }
-/**
- * The options to create a search engine definition in SSR.
- *
- * @group Engine
- */
 export type SearchEngineDefinitionOptions<TControllers extends ControllerDefinitionsMap<SSRSearchEngine, Controller>> = EngineDefinitionOptions<SearchEngineOptions, TControllers>;
 export type SearchCompletedAction = ReturnType<LegacySearchAction['fulfilled' | 'rejected']>;
 export type SearchEngineDefinition<TControllers extends ControllerDefinitionsMap<SSRSearchEngine, Controller>> = EngineDefinition<SSRSearchEngine, TControllers>;
 /**
- * Initializes a Search engine definition in SSR with given controllers definitions and search engine config.
+ * Initializes a Search engine definition in SSR with per-call navigator context support.
  *
  * @param options - The search engine definition
- * @returns Three utility functions to fetch the initial state of the engine in SSR, hydrate the state in CSR,
- *  and a build function that can be used for edge cases requiring more control.
+ * @returns Engine definition with support for per-call navigator context.
+ *
+ * @example
+ * ```ts
+ * const searchEngine = defineSearchEngine(config);
+ *
+ * // Pass navigator context directly to fetchStaticState
+ * const staticState = await searchEngine.fetchStaticState({
+ *   navigatorContext: {
+ *     forwardedFor: req.ip,
+ *     referrer: req.headers.referer || null,
+ *     userAgent: req.headers['user-agent'] || null,
+ *     clientId: 'abc123'
+ *   }
+ * });
+ * ```
  *
  * @group Engine
  */
-export declare function defineSearchEngine<TControllerDefinitions extends ControllerDefinitionsMap<SearchEngine, Controller>>(options: SearchEngineDefinitionOptions<TControllerDefinitions>): {
-    fetchStaticState: import("../../common/types/fetch-static-state.js").FetchStaticState<import("redux").AnyAction, InferControllerStaticStateMapFromDefinitions<TControllerDefinitions>, InferControllerPropsMapFromDefinitions<TControllerDefinitions>>;
-    hydrateStaticState: import("../../common/types/hydrate-static-state.js").HydrateStaticState<SSRSearchEngine, import("../../common/types/inference.js").InferControllersMapFromDefinition<TControllerDefinitions>, import("redux").AnyAction, InferControllerPropsMapFromDefinitions<TControllerDefinitions>>;
-    setNavigatorContextProvider: (navigatorContextProvider: NavigatorContextProvider) => void;
-};
+export declare function defineSearchEngine<TControllerDefinitions extends ControllerDefinitionsMap<SearchEngine, Controller>>(options: SearchEngineDefinitionOptions<TControllerDefinitions>): EngineDefinition<SSRSearchEngine, TControllerDefinitions>;

package/dist/definitions/test/mock-controller.d.ts

@@ -0,0 +1,9 @@
+import type { CoreEngine, CoreEngineNext } from '../app/engine.js';
+import type { Controller } from '../controllers/controller/headless-controller.js';
+import type { SSRCommerceEngine } from '../ssr/commerce/factories/build-factory.js';
+interface MockController {
+    initialState?: Record<string, unknown>;
+}
+export declare function buildMockController(): Controller;
+export declare function buildMockControllerWithInitialState(_engine: CoreEngine | CoreEngineNext | SSRCommerceEngine, props: MockController): Controller;
+export {};

package/dist/definitions/test/mock-ssr-controller-definitions.d.ts

@@ -0,0 +1,38 @@
+import type { SearchEngine } from '../app/search-engine/search-engine.js';
+import type { Controller } from '../controllers/controller/headless-controller.js';
+import type { Kind } from '../ssr/commerce/types/kind.js';
+import type { ControllerDefinitionWithoutProps, ControllerDefinitionWithProps } from '../ssr-next/common/types/controllers.js';
+interface MockController {
+    initialState?: Record<string, unknown>;
+}
+interface MockControllerDefinitionWithoutProps extends ControllerDefinitionWithoutProps<SearchEngine, Controller> {
+}
+interface MockControllerDefinitionWithProps extends ControllerDefinitionWithProps<SearchEngine, Controller, MockController> {
+}
+type SolutionTypeAvailabilities = {
+    listing?: boolean;
+    search?: boolean;
+    standalone?: boolean;
+    recommendation?: boolean;
+};
+export declare function defineMockController(): MockControllerDefinitionWithoutProps;
+export declare function defineMockControllerWithProps(): MockControllerDefinitionWithProps;
+export declare function defineMockCommerceController(options?: SolutionTypeAvailabilities): {
+    build: import("vitest").Mock<(_engine: any) => Controller>;
+    listing: boolean;
+    search: boolean;
+    standalone: boolean;
+    recommendation: boolean;
+};
+export declare function defineMockCommerceControllerWithProps(options?: SolutionTypeAvailabilities): {
+    buildWithProps: import("vitest").Mock<(engine: any, props: any) => {
+        state: {};
+        subscribe(listener: () => void): import("redux").Unsubscribe;
+        _kind: Kind;
+    }>;
+    listing: boolean;
+    search: boolean;
+    standalone: boolean;
+    recommendation: boolean;
+};
+export {};

package/dist/esm/controllers/commerce/core/interactive-product/headless-core-interactive-product.js

@@ -49,7 +49,8 @@ permanentid '${props.options.product.permanentid}':\n\n${warnings.join('\n')}\n\
                     props.options.product.permanentid,
             },
             position: props.options.product.position,
-            responseId: props.responseIdSelector(engine[stateKey]),
+            responseId: props.options.product.responseId ??
+                props.responseIdSelector(engine[stateKey]),
         }));
     };
     return {

package/dist/esm/features/commerce/instant-products/instant-products-slice.js

@@ -25,7 +25,7 @@ export const instantProductsReducer = createReducer(getInstantProductsInitialSta
             totalCountFiltered: totalEntries,
             ...action.meta.arg,
         }, state, {
-            products: products.map((product, index) => preprocessProduct(product, index + 1)),
+            products: products.map((product, index) => preprocessProduct(product, index + 1, responseId)),
         });
     })
         .addCase(fetchInstantProducts.rejected, (state, action) => {
@@ -45,6 +45,7 @@ export const instantProductsReducer = createReducer(getInstantProductsInitialSta
         if (currentParentIndex === -1 || childToPromote === undefined) {
             return;
         }
+        const responseId = products[currentParentIndex].responseId;
         const position = products[currentParentIndex].position;
         const { children, totalNumberOfChildren } = products[currentParentIndex];
         const newParent = {
@@ -52,21 +53,23 @@ export const instantProductsReducer = createReducer(getInstantProductsInitialSta
             children,
             totalNumberOfChildren,
             position,
+            responseId,
         };
         const newProducts = [...products];
         newProducts.splice(currentParentIndex, 1, newParent);
         cache.products = newProducts;
     });
 });
-function preprocessProduct(product, position) {
+function preprocessProduct(product, position, responseId) {
     const isParentAlreadyInChildren = product.children.some((child) => child.permanentid === product.permanentid);
     if (product.children.length === 0 || isParentAlreadyInChildren) {
-        return { ...product, position };
+        return { ...product, position, responseId };
     }
     const { children, totalNumberOfChildren: _totalNumberOfChildren, ...restOfProduct } = product;
     return {
         ...product,
         children: [restOfProduct, ...children],
         position,
+        responseId,
     };
 }

package/dist/esm/features/commerce/product-listing/product-listing-slice.js

@@ -14,7 +14,7 @@ export const productListingReducer = createReducer(getProductListingInitialState
         .addCase(fetchProductListing.fulfilled, (state, action) => {
         const paginationOffset = getPaginationOffset(action.payload);
         handleFullfilled(state, action.payload.response);
-        state.products = action.payload.response.products.map((product, index) => preprocessProduct(product, paginationOffset + index + 1));
+        state.products = action.payload.response.products.map((product, index) => preprocessProduct(product, paginationOffset + index + 1, action.payload.response.responseId));
     })
         .addCase(fetchMoreProducts.fulfilled, (state, action) => {
         if (!action.payload) {
@@ -22,7 +22,7 @@ export const productListingReducer = createReducer(getProductListingInitialState
         }
         const paginationOffset = getPaginationOffset(action.payload);
         handleFullfilled(state, action.payload.response);
-        state.products = state.products.concat(action.payload.response.products.map((product, index) => preprocessProduct(product, paginationOffset + index + 1)));
+        state.products = state.products.concat(action.payload.response.products.map((product, index) => preprocessProduct(product, paginationOffset + index + 1, action.payload?.response.responseId)));
     })
         .addCase(fetchProductListing.pending, (state, action) => {
         handlePending(state, action.meta.requestId);
@@ -40,6 +40,7 @@ export const productListingReducer = createReducer(getProductListingInitialState
         if (currentParentIndex === -1 || childToPromote === undefined) {
             return;
         }
+        const responseId = products[currentParentIndex].responseId;
         const position = products[currentParentIndex].position;
         const { children, totalNumberOfChildren } = products[currentParentIndex];
         const newParent = {
@@ -47,6 +48,7 @@ export const productListingReducer = createReducer(getProductListingInitialState
             children,
             totalNumberOfChildren,
             position,
+            responseId,
         };
         products.splice(currentParentIndex, 1, newParent);
     })
@@ -74,15 +76,16 @@ function getPaginationOffset(payload) {
     const pagination = payload.response.pagination;
     return pagination.page * pagination.perPage;
 }
-function preprocessProduct(product, position) {
+function preprocessProduct(product, position, responseId) {
     const isParentAlreadyInChildren = product.children.some((child) => child.permanentid === product.permanentid);
     if (product.children.length === 0 || isParentAlreadyInChildren) {
-        return { ...product, position };
+        return { ...product, position, responseId };
     }
     const { children, totalNumberOfChildren: _totalNumberOfChildren, ...restOfProduct } = product;
     return {
         ...product,
         children: [restOfProduct, ...children],
         position,
+        responseId,
     };
 }