@incodetech/core 0.0.0-dev-20260126-4504c5b

package/dist/events-B8ZkhAZo.esm.js

@@ -0,0 +1,285 @@
+import { t as endpoints } from "./endpoints-BUsSVoJV.esm.js";
+import { i as isApiConfigured, r as getToken, t as api } from "./api-DfRLAneb.esm.js";
+
+//#region ../infra/src/capabilities/IBrowserEnvironmentCapability.ts
+function getTimestamp() {
+	return Date.now();
+}
+function revokeObjectURL(url) {
+	URL.revokeObjectURL(url);
+}
+
+//#endregion
+//#region src/internal/events/addEvent.ts
+const eventsQueue = [];
+const eventSubscribers = [];
+/**
+* Subscribes to all SDK events for logging, debugging, or custom analytics.
+* Returns an unsubscribe function.
+*
+* @param listener - Callback function that receives each event
+* @returns Unsubscribe function to remove the listener
+*
+* @example
+* ```typescript
+* const unsubscribe = subscribeEvent((event) => {
+*   console.log('[Event]', event.code, event.module);
+* });
+*
+* // Later
+* unsubscribe();
+* ```
+*/
+function subscribeEvent(listener) {
+	eventSubscribers.push(listener);
+	return () => {
+		const index = eventSubscribers.indexOf(listener);
+		if (index > -1) eventSubscribers.splice(index, 1);
+	};
+}
+function notifySubscribers(event) {
+	eventSubscribers.forEach((listener) => {
+		try {
+			listener(event);
+		} catch (_error) {}
+	});
+}
+/**
+* Sends an event to the dashboard for tracking.
+* Fire-and-forget: never blocks, never throws.
+* Events are queued if SDK is not configured yet.
+*/
+function addEvent(event) {
+	notifySubscribers(event);
+	const token = getToken();
+	if (!isApiConfigured() || !token) {
+		eventsQueue.push(event);
+		return;
+	}
+	api.post(endpoints.events, [{
+		code: event.code,
+		module: event.module,
+		screen: event.screen,
+		clientTimestamp: event.clientTimestamp ?? getTimestamp(),
+		payload: event.payload ?? {}
+	}]).catch(() => {});
+}
+/**
+* Flushes any queued events that were sent before SDK was configured.
+* Called automatically by setup() after token is set.
+*/
+function flushEventQueue() {
+	if (!isApiConfigured() || !getToken()) return;
+	const queuedEvents = [...eventsQueue];
+	eventsQueue.length = 0;
+	for (const event of queuedEvents) addEvent(event);
+}
+
+//#endregion
+//#region src/internal/events/helpers.ts
+function screenEvent(params) {
+	addEvent({
+		code: params.code,
+		module: params.module,
+		screen: params.screen,
+		clientTimestamp: getTimestamp(),
+		payload: params.payload
+	});
+}
+function moduleOpened(module, screen, payload) {
+	screenEvent({
+		module,
+		screen,
+		code: "moduleOpened",
+		payload
+	});
+}
+function moduleClosed(module, screen, payload) {
+	screenEvent({
+		module,
+		screen,
+		code: "moduleClosed",
+		payload
+	});
+}
+function screenOpened(module, screen, payload) {
+	screenEvent({
+		module,
+		screen,
+		code: "screenOpened",
+		payload
+	});
+}
+function screenClosed(module, screen, payload) {
+	screenEvent({
+		module,
+		screen,
+		code: "screenClosed",
+		payload
+	});
+}
+
+//#endregion
+//#region src/internal/events/types.ts
+const eventModuleNames = {
+	selfie: "SELFIE",
+	authFace: "AUTH_FACE",
+	mlConsent: "ML_CONSENT",
+	combinedConsent: "COMBINED_CONSENT",
+	curpValidation: "CURP_VALIDATION",
+	faceMatch: "FACE_MATCH",
+	qr: "QR",
+	videoSelfie: "VIDEO_ONBOARDING",
+	passport: "ID",
+	front: "ID",
+	back: "ID",
+	id: "ID",
+	document: "DOCUMENT_CAPTURE",
+	creditCard: "CREDIT_CARD_FRONT",
+	creditCardBack: "CREDIT_CARD_BACK",
+	conference: "CONFERENCE",
+	otp: "OTP",
+	signature: "SIGNATURE",
+	ekyc: "EXTERNAL_VERIFICATION",
+	globalWatchList: "GLOBAL_WATCHLIST",
+	customWatchList: "CUSTOM_WATCHLIST",
+	email: "EMAIL",
+	phone: "PHONE",
+	instantVerifyEmail: "INSTANT_VERIFY_EMAIL",
+	instantVerifyConsent: "INSTANT_VERIFY_CONSENT",
+	forms: "FORMS",
+	customModule: "CUSTOM_MODULE"
+};
+const eventScreenNames = {
+	faceMatch: "FACE_MATCH",
+	faceCaptureTutorial: "SELFIE_CAPTURE_TUTORIAL",
+	faceCaptureCamera: "SELFIE_CAMERA_CAPTURE",
+	faceCaptureError: "SELFIE_ATTEMPT_FAILED",
+	faceCaptureSuccess: "SELFIE_UPLOAD_SUCCEEDED",
+	faceCaptureUpload: "SELFIE_UPLOAD_PROGRESS",
+	mlConsent: "MACHINE_LEARNING_CONSENT",
+	combinedConsent: "COMBINED_CONSENT",
+	curpEnter: "ENTER_CURP",
+	curpValidate: "VALIDATE_CURP",
+	curpGenerate: "GENERATE_CURP",
+	curpValidation: "CURP_VALIDATION_PROGRESS",
+	curpValidationFailed: "CURP_VALIDATION_FAILED",
+	curpValidationSuccess: "CURP_VALIDATION_SUCCEEDED",
+	qrTutorial: "QR_TUTORIAL",
+	qrScan: "QR_SCAN",
+	smsOtp: "OTP",
+	simpleOTP: "OTP",
+	signatureInput: "SIGNATURE_INPUT",
+	frontTutorial: "FRONT_ID_CAPTURE_TUTORIAL",
+	frontCameraCapture: "FRONT_ID_CAMERA_CAPTURE",
+	frontHelp: "FRONT_ID_HELP",
+	frontReviewPhoto: "FRONT_ID_REVIEW_PHOTO",
+	frontUploadProgress: "FRONT_ID_UPLOAD_PROGRESS",
+	frontAttemptFailed: "FRONT_ID_ATTEMPT_FAILED",
+	frontUploadSuccess: "FRONT_ID_UPLOAD_SUCCEEDED",
+	backTutorial: "BACK_ID_CAPTURE_TUTORIAL",
+	backCameraCapture: "BACK_ID_CAMERA_CAPTURE",
+	backReviewPhoto: "BACK_ID_REVIEW_PHOTO",
+	backUploadProgress: "BACK_ID_UPLOAD_PROGRESS",
+	backAttemptFailed: "BACK_ID_ATTEMPT_FAILED",
+	backUploadSuccess: "BACK_ID_UPLOAD_SUCCEEDED",
+	backHelp: "BACK_ID_HELP",
+	passportTutorial: "TUTORIAL_PASSPORT",
+	documentTutorial: "DOCUMENT_CAPTURE_TUTORIAL",
+	documentCameraCapture: "DOCUMENT_CAMERA_CAPTURE",
+	documentHelp: "DOCUMENT_HELP",
+	documentReviewPhoto: "DOCUMENT_REVIEW_PHOTO",
+	documentUploadProgress: "DOCUMENT_UPLOAD_IN_PROGRESS",
+	documentAttemptFailed: "DOCUMENT_ATTEMPT_FAILED",
+	documentUploadSuccess: "DOCUMENT_UPLOAD_SUCCEEDED",
+	conferenceWait: "CONFERENCE_WAIT",
+	conferenceVideoChat: "CONFERENCE_VIDEO_CHAT",
+	conferenceMessageChat: "CONFERENCE_MESSAGE_CHAT",
+	videoSelfieTutorial: "VIDEO_SELFIE_TUTORIAL",
+	videoSelfie: "VIDEO_SELFIE",
+	videoSelfieFaceCapture: "VIDEO_SELFIE_FACE_CAPTURE",
+	videoSelfieFaceUploadProgress: "VIDEO_SELFIE_FACE_UPLOAD_PROGRESS",
+	videoSelfieFaceAttemptFailed: "VIDEO_SELFIE_FACE_ATTEMPT_FAILED",
+	videoSelfieFaceUploadSucceeded: "VIDEO_SELFIE_FACE_UPLOAD_SUCCEEDED",
+	videoSelfieFrontIdCapture: "VIDEO_SELFIE_FRONT_ID_CAPTURE",
+	videoSelfieFrontIdUploadProgress: "VIDEO_SELFIE_FRONT_ID_UPLOAD_PROGRESS",
+	videoSelfieFrontIdAttemptFailed: "VIDEO_SELFIE_FRONT_ID_ATTEMPT_FAILED",
+	videoSelfieFrontIdUploadSucceeded: "VIDEO_SELFIE_FRONT_ID_UPLOAD_SUCCEEDED",
+	videoSelfieBackIdCapture: "VIDEO_SELFIE_BACK_ID_CAPTURE",
+	videoSelfieBackIdUploadProgress: "VIDEO_SELFIE_BACK_ID_UPLOAD_PROGRESS",
+	videoSelfieBackIdAttemptFailed: "VIDEO_SELFIE_BACK_ID_ATTEMPT_FAILED",
+	videoSelfieBackIdUploadSucceeded: "VIDEO_SELFIE_BACK_ID_UPLOAD_SUCCEEDED",
+	videoSelfieDocumentCapture: "VIDEO_SELFIE_DOCUMENT_CAPTURE",
+	videoSelfieVoiceQuestion: "VIDEO_SELFIE_VOICE_QUESTION",
+	videoSelfieVoiceFinalQuestion: "VIDEO_SELFIE_VOICE_FINAL_QUESTION",
+	videoSelfieVideoUpload: "VIDEO SELFIE VIDEO UPLOAD",
+	ekycInput: "EKYC_INPUT",
+	ekycProgress: "EKYC_PROGRESS",
+	ekycSucceeded: "EKYC_SUCCEEDED",
+	ekycFailed: "EKYC_FAILED",
+	forms: "FORMS",
+	globalWatchListInput: "GLOBAL_WATCHLIST_INPUT",
+	globalWatchListProgress: "GLOBAL_WATCHLIST_PROGRESS",
+	globalWatchListSuccess: "GLOBAL_WATCHLIST_SUCCEEDED",
+	globalWatchListFailed: "GLOBAL_WATCHLIST_FAILED",
+	customWatchListInput: "CUSTOM_WATCHLIST_INPUT",
+	customWatchListProgress: "CUSTOM_WATCHLIST_PROGRESS",
+	customWatchListSuccess: "CUSTOM_WATCHLIST_SUCCEEDED",
+	customWatchListFailed: "CUSTOM_WATCHLIST_FAILED",
+	emailInput: "EMAIL_INPUT",
+	phoneInput: "PHONE_INPUT",
+	instantVerify: "INSTANT_VERIFY",
+	authFace: "AUTH_FACE",
+	authFaceError: "AUTH_FACE_ATTEMPT_FAILED",
+	authFaceUpload: "AUTH_FACE_UPLOAD_PROGRESS",
+	authFaceUploadSuccess: "AUTH_FACE_UPLOAD_SUCCEEDED",
+	authFaceUploadFailed: "AUTH_FACE_UPLOAD_FAILED",
+	customModuleCallback: "CUSTOM_MODULE_CALLBACK",
+	customModuleProcessing: "CUSTOM_MODULE_PROCESSING",
+	digitalIdFileSelection: "DIGITAL_ID_FILE_SELECTION",
+	digitalIdFileReview: "DIGITAL_ID_FILE_REVIEW",
+	digitalIdUploadProgress: "DIGITAL_ID_UPLOAD_PROGRESS",
+	digitalIdUploadSuccess: "DIGITAL_ID_UPLOAD_SUCCEEDED",
+	digitalIdUploadFailed: "DIGITAL_ID_UPLOAD_FAILED",
+	digitalIdAnalysisProgress: "DIGITAL_ID_ANALYSIS_PROGRESS",
+	digitalIdVerificationSuccess: "DIGITAL_ID_VERIFICATION_SUCCESS",
+	digitalIdVerificationFailed: "DIGITAL_ID_VERIFICATION_FAILED"
+};
+const videoSelfieEvents = {
+	imageTooBlurry: "imageTooBlurry",
+	fillFrame: "fillFrame",
+	checkCameraOrLighting: "checkCameraOrLighting",
+	frontIdCaptureStarted: "frontIdCaptureStarted",
+	lookAtCamera: "lookAtCamera",
+	moveCloser: "moveCloser",
+	lookingForFrontId: "lookingForFrontId",
+	lookingForBackId: "lookingForBackId",
+	cameraSwitchToBack: "cameraSwitchToBack",
+	cameraSwitchToFront: "cameraSwitchToFront",
+	audioStreamOpened: "audioStreamOpened",
+	audioStreamClosed: "audioStreamClosed",
+	videoSelfieVideoUploadInProgress: "videoSelfieVideoUploadInProgress",
+	videoSelfieTosNotAccepted: "videoSelfieTosNotAccepted",
+	videoSelfieTosAccepted: "videoSelfieTosAccepted",
+	videoSelfieStreamCreated: "videoSelfieStreamCreated",
+	videoSelfieStreamDestroyed: "videoSelfieStreamDestroyed",
+	videoSelfieReconnecting: "videoSelfieReconnecting",
+	videoSelfieReconnected: "videoSelfieReconnected"
+};
+const tutorialScreenNamesMapper = {
+	passport: eventScreenNames.passportTutorial,
+	front: eventScreenNames.frontTutorial,
+	back: eventScreenNames.backTutorial,
+	selfie: eventScreenNames.faceCaptureTutorial
+};
+const cameraScreenNamesMapper = {
+	front: "front",
+	back: "back",
+	passport: "passport",
+	creditCard: "front",
+	creditCardBack: "back",
+	document: "document"
+};
+
+//#endregion
+export { videoSelfieEvents as a, screenClosed as c, addEvent as d, flushEventQueue as f, tutorialScreenNamesMapper as i, screenEvent as l, revokeObjectURL as m, eventModuleNames as n, moduleClosed as o, subscribeEvent as p, eventScreenNames as r, moduleOpened as s, cameraScreenNamesMapper as t, screenOpened as u };

