@umituz/react-native-ai-generation-content 1.89.60 → 1.89.61

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@umituz/react-native-ai-generation-content",
-  "version": "1.89.60",
+  "version": "1.89.61",
   "description": "Provider-agnostic AI generation orchestration for React Native with result preview components",
   "main": "src/index.ts",
   "types": "src/index.ts",

package/src/domain/entities/polling.types.ts

@@ -13,10 +13,10 @@ export interface PollingConfig {
 }
 
 export const DEFAULT_POLLING_CONFIG: PollingConfig = {
-  maxAttempts: 60,
-  initialIntervalMs: 1000,
-  maxIntervalMs: 3000,
-  backoffMultiplier: 1.2,
+  maxAttempts: 40, // Reduced from 60 - 40 attempts with backoff = ~5 minutes total
+  initialIntervalMs: 1500, // Increased from 1000ms - less aggressive initial polling
+  maxIntervalMs: 5000, // Increased from 3000ms - longer intervals between retries
+  backoffMultiplier: 1.3, // Increased from 1.2 - faster exponential backoff
 };
 
 export interface PollingState {

package/src/domains/background/infrastructure/utils/polling-interval.util.ts

@@ -1,22 +1,25 @@
 /**
  * Polling Interval Calculator
+ * Re-exports centralized calculation utility
  */
 
 import type { PollingConfig } from "../../../../domain/entities/polling.types";
+import { calculatePollingInterval as calculateInterval } from "../../../../shared/utils/calculations.util";
 
 export interface IntervalOptions {
   attempt: number;
   config: PollingConfig;
 }
 
+/**
+ * Calculate polling interval using centralized utility
+ */
 export function calculatePollingInterval(options: IntervalOptions): number {
   const { attempt, config } = options;
-  const { initialIntervalMs, maxIntervalMs, backoffMultiplier } = config;
-
-  if (attempt === 0) {
-    return 0;
-  }
-
-  const interval = initialIntervalMs * Math.pow(backoffMultiplier, attempt - 1);
-  return Math.min(interval, maxIntervalMs);
+  return calculateInterval({
+    attempt,
+    initialIntervalMs: config.initialIntervalMs,
+    maxIntervalMs: config.maxIntervalMs,
+    backoffMultiplier: config.backoffMultiplier,
+  });
 }

package/src/domains/background/presentation/hooks/use-background-generation.ts

@@ -2,6 +2,7 @@ import { useCallback, useRef, useState, useMemo } from "react";
 import { usePendingJobs } from "./use-pending-jobs";
 import { executeDirectGeneration, executeQueuedJob } from "../../infrastructure/executors/backgroundJobExecutor";
 import { DEFAULT_QUEUE_CONFIG } from "../../domain/entities/job.types";
+import { calculateFilteredCount } from "../../../../shared/utils/calculations.util";
 import type {
   UseBackgroundGenerationOptions,
   UseBackgroundGenerationReturn,
@@ -90,14 +91,12 @@ export function useBackgroundGeneration<TInput = unknown, TResult = unknown>(
     [removeJob, onAllComplete],
   );
 
-  // Calculate active jobs from TanStack Query state (not ref) for reactivity
-  // Active jobs are those currently processing or queued
-  const activeJobs = useMemo(
-    () => jobs.filter((job) => job.status === "processing" || job.status === "queued"),
+  // Calculate active jobs more efficiently - use centralized utility
+  const activeJobCount = useMemo(
+    () => calculateFilteredCount(jobs, (job) => job.status === "processing" || job.status === "queued"),
     [jobs]
   );
 
-  const activeJobCount = activeJobs.length;
   const hasActiveJobs = activeJobCount > 0;
 
   return {

package/src/domains/background/presentation/hooks/use-pending-jobs.ts

@@ -40,7 +40,7 @@ export function usePendingJobs<TInput = unknown, TResult = unknown>(
     queryKey,
     queryFn: () => [],
     staleTime: Infinity,
-    gcTime: 30 * 60 * 1000,
+    gcTime: 5 * 60 * 1000, // 5 minutes - reduced from 30min to prevent memory bloat
     enabled: options.enabled !== false,
   });
 

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

@@ -17,6 +17,7 @@ import { imageModerator } from "./moderators/image.moderator";
 import { videoModerator } from "./moderators/video.moderator";
 import { voiceModerator } from "./moderators/voice.moderator";
 import { rulesRegistry } from "../rules/rules-registry";
+import { calculateConfidenceScore } from "../../../../shared/utils/calculations.util";
 
 
 interface ServiceConfig {
@@ -95,16 +96,7 @@ class ContentModerationService {
   }
 
   private calculateConfidence(violations: Violation[]): number {
-    if (violations.length === 0) return 1.0;
-
-    const weights = { critical: 1.0, high: 0.75, medium: 0.5, low: 0.25 };
-    const score = violations.reduce(
-      (sum, v) => sum + (weights[v.severity] || 0.25),
-      0
-    );
-
-    // Only divide by 2 if we have violations, otherwise return 1.0
-    return violations.length > 0 ? Math.min(1.0, score / Math.max(1, violations.length)) : 1.0;
+    return calculateConfidenceScore(violations);
   }
 
   private determineAction(

package/src/domains/creations/presentation/components/CreationCard.tsx

@@ -19,7 +19,7 @@ import { getPreviewUrl, getCreationTitle } from "../../domain/utils";
 
 const EMPTY_CALLBACKS: CreationCardCallbacks = {};
 
-export function CreationCard({
+export const CreationCard = React.memo<CreationCardProps>(function CreationCard({
   creation,
   callbacks = EMPTY_CALLBACKS,
   showBadges = true,
@@ -161,4 +161,4 @@ export function CreationCard({
       </View>
     </TouchableOpacity>
   );
-}
+});

package/src/domains/creations/presentation/components/CreationsFilterBar.tsx

@@ -10,7 +10,7 @@ import { useAppDesignTokens } from "@umituz/react-native-design-system/theme";
 import { createFilterButtons } from "../../../../shared/utils/filters";
 import type { CreationsFilterBarProps, MediaFilterLabels, StatusFilterLabels, FilterButton } from "./CreationsFilterBar.types";
 
-export function CreationsFilterBar({
+export const CreationsFilterBar = React.memo<CreationsFilterBarProps>(function CreationsFilterBar({
   filters,
   showClearButton = true,
   clearLabel = "Clear",
@@ -128,7 +128,7 @@ export function CreationsFilterBar({
       </ScrollView>
     </View>
   );
-}
+});
 
 
 /**

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

@@ -37,22 +37,26 @@ export function useCreations({
     }
   }, []);
 
-  const onDataCallback = useCallback((creations: Creation[]) => {
+  // Use refs for callbacks to maintain stable function references
+  const onDataCallbackRef = useRef<(creations: Creation[]) => void>();
+  const onErrorCallbackRef = useRef<(err: Error) => void>();
+
+  onDataCallbackRef.current = (creations: Creation[]) => {
     if (typeof __DEV__ !== "undefined" && __DEV__) {
       console.log("[useCreations] Realtime update:", creations.length);
     }
     setData(creations);
     setIsLoading(false);
     setError(null);
-  }, []);
+  };
 
-  const onErrorCallback = useCallback((err: Error) => {
+  onErrorCallbackRef.current = (err: Error) => {
     if (typeof __DEV__ !== "undefined" && __DEV__) {
       console.error("[useCreations] Realtime listener error:", err);
     }
     setError(err);
     setIsLoading(false);
-  }, []);
+  };
 
   useEffect(() => {
     if (!userId || !enabled) {
@@ -69,21 +73,21 @@ export function useCreations({
     setIsLoading(true);
     setError(null);
 
-    let timeoutId: ReturnType<typeof setTimeout>;
+    let timeoutId: ReturnType<typeof setTimeout> | undefined;
 
     const handleData = (creations: Creation[]) => {
-      clearTimeout(timeoutId);
-      onDataCallback(creations);
+      if (timeoutId) clearTimeout(timeoutId);
+      onDataCallbackRef.current?.(creations);
     };
 
     const handleError = (err: Error) => {
-      clearTimeout(timeoutId);
-      onErrorCallback(err);
+      if (timeoutId) clearTimeout(timeoutId);
+      onErrorCallbackRef.current?.(err);
     };
 
     const unsubscribe = repository.subscribeToAll(userId, handleData, handleError);
 
-    // Fallback timeout: if Firestore doesn't respond in 10s, stop loading
+    // Fallback timeout: if Firestore doesn't respond in 8s, stop loading
     timeoutId = setTimeout(() => {
       if (!isMounted) return;
       if (typeof __DEV__ !== "undefined" && __DEV__) {
@@ -91,17 +95,17 @@ export function useCreations({
       }
       setData((currentData) => currentData ?? []);
       setIsLoading(false);
-    }, 10000);
+    }, 8000);
 
     return () => {
       isMounted = false;
-      clearTimeout(timeoutId);
+      if (timeoutId) clearTimeout(timeoutId);
       if (typeof __DEV__ !== "undefined" && __DEV__) {
         console.log("[useCreations] Cleaning up realtime listener");
       }
       unsubscribe();
     };
-  }, [userId, repository, enabled]); // onDataCallback/onErrorCallback intentionally omitted - stable memoized refs
+  }, [userId, repository, enabled]);
 
   return { data, isLoading, error, refetch };
 }

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

@@ -15,6 +15,7 @@ import {
 } from "../../../generation/wizard/presentation/hooks/generation-result.utils";
 import type { Creation } from "../../domain/entities/Creation";
 import type { ICreationsRepository } from "../../domain/repositories/ICreationsRepository";
+import { isOlderThan, calculateAgeMs } from "../../../../shared/utils/calculations.util";
 
 
 export interface UseProcessingJobsPollerConfig {
@@ -84,10 +85,11 @@ export function useProcessingJobsPoller(
     pollingRef.current.add(creation.id);
 
     // Stale detection: if creation is older than max poll time, mark as failed
-    const ageMs = Date.now() - creation.createdAt.getTime();
-    if (ageMs > DEFAULT_MAX_POLL_TIME_MS) {
+    if (isOlderThan(creation.createdAt, DEFAULT_MAX_POLL_TIME_MS)) {
       if (typeof __DEV__ !== "undefined" && __DEV__) {
-        console.log("[ProcessingJobsPoller] Stale job detected, marking as failed:", creation.id, { ageMs });
+        console.log("[ProcessingJobsPoller] Stale job detected, marking as failed:", creation.id, {
+          ageMs: calculateAgeMs(creation.createdAt),
+        });
       }
       try {
         await repository.update(userId, creation.id, {
@@ -179,10 +181,9 @@ export function useProcessingJobsPoller(
     if (!enabled || !userId || orphanJobs.length === 0) return;
 
     const cleanupOrphans = async () => {
-      const staleOrphans = orphanJobs.filter((creation) => {
-        const ageMs = Date.now() - creation.createdAt.getTime();
-        return ageMs >= DEFAULT_MAX_POLL_TIME_MS;
-      });
+      const staleOrphans = orphanJobs.filter((creation) =>
+        isOlderThan(creation.createdAt, DEFAULT_MAX_POLL_TIME_MS)
+      );
 
       if (staleOrphans.length === 0) return;
 

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

@@ -14,6 +14,7 @@ import { GalleryResultPreview } from "../components/GalleryResultPreview";
 import { GalleryScreenHeader } from "../components/GalleryScreenHeader";
 import { MEDIA_FILTER_OPTIONS, STATUS_FILTER_OPTIONS } from "../../domain/types/creation-filter";
 import { createFilterButtons, createItemTitle } from "../utils/filter-buttons.util";
+import { calculatePaginationSlice, calculateHasMore } from "../../../../shared/utils/calculations.util";
 import type { Creation } from "../../domain/entities/Creation";
 import type { CreationsGalleryScreenProps } from "./creations-gallery.types";
 import { creationsGalleryStyles as styles } from "./creations-gallery.styles";
@@ -111,17 +112,20 @@ export function CreationsGalleryScreen({
   }), [callbacks, onCreationPress, onShareToFeed, galleryState]);
 
   const [pageLimit, setPageLimit] = useState(6);
+  const currentPage = Math.ceil(pageLimit / 6);
 
   const paginatedCreations = useMemo(() => {
-    return filters.filtered.slice(0, pageLimit);
-  }, [filters.filtered, pageLimit]);
+    const { end } = calculatePaginationSlice(filters.filtered.length, currentPage, pageLimit);
+    return filters.filtered.slice(0, end);
+  }, [filters.filtered, currentPage, pageLimit]);
 
   const handleLoadMore = useCallback(() => {
-    if (pageLimit < filters.filtered.length) {
+    const hasMore = calculateHasMore(filters.filtered.length, currentPage, 6);
+    if (hasMore) {
       if (__DEV__) console.log("[CreationsGallery] Loading more...", { current: pageLimit, total: filters.filtered.length });
       setPageLimit(prev => prev + 3);
     }
-  }, [pageLimit, filters.filtered.length]);
+  }, [pageLimit, filters.filtered.length, currentPage]);
 
   const renderItem = useCallback(({ item }: { item: Creation }) => {
     if (viewMode === "grid") {
@@ -233,12 +237,15 @@ export function CreationsGalleryScreen({
           numColumns={viewMode === "grid" ? 2 : 1}
           contentContainerStyle={viewMode === "grid" ? styles.gridContent : styles.listContent}
           onEndReached={handleLoadMore}
-          onEndReachedThreshold={0.5}
-          initialNumToRender={3}
-          maxToRenderPerBatch={3}
-          windowSize={5}
-          removeClippedSubviews={true}
+          onEndReachedThreshold={0.3}
+          initialNumToRender={6} // Increased from 3 - reduces blank space during scroll
+          maxToRenderPerBatch={8} // Increased from 3 - smoother scrolling
+          windowSize={7} // Increased from 5 - better off-screen rendering buffer
+          removeClippedSubviews={false} // Changed to false - prevents Android rendering issues
           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/infrastructure/config/env.config.ts

@@ -33,14 +33,14 @@ export const env = {
   generationMultiImageTimeoutMs: getEnvValue("GENERATION_MULTI_IMAGE_TIMEOUT_MS", 120000) as number,
 
   // Polling Configuration
-  pollDefaultIntervalMs: getEnvValue("POLL_DEFAULT_INTERVAL_MS", 3000) as number,
-  pollGalleryIntervalMs: getEnvValue("POLL_GALLERY_INTERVAL_MS", 5000) as number,
+  pollDefaultIntervalMs: getEnvValue("POLL_DEFAULT_INTERVAL_MS", 4000) as number, // Increased from 3000ms - less aggressive polling
+  pollGalleryIntervalMs: getEnvValue("POLL_GALLERY_INTERVAL_MS", 6000) as number, // Increased from 5000ms - gallery doesn't need frequent updates
   pollMaxTimeMs: getEnvValue("POLL_MAX_TIME_MS", 300000) as number,
-  pollMaxAttempts: getEnvValue("POLL_MAX_ATTEMPTS", 100) as number,
+  pollMaxAttempts: getEnvValue("POLL_MAX_ATTEMPTS", 75) as number, // Reduced from 100 - fewer attempts
   pollMaxConsecutiveErrors: getEnvValue("POLL_MAX_CONSECUTIVE_ERRORS", 5) as number,
-  pollMinBackoffDelayMs: getEnvValue("POLL_MIN_BACKOFF_DELAY_MS", 1000) as number,
+  pollMinBackoffDelayMs: getEnvValue("POLL_MIN_BACKOFF_DELAY_MS", 1500) as number, // Increased from 1000ms
   pollMaxBackoffDelayMs: getEnvValue("POLL_MAX_BACKOFF_DELAY_MS", 30000) as number,
-  pollBackoffMultiplier: getEnvValue("POLL_BACKOFF_MULTIPLIER", 1.5) as number,
+  pollBackoffMultiplier: getEnvValue("POLL_BACKOFF_MULTIPLIER", 1.6) as number, // Increased from 1.5 - faster backoff
 
   // Validation Limits
   validationMaxPromptLength: getEnvValue("VALIDATION_MAX_PROMPT_LENGTH", 10000) as number,

package/src/infrastructure/services/generation-orchestrator.service.ts

@@ -12,6 +12,7 @@ import type {
 import { classifyError } from "../utils/error-classification";
 import { pollJob } from "../../domains/background/infrastructure/services/job-poller.service";
 import { ProviderValidator } from "./provider-validator";
+import { calculateDurationMs } from "../../shared/utils/calculations.util";
 
 
 export interface OrchestratorConfig {
@@ -91,7 +92,7 @@ class GenerationOrchestratorService {
       }
 
       const result = pollResult.data as T;
-      const duration = Date.now() - startTime;
+      const duration = calculateDurationMs(startTime);
 
       if (typeof __DEV__ !== "undefined" && __DEV__) {
         console.log("[Orchestrator] Generate completed:", {
@@ -111,7 +112,7 @@ class GenerationOrchestratorService {
           capability: request.capability,
           startTime,
           endTime: Date.now(),
-          duration,
+          duration: calculateDurationMs(startTime),
         },
       };
     } catch (error) {

package/src/infrastructure/utils/photo-generation/photo-preparation.util.ts

@@ -4,6 +4,11 @@
  * Utilities for preparing photos for AI generation.
  */
 
+import {
+  calculateBase64Size,
+  calculateBase64SizeMB,
+} from "../../../../shared/utils/calculations.util";
+
 export interface PhotoInput {
   base64: string;
   mimeType?: string;
@@ -70,15 +75,16 @@ export const isValidBase64 = (base64: string): boolean => {
 
 /**
  * Get image size estimate in bytes from base64
+ * Uses centralized calculation utility
  */
 export const getBase64Size = (base64: string): number => {
-  const cleaned = cleanBase64(base64);
-  return (cleaned.length * 3) / 4;
+  return calculateBase64Size(base64);
 };
 
 /**
  * Get image size estimate in MB from base64
+ * Uses centralized calculation utility
  */
 export const getBase64SizeMB = (base64: string): number => {
-  return getBase64Size(base64) / (1024 * 1024);
+  return calculateBase64SizeMB(base64);
 };

package/src/shared/hooks/index.ts

@@ -3,3 +3,4 @@
  */
 
 export * from "./factories";
+export * from "./useStableCallback";

package/src/shared/hooks/useStableCallback.ts

@@ -0,0 +1,75 @@
+/**
+ * useStableCallback Hook
+ * Returns a memoized callback that only changes when dependencies change
+ * Prevents unnecessary re-renders and child component updates
+ */
+
+import { useCallback, useRef } from "react";
+
+export function useStableCallback<T extends (...args: unknown[]) => unknown>(
+  callback: T,
+  deps: React.DependencyList
+): T {
+  const callbackRef = useRef(callback);
+  const depsRef = useRef(deps);
+
+  // Check if dependencies actually changed
+  const depsChanged = deps.length !== depsRef.current.length ||
+    deps.some((dep, i) => dep !== depsRef.current[i]);
+
+  if (depsChanged) {
+    callbackRef.current = callback;
+    depsRef.current = [...deps];
+  }
+
+  // Return stable reference
+  return useCallback((...args: Parameters<T>) => {
+    return callbackRef.current(...args);
+  }, []) as T;
+}
+
+/**
+ * useThrottledCallback Hook
+ * Returns a throttled version of the callback
+ */
+
+import { throttle } from "../utils/debounce.util";
+
+export function useThrottledCallback<T extends (...args: unknown[]) => unknown>(
+  callback: T,
+  wait: number,
+  deps: React.DependencyList
+): T {
+  const throttledRef = useRef<ReturnType<typeof throttle<T>> | undefined>(undefined);
+
+  // Recreate throttled function when dependencies change
+  if (!throttledRef.current || deps.some((dep, i) => dep !== (throttledRef.current as unknown as { deps: React.DependencyList }).deps?.[i])) {
+    throttledRef.current = throttle(callback, wait) as unknown as ReturnType<typeof throttle<T>>;
+    (throttledRef.current as unknown as { deps: React.DependencyList }).deps = [...deps];
+  }
+
+  return (throttledRef.current as unknown as T);
+}
+
+/**
+ * useDebouncedCallback Hook
+ * Returns a debounced version of the callback
+ */
+
+import { debounce } from "../utils/debounce.util";
+
+export function useDebouncedCallback<T extends (...args: unknown[]) => unknown>(
+  callback: T,
+  wait: number,
+  deps: React.DependencyList
+): T {
+  const debouncedRef = useRef<ReturnType<typeof debounce<T>> | undefined>(undefined);
+
+  // Recreate debounced function when dependencies change
+  if (!debouncedRef.current || deps.some((dep, i) => dep !== (debouncedRef.current as unknown as { deps: React.DependencyList }).deps?.[i])) {
+    debouncedRef.current = debounce(callback, wait) as unknown as ReturnType<typeof debounce<T>>;
+    (debouncedRef.current as unknown as { deps: React.DependencyList }).deps = [...deps];
+  }
+
+  return (debouncedRef.current as unknown as T);
+}

package/src/shared/index.ts

@@ -12,3 +12,5 @@ export * from "./hooks";
 // Utils
 export * from "./utils/date";
 export * from "./utils/filters";
+export * from "./utils/debounce.util";
+export * from "./utils/calculations.util";

package/src/shared/utils/calculations.util.ts

@@ -0,0 +1,366 @@
+/**
+ * Calculation Utilities
+ * Centralized calculation operations for better performance and maintainability
+ */
+
+/**
+ * Time & Duration Calculations
+ */
+
+/**
+ * Calculate age in milliseconds from a timestamp
+ */
+export function calculateAgeMs(timestamp: Date | number): number {
+  const time = typeof timestamp === "number" ? timestamp : timestamp.getTime();
+  return Date.now() - time;
+}
+
+/**
+ * Calculate age in seconds from a timestamp
+ */
+export function calculateAgeSeconds(timestamp: Date | number): number {
+  return Math.floor(calculateAgeMs(timestamp) / 1000);
+}
+
+/**
+ * Calculate age in minutes from a timestamp
+ */
+export function calculateAgeMinutes(timestamp: Date | number): number {
+  return Math.floor(calculateAgeSeconds(timestamp) / 60);
+}
+
+/**
+ * Check if timestamp is older than specified milliseconds
+ */
+export function isOlderThan(timestamp: Date | number, maxAgeMs: number): boolean {
+  return calculateAgeMs(timestamp) > maxAgeMs;
+}
+
+/**
+ * Calculate duration between two timestamps in milliseconds
+ */
+export function calculateDurationMs(
+  startTime: Date | number,
+  endTime: Date | number = Date.now()
+): number {
+  const start = typeof startTime === "number" ? startTime : startTime.getTime();
+  const end = typeof endTime === "number" ? endTime : endTime.getTime();
+  return end - start;
+}
+
+/**
+ * Format duration in milliseconds to human-readable string
+ */
+export function formatDuration(ms: number): string {
+  const seconds = Math.floor(ms / 1000);
+  const minutes = Math.floor(seconds / 60);
+  const hours = Math.floor(minutes / 60);
+
+  if (hours > 0) {
+    return `${hours}h ${minutes % 60}m`;
+  }
+  if (minutes > 0) {
+    return `${minutes}m ${seconds % 60}s`;
+  }
+  return `${seconds}s`;
+}
+
+/**
+ * Polling Calculations
+ */
+
+/**
+ * Calculate polling interval with exponential backoff
+ */
+export function calculatePollingInterval(options: {
+  attempt: number;
+  initialIntervalMs: number;
+  maxIntervalMs: number;
+  backoffMultiplier: number;
+}): number {
+  const { attempt, initialIntervalMs, maxIntervalMs, backoffMultiplier } = options;
+
+  if (attempt === 0) {
+    return 0;
+  }
+
+  const interval = initialIntervalMs * Math.pow(backoffMultiplier, attempt - 1);
+  return Math.min(interval, maxIntervalMs);
+}
+
+/**
+ * Calculate estimated total polling time
+ */
+export function calculateEstimatedPollingTime(options: {
+  maxAttempts: number;
+  initialIntervalMs: number;
+  maxIntervalMs: number;
+  backoffMultiplier: number;
+}): number {
+  let total = 0;
+  for (let attempt = 1; attempt < options.maxAttempts; attempt++) {
+    total += calculatePollingInterval({ ...options, attempt });
+    if (total >= options.maxIntervalMs * options.maxAttempts) {
+      break;
+    }
+  }
+  return total;
+}
+
+/**
+ * Progress & Percentage Calculations
+ */
+
+/**
+ * Calculate percentage with bounds checking (0-100)
+ */
+export function calculatePercentage(value: number, total: number): number {
+  if (total === 0) return 0;
+  const percentage = (value / total) * 100;
+  return Math.max(0, Math.min(100, percentage));
+}
+
+/**
+ * Calculate progress with min/max bounds
+ */
+export function calculateProgress(
+  current: number,
+  total: number,
+  min: number = 0,
+  max: number = 100
+): number {
+  if (total === 0) return min;
+  const percentage = (current / total) * (max - min) + min;
+  return Math.max(min, Math.min(max, percentage));
+}
+
+/**
+ * Calculate remaining percentage
+ */
+export function calculateRemaining(current: number, total: number): number {
+  return Math.max(0, total - current);
+}
+
+/**
+ * Array & Collection Calculations
+ */
+
+/**
+ * Calculate filtered count with predicate
+ */
+export function calculateFilteredCount<T>(
+  items: readonly T[],
+  predicate: (item: T) => boolean
+): number {
+  return items.reduce((count, item) => (predicate(item) ? count + 1 : count), 0);
+}
+
+/**
+ * Calculate pagination slice
+ */
+export function calculatePaginationSlice(
+  totalItems: number,
+  page: number,
+  pageSize: number
+): { start: number; end: number; count: number } {
+  const start = page * pageSize;
+  const end = Math.min(start + pageSize, totalItems);
+  const count = end - start;
+  return { start, end, count };
+}
+
+/**
+ * Calculate if more items exist for pagination
+ */
+export function calculateHasMore(
+  currentCount: number,
+  currentPage: number,
+  pageSize: number
+): boolean {
+  return currentCount >= currentPage * pageSize;
+}
+
+/**
+ * Base64 & Size Calculations
+ */
+
+/**
+ * Calculate base64 size in bytes
+ */
+export function calculateBase64Size(base64: string): number {
+  // Remove data URI prefix if present
+  const cleanBase64 = base64.replace(/^data:[^;]+;base64,/, "");
+  return (cleanBase64.length * 3) / 4;
+}
+
+/**
+ * Calculate base64 size in megabytes
+ */
+export function calculateBase64SizeMB(base64: string): number {
+  return calculateBase64Size(base64) / (1024 * 1024);
+}
+
+/**
+ * Calculate if base64 size is within limit
+ */
+export function isBase64SizeWithinLimit(base64: string, maxSizeMB: number): boolean {
+  return calculateBase64SizeMB(base64) <= maxSizeMB;
+}
+
+/**
+ * Confidence Score Calculations
+ */
+
+/**
+ * Calculate confidence score from violations with weights
+ */
+export function calculateConfidenceScore(
+  violations: readonly { severity: "critical" | "high" | "medium" | "low" }[]
+): number {
+  if (violations.length === 0) return 1.0;
+
+  const weights = { critical: 1.0, high: 0.75, medium: 0.5, low: 0.25 };
+  const score = violations.reduce(
+    (sum, v) => sum + (weights[v.severity] || 0.25),
+    0
+  );
+
+  // Normalize by number of violations, capped at 1.0
+  return Math.min(1.0, score / Math.max(1, violations.length));
+}
+
+/**
+ * Credit & Cost Calculations
+ */
+
+/**
+ * Calculate cost in credits based on duration and resolution
+ */
+export function calculateCredits(
+  durationSeconds: number,
+  resolutionMultiplier: number = 1,
+  baseCost: number = 1
+): number {
+  return Math.ceil((durationSeconds / 60) * resolutionMultiplier * baseCost);
+}
+
+/**
+ * Calculate resolution multiplier for credits
+ */
+export function calculateResolutionMultiplier(width: number, height: number): number {
+  const totalPixels = width * height;
+  const basePixels = 720 * 1280; // HD baseline
+
+  if (totalPixels <= basePixels) return 1;
+  if (totalPixels <= basePixels * 2) return 1.5;
+  if (totalPixels <= basePixels * 4) return 2;
+  return 3;
+}
+
+/**
+ * Calculate cost to credits conversion
+ */
+export function convertCostToCredits(
+  cost: number,
+  creditsPerDollar: number = 100
+): number {
+  return Math.ceil(cost * creditsPerDollar);
+}
+
+/**
+ * Aspect Ratio Calculations
+ */
+
+/**
+ * Calculate aspect ratio from dimensions
+ */
+export function calculateAspectRatio(width: number, height: number): number {
+  return width / height;
+}
+
+/**
+ * Calculate height from width and aspect ratio
+ */
+export function calculateHeightFromAspectRatio(
+  width: number,
+  aspectRatio: number
+): number {
+  return Math.round(width / aspectRatio);
+}
+
+/**
+ * Calculate width from height and aspect ratio
+ */
+export function calculateWidthFromAspectRatio(
+  height: number,
+  aspectRatio: number
+): number {
+  return Math.round(height * aspectRatio);
+}
+
+/**
+ * Memory & Performance Calculations
+ */
+
+/**
+ * Calculate estimated memory usage for image
+ */
+export function calculateImageMemoryUsage(
+  width: number,
+  height: number,
+  bytesPerPixel: number = 4 // RGBA
+): number {
+  return width * height * bytesPerPixel;
+}
+
+/**
+ * Calculate estimated memory usage in MB
+ */
+export function calculateMemoryMB(bytes: number): number {
+  return bytes / (1024 * 1024);
+}
+
+/**
+ * Calculate safe batch size for processing
+ */
+export function calculateSafeBatchSize(
+  availableMemoryMB: number,
+  itemSizeMB: number,
+  safetyFactor: number = 0.7
+): number {
+  const safeMemory = availableMemoryMB * safetyFactor;
+  return Math.max(1, Math.floor(safeMemory / itemSizeMB));
+}
+
+/**
+ * Utility Functions
+ */
+
+/**
+ * Clamp value between min and max
+ */
+export function clamp(value: number, min: number, max: number): number {
+  return Math.max(min, Math.min(max, value));
+}
+
+/**
+ * Linear interpolation between two values
+ */
+export function lerp(start: number, end: number, progress: number): number {
+  return start + (end - start) * clamp(progress, 0, 1);
+}
+
+/**
+ * Map value from one range to another
+ */
+export function mapRange(
+  value: number,
+  inMin: number,
+  inMax: number,
+  outMin: number,
+  outMax: number
+): number {
+  const inRange = inMax - inMin;
+  const outRange = outMax - outMin;
+  return outMin + ((value - inMin) / inRange) * outRange;
+}

package/src/shared/utils/credit.ts

@@ -3,6 +3,8 @@
  * Provides consistent credit calculation operations
  */
 
+import { calculateCredits as calculateCreditsFromDuration } from "./calculations.util";
+
 /**
  * Validates if a value is a valid credit amount
  * @param credits - Credit value to validate
@@ -46,6 +48,21 @@ export function calculateTotalCost(costPerUnit: number, units: number): number {
   return costPerUnit * units;
 }
 
+/**
+ * Calculates credits based on duration and resolution
+ * @param durationSeconds - Duration in seconds
+ * @param resolutionMultiplier - Resolution multiplier (default: 1)
+ * @param baseCost - Base cost per minute (default: 1)
+ * @returns Required credits
+ */
+export function calculateCredits(
+  durationSeconds: number,
+  resolutionMultiplier: number = 1,
+  baseCost: number = 1
+): number {
+  return calculateCreditsFromDuration(durationSeconds, resolutionMultiplier, baseCost);
+}
+
 /**
  * Formats credits for display
  * @param credits - Credit amount

package/src/shared/utils/debounce.util.ts

@@ -0,0 +1,56 @@
+/**
+ * Debounce Utility
+ * Delays function execution until after wait milliseconds have elapsed
+ * since the last time the debounced function was invoked
+ */
+
+export function debounce<T extends (...args: unknown[]) => unknown>(
+  func: T,
+  wait: number
+): (...args: Parameters<T>) => void {
+  let timeoutId: ReturnType<typeof setTimeout> | undefined;
+
+  return function debounced(...args: Parameters<T>) {
+    if (timeoutId) {
+      clearTimeout(timeoutId);
+    }
+
+    timeoutId = setTimeout(() => {
+      func(...args);
+      timeoutId = undefined;
+    }, wait);
+  };
+}
+
+/**
+ * Throttle Utility
+ * Ensures function execution at most once every wait milliseconds
+ */
+
+export function throttle<T extends (...args: unknown[]) => unknown>(
+  func: T,
+  wait: number
+): (...args: Parameters<T>) => void {
+  let timeoutId: ReturnType<typeof setTimeout> | undefined;
+  let lastCallTime = 0;
+
+  return function throttled(...args: Parameters<T>) {
+    const now = Date.now();
+    const timeSinceLastCall = now - lastCallTime;
+
+    if (timeSinceLastCall >= wait) {
+      lastCallTime = now;
+      func(...args);
+    } else {
+      if (timeoutId) {
+        clearTimeout(timeoutId);
+      }
+
+      timeoutId = setTimeout(() => {
+        lastCallTime = Date.now();
+        func(...args);
+        timeoutId = undefined;
+      }, wait - timeSinceLastCall);
+    }
+  };
+}