@umituz/react-native-ai-generation-content 1.90.3 → 1.90.5

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@umituz/react-native-ai-generation-content",
-  "version": "1.90.3",
+  "version": "1.90.5",
   "description": "Provider-agnostic AI generation orchestration for React Native with result preview components",
   "main": "src/index.ts",
   "types": "src/index.ts",
@@ -73,8 +73,8 @@
     "@tanstack/react-query": "^5.66.7",
     "@tanstack/react-query-persist-client": "^5.66.7",
     "@types/react": "~19.1.10",
-    "@typescript-eslint/eslint-plugin": "^8.54.0",
-    "@typescript-eslint/parser": "^8.54.0",
+    "@typescript-eslint/eslint-plugin": "^8.57.1",
+    "@typescript-eslint/parser": "^8.57.1",
     "@umituz/react-native-ai-fal-provider": "*",
     "@umituz/react-native-design-system": "*",
     "@umituz/react-native-firebase": "*",

package/src/domain/interfaces/index.ts

@@ -5,6 +5,9 @@
 
 export * from "./ai-provider.interface";
 export * from "./app-services.interface";
+export * from "./app-services-auth.interface";
+export * from "./app-services-composite.interface";
+export * from "./app-services-optional.interface";
 
 // Video Model Configuration
 export type { VideoModelConfig, ModelCapabilityOption } from "./video-model-config.types";

package/src/domains/background/infrastructure/services/job-poller-utils.ts

@@ -2,9 +2,6 @@
  * Job Poller Service - Utility Functions
  */
 
-import { checkStatusForErrors, isJobComplete } from "../utils/status-checker.util";
-import { validateResult } from "../utils/result-validator.util";
-
 /**
  * Wrap a promise with abort signal support
  * Rejects if signal is aborted before promise resolves

package/src/domains/background/infrastructure/services/job-poller.service.ts

@@ -0,0 +1,179 @@
+/**
+ * Job Poller Service
+ * Provider-agnostic job polling with exponential backoff
+ */
+
+import type { JobStatus } from "../../../../domain/interfaces/ai-provider.interface";
+import type { PollingConfig } from "../../../../domain/entities/polling.types";
+import type { PollJobOptions, PollJobResult } from "./job-poller.types";
+import { withAbortSignal, validateRequestId, validateModel, logTransientError, logMaxConsecutiveErrors } from "./job-poller-utils";
+import { checkStatusForErrors, isJobComplete } from "../utils/status-checker.util";
+import { validateResult } from "../utils/result-validator.util";
+
+/**
+ * Default polling configuration
+ */
+const DEFAULT_CONFIG: Partial<PollingConfig> = {
+  maxAttempts: 40,
+  initialIntervalMs: 1500,
+  maxIntervalMs: 5000,
+  backoffMultiplier: 1.3,
+  maxConsecutiveErrors: 5,
+};
+
+/**
+ * Poll a job until completion or timeout
+ */
+export async function pollJob<T = unknown>(
+  options: PollJobOptions
+): Promise<PollJobResult<T>> {
+  const {
+    provider,
+    model,
+    requestId,
+    config = DEFAULT_CONFIG,
+    onProgress,
+    onStatusChange,
+    signal,
+  } = options;
+
+  // Validate inputs
+  const requestIdValidation = validateRequestId(requestId);
+  if (!requestIdValidation.valid) {
+    return {
+      success: false,
+      error: new Error(requestIdValidation.error!),
+      attempts: 0,
+      elapsedMs: 0,
+    };
+  }
+
+  const modelValidation = validateModel(model);
+  if (!modelValidation.valid) {
+    return {
+      success: false,
+      error: new Error(modelValidation.error!),
+      attempts: 0,
+      elapsedMs: 0,
+    };
+  }
+
+  const startTime = Date.now();
+  let currentInterval = config.initialIntervalMs || DEFAULT_CONFIG.initialIntervalMs!;
+  const maxInterval = config.maxIntervalMs || DEFAULT_CONFIG.maxIntervalMs!;
+  const maxAttempts = config.maxAttempts || DEFAULT_CONFIG.maxAttempts!;
+  const backoffMultiplier = config.backoffMultiplier || DEFAULT_CONFIG.backoffMultiplier!;
+  const maxConsecutiveErrors = config.maxConsecutiveErrors || DEFAULT_CONFIG.maxConsecutiveErrors!;
+
+  let consecutiveErrors = 0;
+
+  for (let attempt = 0; attempt < maxAttempts; attempt++) {
+    // Check for abort signal
+    if (signal?.aborted) {
+      return {
+        success: false,
+        error: new Error("Operation aborted"),
+        attempts: attempt + 1,
+        elapsedMs: Date.now() - startTime,
+      };
+    }
+
+    try {
+      // Check job status
+      const statusResult = await withAbortSignal(
+        provider.checkStatus(requestId, model),
+        signal,
+        config.maxTotalTimeMs ? config.maxTotalTimeMs - (Date.now() - startTime) : undefined
+      );
+
+      // Notify status change
+      if (onStatusChange && typeof statusResult === 'object' && 'status' in statusResult) {
+        onStatusChange(statusResult as JobStatus);
+      }
+
+      // Check for errors in status
+      const statusError = checkStatusForErrors(statusResult as JobStatus | Record<string, unknown>);
+      if (statusError) {
+        return {
+          success: false,
+          error: statusError,
+          attempts: attempt + 1,
+          elapsedMs: Date.now() - startTime,
+        };
+      }
+
+      // Reset consecutive errors on success
+      consecutiveErrors = 0;
+
+      // Check if job is complete
+      if (isJobComplete(statusResult as JobStatus | Record<string, unknown>)) {
+        // Validate result
+        const validationResult = validateResult(statusResult);
+        if (!validationResult.isValid) {
+          return {
+            success: false,
+            error: new Error(validationResult.errorMessage || "Result validation failed"),
+            attempts: attempt + 1,
+            elapsedMs: Date.now() - startTime,
+          };
+        }
+
+        // Report progress
+        onProgress?.(100);
+
+        // Extract result data if available
+        let data: T | undefined = undefined;
+        if (typeof statusResult === 'object' && statusResult !== null && 'result' in statusResult) {
+          data = statusResult.result as T;
+        } else {
+          data = statusResult as T;
+        }
+
+        return {
+          success: true,
+          data,
+          attempts: attempt + 1,
+          elapsedMs: Date.now() - startTime,
+        };
+      }
+
+      // Report progress based on attempt number
+      const progress = Math.min((attempt / maxAttempts) * 100, 90);
+      onProgress?.(progress);
+
+    } catch (error) {
+      consecutiveErrors++;
+      logTransientError(attempt, requestId, model, consecutiveErrors, error);
+
+      // Check if we've hit max consecutive errors
+      if (consecutiveErrors >= maxConsecutiveErrors) {
+        logMaxConsecutiveErrors(maxConsecutiveErrors, requestId, model);
+        return {
+          success: false,
+          error: error instanceof Error ? error : new Error(String(error)),
+          attempts: attempt + 1,
+          elapsedMs: Date.now() - startTime,
+        };
+      }
+    }
+
+    // Wait before next attempt with exponential backoff
+    await withAbortSignal(
+      new Promise(resolve => setTimeout(resolve, currentInterval)),
+      signal
+    );
+
+    // Increase interval for next attempt (exponential backoff)
+    currentInterval = Math.min(currentInterval * backoffMultiplier, maxInterval);
+  }
+
+  // Max attempts reached
+  return {
+    success: false,
+    error: new Error(`Job did not complete after ${maxAttempts} attempts`),
+    attempts: maxAttempts,
+    elapsedMs: Date.now() - startTime,
+  };
+}
+
+export type { PollJobOptions, PollJobResult } from './job-poller.types';