package/dist/flow.d.ts

@@ -0,0 +1,278 @@
+import { a as AnyStateMachine, n as FlowModule, r as FlowModuleConfig, s as WasmPipeline, t as Flow } from "./types-CMR6NkxW.js";
+import { t as Manager } from "./Manager-Co-PsiG9.js";
+
+//#region src/modules/flow/flowAnalyzer.d.ts
+
+/**
+ * Analyzes a flow configuration and returns the WASM pipelines needed.
+ * Use this to conditionally warmup WASM only when required by the flow.
+ *
+ * @param flow - The flow configuration from /omni/onboarding/flow
+ * @returns Array of WASM pipelines needed (e.g., ['selfie', 'idCapture'])
+ *
+ * @example
+ * ```typescript
+ * const pipelines = getRequiredWasmPipelines(flow);
+ * if (pipelines.length > 0) {
+ *   warmupWasm({ ...wasmConfig, pipelines });
+ * }
+ * ```
+ */
+declare function getRequiredWasmPipelines(flow: Flow): WasmPipeline[];
+//#endregion
+//#region src/modules/flow/flowCompletionService.d.ts
+type FinishStatus = {
+  redirectionUrl: string;
+  action: 'approved' | 'rejected' | 'none';
+  scoreStatus: 'OK' | 'WARN' | 'MANUAL_OK' | 'FAIL' | 'UNKNOWN' | 'MANUAL_FAIL';
+};
+type GetFinishStatusFn = (flowId: string | undefined | null, signal?: AbortSignal) => Promise<FinishStatus>;
+//#endregion
+//#region src/modules/flow/flowServices.d.ts
+type GetFlow = (signal: AbortSignal) => Promise<Flow>;
+//#endregion
+//#region src/modules/flow/flowActor.d.ts
+type CreateFlowActorOptions = {
+  getFlow?: GetFlow;
+};
+//#endregion
+//#region src/modules/flow/flowManager.d.ts
+/** Flow manager is waiting to be started */
+type FlowIdleState = {
+  status: 'idle';
+};
+/** Flow is being fetched from the server */
+type FlowLoadingState = {
+  status: 'loading';
+};
+/** Flow is loaded and ready for navigation */
+type FlowReadyState = {
+  status: 'ready';
+  /** The complete flow configuration from the server */
+  flow: Flow;
+  /** Array of module keys in order */
+  steps: string[];
+  /** Zero-based index of the current step */
+  currentStepIndex: number;
+  /** The module key of the current step (e.g., 'SELFIE', 'ID', 'FACE_MATCH') */
+  currentStep: string | undefined;
+  /** The configuration object for the current module. Type varies by module. */
+  config: unknown;
+};
+/** All steps have been completed */
+type FlowFinishedState = {
+  status: 'finished';
+  /** The complete flow configuration */
+  flow: Flow;
+};
+/** An error occurred while loading or processing the flow */
+type FlowErrorState = {
+  status: 'error';
+  /** The error message */
+  error: string;
+};
+/** Union of all possible flow states */
+type FlowState = FlowIdleState | FlowLoadingState | FlowReadyState | FlowFinishedState | FlowErrorState;
+/**
+ * Creates a flow manager instance for managing onboarding flow state and navigation.
+ *
+ * The flow manager provides:
+ * - State management with statuses: `idle`, `loading`, `ready`, `finished`, `error`
+ * - Step navigation with `nextStep()` and `prevStep()`
+ * - Current step info via `state.currentStep` and `state.config` when in `ready` state
+ * - Module configuration lookup via `getModuleConfig()`
+ *
+ * @param options - Optional configuration for the flow actor
+ * @param options.getFlow - Custom function to fetch flow data. Defaults to `getOnboardingFlow`
+ * @returns A manager instance with state subscription, API methods, and lifecycle controls
+ *
+ * @example
+ * ```ts
+ * const flowManager = createFlowManager();
+ *
+ * flowManager.subscribe((state) => {
+ *   if (state.status === 'ready') {
+ *     console.log(state.currentStep, state.config);
+ *   }
+ * });
+ *
+ * flowManager.load({ token: 'session-token' });
+ * ```
+ */
+declare function createFlowManager(options?: CreateFlowActorOptions): Manager<FlowState> & {
+  /**
+   * Loads the flow from the server.
+   * Transitions the state from `idle` to `loading`, then to `ready` on success or `error` on failure.
+   * Requires setup() to have been called with a token first.
+   */
+  load(): void;
+  /**
+   * Cancels the current loading operation and returns to `idle` state.
+   * Only effective when in `loading` state.
+   */
+  cancel(): void;
+  /**
+   * Resets the flow manager to its initial `idle` state.
+   * Can be called from `ready`, `finished`, or `error` states.
+   */
+  reset(): void;
+  /**
+   * Advances to the next step in the flow.
+   * If on the last step, transitions to `finished` state.
+   * Only effective when in `ready` state.
+   */
+  nextStep(): void;
+  /**
+   * Goes back to the previous step in the flow.
+   * Does nothing if already on the first step.
+   * Only effective when in `ready` state.
+   */
+  prevStep(): void;
+  /**
+   * Whether the flow can advance to the next step.
+   * Returns `true` if in `ready` state and not on the last step.
+   */
+  readonly canNext: boolean;
+  /**
+   * Whether the flow can go back to the previous step.
+   * Returns `true` if in `ready` state and not on the first step.
+   */
+  readonly canPrev: boolean;
+  /**
+   * Gets the configuration for a specific module by its key.
+   * Useful for accessing config of modules other than the current one.
+   * @param moduleKey - The unique key identifier of the module
+   * @returns The module configuration or `undefined` if not found or not in `ready` state
+   */
+  getModuleConfig: <T$1 = unknown>(moduleKey: string) => T$1 | undefined;
+  /**
+   * Checks if a module is enabled in the current flow.
+   * @param moduleKey - The unique key identifier of the module
+   * @returns `true` if the module exists in the flow, `false` otherwise or if not in `ready` state
+   */
+  isModuleEnabled: (moduleKey: string) => boolean;
+};
+//#endregion
+//#region src/modules/flow/moduleLoader.d.ts
+type LazyModule<T$1> = () => Promise<T$1>;
+type ModuleLoaderRegistry = {
+  [key: string]: LazyModule<{
+    default: unknown;
+  }>;
+};
+interface ModuleLoader {
+  load<T$1>(moduleKey: string): Promise<T$1>;
+  prefetch(moduleKey: string): void;
+  isLoaded(moduleKey: string): boolean;
+}
+declare function createModuleLoader(registry: ModuleLoaderRegistry): ModuleLoader;
+//#endregion
+//#region src/modules/flow/orchestratedFlowStateMachine.d.ts
+type GetFlowFn = (signal: AbortSignal) => Promise<Flow>;
+type ModuleRegistry = {
+  PHONE?: AnyStateMachine;
+  EMAIL?: AnyStateMachine;
+  SELFIE?: AnyStateMachine;
+  [key: string]: AnyStateMachine | undefined;
+};
+type OrchestratedFlowInput = {
+  getFlow: GetFlowFn;
+  modules: ModuleRegistry;
+  getFinishStatus?: GetFinishStatusFn;
+};
+type OrchestratedFlowEvent = {
+  type: 'LOAD';
+} | {
+  type: 'CANCEL';
+} | {
+  type: 'RESET';
+} | {
+  type: 'MODULE_COMPLETE';
+} | {
+  type: '*';
+  [key: string]: unknown;
+} | {
+  type: string;
+  [key: string]: unknown;
+};
+//#endregion
+//#region src/modules/flow/orchestratedFlowManager.d.ts
+type OrchestratedFlowIdleState = {
+  status: 'idle';
+};
+type OrchestratedFlowLoadingState = {
+  status: 'loading';
+};
+type OrchestratedFlowReadyState = {
+  status: 'ready';
+  flow: Flow;
+  steps: string[];
+  currentStepIndex: number;
+  currentStep: string | undefined;
+  config: unknown;
+  moduleState: unknown;
+};
+type OrchestratedFlowFinishedState = {
+  status: 'finished';
+  flow: Flow;
+  finishStatus: {
+    redirectionUrl: string;
+    action: 'approved' | 'rejected' | 'none';
+    scoreStatus: 'OK' | 'WARN' | 'MANUAL_OK' | 'FAIL' | 'UNKNOWN' | 'MANUAL_FAIL';
+  };
+};
+type OrchestratedFlowErrorState = {
+  status: 'error';
+  error: string;
+};
+type OrchestratedFlowState = OrchestratedFlowIdleState | OrchestratedFlowLoadingState | OrchestratedFlowReadyState | OrchestratedFlowFinishedState | OrchestratedFlowErrorState;
+type CreateOrchestratedFlowActorOptions = {
+  getFlow?: GetFlowFn;
+  modules: ModuleRegistry;
+  getFinishStatus?: OrchestratedFlowInput['getFinishStatus'];
+};
+declare function createOrchestratedFlowManager(options: CreateOrchestratedFlowActorOptions): Manager<OrchestratedFlowState> & {
+  /**
+   * Start loading the flow configuration from the backend.
+   */
+  load(): void;
+  /**
+   * Cancel an in-progress flow load.
+   */
+  cancel(): void;
+  /**
+   * Reset the flow to its initial idle state.
+   */
+  reset(): void;
+  /**
+   * Signal that the current module has completed successfully.
+   * Call this from your UI component's `onFinish` callback.
+   *
+   * @example
+   * ```tsx
+   * <Phone
+   *   config={config}
+   *   onFinish={() => flowManager.completeModule()}
+   * />
+   * ```
+   */
+  completeModule(): void;
+  /**
+   * Signal that the current module encountered an error.
+   * Call this from your UI component's `onError` callback if you want
+   * the flow to transition to an error state.
+   *
+   * @param error - Error message describing what went wrong
+   */
+  errorModule(error: string): void;
+  /**
+   * Send a raw event to the flow state machine.
+   * Prefer using the typed methods (completeModule, errorModule) when possible.
+   */
+  send(event: OrchestratedFlowEvent): void;
+  readonly canNext: boolean;
+  getModuleConfig: <T$1 = unknown>(moduleKey: string) => T$1 | undefined;
+  isModuleEnabled: (moduleKey: string) => boolean;
+};
+//#endregion
+export { type FinishStatus, type Flow, type FlowModule, type FlowModuleConfig, type FlowReadyState, type FlowState, type LazyModule, type ModuleLoader, type ModuleLoaderRegistry, type ModuleRegistry, type OrchestratedFlowFinishedState, type OrchestratedFlowInput, type OrchestratedFlowReadyState, type OrchestratedFlowState, createFlowManager, createModuleLoader, createOrchestratedFlowManager, getRequiredWasmPipelines };