@umituz/web-ai 1.0.2 → 1.0.4

package/dist/content/index.js

@@ -1,3 +1,61 @@
+// src/content/domain/types/index.ts
+var PLATFORM_SPECS = {
+  twitter: {
+    maxLength: 280,
+    style: "concise, engaging, thread-friendly",
+    emojiSupport: true,
+    hashtagSupport: true,
+    imageSupport: true,
+    videoSupport: true,
+    maxHashtags: 5
+  },
+  linkedin: {
+    maxLength: 3e3,
+    style: "professional, insightful, industry-focused",
+    emojiSupport: true,
+    hashtagSupport: true,
+    imageSupport: true,
+    videoSupport: true,
+    maxHashtags: 5
+  },
+  instagram: {
+    maxLength: 2200,
+    style: "visual, engaging, emoji-rich",
+    emojiSupport: true,
+    hashtagSupport: true,
+    imageSupport: true,
+    videoSupport: true,
+    maxHashtags: 30
+  },
+  threads: {
+    maxLength: 500,
+    style: "conversational, community-driven",
+    emojiSupport: true,
+    hashtagSupport: true,
+    imageSupport: true,
+    videoSupport: true,
+    maxHashtags: 5
+  },
+  tiktok: {
+    maxLength: 150,
+    style: "catchy, trending, short-form",
+    emojiSupport: true,
+    hashtagSupport: true,
+    imageSupport: false,
+    videoSupport: true,
+    maxHashtags: 5
+  },
+  facebook: {
+    maxLength: 63206,
+    style: "conversational, engaging, shareable",
+    emojiSupport: true,
+    hashtagSupport: true,
+    imageSupport: true,
+    videoSupport: true,
+    maxHashtags: 5
+  }
+};
+
 // src/content/domain/calculations/ContentCreditCost.ts
 var CREDIT_COSTS = {
   "text-to-image": { standard: 1, hd: 2, "4k": 4 },
@@ -153,48 +211,428 @@ var AIError = class _AIError extends Error {
     this.cause = cause;
     this.metadata = metadata;
   }
-  static from(error, fallbackCode = "UNKNOWN") {
-    if (error instanceof _AIError) return error;
-    if (error instanceof Error) {
-      const code = mapMessageToCode(error.message, fallbackCode);
-      return new _AIError(error.message, code, error);
-    }
-    return new _AIError(String(error), fallbackCode, error);
+  static from(error, fallbackCode = "UNKNOWN") {
+    if (error instanceof _AIError) return error;
+    if (error instanceof Error) {
+      const code = mapMessageToCode(error.message, fallbackCode);
+      return new _AIError(error.message, code, error);
+    }
+    return new _AIError(String(error), fallbackCode, error);
+  }
+  toString() {
+    const statusPart = typeof this.metadata.status === "number" ? ` (HTTP ${this.metadata.status})` : "";
+    return `${this.name} [${this.type}]: ${this.message}${statusPart}`;
+  }
+  toJSON() {
+    return {
+      name: this.name,
+      type: this.type,
+      code: this.code,
+      message: this.message,
+      metadata: this.metadata
+    };
+  }
+};
+
+// src/content/domain/errors/AIErrors.ts
+var ValidationError = class extends AIError {
+  constructor(message) {
+    super(message, "VALIDATION_ERROR");
+    this.name = "ValidationError";
+  }
+};
+var ProviderUnavailableError = class extends AIError {
+  constructor(providerId) {
+    super(`Provider ${providerId} is not available`, "PROVIDER_UNAVAILABLE");
+    this.name = "ProviderUnavailableError";
+  }
+};
+var ProviderQuotaExhaustedError = class extends AIError {
+  constructor(providerId) {
+    super(`Provider ${providerId} quota exhausted`, "PROVIDER_QUOTA_EXHAUSTED");
+    this.name = "ProviderQuotaExhaustedError";
+  }
+};
+
+// src/content/domain/limits/ValidationLimits.ts
+var ValidationLimits = {
+  TOPIC: {
+    MIN: 1,
+    MAX: 500
+  },
+  CONTENT: {
+    MIN: 1,
+    MAX: 1e4
+  },
+  KEYWORD: {
+    MAX_COUNT: 20,
+    MAX_LENGTH: 50
+  },
+  DURATION_SECONDS: {
+    MIN: 10,
+    MAX: 600
+  },
+  CALENDAR_DAYS: {
+    MIN: 1,
+    MAX: 90
+  },
+  HASHTAG_COUNT: {
+    MIN: 1,
+    MAX: 50
+  },
+  SEO_CONTENT_PREVIEW: 500,
+  BLOG_PROMPT_PREVIEW: 1e3,
+  AB_VARIANT_CONTENT_PREVIEW: 200
+};
+
+// src/content/domain/limits/SpeechPaceConfig.ts
+var SpeechPaceConfig = {
+  WORDS_PER_SECOND: 2.5,
+  TOKENS_PER_SECOND: 10,
+  JSON_TOKEN_OVERHEAD: 500,
+  TOKENS_PER_CALENDAR_DAY: 150
+};
+
+// src/content/domain/limits/ProviderTimingConfig.ts
+var ProviderTimingConfig = {
+  DEFAULT_TIMEOUT_MS: 3e4,
+  DEFAULT_RETRY_ATTEMPTS: 3,
+  FAL_TIMEOUT_MS: 12e4,
+  FAL_RETRY_ATTEMPTS: 2,
+  GEMINI_TIMEOUT_MS: 6e4,
+  GEMINI_RETRY_ATTEMPTS: 3,
+  GROQ_TIMEOUT_MS: 3e4,
+  GROQ_RETRY_ATTEMPTS: 3,
+  HEALTH_CHECK_TTL_MS: 5 * 60 * 1e3,
+  RETRY_BACKOFF_BASE_MS: 1e3
+};
+
+// src/content/domain/limits/ModelDefaults.ts
+var ModelDefaults = {
+  GROQ_TEXT: "llama-3.1-8b-instant",
+  GROQ_CHAT: "llama-3.1-8b-instant",
+  FAL_IMAGE: "fal-ai/flux/schnell",
+  FAL_VIDEO: "fal-ai/hunyuan-video/1",
+  FAL_IMAGE_TO_VIDEO: "fal-ai/fast-animatediff/image-to-video",
+  GEMINI_TEXT: "gemini-2.0-flash",
+  GEMINI_IMAGE: "imagen-4.0-generate-001",
+  PRUNA_IMAGE: "p-image",
+  PRUNA_IMAGE_EDIT: "p-image-edit",
+  PRUNA_VIDEO: "p-video"
+};
+var TextModelDefaults = {
+  TEXT_MODEL: "claude-sonnet-4-20250514",
+  MAX_TOKENS: 4096,
+  DEFAULT_TEMPERATURE: 0.7,
+  DEFAULT_TOP_P: 0.9
+};
+
+// src/content/domain/limits/RequestQueueConfig.ts
+var RequestQueueConfig = {
+  MAX_CONCURRENT: 3,
+  MAX_QUEUE_SIZE: 50,
+  DEFAULT_TIMEOUT_MS: 3e4,
+  RETRY_DELAY_MS: 1e3,
+  RATE_LIMIT: {
+    ENABLED: true,
+    WINDOW_MS: 6e4,
+    MAX_REQUESTS_PER_WINDOW: 100
+  },
+  POLL_INTERVAL_MS: 100
+};
+
+// src/content/domain/limits/MemoryConfig.ts
+var MemoryConfig = {
+  MANAGER: {
+    MAX_SIZE_BYTES: 50 * 1024 * 1024,
+    CLEANUP_THRESHOLD_RATIO: 0.8,
+    RETENTION_RATIO: 0.5
+  },
+  POOL: {
+    DEFAULT_MAX_SIZE: 100
+  },
+  EXPIRING_CACHE: {
+    DEFAULT_TTL_MS: 6e4,
+    CLEANUP_INTERVAL_MS: 6e4
+  }
+};
+
+// src/content/domain/calculations/SpeechPaceEstimate.ts
+function estimateWordCountForDuration(durationSeconds) {
+  return Math.floor(durationSeconds * SpeechPaceConfig.WORDS_PER_SECOND);
+}
+function estimateTokenBudgetForDuration(durationSeconds) {
+  return durationSeconds * SpeechPaceConfig.TOKENS_PER_SECOND + SpeechPaceConfig.JSON_TOKEN_OVERHEAD;
+}
+function estimateTokenBudgetForCalendarDays(days) {
+  return days * SpeechPaceConfig.TOKENS_PER_CALENDAR_DAY + SpeechPaceConfig.JSON_TOKEN_OVERHEAD;
+}
+
+// src/content/domain/calculations/SeoKeywordDensity.ts
+function countKeywordOccurrences(content, keyword) {
+  if (!keyword) return 0;
+  const escaped = keyword.replace(/[.*+?^${}()|[\]\\]/g, "\\$&");
+  const matches = content.match(new RegExp(escaped, "gi"));
+  return matches ? matches.length : 0;
+}
+function countWordsInContent(content) {
+  const tokens = content.split(/\s+/).filter(Boolean);
+  return tokens.length || 1;
+}
+function calculateKeywordDensity(content, keyword) {
+  const totalWords = countWordsInContent(content);
+  const occurrences = countKeywordOccurrences(content, keyword);
+  return occurrences / totalWords * 100;
+}
+
+// src/content/domain/calculations/AbTestImprovementRatio.ts
+function calculateImprovementPercentage(scoreA, scoreB) {
+  const higher = Math.max(scoreA, scoreB);
+  const lower = Math.min(scoreA, scoreB);
+  if (lower <= 0) {
+    return "100";
+  }
+  const delta = (higher / lower - 1) * 100;
+  return Math.abs(delta).toFixed(0);
+}
+function selectHigherScoreVariantId(scoreA, scoreB, idA = "A", idB = "B") {
+  return scoreA > scoreB ? idA : idB;
+}
+
+// src/content/domain/calculations/RetryBackoffDelay.ts
+function calculateRetryBackoffDelayMs(attemptIndex) {
+  return ProviderTimingConfig.RETRY_BACKOFF_BASE_MS * Math.pow(2, attemptIndex);
+}
+
+// src/content/domain/calculations/ContentCalendarDateOffset.ts
+var ONE_DAY_MS = 24 * 60 * 60 * 1e3;
+function resolveCalendarEntryDate(dayIndex, baseTimestamp = Date.now()) {
+  return new Date(baseTimestamp + (dayIndex - 1) * ONE_DAY_MS);
+}
+
+// src/content/domain/calculations/DefaultModelSelection.ts
+function resolveDefaultPrunaModel(generationType) {
+  switch (generationType) {
+    case "image-to-image":
+      return ModelDefaults.PRUNA_IMAGE_EDIT;
+    case "image-to-video":
+      return ModelDefaults.PRUNA_VIDEO;
+    case "text-to-image":
+      return ModelDefaults.PRUNA_IMAGE;
+    case "text-to-video":
+      return ModelDefaults.PRUNA_VIDEO;
+  }
+}
+
+// src/content/domain/predicates/KeywordProminenceClassifier.ts
+var HIGH_DENSITY_THRESHOLD = 2;
+var MEDIUM_DENSITY_THRESHOLD = 1;
+function classifyKeywordProminence(densityPercent) {
+  if (densityPercent > HIGH_DENSITY_THRESHOLD) return "high";
+  if (densityPercent > MEDIUM_DENSITY_THRESHOLD) return "medium";
+  return "low";
+}
+function isUnderutilizedKeyword(densityPercent) {
+  return densityPercent < 1;
+}
+
+// src/content/domain/predicates/HashtagPriorityRanker.ts
+var DEFAULT_HASHTAG_BUDGET = Number.MAX_SAFE_INTEGER;
+function resolveHashtagBudget(platform) {
+  return PLATFORM_SPECS[platform]?.maxHashtags ?? DEFAULT_HASHTAG_BUDGET;
+}
+function rankAndTrimHashtags(hashtags, budget) {
+  if (hashtags.length <= budget) return [...hashtags];
+  return [...hashtags].sort((a, b) => b.length - a.length).slice(0, budget);
+}
+
+// src/content/domain/predicates/PlatformSpecResolver.ts
+var FALLBACK_SPEC = {
+  maxLength: 280,
+  style: "concise, engaging, audience-friendly",
+  emojiSupport: true,
+  hashtagSupport: true,
+  imageSupport: true,
+  videoSupport: true,
+  maxHashtags: 5
+};
+function resolvePlatformSpec(platform) {
+  return PLATFORM_SPECS[platform] ?? FALLBACK_SPEC;
+}
+function resolveMaxContentLength(platform, override) {
+  return override ?? resolvePlatformSpec(platform).maxLength;
+}
+
+// src/content/domain/predicates/ScoreRangeGuard.ts
+var SCORE_MIN = 0;
+var SCORE_MAX = 100;
+var SCORE_FALLBACK = 50;
+var CONFIDENCE_MIN = 0;
+var CONFIDENCE_MAX = 1;
+var CONFIDENCE_FALLBACK = 0.5;
+function clampScoreToValidRange(score, fallback = SCORE_FALLBACK) {
+  if (!Number.isFinite(score)) return fallback;
+  return Math.max(SCORE_MIN, Math.min(SCORE_MAX, score));
+}
+function clampConfidenceToValidRange(confidence, fallback = CONFIDENCE_FALLBACK) {
+  if (!Number.isFinite(confidence)) return fallback;
+  return Math.max(CONFIDENCE_MIN, Math.min(CONFIDENCE_MAX, confidence));
+}
+
+// src/content/domain/predicates/AbTestConfidence.ts
+var AB_TEST_DEFAULT_CONFIDENCE = 0.7;
+
+// src/content/domain/predicates/ProviderCostEstimator.ts
+var FAL_FIXED_COST = 1;
+var GROQ_FREE_TIER_COST = 0;
+var GEMINI_IMAGE_COST = 0.02;
+var GEMINI_TEXT_PER_1K_CHARS_COST = 1e-4;
+var PRUNA_FIXED_COST = 1;
+var UNKNOWN_PROVIDER_COST = 0;
+function estimateGroqGenerationCost(_request) {
+  return GROQ_FREE_TIER_COST;
+}
+function estimateFalGenerationCost(_request) {
+  return FAL_FIXED_COST;
+}
+function estimateGeminiGenerationCost(request) {
+  if (request.type === "image") return GEMINI_IMAGE_COST;
+  return GEMINI_TEXT_PER_1K_CHARS_COST;
+}
+function estimatePrunaGenerationCost() {
+  return PRUNA_FIXED_COST;
+}
+function estimateUnknownProviderCost() {
+  return UNKNOWN_PROVIDER_COST;
+}
+
+// src/content/domain/predicates/FalImageRenderingOptions.ts
+var FAL_FORMAT_TO_IMAGE_SIZE = {
+  square: "square_hd",
+  landscape: "landscape_16_9",
+  portrait: "portrait_9_16",
+  story: "portrait_9_16",
+  banner: "landscape_16_9"
+};
+var FAL_DEFAULT_IMAGE_SIZE = "square_hd";
+var FAL_QUALITY_TO_STEPS = {
+  standard: 4,
+  high: 6,
+  ultra: 8
+};
+var FAL_DEFAULT_QUALITY_STEPS = 6;
+function resolveFalImageSize(format) {
+  if (!format) return FAL_DEFAULT_IMAGE_SIZE;
+  return FAL_FORMAT_TO_IMAGE_SIZE[format] ?? FAL_DEFAULT_IMAGE_SIZE;
+}
+function resolveFalInferenceSteps(quality) {
+  if (!quality) return FAL_DEFAULT_QUALITY_STEPS;
+  return FAL_QUALITY_TO_STEPS[quality] ?? FAL_DEFAULT_QUALITY_STEPS;
+}
+
+// src/content/domain/validation/TopicTextValidator.ts
+function validateTopicText(topic) {
+  if (typeof topic !== "string" || topic.trim().length < ValidationLimits.TOPIC.MIN) {
+    throw new ValidationError("Topic cannot be empty");
+  }
+  const trimmed = topic.trim();
+  if (trimmed.length > ValidationLimits.TOPIC.MAX) {
+    throw new ValidationError(`Topic exceeds maximum length of ${ValidationLimits.TOPIC.MAX} characters`);
+  }
+  return trimmed;
+}
+
+// src/content/domain/validation/ContentBodyValidator.ts
+function validateContentBody(content) {
+  if (typeof content !== "string" || content.trim().length < ValidationLimits.CONTENT.MIN) {
+    throw new ValidationError("Content cannot be empty");
+  }
+  const trimmed = content.trim();
+  if (trimmed.length > ValidationLimits.CONTENT.MAX) {
+    throw new ValidationError(`Content exceeds maximum length of ${ValidationLimits.CONTENT.MAX} characters`);
+  }
+  return trimmed;
+}
+function truncateForSeoPreview(content) {
+  return content.substring(0, ValidationLimits.SEO_CONTENT_PREVIEW);
+}
+function truncateForBlogPromptPreview(content) {
+  return content.substring(0, ValidationLimits.BLOG_PROMPT_PREVIEW);
+}
+function truncateForAbVariantPreview(content) {
+  return content.substring(0, ValidationLimits.AB_VARIANT_CONTENT_PREVIEW);
+}
+
+// src/content/domain/validation/KeywordListValidator.ts
+function validateKeywordList(keywords) {
+  if (!Array.isArray(keywords)) {
+    throw new ValidationError("Keywords must be an array");
+  }
+  if (keywords.length > ValidationLimits.KEYWORD.MAX_COUNT) {
+    throw new ValidationError(`Cannot process more than ${ValidationLimits.KEYWORD.MAX_COUNT} keywords`);
+  }
+  return keywords.filter((k) => typeof k === "string" && k.trim().length > 0).map((keyword) => {
+    const trimmed = keyword.trim();
+    if (trimmed.length > ValidationLimits.KEYWORD.MAX_LENGTH) {
+      const preview = trimmed.substring(0, 20);
+      throw new ValidationError(
+        `Keyword "${preview}..." exceeds maximum length of ${ValidationLimits.KEYWORD.MAX_LENGTH} characters`
+      );
+    }
+    return trimmed;
+  });
+}
+
+// src/content/domain/validation/DurationSecondsValidator.ts
+function validateDurationSeconds(duration) {
+  if (!Number.isFinite(duration)) {
+    throw new ValidationError(
+      `Duration must be between ${ValidationLimits.DURATION_SECONDS.MIN} and ${ValidationLimits.DURATION_SECONDS.MAX} seconds`
+    );
+  }
+  if (duration < ValidationLimits.DURATION_SECONDS.MIN || duration > ValidationLimits.DURATION_SECONDS.MAX) {
+    throw new ValidationError(
+      `Duration must be between ${ValidationLimits.DURATION_SECONDS.MIN} and ${ValidationLimits.DURATION_SECONDS.MAX} seconds`
+    );
   }
-  toString() {
-    const statusPart = typeof this.metadata.status === "number" ? ` (HTTP ${this.metadata.status})` : "";
-    return `${this.name} [${this.type}]: ${this.message}${statusPart}`;
+  return duration;
+}
+
+// src/content/domain/validation/CalendarDaysValidator.ts
+function validateCalendarDays(days) {
+  if (!Number.isFinite(days)) {
+    throw new ValidationError(
+      `Days must be between ${ValidationLimits.CALENDAR_DAYS.MIN} and ${ValidationLimits.CALENDAR_DAYS.MAX}`
+    );
   }
-  toJSON() {
-    return {
-      name: this.name,
-      type: this.type,
-      code: this.code,
-      message: this.message,
-      metadata: this.metadata
-    };
+  if (days < ValidationLimits.CALENDAR_DAYS.MIN || days > ValidationLimits.CALENDAR_DAYS.MAX) {
+    throw new ValidationError(
+      `Days must be between ${ValidationLimits.CALENDAR_DAYS.MIN} and ${ValidationLimits.CALENDAR_DAYS.MAX}`
+    );
   }
-};
+  return days;
+}
 
-// src/content/domain/errors/AIErrors.ts
-var ValidationError = class extends AIError {
-  constructor(message) {
-    super(message, "VALIDATION_ERROR");
-    this.name = "ValidationError";
-  }
-};
-var ProviderUnavailableError = class extends AIError {
-  constructor(providerId) {
-    super(`Provider ${providerId} is not available`, "PROVIDER_UNAVAILABLE");
-    this.name = "ProviderUnavailableError";
+// src/content/domain/validation/HashtagCountValidator.ts
+function validateHashtagCount(count) {
+  if (!Number.isFinite(count)) {
+    throw new ValidationError(
+      `Hashtag count must be between ${ValidationLimits.HASHTAG_COUNT.MIN} and ${ValidationLimits.HASHTAG_COUNT.MAX}`
+    );
   }
-};
-var ProviderQuotaExhaustedError = class extends AIError {
-  constructor(providerId) {
-    super(`Provider ${providerId} quota exhausted`, "PROVIDER_QUOTA_EXHAUSTED");
-    this.name = "ProviderQuotaExhaustedError";
+  if (count < ValidationLimits.HASHTAG_COUNT.MIN || count > ValidationLimits.HASHTAG_COUNT.MAX) {
+    throw new ValidationError(
+      `Hashtag count must be between ${ValidationLimits.HASHTAG_COUNT.MIN} and ${ValidationLimits.HASHTAG_COUNT.MAX}`
+    );
   }
-};
+  return Math.floor(count);
+}
+
+// src/content/domain/utils/IdGenerator.ts
+function generateId(prefix) {
+  const id = typeof crypto !== "undefined" && typeof crypto.randomUUID === "function" ? crypto.randomUUID() : `${Date.now().toString(36)}-${Math.random().toString(36).slice(2, 11)}`;
+  return prefix ? `${prefix}-${id}` : id;
+}
 
 // src/core/errors/groq-error.ts
 var GroqError = class extends AIError {
@@ -263,18 +701,6 @@ function isTextProvider(provider) {
   return provider.capabilities.includes("text");
 }
 
-// src/content/domain/limits/ProviderTimingConfig.ts
-var ProviderTimingConfig = {
-  DEFAULT_TIMEOUT_MS: 3e4,
-  DEFAULT_RETRY_ATTEMPTS: 3,
-  FAL_TIMEOUT_MS: 12e4,
-  FAL_RETRY_ATTEMPTS: 2,
-  GEMINI_TIMEOUT_MS: 6e4,
-  GEMINI_RETRY_ATTEMPTS: 3,
-  HEALTH_CHECK_TTL_MS: 5 * 60 * 1e3,
-  RETRY_BACKOFF_BASE_MS: 1e3
-};
-
 // src/providers/factory/provider.factory.ts
 var ProviderFactory = class {
   providers = /* @__PURE__ */ new Map();
@@ -2048,11 +2474,6 @@ function findLastIndex2(items, predicate) {
   return -1;
 }
 
-// src/content/domain/calculations/RetryBackoffDelay.ts
-function calculateRetryBackoffDelayMs(attemptIndex) {
-  return ProviderTimingConfig.RETRY_BACKOFF_BASE_MS * Math.pow(2, attemptIndex);
-}
-
 // src/providers/base/base.provider.ts
 var BaseProvider = class {
   config;
@@ -2101,26 +2522,6 @@ var BaseProvider = class {
   }
 };
 
-// src/content/domain/predicates/ProviderCostEstimator.ts
-var FAL_FIXED_COST = 1;
-var GEMINI_IMAGE_COST = 0.02;
-var GEMINI_TEXT_PER_1K_CHARS_COST = 1e-4;
-function estimateFalGenerationCost(_request) {
-  return FAL_FIXED_COST;
-}
-function estimateGeminiGenerationCost(request) {
-  if (request.type === "image") return GEMINI_IMAGE_COST;
-  return GEMINI_TEXT_PER_1K_CHARS_COST;
-}
-
-// src/content/domain/limits/ModelDefaults.ts
-var ModelDefaults = {
-  FAL_IMAGE: "fal-ai/flux/schnell",
-  FAL_VIDEO: "fal-ai/hunyuan-video/1",
-  FAL_IMAGE_TO_VIDEO: "fal-ai/fast-animatediff/image-to-video",
-  GEMINI_TEXT: "gemini-2.0-flash",
-  GEMINI_IMAGE: "imagen-4.0-generate-001"};
-
 // src/providers/gemini/gemini.provider.ts
 var GEMINI_TIERS = {
   fast: "gemini-2.0-flash-lite",
@@ -2350,152 +2751,12 @@ function mapGeminiFinishReason(reason) {
   if (reason === "SAFETY" || reason === "PROHIBITED_CONTENT") return "content_filter";
   return void 0;
 }
-function findLastIndex3(items, predicate) {
-  for (let i = items.length - 1; i >= 0; i--) {
-    if (predicate(items[i])) return i;
-  }
-  return -1;
-}
-
-// src/content/domain/predicates/KeywordProminenceClassifier.ts
-var HIGH_DENSITY_THRESHOLD = 2;
-var MEDIUM_DENSITY_THRESHOLD = 1;
-function classifyKeywordProminence(densityPercent) {
-  if (densityPercent > HIGH_DENSITY_THRESHOLD) return "high";
-  if (densityPercent > MEDIUM_DENSITY_THRESHOLD) return "medium";
-  return "low";
-}
-function isUnderutilizedKeyword(densityPercent) {
-  return densityPercent < 1;
-}
-
-// src/content/domain/types/index.ts
-var PLATFORM_SPECS = {
-  twitter: {
-    maxLength: 280,
-    style: "concise, engaging, thread-friendly",
-    emojiSupport: true,
-    hashtagSupport: true,
-    imageSupport: true,
-    videoSupport: true,
-    maxHashtags: 5
-  },
-  linkedin: {
-    maxLength: 3e3,
-    style: "professional, insightful, industry-focused",
-    emojiSupport: true,
-    hashtagSupport: true,
-    imageSupport: true,
-    videoSupport: true,
-    maxHashtags: 5
-  },
-  instagram: {
-    maxLength: 2200,
-    style: "visual, engaging, emoji-rich",
-    emojiSupport: true,
-    hashtagSupport: true,
-    imageSupport: true,
-    videoSupport: true,
-    maxHashtags: 30
-  },
-  threads: {
-    maxLength: 500,
-    style: "conversational, community-driven",
-    emojiSupport: true,
-    hashtagSupport: true,
-    imageSupport: true,
-    videoSupport: true,
-    maxHashtags: 5
-  },
-  tiktok: {
-    maxLength: 150,
-    style: "catchy, trending, short-form",
-    emojiSupport: true,
-    hashtagSupport: true,
-    imageSupport: false,
-    videoSupport: true,
-    maxHashtags: 5
-  },
-  facebook: {
-    maxLength: 63206,
-    style: "conversational, engaging, shareable",
-    emojiSupport: true,
-    hashtagSupport: true,
-    imageSupport: true,
-    videoSupport: true,
-    maxHashtags: 5
-  }
-};
-
-// src/content/domain/predicates/HashtagPriorityRanker.ts
-var DEFAULT_HASHTAG_BUDGET = Number.MAX_SAFE_INTEGER;
-function resolveHashtagBudget(platform) {
-  return PLATFORM_SPECS[platform]?.maxHashtags ?? DEFAULT_HASHTAG_BUDGET;
-}
-function rankAndTrimHashtags(hashtags, budget) {
-  if (hashtags.length <= budget) return [...hashtags];
-  return [...hashtags].sort((a, b) => b.length - a.length).slice(0, budget);
-}
-
-// src/content/domain/predicates/PlatformSpecResolver.ts
-var FALLBACK_SPEC = {
-  maxLength: 280,
-  style: "concise, engaging, audience-friendly",
-  emojiSupport: true,
-  hashtagSupport: true,
-  imageSupport: true,
-  videoSupport: true,
-  maxHashtags: 5
-};
-function resolvePlatformSpec(platform) {
-  return PLATFORM_SPECS[platform] ?? FALLBACK_SPEC;
-}
-function resolveMaxContentLength(platform, override) {
-  return override ?? resolvePlatformSpec(platform).maxLength;
-}
-
-// src/content/domain/predicates/ScoreRangeGuard.ts
-var SCORE_MIN = 0;
-var SCORE_MAX = 100;
-var SCORE_FALLBACK = 50;
-var CONFIDENCE_MIN = 0;
-var CONFIDENCE_MAX = 1;
-var CONFIDENCE_FALLBACK = 0.5;
-function clampScoreToValidRange(score, fallback = SCORE_FALLBACK) {
-  if (!Number.isFinite(score)) return fallback;
-  return Math.max(SCORE_MIN, Math.min(SCORE_MAX, score));
-}
-function clampConfidenceToValidRange(confidence, fallback = CONFIDENCE_FALLBACK) {
-  if (!Number.isFinite(confidence)) return fallback;
-  return Math.max(CONFIDENCE_MIN, Math.min(CONFIDENCE_MAX, confidence));
-}
-
-// src/content/domain/predicates/AbTestConfidence.ts
-var AB_TEST_DEFAULT_CONFIDENCE = 0.7;
-
-// src/content/domain/predicates/FalImageRenderingOptions.ts
-var FAL_FORMAT_TO_IMAGE_SIZE = {
-  square: "square_hd",
-  landscape: "landscape_16_9",
-  portrait: "portrait_9_16",
-  story: "portrait_9_16",
-  banner: "landscape_16_9"
-};
-var FAL_DEFAULT_IMAGE_SIZE = "square_hd";
-var FAL_QUALITY_TO_STEPS = {
-  standard: 4,
-  high: 6,
-  ultra: 8
-};
-var FAL_DEFAULT_QUALITY_STEPS = 6;
-function resolveFalImageSize(format) {
-  if (!format) return FAL_DEFAULT_IMAGE_SIZE;
-  return FAL_FORMAT_TO_IMAGE_SIZE[format] ?? FAL_DEFAULT_IMAGE_SIZE;
-}
-function resolveFalInferenceSteps(quality) {
-  if (!quality) return FAL_DEFAULT_QUALITY_STEPS;
-  return FAL_QUALITY_TO_STEPS[quality] ?? FAL_DEFAULT_QUALITY_STEPS;
-}
+function findLastIndex3(items, predicate) {
+  for (let i = items.length - 1; i >= 0; i--) {
+    if (predicate(items[i])) return i;
+  }
+  return -1;
+}
 
 // src/providers/fal/fal.provider.ts
 var FalProvider = class extends BaseProvider {
@@ -2666,39 +2927,810 @@ var FalProvider = class extends BaseProvider {
   }
 };
 
-// src/providers/pruna/pruna-generate.ts
-var prunaCorePromise = null;
-async function loadPrunaCore() {
-  if (!prunaCorePromise) {
-    const specifier = "@umituz/pruna-provider/core";
-    prunaCorePromise = import(specifier);
+// src/providers/pruna/client/core/constants/limits.ts
+var DEFAULT_ASPECT_RATIO = "16:9";
+var P_VIDEO_DEFAULTS = {
+  duration: 5,
+  resolution: "720p",
+  fps: 24,
+  draft: false,
+  promptUpsampling: true
+};
+var POLL_DEFAULTS = {
+  intervalMs: 3e3,
+  maxAttempts: 120,
+  maxIntervalMs: 1e4,
+  backoffBase: 1.5,
+  jitterPercent: 0.1
+};
+var DEFAULT_DEDUPLICATOR_TTL_MS = 3e4;
+var DEDUPLICATOR_CLEANUP_GRACE_MS = 100;
+
+// src/providers/pruna/client/core/constants/network.ts
+var HTTPS_PREFIX = "https://";
+var HTTP_PREFIX = "http://";
+var BASE64_MARKER = "base64,";
+var PRUNA_BASE_URL = "https://api.pruna.ai";
+var PRUNA_PREDICTIONS_URL = `${PRUNA_BASE_URL}/v1/predictions`;
+var PRUNA_FILES_URL = `${PRUNA_BASE_URL}/v1/files`;
+var AUTH_FAILURE_STATUSES = [401, 403];
+var MIN_API_KEY_LENGTH = 1;
+var MAX_API_KEY_LENGTH = 256;
+
+// src/providers/pruna/client/core/constants/mime-types.ts
+var MIME_PNG = "image/png";
+var MIME_JPEG = "image/jpeg";
+var MIME_WEBP = "image/webp";
+var DEFAULT_IMAGE_MIME = MIME_PNG;
+var MIME_FILE_EXTENSION = {
+  [MIME_PNG]: "png",
+  [MIME_JPEG]: "jpg",
+  [MIME_WEBP]: "webp"
+};
+var IMAGE_SIGNATURES = {
+  PNG: [137, 80],
+  JPEG: [255, 216],
+  WEBP_RIFF: [82, 73]
+};
+
+// src/providers/pruna/client/core/errors/cancellation-error.ts
+var CANCELLATION_MESSAGE = "Request cancelled by user";
+var CancellationError = class extends Error {
+  constructor(message = CANCELLATION_MESSAGE) {
+    super(message);
+    this.name = "CancellationError";
+  }
+};
+
+// src/providers/pruna/client/core/errors/authentication-error.ts
+var AUTHENTICATION_MESSAGE = "Authentication failed. Please check your API key.";
+var AuthenticationError = class extends Error {
+  constructor(message = AUTHENTICATION_MESSAGE) {
+    super(message);
+    this.name = "AuthenticationError";
+  }
+};
+
+// src/providers/pruna/client/core/errors/timeout-error.ts
+var TIMEOUT_MESSAGE = "Generation timed out. Maximum polling attempts reached.";
+var TimeoutError = class extends Error {
+  constructor(message = TIMEOUT_MESSAGE) {
+    super(message);
+    this.name = "TimeoutError";
+  }
+};
+
+// src/providers/pruna/client/core/errors/validation-error.ts
+var ValidationError2 = class extends Error {
+  field;
+  reason;
+  receivedValue;
+  constructor(context) {
+    super(`Invalid ${context.field}: ${context.reason}`);
+    this.name = "ValidationError";
+    this.field = context.field;
+    this.reason = context.reason;
+    this.receivedValue = context.receivedValue;
+  }
+};
+
+// src/providers/pruna/client/core/utils/base64.ts
+var globalScope = globalThis;
+var hasBuffer = typeof globalScope.Buffer?.from === "function";
+function base64ToBytes(raw) {
+  if (hasBuffer) {
+    const bufferFactory = globalScope.Buffer;
+    if (!bufferFactory) {
+      throw new Error("Buffer unavailable despite detection flag");
+    }
+    const buf = bufferFactory.from(raw, "base64");
+    return new Uint8Array(buf.buffer, buf.byteOffset, buf.byteLength);
   }
-  return prunaCorePromise;
+  const decoded = atob(raw);
+  return Uint8Array.from(decoded, (char) => char.charCodeAt(0));
 }
-async function* generateWithPruna(request, apiKey, signal, onProgress) {
-  const prunaCore = await loadPrunaCore();
-  if (prunaCore.generateWithPruna) {
-    yield* prunaCore.generateWithPruna(request, apiKey, signal, onProgress);
-    return;
-  }
-  if (!prunaCore.submitPrediction || !prunaCore.pollForResult) {
-    throw new Error("@umituz/pruna-provider/core does not export required functions");
-  }
-  const modelId = request.model || (request.image ? "p-image-edit" : "p-image");
-  const prediction = await prunaCore.submitPrediction(modelId, request, apiKey, signal, onProgress);
-  if (prediction.output && typeof prediction.output === "object" && "url" in prediction.output) {
-    yield {
-      stage: "predicting",
-      result: { url: prediction.output.url, model: modelId }
+
+// src/providers/pruna/client/core/utils/mime-detector.ts
+var MIN_SIGNATURE_BYTES = 2;
+function matchesSignature(bytes, signature) {
+  if (bytes.length < signature.length) return false;
+  return signature.every((value, index) => bytes[index] === value);
+}
+function detectImageMime(bytes) {
+  if (bytes.length < MIN_SIGNATURE_BYTES) return DEFAULT_IMAGE_MIME;
+  if (matchesSignature(bytes, IMAGE_SIGNATURES.PNG)) return MIME_PNG;
+  if (matchesSignature(bytes, IMAGE_SIGNATURES.JPEG)) return MIME_JPEG;
+  if (matchesSignature(bytes, IMAGE_SIGNATURES.WEBP_RIFF)) return MIME_WEBP;
+  return DEFAULT_IMAGE_MIME;
+}
+
+// src/providers/pruna/client/core/utils/api-error-parser.ts
+async function parseApiError(response, fallback) {
+  const payload = await response.json().catch(() => ({ message: response.statusText }));
+  const message = payload.message ?? `${fallback}: ${response.status}`;
+  const error = new Error(message);
+  error.statusCode = response.status;
+  return error;
+}
+
+// src/providers/pruna/client/core/protocol/http-status.ts
+function isAuthFailureStatus(status) {
+  return AUTH_FAILURE_STATUSES.includes(status);
+}
+
+// src/providers/pruna/client/core/protocol/job-status.ts
+var TERMINAL_SUCCESS_STATUSES = ["succeeded", "completed"];
+var TERMINAL_FAILURE_STATUSES = ["failed"];
+function isTerminalSuccessStatus(status) {
+  if (!status) return false;
+  return TERMINAL_SUCCESS_STATUSES.includes(status);
+}
+function isTerminalFailureStatus(status) {
+  if (!status) return false;
+  return TERMINAL_FAILURE_STATUSES.includes(status);
+}
+
+// src/providers/pruna/client/core/protocol/abort-signal-classifier.ts
+function isAbortError(err) {
+  if (err instanceof DOMException && err.code === DOMException.ABORT_ERR) return true;
+  if (err instanceof Error && err.name === "AbortError") return true;
+  return false;
+}
+
+// src/providers/pruna/client/core/protocol/pruna-url-builder.ts
+function isAbsoluteHttpUrl(value) {
+  return value.startsWith(HTTPS_PREFIX) || value.startsWith(HTTP_PREFIX);
+}
+function isHttpsUrl(value) {
+  return value.startsWith(HTTPS_PREFIX);
+}
+function buildPrunaApiUrl(pathOrUrl) {
+  if (isAbsoluteHttpUrl(pathOrUrl)) return pathOrUrl;
+  return `${PRUNA_BASE_URL}${pathOrUrl}`;
+}
+function buildFileUrlById(fileId) {
+  return `${PRUNA_FILES_URL}/${fileId}`;
+}
+
+// src/providers/pruna/client/core/math/exponential-backoff.ts
+function calculateExponentialBackoff2(inputs) {
+  const {
+    attempt,
+    baseIntervalMs,
+    maxIntervalMs = POLL_DEFAULTS.maxIntervalMs,
+    jitterPercent = POLL_DEFAULTS.jitterPercent,
+    growthBase = POLL_DEFAULTS.backoffBase
+  } = inputs;
+  const safeAttempt = Math.max(0, attempt);
+  const safeBase = Math.max(0, baseIntervalMs);
+  const exponentialDelay = Math.min(safeBase * Math.pow(growthBase, safeAttempt), maxIntervalMs);
+  const jitter = exponentialDelay * jitterPercent * Math.random();
+  return exponentialDelay + jitter;
+}
+
+// src/providers/pruna/client/core/utils/uri-resolver.ts
+var uriCache = /* @__PURE__ */ new WeakMap();
+function stripBase64Prefix(image) {
+  if (isHttpsUrl(image)) return image;
+  const base64Index = image.indexOf(BASE64_MARKER);
+  return base64Index !== -1 ? image.slice(base64Index + BASE64_MARKER.length) : image;
+}
+function readOutput(output) {
+  if (typeof output === "string") return output;
+  if (Array.isArray(output) && output.length > 0) return output[0] ?? null;
+  if (output !== null && typeof output === "object" && "url" in output) {
+    return output.url;
+  }
+  return null;
+}
+function extractUri(data) {
+  const cached = uriCache.get(data);
+  if (cached !== void 0) return cached;
+  if (!isTerminalSuccessStatus(data.status)) {
+    uriCache.set(data, null);
+    return null;
+  }
+  const result = data.generation_url ?? readOutput(data.output) ?? data.video_url ?? data.data ?? null;
+  uriCache.set(data, result);
+  return result;
+}
+function resolveUri(uri) {
+  return uri.startsWith("/") ? `${PRUNA_BASE_URL}${uri}` : uri;
+}
+
+// src/providers/pruna/client/core/services/pruna-client.service.ts
+function buildFileExtension(mime) {
+  return MIME_FILE_EXTENSION[mime] ?? "bin";
+}
+async function uploadImage(base64OrUrl, apiKey, onProgress) {
+  if (isHttpsUrl(base64OrUrl)) return base64OrUrl;
+  if (base64OrUrl.startsWith(HTTP_PREFIX)) {
+    throw new Error("Only HTTPS URLs are supported for security.");
+  }
+  onProgress?.("uploading");
+  const raw = stripBase64Prefix(base64OrUrl);
+  let bytes;
+  try {
+    bytes = base64ToBytes(raw);
+  } catch {
+    throw new Error("Invalid image format. Provide base64 or a valid HTTPS URL.");
+  }
+  const mime = detectImageMime(bytes);
+  const buffer = bytes.buffer.slice(
+    bytes.byteOffset,
+    bytes.byteOffset + bytes.byteLength
+  );
+  const blob = new Blob([buffer], { type: mime });
+  const formData = new FormData();
+  formData.append("content", blob, `upload.${buildFileExtension(mime)}`);
+  const res = await fetch(PRUNA_FILES_URL, {
+    method: "POST",
+    headers: { apikey: apiKey },
+    body: formData
+  });
+  if (!res.ok) {
+    throw await parseApiError(res, "File upload error");
+  }
+  const data = await res.json();
+  return data.urls?.get ?? buildFileUrlById(data.id ?? "");
+}
+async function submitPrediction(model, input, apiKey, signal, onProgress) {
+  onProgress?.("predicting");
+  const res = await fetch(PRUNA_PREDICTIONS_URL, {
+    method: "POST",
+    headers: {
+      apikey: apiKey,
+      Model: model,
+      "Try-Sync": "true",
+      "Content-Type": "application/json"
+    },
+    body: JSON.stringify({ input }),
+    signal
+  });
+  if (!res.ok) {
+    throw await parseApiError(res, "API error");
+  }
+  return res.json();
+}
+var GenerationFailedError = class extends Error {
+  constructor(message) {
+    super(message);
+    this.name = "GenerationFailedError";
+  }
+};
+async function attemptPoll(fullUrl, apiKey, signal) {
+  let res;
+  try {
+    res = await fetch(fullUrl, { headers: { apikey: apiKey }, signal });
+  } catch (err) {
+    if (isAbortError(err)) throw new CancellationError();
+    return { outcome: "transient-failure" };
+  }
+  if (!res.ok) {
+    if (isAuthFailureStatus(res.status)) throw new AuthenticationError();
+    return { outcome: "transient-failure" };
+  }
+  let data;
+  try {
+    data = await res.json();
+  } catch {
+    return { outcome: "transient-failure" };
+  }
+  if (isTerminalSuccessStatus(data.status)) {
+    const uri = extractUri(data);
+    if (uri) return { outcome: "succeeded", uri: resolveUri(uri) };
+    return { outcome: "transient-failure" };
+  }
+  if (isTerminalFailureStatus(data.status)) {
+    throw new GenerationFailedError(data.error ?? "Generation failed during processing.");
+  }
+  return { outcome: "continue" };
+}
+async function pollForResult(pollUrl, apiKey, maxAttempts = POLL_DEFAULTS.maxAttempts, intervalMs = POLL_DEFAULTS.intervalMs, signal, onProgress) {
+  const fullUrl = isAbsoluteHttpUrl(pollUrl) ? pollUrl : buildPrunaApiUrl(pollUrl);
+  const controller = new AbortController();
+  const onExternalAbort = () => controller.abort();
+  signal?.addEventListener("abort", onExternalAbort);
+  try {
+    for (let i = 0; i < maxAttempts; i++) {
+      if (signal?.aborted) throw new CancellationError();
+      const delay = calculateExponentialBackoff2({ attempt: i, baseIntervalMs: intervalMs });
+      await new Promise((resolve) => setTimeout(resolve, delay));
+      if (signal?.aborted) throw new CancellationError();
+      onProgress?.("polling", i + 1);
+      const result = await attemptPoll(fullUrl, apiKey, controller.signal);
+      if (result.outcome === "succeeded" && result.uri) {
+        return result.uri;
+      }
+    }
+    throw new TimeoutError();
+  } finally {
+    signal?.removeEventListener("abort", onExternalAbort);
+    controller.abort();
+  }
+}
+
+// src/providers/pruna/client/core/math/comparison-hash.ts
+function sortKeysDeep(value) {
+  if (Array.isArray(value)) {
+    return value.map(sortKeysDeep);
+  }
+  if (value !== null && typeof value === "object") {
+    const record = value;
+    return Object.keys(record).sort().reduce((acc, key) => {
+      acc[key] = sortKeysDeep(record[key]);
+      return acc;
+    }, {});
+  }
+  return value;
+}
+function hashValue(value) {
+  if (value === null || typeof value !== "object") {
+    return String(value);
+  }
+  try {
+    return JSON.stringify(sortKeysDeep(value));
+  } catch {
+    return String(value);
+  }
+}
+function compositeHash(...values) {
+  return values.map(hashValue).join("|");
+}
+
+// src/providers/pruna/client/core/math/cache-key-derivation.ts
+function deriveGenerationCacheKey(apiKey, input) {
+  return `${apiKey}:${compositeHash(input)}`;
+}
+
+// src/providers/pruna/client/core/validation/api-key-validator.ts
+function assertValidApiKey(apiKey) {
+  if (typeof apiKey !== "string") {
+    throw new ValidationError2({
+      field: "apiKey",
+      reason: "must be a string",
+      receivedValue: typeof apiKey
+    });
+  }
+  if (apiKey.length < MIN_API_KEY_LENGTH) {
+    throw new ValidationError2({
+      field: "apiKey",
+      reason: "must not be empty",
+      receivedValue: apiKey
+    });
+  }
+  if (apiKey.length > MAX_API_KEY_LENGTH) {
+    throw new ValidationError2({
+      field: "apiKey",
+      reason: `exceeds maximum length of ${MAX_API_KEY_LENGTH}`,
+      receivedValue: apiKey.length
+    });
+  }
+}
+
+// src/providers/pruna/client/core/validation/image-source-validator.ts
+function classifyImageSource(source) {
+  if (source.startsWith(HTTPS_PREFIX)) return "https-url";
+  if (source.startsWith(HTTP_PREFIX)) return "http-url";
+  if (source.includes(BASE64_MARKER) || /^[A-Za-z0-9+/=]+$/.test(source)) return "base64";
+  return "unknown";
+}
+function assertSecureImageSource(image, fieldName = "image") {
+  if (typeof image !== "string") {
+    throw new ValidationError2({
+      field: fieldName,
+      reason: "must be a string",
+      receivedValue: typeof image
+    });
+  }
+  const kind = classifyImageSource(image);
+  if (kind === "http-url") {
+    throw new ValidationError2({
+      field: fieldName,
+      reason: "HTTP URLs are not supported; use HTTPS or a base64 data URI",
+      receivedValue: image
+    });
+  }
+  if (kind === "unknown") {
+    throw new ValidationError2({
+      field: fieldName,
+      reason: "must be an HTTPS URL or a base64 data URI",
+      receivedValue: typeof image
+    });
+  }
+}
+
+// src/providers/pruna/client/core/validation/aspect-ratio-validator.ts
+var SUPPORTED_ASPECT_RATIOS = [
+  "16:9",
+  "9:16",
+  "1:1",
+  "4:3",
+  "3:4",
+  "3:2",
+  "2:3"
+];
+function isSupportedAspectRatio(value) {
+  return typeof value === "string" && SUPPORTED_ASPECT_RATIOS.includes(value);
+}
+function assertValidAspectRatio(value, fieldName = "aspect_ratio") {
+  if (value === void 0 || value === null) return;
+  if (!isSupportedAspectRatio(value)) {
+    throw new ValidationError2({
+      field: fieldName,
+      reason: `must be one of ${SUPPORTED_ASPECT_RATIOS.join(", ")}`,
+      receivedValue: value
+    });
+  }
+}
+
+// src/providers/pruna/client/core/validation/resolution-validator.ts
+var SUPPORTED_RESOLUTIONS = ["720p", "1080p"];
+function isSupportedResolution(value) {
+  return typeof value === "string" && SUPPORTED_RESOLUTIONS.includes(value);
+}
+function assertValidResolution(value, fieldName = "resolution") {
+  if (value === void 0 || value === null) return;
+  if (!isSupportedResolution(value)) {
+    throw new ValidationError2({
+      field: fieldName,
+      reason: `must be one of ${SUPPORTED_RESOLUTIONS.join(", ")}`,
+      receivedValue: value
+    });
+  }
+}
+
+// src/providers/pruna/client/core/validation/duration-validator.ts
+var MIN_VIDEO_DURATION_SECONDS = 1;
+var MAX_VIDEO_DURATION_SECONDS = 30;
+function isValidDuration(value) {
+  return typeof value === "number" && Number.isFinite(value) && value >= MIN_VIDEO_DURATION_SECONDS && value <= MAX_VIDEO_DURATION_SECONDS && Number.isInteger(value);
+}
+function assertValidDuration(value, fieldName = "duration") {
+  if (value === void 0 || value === null) return;
+  if (!isValidDuration(value)) {
+    throw new ValidationError2({
+      field: fieldName,
+      reason: `must be an integer between ${MIN_VIDEO_DURATION_SECONDS} and ${MAX_VIDEO_DURATION_SECONDS} seconds`,
+      receivedValue: value
+    });
+  }
+}
+
+// src/providers/pruna/client/core/validation/prompt-validator.ts
+var MIN_PROMPT_LENGTH = 1;
+var MAX_PROMPT_LENGTH = 4e3;
+function assertValidPrompt(value, fieldName = "prompt") {
+  if (typeof value !== "string") {
+    throw new ValidationError2({
+      field: fieldName,
+      reason: "must be a string",
+      receivedValue: typeof value
+    });
+  }
+  if (value.trim().length < MIN_PROMPT_LENGTH) {
+    throw new ValidationError2({
+      field: fieldName,
+      reason: "must not be empty or whitespace-only",
+      receivedValue: value
+    });
+  }
+  if (value.length > MAX_PROMPT_LENGTH) {
+    throw new ValidationError2({
+      field: fieldName,
+      reason: `exceeds maximum length of ${MAX_PROMPT_LENGTH} characters`,
+      receivedValue: value.length
+    });
+  }
+}
+
+// src/providers/pruna/client/core/validation/seed-validator.ts
+var MIN_SEED = -2147483648;
+var MAX_SEED = 2147483647;
+function isValidSeed(value) {
+  return typeof value === "number" && Number.isFinite(value) && Number.isInteger(value) && value >= MIN_SEED && value <= MAX_SEED;
+}
+function assertValidSeed(value, fieldName = "seed") {
+  if (value === void 0 || value === null) return;
+  if (!isValidSeed(value)) {
+    throw new ValidationError2({
+      field: fieldName,
+      reason: `must be an integer in [${MIN_SEED}, ${MAX_SEED}]`,
+      receivedValue: value
+    });
+  }
+}
+
+// src/providers/pruna/client/core/protocol/input-type-guard.ts
+function isTextToImageInput(input) {
+  return input.model === "p-image";
+}
+function isImageToImageInput(input) {
+  return input.model === "p-image-edit";
+}
+function isImageToVideoInput(input) {
+  return input.model === "p-video";
+}
+
+// src/providers/pruna/client/core/utils/request-deduplicator.ts
+var RequestDeduplicator2 = class {
+  pendingRequests = /* @__PURE__ */ new Map();
+  ttl;
+  constructor(ttl = DEFAULT_DEDUPLICATOR_TTL_MS) {
+    this.ttl = ttl;
+  }
+  execute(key, fn) {
+    const existing = this.pendingRequests.get(key);
+    if (existing) {
+      if (Date.now() - existing.timestamp < this.ttl) {
+        return existing.promise;
+      }
+      this.pendingRequests.delete(key);
+    }
+    const promise = fn().finally(() => {
+      setTimeout(() => {
+        this.pendingRequests.delete(key);
+      }, DEDUPLICATOR_CLEANUP_GRACE_MS);
+    });
+    this.pendingRequests.set(key, { promise, timestamp: Date.now() });
+    return promise;
+  }
+  clear() {
+    this.pendingRequests.clear();
+  }
+  size() {
+    this.purgeExpired();
+    return this.pendingRequests.size;
+  }
+  purgeExpired() {
+    const now = Date.now();
+    for (const [key, value] of this.pendingRequests) {
+      if (now - value.timestamp >= this.ttl) {
+        this.pendingRequests.delete(key);
+      }
+    }
+  }
+};
+var globalDeduplicator = new RequestDeduplicator2();
+
+// src/providers/pruna/client/generation/builders/text-to-image.builder.ts
+var TextToImageInputBuilder = class {
+  model = "p-image";
+  build(input, _context) {
+    const payload = {
+      prompt: input.prompt,
+      aspect_ratio: input.aspect_ratio ?? DEFAULT_ASPECT_RATIO
+    };
+    if (input.seed !== void 0) {
+      payload.seed = input.seed;
+    }
+    return Promise.resolve(payload);
+  }
+};
+
+// src/providers/pruna/client/generation/builders/image-to-image.builder.ts
+var ImageToImageInputBuilder = class {
+  model = "p-image-edit";
+  build(input, _context) {
+    const payload = {
+      images: [stripBase64Prefix(input.image)],
+      prompt: input.prompt,
+      aspect_ratio: input.aspect_ratio ?? DEFAULT_ASPECT_RATIO
+    };
+    if (input.seed !== void 0) {
+      payload.seed = input.seed;
+    }
+    return Promise.resolve(payload);
+  }
+};
+
+// src/providers/pruna/client/generation/builders/image-to-video.builder.ts
+var ImageToVideoInputBuilder = class {
+  model = "p-video";
+  async build(input, context) {
+    if (context.signal?.aborted) {
+      throw new CancellationError();
+    }
+    const fileUrl = await uploadImage(
+      input.image,
+      context.apiKey,
+      context.onProgress
+    );
+    return {
+      image: fileUrl,
+      prompt: input.prompt,
+      duration: input.duration ?? P_VIDEO_DEFAULTS.duration,
+      resolution: input.resolution ?? P_VIDEO_DEFAULTS.resolution,
+      fps: P_VIDEO_DEFAULTS.fps,
+      draft: input.draft ?? P_VIDEO_DEFAULTS.draft,
+      aspect_ratio: input.aspect_ratio ?? DEFAULT_ASPECT_RATIO,
+      prompt_upsampling: P_VIDEO_DEFAULTS.promptUpsampling
     };
-    return;
   }
-  const pollUrl = prediction.status_url || prediction.generation_url;
+};
+
+// src/providers/pruna/client/generation/builders/model-input-builder.ts
+var ModelInputBuilderRegistry = class {
+  builders = /* @__PURE__ */ new Map();
+  register(builder) {
+    this.builders.set(builder.model, builder);
+    return this;
+  }
+  resolve(model) {
+    const builder = this.builders.get(model);
+    if (!builder) {
+      throw new Error(`No input builder registered for model: ${model}`);
+    }
+    return builder;
+  }
+};
+
+// src/providers/pruna/client/generation/builders/builder-factory.ts
+function createDefaultBuilderRegistry() {
+  return new ModelInputBuilderRegistry().register(new TextToImageInputBuilder()).register(new ImageToImageInputBuilder()).register(new ImageToVideoInputBuilder());
+}
+
+// src/providers/pruna/client/generation/services/generation.service.ts
+var builderRegistry = createDefaultBuilderRegistry();
+function validateGenerateInput(input) {
+  assertValidPrompt(input.prompt, `${input.model}.prompt`);
+  assertValidAspectRatio(input.aspect_ratio, `${input.model}.aspect_ratio`);
+  if (isTextToImageInput(input)) {
+    assertValidSeed(input.seed, `${input.model}.seed`);
+  } else if (isImageToImageInput(input)) {
+    assertSecureImageSource(input.image, `${input.model}.image`);
+    assertValidSeed(input.seed, `${input.model}.seed`);
+  } else if (isImageToVideoInput(input)) {
+    assertSecureImageSource(input.image, `${input.model}.image`);
+    assertValidDuration(input.duration, `${input.model}.duration`);
+    assertValidResolution(input.resolution, `${input.model}.resolution`);
+  }
+}
+async function generate(apiKey, input, options = {}) {
+  assertValidApiKey(apiKey);
+  validateGenerateInput(input);
+  const { signal, onProgress, useCache = true } = options;
+  if (useCache) {
+    const cacheKey = deriveGenerationCacheKey(apiKey, input);
+    return globalDeduplicator.execute(
+      cacheKey,
+      () => generateInternal(apiKey, input, { signal, onProgress })
+    );
+  }
+  return generateInternal(apiKey, input, { signal, onProgress });
+}
+async function generateInternal(apiKey, input, options) {
+  const { signal, onProgress } = options;
+  const builder = builderRegistry.resolve(input.model);
+  const modelInput = await builder.build(input, { apiKey, signal, onProgress });
+  const response = await submitPrediction(input.model, modelInput, apiKey, signal, onProgress);
+  const syncUri = extractUri(response);
+  if (syncUri) {
+    return { url: resolveUri(syncUri), model: input.model };
+  }
+  const pollUrl = response.get_url ?? response.status_url;
   if (!pollUrl) {
-    throw new Error("Pruna prediction response missing polling URL");
+    throw new Error("Pruna API returned no result and no polling URL.");
+  }
+  const url = await pollForResult(
+    pollUrl,
+    apiKey,
+    POLL_DEFAULTS.maxAttempts,
+    POLL_DEFAULTS.intervalMs,
+    signal,
+    onProgress
+  );
+  return { url, model: input.model };
+}
+async function generateImageThenVideo(apiKey, input, options = {}) {
+  assertValidApiKey(apiKey);
+  assertValidPrompt(input.prompt, "text-to-video.prompt");
+  assertValidAspectRatio(input.aspect_ratio, "text-to-video.aspect_ratio");
+  assertValidDuration(input.duration, "text-to-video.duration");
+  assertValidResolution(input.resolution, "text-to-video.resolution");
+  const { signal, onProgress } = options;
+  const aspectRatio = input.aspect_ratio ?? DEFAULT_ASPECT_RATIO;
+  onProgress?.("predicting", 1);
+  const imageResult = await generate(
+    apiKey,
+    { model: "p-image", prompt: input.prompt, aspect_ratio: aspectRatio },
+    { signal }
+  );
+  onProgress?.("predicting", 2);
+  return generate(
+    apiKey,
+    {
+      model: "p-video",
+      prompt: input.prompt,
+      image: imageResult.url,
+      duration: input.duration ?? P_VIDEO_DEFAULTS.duration,
+      resolution: input.resolution ?? P_VIDEO_DEFAULTS.resolution,
+      aspect_ratio: aspectRatio,
+      draft: input.draft ?? P_VIDEO_DEFAULTS.draft
+    },
+    { signal, onProgress }
+  );
+}
+
+// src/providers/pruna/pruna-generate.ts
+async function* generateWithPruna(request, apiKey, signal, onProgress) {
+  const stages = [];
+  let notify = null;
+  let done = false;
+  const wake = () => {
+    const fn = notify;
+    if (fn) {
+      notify = null;
+      fn();
+    }
+  };
+  const handleProgress = (stage) => {
+    stages.push({ stage });
+    wake();
+  };
+  const promise = (async () => {
+    try {
+      const model = request.model ?? (request.image ? "p-image-edit" : "p-image");
+      if (model === "p-video" && !request.image && request.prompt) {
+        const videoRes = await generateImageThenVideo(
+          apiKey,
+          {
+            prompt: request.prompt,
+            duration: request.duration ?? 5,
+            aspect_ratio: request.aspectRatio ?? request.aspect_ratio ?? "16:9"
+          },
+          { signal, onProgress: handleProgress }
+        );
+        stages.push({
+          stage: "polling",
+          result: { url: videoRes.url, model: "p-video" }
+        });
+        return;
+      }
+      const input = {
+        model,
+        prompt: request.prompt ?? "",
+        aspect_ratio: request.aspectRatio ?? request.aspect_ratio ?? "1:1",
+        ...request.image ? { image: request.image } : {},
+        ...request.duration ? { duration: request.duration } : {},
+        ...request.resolution ? { resolution: request.resolution } : {},
+        ...request.seed !== void 0 ? { seed: request.seed } : {}
+      };
+      const res = await generate(apiKey, input, {
+        signal,
+        onProgress: handleProgress
+      });
+      stages.push({
+        stage: "polling",
+        result: { url: res.url, model: res.model }
+      });
+    } catch (err) {
+      stages.push({
+        stage: "processing",
+        error: err instanceof Error ? err : new Error(String(err))
+      });
+    } finally {
+      done = true;
+      wake();
+    }
+  })();
+  while (!done || stages.length > 0) {
+    if (stages.length === 0 && !done) {
+      await new Promise((resolve) => {
+        notify = resolve;
+      });
+      notify = null;
+    }
+    while (stages.length > 0) {
+      const nextStage = stages.shift();
+      if (!nextStage) continue;
+      yield nextStage;
+      if (nextStage.error) {
+        throw nextStage.error;
+      }
+    }
   }
-  const resultUrl = await prunaCore.pollForResult(pollUrl, apiKey, 60, 2e3, signal, onProgress);
-  yield { stage: "polling", result: { url: resultUrl, model: modelId } };
+  await promise;
 }
 
 // src/providers/pruna/pruna.provider.ts
@@ -2791,40 +3823,21 @@ function createAI(config = {}) {
     defaultTier: config.defaultTier
   });
   if (config.anthropic?.apiKey) {
-    factory.register(new AnthropicProvider(config.anthropic));
-  }
-  if (config.groq?.apiKey) {
-    factory.register(new GroqProvider(config.groq));
-  }
-  if (config.gemini?.apiKey) {
-    factory.register(new GeminiProvider({ ...config.gemini, enabled: true }));
-  }
-  if (config.fal?.apiKey) {
-    factory.register(new FalProvider({ ...config.fal, enabled: true }));
-  }
-  if (config.pruna?.apiKey) {
-    factory.register(new PrunaProvider({ ...config.pruna, enabled: true }));
-  }
-  return factory;
-}
-
-// src/content/domain/limits/SpeechPaceConfig.ts
-var SpeechPaceConfig = {
-  WORDS_PER_SECOND: 2.5,
-  TOKENS_PER_SECOND: 10,
-  JSON_TOKEN_OVERHEAD: 500,
-  TOKENS_PER_CALENDAR_DAY: 150
-};
-
-// src/content/domain/calculations/SpeechPaceEstimate.ts
-function estimateWordCountForDuration(durationSeconds) {
-  return Math.floor(durationSeconds * SpeechPaceConfig.WORDS_PER_SECOND);
-}
-function estimateTokenBudgetForDuration(durationSeconds) {
-  return durationSeconds * SpeechPaceConfig.TOKENS_PER_SECOND + SpeechPaceConfig.JSON_TOKEN_OVERHEAD;
-}
-function estimateTokenBudgetForCalendarDays(days) {
-  return days * SpeechPaceConfig.TOKENS_PER_CALENDAR_DAY + SpeechPaceConfig.JSON_TOKEN_OVERHEAD;
+    factory.register(new AnthropicProvider(config.anthropic));
+  }
+  if (config.groq?.apiKey) {
+    factory.register(new GroqProvider(config.groq));
+  }
+  if (config.gemini?.apiKey) {
+    factory.register(new GeminiProvider({ ...config.gemini, enabled: true }));
+  }
+  if (config.fal?.apiKey) {
+    factory.register(new FalProvider({ ...config.fal, enabled: true }));
+  }
+  if (config.pruna?.apiKey) {
+    factory.register(new PrunaProvider({ ...config.pruna, enabled: true }));
+  }
+  return factory;
 }
 
 // src/content/application/prompts/PromptBuilder.ts
@@ -3137,75 +4150,6 @@ Return only the JSON:
   }
 };
 
-// src/content/domain/limits/ValidationLimits.ts
-var ValidationLimits = {
-  TOPIC: {
-    MIN: 1,
-    MAX: 500
-  },
-  CONTENT: {
-    MIN: 1,
-    MAX: 1e4
-  },
-  KEYWORD: {
-    MAX_COUNT: 20,
-    MAX_LENGTH: 50
-  },
-  DURATION_SECONDS: {
-    MIN: 10,
-    MAX: 600
-  },
-  CALENDAR_DAYS: {
-    MIN: 1,
-    MAX: 90
-  },
-  HASHTAG_COUNT: {
-    MIN: 1,
-    MAX: 50
-  },
-  SEO_CONTENT_PREVIEW: 500,
-  BLOG_PROMPT_PREVIEW: 1e3,
-  AB_VARIANT_CONTENT_PREVIEW: 200
-};
-
-// src/content/domain/validation/TopicTextValidator.ts
-function validateTopicText(topic) {
-  if (typeof topic !== "string" || topic.trim().length < ValidationLimits.TOPIC.MIN) {
-    throw new ValidationError("Topic cannot be empty");
-  }
-  const trimmed = topic.trim();
-  if (trimmed.length > ValidationLimits.TOPIC.MAX) {
-    throw new ValidationError(`Topic exceeds maximum length of ${ValidationLimits.TOPIC.MAX} characters`);
-  }
-  return trimmed;
-}
-
-// src/content/domain/validation/KeywordListValidator.ts
-function validateKeywordList(keywords) {
-  if (!Array.isArray(keywords)) {
-    throw new ValidationError("Keywords must be an array");
-  }
-  if (keywords.length > ValidationLimits.KEYWORD.MAX_COUNT) {
-    throw new ValidationError(`Cannot process more than ${ValidationLimits.KEYWORD.MAX_COUNT} keywords`);
-  }
-  return keywords.filter((k) => typeof k === "string" && k.trim().length > 0).map((keyword) => {
-    const trimmed = keyword.trim();
-    if (trimmed.length > ValidationLimits.KEYWORD.MAX_LENGTH) {
-      const preview = trimmed.substring(0, 20);
-      throw new ValidationError(
-        `Keyword "${preview}..." exceeds maximum length of ${ValidationLimits.KEYWORD.MAX_LENGTH} characters`
-      );
-    }
-    return trimmed;
-  });
-}
-
-// src/content/domain/utils/IdGenerator.ts
-function generateId(prefix) {
-  const id = typeof crypto !== "undefined" && typeof crypto.randomUUID === "function" ? crypto.randomUUID() : `${Date.now().toString(36)}-${Math.random().toString(36).slice(2, 11)}`;
-  return prefix ? `${prefix}-${id}` : id;
-}
-
 // src/content/application/services/BlogService.ts
 var BlogService = class {
   constructor(executor) {
@@ -3242,6 +4186,17 @@ var BlogService = class {
     };
   }
 };
+
+// src/content/infrastructure/utils/requestQueue.ts
+({
+  maxConcurrent: RequestQueueConfig.MAX_CONCURRENT,
+  maxQueueSize: RequestQueueConfig.MAX_QUEUE_SIZE,
+  defaultTimeout: RequestQueueConfig.DEFAULT_TIMEOUT_MS,
+  retryDelay: RequestQueueConfig.RETRY_DELAY_MS,
+  enableRateLimit: RequestQueueConfig.RATE_LIMIT.ENABLED,
+  rateLimitWindow: RequestQueueConfig.RATE_LIMIT.WINDOW_MS,
+  rateLimitMaxRequests: RequestQueueConfig.RATE_LIMIT.MAX_REQUESTS_PER_WINDOW
+});
 async function batchRequest(requests, options = {}) {
   const {
     concurrency = 3,
@@ -3273,21 +4228,6 @@ async function batchRequest(requests, options = {}) {
   return results;
 }
 
-// src/content/domain/validation/HashtagCountValidator.ts
-function validateHashtagCount(count) {
-  if (!Number.isFinite(count)) {
-    throw new ValidationError(
-      `Hashtag count must be between ${ValidationLimits.HASHTAG_COUNT.MIN} and ${ValidationLimits.HASHTAG_COUNT.MAX}`
-    );
-  }
-  if (count < ValidationLimits.HASHTAG_COUNT.MIN || count > ValidationLimits.HASHTAG_COUNT.MAX) {
-    throw new ValidationError(
-      `Hashtag count must be between ${ValidationLimits.HASHTAG_COUNT.MIN} and ${ValidationLimits.HASHTAG_COUNT.MAX}`
-    );
-  }
-  return Math.floor(count);
-}
-
 // src/content/application/services/SocialService.ts
 var MULTI_PLATFORMS = [
   "twitter",
@@ -3365,21 +4305,6 @@ var SocialService = class {
   }
 };
 
-// src/content/domain/validation/DurationSecondsValidator.ts
-function validateDurationSeconds(duration) {
-  if (!Number.isFinite(duration)) {
-    throw new ValidationError(
-      `Duration must be between ${ValidationLimits.DURATION_SECONDS.MIN} and ${ValidationLimits.DURATION_SECONDS.MAX} seconds`
-    );
-  }
-  if (duration < ValidationLimits.DURATION_SECONDS.MIN || duration > ValidationLimits.DURATION_SECONDS.MAX) {
-    throw new ValidationError(
-      `Duration must be between ${ValidationLimits.DURATION_SECONDS.MIN} and ${ValidationLimits.DURATION_SECONDS.MAX} seconds`
-    );
-  }
-  return duration;
-}
-
 // src/content/application/services/VideoScriptService.ts
 var buildScriptResult = (parsed, duration) => {
   const script = parsed.script ?? "";
@@ -3434,27 +4359,6 @@ var VideoScriptService = class {
   }
 };
 
-// src/content/domain/validation/ContentBodyValidator.ts
-function validateContentBody(content) {
-  if (typeof content !== "string" || content.trim().length < ValidationLimits.CONTENT.MIN) {
-    throw new ValidationError("Content cannot be empty");
-  }
-  const trimmed = content.trim();
-  if (trimmed.length > ValidationLimits.CONTENT.MAX) {
-    throw new ValidationError(`Content exceeds maximum length of ${ValidationLimits.CONTENT.MAX} characters`);
-  }
-  return trimmed;
-}
-function truncateForSeoPreview(content) {
-  return content.substring(0, ValidationLimits.SEO_CONTENT_PREVIEW);
-}
-function truncateForBlogPromptPreview(content) {
-  return content.substring(0, ValidationLimits.BLOG_PROMPT_PREVIEW);
-}
-function truncateForAbVariantPreview(content) {
-  return content.substring(0, ValidationLimits.AB_VARIANT_CONTENT_PREVIEW);
-}
-
 // src/content/application/services/AnalysisService.ts
 var DEFAULT_SENTIMENT = {
   sentiment: "neutral",
@@ -3507,23 +4411,6 @@ var AnalysisService = class {
   }
 };
 
-// src/content/domain/calculations/SeoKeywordDensity.ts
-function countKeywordOccurrences(content, keyword) {
-  if (!keyword) return 0;
-  const escaped = keyword.replace(/[.*+?^${}()|[\]\\]/g, "\\$&");
-  const matches = content.match(new RegExp(escaped, "gi"));
-  return matches ? matches.length : 0;
-}
-function countWordsInContent(content) {
-  const tokens = content.split(/\s+/).filter(Boolean);
-  return tokens.length || 1;
-}
-function calculateKeywordDensity(content, keyword) {
-  const totalWords = countWordsInContent(content);
-  const occurrences = countKeywordOccurrences(content, keyword);
-  return occurrences / totalWords * 100;
-}
-
 // src/content/application/services/SeoService.ts
 var DEFAULT_SEO_SCORE = {
   keywordDensity: 50,
@@ -3600,20 +4487,6 @@ var SeoService = class {
   }
 };
 
-// src/content/domain/calculations/AbTestImprovementRatio.ts
-function calculateImprovementPercentage(scoreA, scoreB) {
-  const higher = Math.max(scoreA, scoreB);
-  const lower = Math.min(scoreA, scoreB);
-  if (lower <= 0) {
-    return "100";
-  }
-  const delta = (higher / lower - 1) * 100;
-  return Math.abs(delta).toFixed(0);
-}
-function selectHigherScoreVariantId(scoreA, scoreB, idA = "A", idB = "B") {
-  return scoreA > scoreB ? idA : idB;
-}
-
 // src/content/application/services/ABTestService.ts
 var DEFAULT_PREDICTION = {
   variantId: "",
@@ -3715,27 +4588,6 @@ var ImagePromptService = class {
   }
 };
 
-// src/content/domain/validation/CalendarDaysValidator.ts
-function validateCalendarDays(days) {
-  if (!Number.isFinite(days)) {
-    throw new ValidationError(
-      `Days must be between ${ValidationLimits.CALENDAR_DAYS.MIN} and ${ValidationLimits.CALENDAR_DAYS.MAX}`
-    );
-  }
-  if (days < ValidationLimits.CALENDAR_DAYS.MIN || days > ValidationLimits.CALENDAR_DAYS.MAX) {
-    throw new ValidationError(
-      `Days must be between ${ValidationLimits.CALENDAR_DAYS.MIN} and ${ValidationLimits.CALENDAR_DAYS.MAX}`
-    );
-  }
-  return days;
-}
-
-// src/content/domain/calculations/ContentCalendarDateOffset.ts
-var ONE_DAY_MS = 24 * 60 * 60 * 1e3;
-function resolveCalendarEntryDate(dayIndex, baseTimestamp = Date.now()) {
-  return new Date(baseTimestamp + (dayIndex - 1) * ONE_DAY_MS);
-}
-
 // src/content/application/services/ContentCalendarService.ts
 var toCalendarEntry = (item) => ({
   date: resolveCalendarEntryDate(item.day),
@@ -4046,6 +4898,226 @@ var AIContentService = class {
   }
 };
 
-export { ABTestService, AIContentService, AIError, ASPECT_RATIO_OPTIONS, ASPECT_RATIO_VALUES, AnalysisService, BlogService, ContentCalendarService, CREDIT_COSTS as GENERATION_COSTS, GenerationExecutor, IMAGE_QUALITY_OPTIONS, IMAGE_QUALITY_VALUES, ImagePromptService, MOTION_OPTIONS, MediaGenerationService, PromptBuilder, ProviderQuotaExhaustedError, ProviderUnavailableError, STYLE_PRESETS, SeoService, SocialService, VIDEO_DURATION_OPTIONS, VIDEO_DURATION_OPTIONS_SECONDS, VIDEO_QUALITY_OPTIONS, VIDEO_QUALITY_VALUES, ValidationError, VideoScriptService, calculateContentCreditCost as calculateCreditCost, getDimensionsForAspectRatio, getRecommendedQuality };
+// src/wizard/content.wizard.ts
+var CONTENT_WIZARD_STEPS = [
+  {
+    id: "select-type",
+    label: "Select Type",
+    icon: "Layers",
+    description: "Choose the type of content you want to generate",
+    validate: (data) => Boolean(data.contentType)
+  },
+  {
+    id: "input-topic",
+    label: "Topic",
+    icon: "Lightbulb",
+    description: "Enter your topic or idea",
+    validate: (data) => {
+      const topic = data.topic;
+      return typeof topic === "string" && topic.length > 0;
+    }
+  },
+  {
+    id: "configure",
+    label: "Configure",
+    icon: "Settings",
+    description: "Set tone, audience, and platform",
+    validate: (data) => {
+      const d = data;
+      return Boolean(d.tone && d.targetAudience);
+    }
+  },
+  {
+    id: "advanced",
+    label: "Advanced",
+    icon: "Sliders",
+    description: "Additional options and optimizations",
+    optional: true
+  },
+  {
+    id: "preview",
+    label: "Preview",
+    icon: "Eye",
+    description: "Review your settings before generation"
+  },
+  {
+    id: "generating",
+    label: "Generating",
+    icon: "Sparkles",
+    description: "AI is generating your content"
+  },
+  {
+    id: "results",
+    label: "Results",
+    icon: "CheckCircle",
+    description: "Your generated content is ready"
+  }
+];
+function buildContentRequest(data) {
+  switch (data.contentType) {
+    case "blog":
+      return {
+        topic: data.topic ?? "",
+        blogType: "tutorial",
+        targetKeywords: data.keywords ?? [],
+        tone: data.tone ?? "professional",
+        wordCount: data.wordCount ?? 1e3,
+        targetAudience: data.targetAudience ?? "",
+        seoOptimization: data.seoOptimization ?? false,
+        includeImages: data.includeImages ?? false,
+        includeSchema: false
+      };
+    case "social":
+      return {
+        topic: data.topic ?? "",
+        platform: data.platform ?? "twitter",
+        tone: data.tone ?? "casual",
+        hashtags: true,
+        targetAudience: data.targetAudience,
+        includeCallToAction: data.includeCallToAction
+      };
+    case "script":
+      return {
+        topic: data.topic ?? "",
+        tone: data.tone ?? "professional",
+        duration: data.duration ?? 60,
+        targetAudience: data.targetAudience ?? "",
+        includeVisuals: true,
+        includeCallToAction: data.includeCallToAction ?? false
+      };
+    default:
+      throw new Error(`Unsupported content type: ${data.contentType}`);
+  }
+}
+
+// src/wizard/image.wizard.ts
+var IMAGE_WIZARD_STEPS = [
+  {
+    id: "input-prompt",
+    label: "Describe Image",
+    icon: "Image",
+    description: "Describe the image you want to create",
+    validate: (data) => {
+      const prompt = data.prompt;
+      return typeof prompt === "string" && prompt.length > 0;
+    }
+  },
+  {
+    id: "select-style",
+    label: "Style",
+    icon: "Palette",
+    description: "Choose the artistic style",
+    validate: (data) => Boolean(data.style)
+  },
+  {
+    id: "configure",
+    label: "Configure",
+    icon: "Settings",
+    description: "Set format, quality, and quantity",
+    validate: (data) => {
+      const d = data;
+      return Boolean(d.format && d.quality);
+    }
+  },
+  {
+    id: "advanced",
+    label: "Advanced",
+    icon: "Sliders",
+    description: "Color palette and platform optimization",
+    optional: true
+  },
+  { id: "preview", label: "Preview", icon: "Eye", description: "Review your settings" },
+  { id: "generating", label: "Generating", icon: "Sparkles", description: "AI is creating your image" },
+  { id: "results", label: "Results", icon: "Image", description: "Your generated image is ready" }
+];
+function buildImageRequest(data) {
+  return {
+    type: "image",
+    prompt: data.prompt ?? "",
+    style: data.style,
+    format: data.format,
+    quality: data.quality,
+    quantity: data.quantity ?? 1
+  };
+}
+
+// src/wizard/video.wizard.ts
+var validateSource = (data) => {
+  const d = data;
+  if (d.generationType === "text-to-video") {
+    return typeof d.prompt === "string" && d.prompt.length > 0;
+  }
+  if (d.generationType === "image-to-video") {
+    return typeof d.imageUrl === "string" && d.imageUrl.length > 0;
+  }
+  if (d.generationType === "video-to-video") {
+    return typeof d.sourceVideoUrl === "string" && d.sourceVideoUrl.length > 0 && typeof d.prompt === "string" && d.prompt.length > 0;
+  }
+  return false;
+};
+var VIDEO_WIZARD_STEPS = [
+  {
+    id: "select-type",
+    label: "Select Type",
+    icon: "Video",
+    description: "Choose video generation type",
+    validate: (data) => Boolean(data.generationType)
+  },
+  {
+    id: "input-source",
+    label: "Source",
+    icon: "FileInput",
+    description: "Provide your source (prompt, image, or video)",
+    validate: validateSource
+  },
+  {
+    id: "configure",
+    label: "Configure",
+    icon: "Settings",
+    description: "Set duration, aspect ratio, and style",
+    validate: (data) => {
+      const d = data;
+      return Boolean(d.duration && d.aspectRatio);
+    }
+  },
+  { id: "advanced", label: "Advanced", icon: "Sliders", description: "Additional video options", optional: true },
+  { id: "preview", label: "Preview", icon: "Eye", description: "Review your settings" },
+  { id: "generating", label: "Generating", icon: "Sparkles", description: "AI is creating your video" },
+  { id: "results", label: "Results", icon: "Video", description: "Your generated video is ready" }
+];
+function buildVideoRequest(data) {
+  switch (data.generationType) {
+    case "text-to-video":
+      return {
+        type: "video",
+        prompt: data.prompt ?? "",
+        duration: data.duration ?? 5,
+        aspectRatio: data.aspectRatio ?? "16:9",
+        style: data.style,
+        quality: data.quality
+      };
+    case "image-to-video":
+      return {
+        type: "video",
+        imageUrl: data.imageUrl ?? "",
+        prompt: data.prompt,
+        duration: data.duration ?? 5,
+        motion: data.motion ?? "medium",
+        camera: data.camera ?? "static"
+      };
+    case "video-to-video":
+      return {
+        type: "video",
+        sourceVideoUrl: data.sourceVideoUrl ?? "",
+        prompt: data.prompt ?? "",
+        styleTransfer: data.styleTransfer,
+        enhanceQuality: data.enhanceQuality
+      };
+    default:
+      throw new Error(`Unsupported generation type: ${data.generationType}`);
+  }
+}
+
+export { ABTestService, AB_TEST_DEFAULT_CONFIDENCE, AIContentService, AIError, ASPECT_RATIO_OPTIONS, ASPECT_RATIO_VALUES, AnalysisService, BlogService, CONTENT_WIZARD_STEPS, CREDIT_COSTS, ContentCalendarService, DEFAULT_CREDIT_COST, DEFAULT_HASHTAG_BUDGET, CREDIT_COSTS as GENERATION_COSTS, GenerationExecutor, IMAGE_QUALITY_OPTIONS, IMAGE_QUALITY_VALUES, IMAGE_WIZARD_STEPS, ImagePromptService, MOTION_OPTIONS, MediaGenerationService, MemoryConfig, ModelDefaults, PLATFORM_SPECS, PromptBuilder, ProviderQuotaExhaustedError, ProviderTimingConfig, ProviderUnavailableError, RequestQueueConfig, STYLE_PRESETS, SeoService, SocialService, SpeechPaceConfig, TextModelDefaults, VIDEO_DURATION_OPTIONS, VIDEO_DURATION_OPTIONS_SECONDS, VIDEO_QUALITY_OPTIONS, VIDEO_QUALITY_VALUES, VIDEO_WIZARD_STEPS, ValidationError, ValidationLimits, VideoScriptService, buildContentRequest, buildImageRequest, buildVideoRequest, calculateContentCreditCost, calculateContentCreditCost as calculateCreditCost, calculateImprovementPercentage, calculateKeywordDensity, calculateRetryBackoffDelayMs, clampConfidenceToValidRange, clampScoreToValidRange, classifyKeywordProminence, countKeywordOccurrences, countWordsInContent, estimateFalGenerationCost, estimateGeminiGenerationCost, estimateGroqGenerationCost, estimatePrunaGenerationCost, estimateTokenBudgetForCalendarDays, estimateTokenBudgetForDuration, estimateUnknownProviderCost, estimateWordCountForDuration, generateId, getDimensionsForAspectRatio, getRecommendedQuality, isUnderutilizedKeyword, rankAndTrimHashtags, recommendQualityForAspectRatio, resolveCalendarEntryDate, resolveDefaultPrunaModel, resolveDimensionsForAspectRatio, resolveFalImageSize, resolveFalInferenceSteps, resolveHashtagBudget, resolveMaxContentLength, resolvePlatformSpec, selectHigherScoreVariantId, toQualityTier, truncateForAbVariantPreview, truncateForBlogPromptPreview, truncateForSeoPreview, validateCalendarDays, validateContentBody, validateDurationSeconds, validateHashtagCount, validateKeywordList, validateTopicText };
 //# sourceMappingURL=index.js.map
 //# sourceMappingURL=index.js.map