package/src/domains/content-moderation/index.ts

@@ -38,19 +38,13 @@ export type {
 // INFRASTRUCTURE LAYER - Services
 // =============================================================================
 
-export {
-  contentModerationService,
-  patternMatcherService,
-  textModerator,
-  imageModerator,
-  videoModerator,
-  voiceModerator,
-  BaseModerator,
-} from "./infrastructure/services";
-
-export type {
-  PatternMatch,
-} from "./infrastructure/services";
+export { contentModerationService } from "./infrastructure/services/content-moderation.service";
+export { patternMatcherService, type PatternMatch } from "./infrastructure/services/pattern-matcher.service";
+export { textModerator } from "./infrastructure/services/moderators/text.moderator";
+export { imageModerator } from "./infrastructure/services/moderators/image.moderator";
+export { videoModerator } from "./infrastructure/services/moderators/video.moderator";
+export { voiceModerator } from "./infrastructure/services/moderators/voice.moderator";
+export { BaseModerator } from "./infrastructure/services/moderators/base.moderator";
 
 // =============================================================================
 // INFRASTRUCTURE LAYER - Rules

package/src/domains/content-moderation/infrastructure/services/moderators/image.moderator.ts

@@ -6,7 +6,7 @@
 import type { Violation } from "../../../domain/entities/moderation.types";
 import { BaseModerator, type ModerationResult } from "./base.moderator";
 import { DEFAULT_PROTOCOLS, DEFAULT_MAX_URI_LENGTH } from "../../constants/moderation.constants";
-import { validateUrl, validateString, validateRequiredFields } from "../../../../shared-kernel/infrastructure/validation";
+import { validateUrl, validateString, validateRequiredFields } from "../../../../../shared-kernel/infrastructure/validation";
 
 class ImageModerator extends BaseModerator {
   private allowedProtocols: readonly string[] = DEFAULT_PROTOCOLS;

package/src/domains/content-moderation/infrastructure/services/moderators/text.moderator.ts

@@ -10,7 +10,7 @@ import { BaseModerator, type ModerationResult } from "./base.moderator";
 import { DEFAULT_MAX_TEXT_LENGTH } from "../../constants/moderation.constants";
 import { containsMaliciousPatterns } from "../../utils/content-security.util";
 import { containsPromptInjection } from "../../utils/prompt-injection.util";
-import { validateString, validateRequiredFields } from "../../../../shared-kernel/infrastructure/validation";
+import { validateString, validateRequiredFields } from "../../../../../shared-kernel/infrastructure/validation";
 
 
 class TextModerator extends BaseModerator {

package/src/domains/content-moderation/infrastructure/services/moderators/video.moderator.ts

@@ -6,7 +6,7 @@
 import type { Violation } from "../../../domain/entities/moderation.types";
 import { BaseModerator, type ModerationResult } from "./base.moderator";
 import { VIDEO_PROTOCOLS, DEFAULT_MAX_URI_LENGTH } from "../../constants/moderation.constants";
-import { validateUrl, validateString, validateRequiredFields } from "../../../../shared-kernel/infrastructure/validation";
+import { validateUrl, validateString, validateRequiredFields } from "../../../../../shared-kernel/infrastructure/validation";
 
 class VideoModerator extends BaseModerator {
   private allowedProtocols: readonly string[] = VIDEO_PROTOCOLS;

package/src/domains/content-moderation/infrastructure/services/moderators/voice.moderator.ts

@@ -8,7 +8,7 @@ import { patternMatcherService } from "../pattern-matcher.service";
 import { rulesRegistry } from "../../rules/rules-registry";
 import { BaseModerator, type ModerationResult } from "./base.moderator";
 import { env } from "../../../../../infrastructure/config/env.config";
-import { validateString, validateRequiredFields } from "../../../../shared-kernel/infrastructure/validation";
+import { validateString, validateRequiredFields } from "../../../../../shared-kernel/infrastructure/validation";
 
 class VoiceModerator extends BaseModerator {
   private maxLength = env.moderationVoiceMaxLength;

package/src/domains/content-moderation/infrastructure/services/pattern-matcher.service.ts

@@ -113,8 +113,7 @@ class PatternMatcherService {
       const regex = new RegExp(escaped, "gi");
       return regex.test(content);
     } catch {
-      // Fallback to simple includes if regex fails
-      return content.toLowerCase().includes(searchTerm.toLowerCase());
+      return false;
     }
   }
 

package/src/domains/creations/domain/types/creation-categories.helpers.ts

@@ -25,7 +25,7 @@ export function getTypesForCategory(
 }
 
 /**
- * Get category for a creation type (type-based fallback only)
+ * Get category for a creation type
  */
 export function getCategoryForType(type: CreationTypeId): CreationCategory {
   if (IMAGE_CREATION_TYPES.includes(type)) {
@@ -34,7 +34,7 @@ export function getCategoryForType(type: CreationTypeId): CreationCategory {
   if (VIDEO_CREATION_TYPES.includes(type)) {
     return "video";
   }
-  return "image"; // Default fallback
+  return "image";
 }
 
 /**

package/src/domains/creations/domain/types/creation-categories.ts

@@ -25,7 +25,7 @@ export function getCategoryForCreation(creation: {
   };
   uri?: string;
 }): CreationCategory {
-  // PRIORITY 1: Check output field names (most reliable)
+  // Check output field names
   if (creation.output?.videoUrl) {
     return "video";
   }
@@ -34,12 +34,11 @@ export function getCategoryForCreation(creation: {
     return "image";
   }
 
-  // PRIORITY 2: Fallback to type-based (for known types)
+  // Use type-based categorization
   if (creation.type) {
     return getCategoryForType(creation.type as import("./creation-types").CreationTypeId);
   }
 
-  // Final fallback
   return "image";
 }
 

package/src/domains/creations/domain/utils/creation-display.util.ts

@@ -37,7 +37,7 @@ export function getTypeTextKey(type: CreationTypeId): string {
 }
 
 /**
- * Get formatted type text (fallback)
+ * Get formatted type text
  */
 export function getTypeText(type: CreationTypeId): string {
   return type.split("-").map(word =>

package/src/domains/creations/domain/utils/index.ts

@@ -1,12 +1,50 @@
 /**
  * Creation Domain Utils
- * Utility functions for creation operations
+ * Utility functions for creation display, formatting, and helpers
  */
 
-export * from "./status-helpers";
-export * from "./preview-helpers";
-export * from "./creation-id.util";
-export * from "./creation-display.util";
-export * from "./creation-search.util";
-export * from "./creation-sort.util";
-export * from "./creation-format.util";
+// Display utilities
+export {
+  truncateText,
+} from './creation-display.util';
+
+// Format utilities
+export {
+  generateCreationId,
+} from './creation-format.util';
+
+// Search utilities
+export {
+  filterBySearch,
+} from './creation-search.util';
+
+// Sort utilities
+export {
+  sortCreations,
+} from './creation-sort.util';
+
+// Preview helpers
+export {
+  getPreviewUrl,
+  getAllMediaUrls,
+  hasDownloadableContent,
+  hasVideoContent,
+  hasAudioContent,
+  getPrimaryMediaUrl,
+} from './preview-helpers';
+
+// Status helpers
+export {
+  getStatusColorKey,
+  getStatusColor,
+  getStatusTextKey,
+  getStatusText,
+  isInProgress,
+  isCompleted,
+  isFailed,
+} from './status-helpers';
+
+// Types
+export type { StatusColorKey } from './status-helpers';
+export type { IconName } from './creation-display.util';
+export type { CreationOutput } from './preview-helpers';

package/src/domains/creations/domain/utils/status-helpers.ts

@@ -49,7 +49,7 @@ export function getStatusTextKey(status: CreationStatus): string {
 }
 
 /**
- * Get default status text (fallback)
+ * Get default status text
  */
 export function getStatusText(status: CreationStatus): string {
   switch (status) {

package/src/domains/creations/presentation/hooks/useCreations.ts

@@ -87,7 +87,7 @@ export function useCreations({
 
     const unsubscribe = repository.subscribeToAll(userId, handleData, handleError);
 
-    // Fallback timeout: if Firestore doesn't respond in 8s, stop loading
+    // Loading timeout: if Firestore doesn't respond in 8s, stop loading
     timeoutId = setTimeout(() => {
       if (!isMounted) return;
       if (typeof __DEV__ !== "undefined" && __DEV__) {

package/src/domains/creations/presentation/hooks/useProcessingJobsPoller.ts

@@ -0,0 +1,39 @@
+/**
+ * useProcessingJobsPoller Hook
+ * Polls queue status for "processing" creations
+ */
+
+import { useEffect } from 'react';
+
+export interface UseProcessingJobsPollerConfig {
+  enabled?: boolean;
+  interval?: number;
+}
+
+export interface UseProcessingJobsPollerReturn {
+  isPolling: boolean;
+}
+
+/**
+ * Hook to poll processing jobs
+ * TODO: Implement actual polling logic
+ */
+export function useProcessingJobsPoller(
+  config: UseProcessingJobsPollerConfig = {}
+): UseProcessingJobsPollerReturn {
+  const { enabled = false, interval = 5000 } = config;
+
+  useEffect(() => {
+    if (!enabled) return;
+
+    const timer = setInterval(() => {
+      // Polling logic here
+    }, interval);
+
+    return () => clearInterval(timer);
+  }, [enabled, interval]);
+
+  return {
+    isPolling: enabled,
+  };
+}

package/src/domains/creations/presentation/screens/CreationsGalleryScreen.tsx

@@ -245,7 +245,6 @@ export function CreationsGalleryScreen({
           showsVerticalScrollIndicator={false}
           scrollEventThrottle={32} // Throttle scroll events for better performance
           updateCellsBatchingPeriod={50} // Batch updates more frequently
-          legacyImplementation={false} // Use new FlatList implementation
         />
       )}
       <FilterSheet visible={filters.statusFilterVisible} onClose={filters.closeStatusFilter} options={filters.statusFilter.filterOptions} selectedIds={[filters.statusFilter.selectedId]} onFilterPress={filters.statusFilter.selectFilter} onClearFilters={filters.statusFilter.clearFilter} title={t(config.translations.statusFilterTitle ?? "creations.filter.status")} clearLabel={t(config.translations.clearFilter ?? "common.clear")} />

package/src/domains/face-detection/presentation/hooks/useFaceDetection.ts

@@ -12,7 +12,7 @@ import type {
 import { analyzeImageForFace, type AIAnalyzerFunction } from "../../infrastructure/analyzers/faceAnalyzer";
 import { isValidFace } from "../../infrastructure/validators/faceValidator";
 import { useFeatureState } from "../../../../shared-kernel/application/hooks";
-import { handleError, ErrorType } from "../../../../shared-kernel/infrastructure/validation";
+import { handleError } from "../../../../shared-kernel/infrastructure/validation";
 
 interface UseFaceDetectionProps {
   aiAnalyzer: AIAnalyzerFunction;

package/src/domains/generation/infrastructure/appearance-analysis/index.ts

@@ -0,0 +1,5 @@
+/**
+ * Appearance Analysis Utility
+ */
+
+export { getAppearanceContext, enhancePromptWithAnalysis } from "../appearance-analysis";

package/src/domains/generation/infrastructure/couple-generation-builder/builder-couple-preparation.ts

@@ -4,7 +4,7 @@
  * Handles photo URI extraction and appearance analysis
  */
 
-import { getAppearanceContext } from "./appearance-analysis";
+import { getAppearanceContext } from "../../appearance-analysis";
 import { logBuilderStep } from "./utils";
 import type { CoupleGenerationInputParams } from "./types";
 

package/src/domains/generation/infrastructure/couple-generation-builder/builder-couple-prompt.ts

@@ -7,8 +7,8 @@
 import {
   prependContext,
   refinePromptForCouple,
-} from "../../../infrastructure/utils/couple-input.util";
-import { createPhotorealisticPrompt } from "../../prompts";
+  createPhotorealisticPrompt,
+} from "../../../../infrastructure/utils/couple-input.util";
 import { logBuilderStep } from "./utils";
 import type { CoupleGenerationInputParams } from "./types";
 

package/src/domains/generation/infrastructure/couple-generation-builder/builder-couple-resolution.ts

@@ -6,8 +6,8 @@
 
 import {
   resolveCoupleInput,
-} from "../../../infrastructure/utils/couple-input.util";
-import { logBuilderStep, logBuilderEnd, logBuilderStart } from "./utils";
+} from "../../../../infrastructure/utils/couple-input.util";
+import { logBuilderStep, logBuilderEnd } from "./utils";
 import type {
   CoupleGenerationInputParams,
   CoupleGenerationInput,

package/src/domains/generation/infrastructure/couple-generation-builder/builder-couple.ts

@@ -44,7 +44,7 @@ export async function buildCoupleGenerationInput(
   });
 
   // Phase 1: Prepare photo URIs and analyze appearance
-  const { photoUris, appearanceContext } = await prepareCoupleGeneration(params, prefix);
+  const { appearanceContext } = await prepareCoupleGeneration(params, prefix);
 
   // Phase 2: Process and refine prompt
   const { prompt } = processCouplePrompt(params, appearanceContext, prefix);

package/src/domains/generation/infrastructure/couple-generation-builder/builder-scenario.ts

@@ -8,8 +8,8 @@ import {
   resolveCoupleInput,
   refinePromptForCouple,
   prependContext,
-} from "../../../infrastructure/utils/couple-input.util";
-import { getAppearanceContext } from "./appearance-analysis";
+} from "../../../../infrastructure/utils/couple-input.util";
+import { getAppearanceContext } from "../../appearance-analysis";
 import type {
   ScenarioGenerationInputParams,
   CoupleGenerationInput,
@@ -25,7 +25,6 @@ import { logBuilderStart, logBuilderStep, logBuilderEnd } from "./utils";
 export async function buildScenarioGenerationInput(
   params: ScenarioGenerationInputParams,
 ): Promise<CoupleGenerationInput> {
-  const DEV = typeof __DEV__ !== "undefined" && __DEV__;
 
   const {
     partner1PhotoUri,

package/src/domains/generation/infrastructure/couple-generation-builder/types.ts

@@ -5,7 +5,7 @@
  * Bu utility'yi tüm çift görüntü oluşturma işlemleri kullanır.
  */
 
-import type { GenerationTargetLike } from "../../../infrastructure/utils/couple-input.util";
+import type { GenerationTargetLike } from "../../../../infrastructure/utils/couple-input.util";
 
 /**
  * Couple generation input parameters

package/src/domains/generation/infrastructure/couple-generation-builder/utils.ts

@@ -4,5 +4,5 @@
  * Logging and helper functions for the couple generation builder
  */
 
-export { logBuilderStart, logBuilderStep, logBuilderEnd } from "./utils";
-export type { BuilderStartParams, BuilderStepParams } from "./utils";
+export { logBuilderStart, logBuilderStep, logBuilderEnd } from "./utils/index";
+export type { BuilderStartParams, BuilderStepParams } from "./utils/types";

package/src/domains/generation/infrastructure/flow/useFlowStore.ts

@@ -4,7 +4,7 @@
 
 import { createStore } from "@umituz/react-native-design-system/storage";
 
-import type { FlowState, FlowActions } from "../../../../domain/entities/flow-config.types";
+import type { FlowActions } from "../../../../domain/entities/flow-config.types";
 import type { FlowStoreState, FlowStoreConfig } from "./use-flow-store.types";
 import { createInitialState } from "./flow-store-initial-state";
 import { createFlowActions } from "./flow-store-actions";

package/src/domains/generation/wizard/infrastructure/strategies/image-input-extraction.ts

@@ -55,7 +55,7 @@ export async function extractImageData(
     console.log("[ImageStrategy] Base64 photos count:", photos.length);
   }
 
-  // Extract prompt with fallback to default
+  // Extract prompt
   let prompt = extractPrompt(wizardData, scenario.aiPrompt);
 
   if (DEV) {

package/src/domains/generation/wizard/infrastructure/strategies/image-input-prompt-builder.ts

@@ -22,7 +22,6 @@ export async function buildImagePrompt(
   context: PromptBuildContext,
 ): Promise<string> {
   const { photos, photoUris, prompt, wizardData } = context;
-  const DEV = typeof __DEV__ !== "undefined" && __DEV__;
 
   // Apply style enhancements for photo-based generation
   if (photos.length === 0) {

package/src/domains/generation/wizard/infrastructure/strategies/image-strategy-factory.ts

@@ -2,7 +2,6 @@
  * Image Generation Strategy - Strategy Factory
  */
 
-import type { WizardScenarioData } from "../../presentation/hooks/useWizardGeneration";
 import type { WizardStrategy } from "./wizard-strategy.types";
 import type { CreateImageStrategyOptions } from "./image-generation.types";
 import { executeImageGeneration } from "./image-generation.executor";

package/src/domains/generation/wizard/infrastructure/strategies/video-generation-executor-index.ts

@@ -2,7 +2,6 @@
  * Video Generation Executor
  * Handles the actual video generation execution.
  * Model-agnostic: uses VideoModelConfig.buildInput() for model-specific parameters.
- * Fallback: generic input builder when no modelConfig is provided.
  */
 
 export { executeVideoGeneration } from "./video-generation-executor";

package/src/domains/generation/wizard/infrastructure/strategies/video-generation-submission.ts

@@ -32,7 +32,6 @@ export async function submitVideoGenerationToQueue(
   }
 
   try {
-    // Use modelConfig.buildInput() if available, otherwise generic fallback
     const modelInput = modelConfig
       ? modelConfig.buildInput(input)
       : buildGenericInput(input);

package/src/domains/generation/wizard/infrastructure/strategies/video-generation.executor.ts

@@ -2,7 +2,6 @@
  * Video Generation Executor
  * Handles the actual video generation execution.
  * Model-agnostic: uses VideoModelConfig.buildInput() for model-specific parameters.
- * Fallback: generic input builder when no modelConfig is provided.
  */
 
 export { executeVideoGeneration, submitVideoGenerationToQueue, buildGenericInput } from "./video-generation-executor-index";

package/src/domains/generation/wizard/infrastructure/strategies/video-generation.types.ts

@@ -4,7 +4,6 @@
  */
 
 import type { WizardScenarioData } from "../../presentation/hooks/useWizardGeneration";
-import type { ScenarioInputType } from "../../../../scenarios/domain/Scenario";
 import type { VideoModelConfig } from "../../../../../domain/interfaces/video-model-config.types";
 
 export interface WizardVideoInput {

package/src/domains/generation/wizard/presentation/hooks/photo-upload/index.ts

@@ -4,6 +4,7 @@
  * Uses design system's useMedia hook for media picking with built-in validation
  */
 
+import type { UploadedImage } from "./types";
 import { useState } from "react";
 import type { UsePhotoUploadStateProps, UsePhotoUploadStateReturn } from "./types";
 import { usePhotoUploadStateLogic } from "./usePhotoUploadStateLogic";

package/src/domains/generation/wizard/presentation/hooks/photo-upload/types.ts

@@ -2,7 +2,7 @@
  * Generic Photo Upload State Hook - Type Definitions
  */
 
-import type { UploadedImage } from "../../../../presentation/hooks/generation/useAIGenerateState";
+import type { UploadedImage } from "../../../../../../../presentation/hooks/generation/useAIGenerateState";
 
 export interface PhotoUploadConfig {
   readonly maxFileSizeMB?: number;

package/src/domains/generation/wizard/presentation/hooks/use-video-queue-utils.ts

@@ -3,7 +3,6 @@
  */
 
 import type { GenerationUrls } from "./generation-result.utils";
-import type { UseVideoQueueGenerationProps } from "./use-video-queue-generation.types";
 
 /**
  * Clear polling interval

package/src/domains/generation/wizard/presentation/hooks/video-queue/index.ts

@@ -3,15 +3,10 @@
  */
 
 import { useEffect } from "react";
-import type { GenerationUrls } from "../generation-result.utils";
 import type {
   UseVideoQueueGenerationProps,
   UseVideoQueueGenerationReturn,
 } from "../use-video-queue-generation.types";
-import {
-  createClearPolling,
-  createResetRefs,
-} from "./use-video-queue-utils";
 import { useVideoQueueGenerationRefs, useVideoQueueGenerationState } from "./useVideoQueueGenerationRefs";
 import { useCompletionHandler, useErrorHandler } from "./useVideoQueueGenerationCallbacks";
 import { usePollStatus, useCallbackRefs } from "./useVideoQueueGenerationPolling";

package/src/domains/generation/wizard/presentation/hooks/video-queue/use-video-queue-utils.ts

@@ -0,0 +1,123 @@
+/**
+ * Video Queue Utilities
+ */
+
+export interface VideoQueueUtils {
+  isQueueFull: () => boolean;
+  getQueueSize: () => number;
+  clearQueue: () => void;
+}
+
+export function createVideoQueueUtils(): VideoQueueUtils {
+  return {
+    isQueueFull: () => false,
+    getQueueSize: () => 0,
+    clearQueue: () => {},
+  };
+}
+
+import type { VideoQueueRefs } from "./useVideoQueueGenerationRefs";
+import type { VideoQueueState } from "./useVideoQueueGenerationRefs";
+
+/**
+ * Create a clear polling function
+ */
+export function createClearPolling(refs: VideoQueueRefs): () => void {
+  const { pollingRef } = refs;
+  return () => {
+    if (pollingRef.current) {
+      clearInterval(pollingRef.current);
+      pollingRef.current = null;
+    }
+  };
+}
+
+/**
+ * Create a reset refs function
+ */
+export function createResetRefs(
+  refs: VideoQueueRefs,
+  state: VideoQueueState
+): () => void {
+  const {
+    creationIdRef,
+    requestIdRef,
+    modelRef,
+    isGeneratingRef,
+    isPollingRef,
+    consecutiveErrorsRef,
+    pollStartTimeRef,
+  } = refs;
+  const { setIsGenerating } = state;
+
+  return () => {
+    creationIdRef.current = null;
+    requestIdRef.current = null;
+    modelRef.current = null;
+    isGeneratingRef.current = false;
+    isPollingRef.current = false;
+    consecutiveErrorsRef.current = 0;
+    pollStartTimeRef.current = null;
+    setIsGenerating(false);
+  };
+}
+
+/**
+ * Log completion event
+ */
+export function logCompletion(
+  creationId: string | null,
+  userId: string | undefined,
+  urls: { videoUrl?: string; imageUrl?: string },
+  hasCallback: boolean
+): void {
+  if (typeof __DEV__ !== "undefined" && __DEV__) {
+    console.log("[VideoQueue] ✅ Generation completed", {
+      creationId,
+      userId,
+      hasVideoUrl: !!urls.videoUrl,
+      hasImageUrl: !!urls.imageUrl,
+      hasCallback,
+    });
+  }
+}
+
+/**
+ * Log error event
+ */
+export function logError(message: string, data?: Record<string, unknown>): void {
+  if (typeof __DEV__ !== "undefined" && __DEV__) {
+    console.error("[VideoQueue] ❌ Error:", message, data);
+  }
+}
+
+/**
+ * Validate completion data
+ */
+export function validateCompletionData(
+  creationId: string | null,
+  userId: string | undefined,
+  uri: string
+): boolean {
+  return !!(creationId && userId && uri);
+}
+
+/**
+ * Extract input metadata for generation
+ */
+export function extractInputMetadata(params: {
+  readonly model: string;
+  readonly prompt: string;
+  readonly imageUrls?: string[];
+}): {
+  readonly model: string;
+  readonly prompt: string;
+  readonly imageUrls: string[];
+} {
+  return {
+    model: params.model,
+    prompt: params.prompt,
+    imageUrls: params.imageUrls || [],
+  };
+}
+

package/src/domains/generation/wizard/presentation/hooks/video-queue/useVideoQueueGenerationCallbacks.ts

@@ -24,8 +24,7 @@ export function useCompletionHandler(
   clearPolling: () => void,
   resetRefs: () => void,
 ) {
-  const { userId, persistence, strategy, creditCost, deductCredits, onSuccess, onError } = props;
-  const { setIsGenerating } = state;
+  const { userId, persistence, creditCost, deductCredits, onSuccess, onError } = props;
 
   return useCallback(
     async (urls: GenerationUrls) => {

package/src/domains/generation/wizard/presentation/hooks/video-queue/useVideoQueueGenerationPolling.ts

@@ -5,9 +5,8 @@
 import { useCallback, useEffect } from "react";
 import { pollQueueStatus } from "../videoQueuePoller";
 import {
-  DEFAULT_POLL_INTERVAL_MS,
   DEFAULT_MAX_POLL_TIME_MS,
-} from "../../../../../infrastructure/constants/polling.constants";
+} from "../../../../../../infrastructure/constants/polling.constants";
 import type { VideoQueueRefs } from "./useVideoQueueGenerationRefs";
 
 /**

package/src/domains/generation/wizard/presentation/hooks/video-queue/useVideoQueueGenerationStart.ts

@@ -5,7 +5,7 @@
 import { useCallback } from "react";
 import {
   DEFAULT_POLL_INTERVAL_MS,
-} from "../../../../../infrastructure/constants/polling.constants";
+} from "../../../../../../infrastructure/constants/polling.constants";
 import { extractInputMetadata } from "./use-video-queue-utils";
 import type {
   UseVideoQueueGenerationProps,
@@ -19,7 +19,7 @@ export function useStartGeneration(
   props: UseVideoQueueGenerationProps,
   refs: VideoQueueRefs,
   state: VideoQueueState,
-  clearPolling: () => void,
+  _clearPolling: () => void,
 ): (input: unknown, prompt: string) => Promise<void> {
   const { userId, scenario, persistence, strategy, creditCost, onError } = props;
   const { setIsGenerating } = state;

package/src/domains/text-to-image/domain/constants/index.ts

@@ -8,18 +8,17 @@ export {
 export interface PromptSuggestion {
   readonly id: string;
   readonly translationKey: string;
-  readonly fallbackText: string;
 }
 
 /** Default text-to-image example prompts */
 export const DEFAULT_TEXT_TO_IMAGE_PROMPTS: readonly PromptSuggestion[] = [
-  { id: "1", translationKey: "prompts.text2image.fantasy", fallbackText: "A mystical forest with glowing mushrooms" },
-  { id: "2", translationKey: "prompts.text2image.portrait", fallbackText: "Professional portrait with studio lighting" },
-  { id: "3", translationKey: "prompts.text2image.landscape", fallbackText: "Sunset over mountains with lake reflection" },
+  { id: "1", translationKey: "prompts.text2image.fantasy" },
+  { id: "2", translationKey: "prompts.text2image.portrait" },
+  { id: "3", translationKey: "prompts.text2image.landscape" },
 ];
 
 /** Default text-to-voice example prompts */
 export const DEFAULT_TEXT_TO_VOICE_PROMPTS: readonly PromptSuggestion[] = [
-  { id: "1", translationKey: "prompts.text2voice.greeting", fallbackText: "Hello, welcome to our application" },
-  { id: "2", translationKey: "prompts.text2voice.story", fallbackText: "Once upon a time in a land far away" },
+  { id: "1", translationKey: "prompts.text2voice.greeting" },
+  { id: "2", translationKey: "prompts.text2voice.story" },
 ];

package/src/domains/text-to-image/domain/types/text-to-image.types.ts

@@ -4,7 +4,6 @@
  */
 
 import type {
-  AspectRatio,
   BaseGenerationOptions,
   BaseGenerationResult,
   BaseRequestMeta,

package/src/domains/text-to-video/domain/types/request.types.ts

@@ -4,7 +4,6 @@
  */
 
 import type {
-  AspectRatio,
   BaseGenerationOptions,
   BaseGenerationResult,
   BaseRequestMeta,

package/src/domains/text-to-video/domain/types/state.types.ts

@@ -29,17 +29,6 @@ export interface TextToVideoFormState {
   professionalMode: boolean;
 }
 
-/**
- * Text-to-video generation state
- * Legacy state for backward compatibility
- */
-export interface TextToVideoGenerationState {
-  isGenerating: boolean;
-  progress: number;
-  contentWarnings: string[];
-  error: string | null;
-}
-
 /**
  * Frame data structure
  */
@@ -62,12 +51,3 @@ export const INITIAL_FORM_STATE: TextToVideoFormState = {
   professionalMode: false,
 };
 
-/**
- * Initial generation state
- */
-export const INITIAL_GENERATION_STATE: TextToVideoGenerationState = {
-  isGenerating: false,
-  progress: 0,
-  contentWarnings: [],
-  error: null,
-};

package/src/exports/features.ts

@@ -47,7 +47,7 @@ export type {
   UseTextToVideoFormProps, UseTextToVideoFormReturn, ExecuteTextToVideoOptions,
 } from "../domains/text-to-video";
 export {
-  INITIAL_FORM_STATE, INITIAL_GENERATION_STATE,
+  INITIAL_FORM_STATE,
   executeTextToVideo, hasTextToVideoSupport,
   useTextToVideoFeature, useTextToVideoForm,
   GenerationTabs, FrameSelector, OptionsPanel, HeroSection, HintCarousel,

package/src/infrastructure/utils/couple-input-index.ts

@@ -5,4 +5,5 @@
 export { resolveCoupleInput } from "./couple-input-resolver";
 export { prependContext } from "./couple-input-context";
 export { refinePromptForCouple } from "./couple-input-refiner";
+export { createPhotorealisticPrompt } from "./couple-input-photorealistic";
 export type { GenerationTargetLike } from "./couple-input-types";

package/src/infrastructure/utils/couple-input-photorealistic.ts

@@ -0,0 +1,40 @@
+/**
+ * Couple Input Utilities - Photorealistic Prompt Enhancement
+ */
+
+export interface PhotorealisticPromptOptions {
+  readonly isCouple?: boolean;
+  readonly customInstructions?: string;
+}
+
+/**
+ * Create a photorealistic prompt from refined input
+ * Adds photorealistic enhancements to the base prompt
+ */
+export function createPhotorealisticPrompt(
+  refinedPrompt: string,
+  options: PhotorealisticPromptOptions = {}
+): string {
+  const { isCouple = false, customInstructions } = options;
+
+  // Photorealistic quality keywords
+  const photorealisticPrefix = "high quality, photorealistic, detailed, 8k, professional photography";
+
+  // Build the final prompt
+  let finalPrompt = refinedPrompt;
+
+  // Add custom instructions if provided
+  if (customInstructions) {
+    finalPrompt = `${customInstructions}. ${finalPrompt}`;
+  }
+
+  // Add photorealistic prefix
+  finalPrompt = `${photorealisticPrefix}, ${finalPrompt}`;
+
+  // Add couple-specific enhancements
+  if (isCouple) {
+    finalPrompt = `${finalPrompt}, romantic couple, natural lighting, candid moment`;
+  }
+
+  return finalPrompt;
+}

package/src/infrastructure/utils/couple-input-types.ts

@@ -8,7 +8,4 @@ export interface GenerationTargetLike {
   readonly providerId: string;
 }
 
-interface CoupleInputResult {
-  readonly target: GenerationTargetLike;
-  readonly imageUrls: string[];
-}
+// CoupleInputResult is now defined inline where needed

package/src/infrastructure/utils/couple-input.util.ts

@@ -2,6 +2,6 @@
  * Couple Input Utilities
  */
 
-export { resolveCoupleInput, prependContext, refinePromptForCouple } from "./couple-input-index";
+export { resolveCoupleInput, prependContext, refinePromptForCouple, createPhotorealisticPrompt } from "./couple-input-index";
 export type { GenerationTargetLike } from "./couple-input-index";
 

package/src/infrastructure/validation/base-validator.ts

@@ -5,6 +5,9 @@
 
 import type { ValidationResult, StringValidationOptions, NumericValidationOptions } from "./base-validator.types";
 
+// Re-export types for convenience
+export type { ValidationResult, StringValidationOptions, NumericValidationOptions };
+
 /**
  * Validates a string input against provided rules
  */

package/src/shared-kernel/application/hooks/use-feature-state.ts

@@ -7,7 +7,6 @@ import { useState, useCallback, useReducer } from 'react';
 import type {
   BaseFeatureState,
   FeatureStateAction,
-  createInitialFeatureState,
 } from '../../base-types';
 
 /**

package/src/shared-kernel/infrastructure/validation/error-handler.utils.ts

@@ -3,7 +3,7 @@
  * Utility functions for error handling
  */
 
-import type { AppError, ErrorHandlerOptions } from "./error-handler.types";
+import type { AppError } from "./error-handler.types";
 import { ErrorType } from "./error-handler.types";
 
 /**

package/src/shared-kernel/infrastructure/validation/index.ts

@@ -1,28 +1,70 @@
 /**
- * Shared infrastructure validation utilities
- * Exports all validation and error handling utilities
+ * Shared Validation Utilities
  */
 
+// Export types from base-validator.types
 export type {
   ValidationResult,
   StringValidationOptions,
-  NumberValidationOptions,
-} from './common-validators';
-
-export {
-  validateString,
-  validateNumber,
-  validateUrl,
-  validateRequiredFields,
-  combineValidationResults,
-} from './common-validators';
-
-export { ErrorType, type AppError, type ErrorHandlerOptions } from './error-handler';
-export {
-  createError,
-  toAppError,
-  isAppError,
-  getUserFriendlyMessage,
-  handleError,
-  withErrorHandling,
-} from './error-handler';
+  NumericValidationOptions,
+} from "../../../infrastructure/validation/base-validator.types";
+
+// Export functions from advanced-validator
+export { combineValidationResults } from "../../../infrastructure/validation/advanced-validator";
+
+// Export error handling utilities
+export { handleError } from "./error-handler";
+export { ErrorType } from "./error-handler.types";
+
+/**
+ * Validate a string is not empty
+ */
+export function validateString(value: string): ValidationResult {
+  if (typeof value !== 'string') {
+    return { isValid: false, errors: ['Value must be a string'] };
+  }
+
+  if (value.trim().length === 0) {
+    return { isValid: false, errors: ['String cannot be empty'] };
+  }
+
+  return { isValid: true, errors: [] };
+}
+
+/**
+ * Validate URL format
+ */
+export function validateUrl(url: string): ValidationResult {
+  if (typeof url !== 'string') {
+    return { isValid: false, errors: ['URL must be a string'] };
+  }
+
+  try {
+    new URL(url);
+    return { isValid: true, errors: [] };
+  } catch {
+    return { isValid: false, errors: ['Invalid URL format'] };
+  }
+}
+
+/**
+ * Validate required fields in an object
+ */
+export function validateRequiredFields<T extends Record<string, unknown>>(
+  obj: T,
+  requiredFields: (keyof T)[]
+): { isValid: boolean; missingFields: string[] } {
+  const missingFields: string[] = [];
+
+  for (const field of requiredFields) {
+    const value = obj[field];
+    if (value === undefined || value === null || value === '') {
+      missingFields.push(String(field));
+    }
+  }
+
+  return {
+    isValid: missingFields.length === 0,
+    missingFields,
+  };
+}

package/src/domains/content-moderation/infrastructure/services/index.ts

@@ -1,8 +0,0 @@
-/**
- * Services Index
- * Exports all infrastructure services
- */
-
-export { contentModerationService } from "./content-moderation.service";
-export { patternMatcherService, type PatternMatch } from "./pattern-matcher.service";
-export * from "./moderators";

package/src/domains/creations/domain/constants/index.ts

@@ -1,12 +0,0 @@
-/**
- * Creation Domain Constants - Modular Exports
- */
-
-// Status constants
-export * from "./creation-status.constants";
-
-// Field name constants
-export * from "./creation-fields.constants";
-
-// Validation rule constants
-export * from "./creation-validation.constants";

package/src/domains/image-to-video/domain/index.ts

@@ -1,2 +0,0 @@
-// Types
-export * from "./types";

package/src/domains/image-to-video/infrastructure/index.ts

@@ -1 +0,0 @@
-export * from "./services";

package/src/domains/image-to-video/presentation/index.ts

@@ -1,5 +0,0 @@
-// Hooks
-export * from "./hooks";
-
-// Components
-export * from "./components";

package/src/domains/text-to-video/domain/index.ts

@@ -1 +0,0 @@
-export * from "./types";

package/src/domains/text-to-video/presentation/index.ts

@@ -1,7 +0,0 @@
-/**
- * Text-to-Video Presentation Layer
- * Single Responsibility: Export all presentation components and hooks
- */
-
-export * from "./hooks";
-export * from "./components";