@umituz/web-ai 1.0.3 → 1.0.4

package/dist/index.cjs

@@ -1084,6 +1084,26 @@ function isMediaProvider(provider) {
   return provider.capabilities.includes("image") || provider.capabilities.includes("video");
 }
 
+// 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/ProviderTimingConfig.ts
 var ProviderTimingConfig = {
   DEFAULT_TIMEOUT_MS: 3e4,
@@ -1426,6 +1446,9 @@ var ProviderFactory = class {
     );
   }
 };
+function createProviderFactory(config) {
+  return new ProviderFactory(config);
+}
 
 // src/providers/anthropic/anthropic.constants.ts
 var ANTHROPIC_MODELS = {
@@ -2455,6 +2478,9 @@ function toGroqMessages(messages, systemPrompt) {
   }
   return wire;
 }
+function createGroqProvider(config) {
+  return new GroqProvider(config);
+}
 function findLastIndex2(items, predicate) {
   for (let i = items.length - 1; i >= 0; i--) {
     if (predicate(items[i])) return i;
@@ -2721,6 +2747,128 @@ function createGeminiProvider(config) {
   return new GeminiProvider(config);
 }
 
+// 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/QualityRecommenderByRatio.ts
+var WIDE_RATIOS = /* @__PURE__ */ new Set(["16:9", "4:3"]);
+function recommendQualityForAspectRatio(ratio) {
+  return WIDE_RATIOS.has(ratio) ? "hd" : "standard";
+}
+
+// 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",
@@ -2991,7 +3139,7 @@ var TimeoutError = class extends Error {
 };
 
 // src/providers/pruna/client/core/errors/validation-error.ts
-var ValidationError = class extends Error {
+var ValidationError2 = class extends Error {
   field;
   reason;
   receivedValue;
@@ -3276,21 +3424,21 @@ function deriveGenerationCacheKey(apiKey, input) {
 // src/providers/pruna/client/core/validation/api-key-validator.ts
 function assertValidApiKey(apiKey) {
   if (typeof apiKey !== "string") {
-    throw new ValidationError({
+    throw new ValidationError2({
       field: "apiKey",
       reason: "must be a string",
       receivedValue: typeof apiKey
     });
   }
   if (apiKey.length < MIN_API_KEY_LENGTH) {
-    throw new ValidationError({
+    throw new ValidationError2({
       field: "apiKey",
       reason: "must not be empty",
       receivedValue: apiKey
     });
   }
   if (apiKey.length > MAX_API_KEY_LENGTH) {
-    throw new ValidationError({
+    throw new ValidationError2({
       field: "apiKey",
       reason: `exceeds maximum length of ${MAX_API_KEY_LENGTH}`,
       receivedValue: apiKey.length
@@ -3307,7 +3455,7 @@ function classifyImageSource(source) {
 }
 function assertSecureImageSource(image, fieldName = "image") {
   if (typeof image !== "string") {
-    throw new ValidationError({
+    throw new ValidationError2({
       field: fieldName,
       reason: "must be a string",
       receivedValue: typeof image
@@ -3315,14 +3463,14 @@ function assertSecureImageSource(image, fieldName = "image") {
   }
   const kind = classifyImageSource(image);
   if (kind === "http-url") {
-    throw new ValidationError({
+    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 ValidationError({
+    throw new ValidationError2({
       field: fieldName,
       reason: "must be an HTTPS URL or a base64 data URI",
       receivedValue: typeof image
@@ -3346,7 +3494,7 @@ function isSupportedAspectRatio(value) {
 function assertValidAspectRatio(value, fieldName = "aspect_ratio") {
   if (value === void 0 || value === null) return;
   if (!isSupportedAspectRatio(value)) {
-    throw new ValidationError({
+    throw new ValidationError2({
       field: fieldName,
       reason: `must be one of ${SUPPORTED_ASPECT_RATIOS.join(", ")}`,
       receivedValue: value
@@ -3362,7 +3510,7 @@ function isSupportedResolution(value) {
 function assertValidResolution(value, fieldName = "resolution") {
   if (value === void 0 || value === null) return;
   if (!isSupportedResolution(value)) {
-    throw new ValidationError({
+    throw new ValidationError2({
       field: fieldName,
       reason: `must be one of ${SUPPORTED_RESOLUTIONS.join(", ")}`,
       receivedValue: value
@@ -3379,7 +3527,7 @@ function isValidDuration(value) {
 function assertValidDuration(value, fieldName = "duration") {
   if (value === void 0 || value === null) return;
   if (!isValidDuration(value)) {
-    throw new ValidationError({
+    throw new ValidationError2({
       field: fieldName,
       reason: `must be an integer between ${MIN_VIDEO_DURATION_SECONDS} and ${MAX_VIDEO_DURATION_SECONDS} seconds`,
       receivedValue: value
@@ -3392,21 +3540,21 @@ var MIN_PROMPT_LENGTH = 1;
 var MAX_PROMPT_LENGTH = 4e3;
 function assertValidPrompt(value, fieldName = "prompt") {
   if (typeof value !== "string") {
-    throw new ValidationError({
+    throw new ValidationError2({
       field: fieldName,
       reason: "must be a string",
       receivedValue: typeof value
     });
   }
   if (value.trim().length < MIN_PROMPT_LENGTH) {
-    throw new ValidationError({
+    throw new ValidationError2({
       field: fieldName,
       reason: "must not be empty or whitespace-only",
       receivedValue: value
     });
   }
   if (value.length > MAX_PROMPT_LENGTH) {
-    throw new ValidationError({
+    throw new ValidationError2({
       field: fieldName,
       reason: `exceeds maximum length of ${MAX_PROMPT_LENGTH} characters`,
       receivedValue: value.length
@@ -3423,7 +3571,7 @@ function isValidSeed(value) {
 function assertValidSeed(value, fieldName = "seed") {
   if (value === void 0 || value === null) return;
   if (!isValidSeed(value)) {
-    throw new ValidationError({
+    throw new ValidationError2({
       field: fieldName,
       reason: `must be an integer in [${MIN_SEED}, ${MAX_SEED}]`,
       receivedValue: value
@@ -4357,6 +4505,1535 @@ function resetProvider() {
   container = null;
 }
 
+// src/content/domain/calculations/ContentCreditCost.ts
+var CREDIT_COSTS = {
+  "text-to-image": { standard: 1, hd: 2, "4k": 4 },
+  "image-to-image": { standard: 1, hd: 2, "4k": 4 },
+  "image-to-video": { standard: 3, hd: 5, "4k": 8 },
+  "text-to-video": { standard: 5, hd: 8, "4k": 12 }
+};
+var DEFAULT_CREDIT_COST = 0;
+function toQualityTier(quality) {
+  if (quality === "4k") return "4k";
+  if (quality === "hd" || quality === "1080p") return "hd";
+  return "standard";
+}
+function calculateContentCreditCost(type, quality = "standard") {
+  const tierCosts = CREDIT_COSTS[type];
+  if (!tierCosts) return DEFAULT_CREDIT_COST;
+  return tierCosts[toQualityTier(quality)] ?? tierCosts.standard;
+}
+
+// src/content/domain/limits/ImageFormatOptions.ts
+var ASPECT_RATIO_OPTIONS = [
+  { value: "1:1", label: "Square", width: 1024, height: 1024 },
+  { value: "16:9", label: "Landscape", width: 1920, height: 1080 },
+  { value: "9:16", label: "Portrait", width: 1080, height: 1920 },
+  { value: "4:3", label: "Standard", width: 1440, height: 1080 },
+  { value: "3:4", label: "Tall", width: 1080, height: 1440 }
+];
+var IMAGE_QUALITY_OPTIONS = [
+  { value: "standard", label: "Standard", description: "1024x1024, good quality", resolution: "1024x1024" },
+  { value: "hd", label: "HD", description: "1920x1080, high quality", resolution: "1920x1080" },
+  { value: "4k", label: "4K", description: "3840x2160, ultra quality", resolution: "3840x2160" }
+];
+var VIDEO_QUALITY_OPTIONS = [
+  { value: "720p", label: "720p HD", resolution: "1280x720" },
+  { value: "1080p", label: "1080p Full HD", resolution: "1920x1080" },
+  { value: "4k", label: "4K Ultra HD", resolution: "3840x2160" }
+];
+var VIDEO_DURATION_OPTIONS_SECONDS = [2, 3, 4, 5, 6, 7, 8, 9, 10];
+var MOTION_OPTIONS = [
+  { value: "slow", label: "Slow", description: "Gentle movement" },
+  { value: "medium", label: "Medium", description: "Balanced motion" },
+  { value: "fast", label: "Fast", description: "Dynamic movement" }
+];
+var STYLE_PRESETS = [
+  { value: "realistic", label: "Realistic", promptFragment: "realistic, photograph, detailed" },
+  { value: "artistic", label: "Artistic", promptFragment: "artistic, painting, creative" },
+  { value: "anime", label: "Anime", promptFragment: "anime style, manga, vibrant colors" },
+  { value: "cinematic", label: "Cinematic", promptFragment: "cinematic, movie scene, dramatic lighting" },
+  { value: "vintage", label: "Vintage", promptFragment: "vintage, retro, film grain" },
+  { value: "fantasy", label: "Fantasy", promptFragment: "fantasy, magical, ethereal" },
+  { value: "minimalist", label: "Minimalist", promptFragment: "minimalist, clean, simple" },
+  { value: "abstract", label: "Abstract", promptFragment: "abstract, geometric, artistic" }
+];
+
+// src/content/domain/calculations/AspectRatioDimensions.ts
+var FALLBACK_DIMENSIONS = { width: 1024, height: 1024 };
+function resolveDimensionsForAspectRatio(ratio) {
+  const match = ASPECT_RATIO_OPTIONS.find((option) => option.value === ratio);
+  return match ? { width: match.width, height: match.height } : FALLBACK_DIMENSIONS;
+}
+
+// src/content/domain/constants/GenerationConstants.ts
+var ASPECT_RATIO_VALUES = ASPECT_RATIO_OPTIONS.map((o) => o.value);
+var IMAGE_QUALITY_VALUES = IMAGE_QUALITY_OPTIONS.map((o) => o.value);
+var VIDEO_QUALITY_VALUES = VIDEO_QUALITY_OPTIONS.map((o) => o.value);
+var VIDEO_DURATION_OPTIONS = VIDEO_DURATION_OPTIONS_SECONDS;
+var getDimensionsForAspectRatio = resolveDimensionsForAspectRatio;
+var getRecommendedQuality = recommendQualityForAspectRatio;
+
+// 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/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/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/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`
+    );
+  }
+  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}`
+    );
+  }
+  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/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/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/prompts/PromptBuilder.ts
+var PromptBuilder = class {
+  static blogPost(input) {
+    return `
+As an expert SEO Content Strategist and Copywriter, generate a high-quality, comprehensive blog post.
+
+TOPIC: ${input.topic}
+TYPE: ${input.blogType}
+KEYWORDS: ${input.keywords.join(", ")}
+TONE: ${input.tone}
+TARGET AUDIENCE: ${input.targetAudience}
+WORD COUNT: ${input.wordCount}
+LANGUAGE: ${input.language || "English"}
+
+OPTIMIZATION REQUIREMENTS:
+- SEO Optimization: ${input.seoOptimization ? "ON (Include semantic keywords, LSI, and proper H1-H3 structure)" : "OFF"}
+- Include Schema Markup: ${input.includeSchema ? "ON (Generate JSON-LD for this blog type)" : "OFF"}
+- Image Suggestions: ${input.includeImages ? "ON (Provide DALL-E/Midjourney style prompts for contextually relevant images)" : "OFF"}
+
+RESPONSE FORMAT (STRICT JSON ONLY):
+{
+  "title": "Compelling, Click-worthy Title",
+  "content": "Full markdown-formatted blog content with headers",
+  "metaDescription": "SEO-optimized description (150-160 chars)",
+  "seoScore": 0-100,
+  "readabilityScore": 0-100,
+  "keywords": ["list", "of", "optimized", "keywords"],
+  "performance": {
+    "readingTime": minutes (number),
+    "shareability": 0-10 (number),
+    "seoRank": 0-10 (number)
+  },
+  "schemaMarkup": "JSON-LD string (if requested)",
+  "imagePrompts": ["Prompt 1", "Prompt 2"] (if requested)
+}
+`;
+  }
+  static socialPost(input) {
+    return `
+Write a ${input.tone} social media post about: ${input.topic}
+
+Platform: ${input.platform}
+Style: ${input.style}
+Maximum length: ${input.maxLength} characters
+${input.includeHashtags ? "Include relevant hashtags" : "No hashtags"}
+${input.includeCallToAction ? "Include a call-to-action" : ""}
+
+Requirements:
+- Platform-optimized formatting
+- Engaging hook in first sentence
+- Natural, conversational tone
+- Platform-appropriate emoji usage
+
+Generate the post in JSON format:
+{
+  "content": "The post content",
+  "hashtags": ["hashtag1", "hashtag2"],
+  "emojis": ["emoji1", "emoji2"],
+  "estimatedEngagement": 0-100
+}
+`;
+  }
+  static videoScript(input) {
+    return `
+Create a ${input.tone} video script about: ${input.topic}
+
+Duration: ${input.duration} seconds
+Target Audience: ${input.targetAudience}
+Include Visual Cues: ${input.includeVisuals ? "Yes" : "No"}
+Include CTA: ${input.includeCallToAction ? "Yes" : "No"}
+
+Approximate word count: ${estimateWordCountForDuration(input.duration)} words
+
+Generate in JSON format:
+{
+  "script": "Full script with dialogue and narration",
+  "visualCues": ["Visual cue 1", "Visual cue 2"],
+  "callToAction": "Call to action text (if requested)",
+  "estimatedEngagement": 0-100
+}
+`;
+  }
+  static voiceScript(input) {
+    return `
+Create a ${input.emotion} voice script about: ${input.topic}
+
+Duration: ${input.duration} seconds
+Emotion: ${input.emotion}
+
+The script should:
+- Evoke the specified emotion
+- Be suitable for voice recording with emotion control
+- Include natural speech patterns
+- Have appropriate pacing for the emotion
+- Include emotional cues in brackets where needed
+
+Approximate word count: ${estimateWordCountForDuration(input.duration)} words
+
+Generate in JSON format:
+{
+  "script": "Full script with emotional cues",
+  "visualCues": ["Visual cue 1", "Visual cue 2"],
+  "estimatedEngagement": 0-100
+}
+`;
+  }
+  static contentCalendar(niche, days) {
+    return `
+Generate a ${days}-day content calendar for: ${niche}
+
+For each day, provide:
+- Topic
+- Content type (blog, video, social, email, caption, script)
+- Best platform for this content
+- Brief description
+- Estimated engagement (0-100)
+- Priority level (high, medium, low)
+
+Format as JSON array:
+[
+  {
+    "day": 1,
+    "topic": "...",
+    "contentType": "blog|video|social|email|caption|script",
+    "platform": "twitter|linkedin|instagram|threads|tiktok|facebook",
+    "description": "...",
+    "estimatedEngagement": 0-100,
+    "priority": "high|medium|low"
+  }
+]
+
+Requirements:
+- Mix of content types across platforms
+- Platform-appropriate suggestions
+- Engaging, varied topics
+- Realistic posting schedule
+`;
+  }
+  static sentiment(content) {
+    return `
+Analyze the sentiment of this social media post:
+
+"${content}"
+
+Provide analysis in JSON format:
+{
+  "sentiment": "positive|neutral|negative",
+  "confidence": 0-1,
+  "emotions": [
+    {"emotion": "happy|excited|calm|sad|angry|surprised|fearful|disgusted|neutral", "score": 0-1}
+  ]
+}
+
+Return only the JSON:
+`;
+  }
+  static contentAnalysis(content) {
+    return `
+Analyze this content:
+
+"${content}"
+
+Provide analysis in JSON format:
+{
+  "keywords": ["keyword1", "keyword2", ...],
+  "entities": ["entity1", "entity2", ...],
+  "suggestedImprovements": ["suggestion1", ...],
+  "readabilityScore": 0-100,
+  "estimatedEngagement": 0-100
+}
+
+Return only the JSON:
+`;
+  }
+  static seoOptimization(content, keywords) {
+    return `
+Optimize this content for SEO:
+
+Content: "${content}"
+Keywords: ${keywords.join(", ")}
+
+Tasks:
+1. Incorporate keywords naturally
+2. Improve engagement potential
+3. Add relevant call-to-action if appropriate
+4. Optimize for readability
+5. Enhance heading structure
+
+Return JSON:
+{
+  "optimized": "...",
+  "score": 0-100,
+  "suggestions": ["suggestion1", ...],
+  "addedKeywords": ["keyword1", ...],
+  "removedFillerWords": number,
+  "readabilityImprovements": ["improvement1", ...],
+  "metaDescription": "SEO-optimized meta description",
+  "titleSuggestions": ["title1", ...]
+}
+
+Return only the JSON:
+`;
+  }
+  static seoScore(content, keywords) {
+    return `
+Calculate SEO score for this content:
+
+Content: "${content}"
+Keywords: ${keywords.join(", ")}
+
+Provide breakdown in JSON:
+{
+  "keywordDensity": 0-100,
+  "readabilityScore": 0-100,
+  "titleOptimization": 0-100,
+  "metaDescription": 0-100,
+  "headingStructure": 0-100,
+  "internalLinking": 0-100,
+  "overall": 0-100
+}
+
+Return only the JSON:
+`;
+  }
+  static abTestVariant(input) {
+    return `
+Predict performance for this content variant:
+
+Content: "${input.content}"
+Content Type: ${input.contentType}
+Tone: ${input.tone}
+Target Audience: ${input.targetAudience}
+Platform: ${input.platform}
+Goals: ${input.goals.join(", ")}
+
+Provide prediction in JSON:
+{
+  "predictedEngagement": 0-100,
+  "predictedCTR": 0-100,
+  "predictedConversions": 0-100,
+  "confidence": 0-1,
+  "reasoning": "...",
+  "strengths": ["strength1", ...],
+  "weaknesses": ["weakness1", ...],
+  "suggestions": ["suggestion1", ...]
+}
+
+Return only the JSON:
+`;
+  }
+  static hashtags(content, count) {
+    return `
+Generate ${count} relevant hashtags for this content:
+
+"${content}"
+
+Requirements:
+- Mix of popular and niche hashtags
+- Industry-specific when possible
+- Trending if relevant
+- No duplicated words
+- Format: #hashtag (one per line)
+
+Return only the hashtags:
+`;
+  }
+  static imagePrompt(description, style) {
+    return `
+Generate a detailed AI image generation prompt for:
+
+Description: ${description}
+Style: ${style || "realistic"}
+
+Create a detailed, descriptive prompt that includes:
+- Subject details
+- Mood and atmosphere
+- Lighting
+- Composition
+- Art style reference
+- Technical specifications (aspect ratio, quality)
+
+The prompt should be optimized for models like Midjourney, DALL-E, or Stable Diffusion.
+
+Generate the prompt:
+`;
+  }
+  static blogImagePrompts(blogContent) {
+    return `
+Analyze this blog content and generate 3-5 detailed image prompts for illustrative images:
+
+Blog Content: "${blogContent}"
+
+For each image prompt, provide:
+- Subject description
+- Mood and atmosphere
+- Style reference
+- Composition details
+- Technical specs
+
+Return as JSON array:
+["prompt1", "prompt2", "prompt3", ...]
+
+Return only the JSON:
+`;
+  }
+  static maxTokensForDuration(durationSeconds) {
+    return estimateTokenBudgetForDuration(durationSeconds);
+  }
+};
+
+// src/content/application/services/BlogService.ts
+var BlogService = class {
+  constructor(executor) {
+    this.executor = executor;
+  }
+  executor;
+  async generateBlogPost(request) {
+    const topic = validateTopicText(request.topic);
+    const keywords = validateKeywordList(request.targetKeywords);
+    const prompt = PromptBuilder.blogPost({
+      topic,
+      blogType: request.blogType,
+      keywords,
+      tone: request.tone,
+      targetAudience: request.targetAudience,
+      wordCount: request.wordCount,
+      language: request.language,
+      seoOptimization: request.seoOptimization,
+      includeSchema: request.includeSchema,
+      includeImages: request.includeImages
+    });
+    const parsed = await this.executor.runJson(
+      prompt,
+      {},
+      { maxTokens: request.wordCount * 2, temperature: 0.7 }
+    );
+    return {
+      id: generateId("blog"),
+      ...parsed,
+      blogType: request.blogType,
+      tone: request.tone,
+      wordCount: request.wordCount,
+      createdAt: (/* @__PURE__ */ new Date()).toISOString()
+    };
+  }
+};
+async function batchRequest(requests, options = {}) {
+  const {
+    concurrency = 3,
+    stopOnError = false
+  } = options;
+  const results = [];
+  const errors = [];
+  for (let i = 0; i < requests.length; i += concurrency) {
+    const batch = requests.slice(i, i + concurrency);
+    const batchResults = await Promise.allSettled(
+      batch.map((fn) => fn())
+    );
+    for (const result of batchResults) {
+      if (result.status === "fulfilled") {
+        results.push(result.value);
+      } else {
+        errors.push(result.reason);
+        if (stopOnError) {
+          throw new Error(
+            `Batch request failed: ${errors[0].message}`
+          );
+        }
+      }
+    }
+  }
+  if (errors.length > 0 && !stopOnError) {
+    console.warn(`${errors.length} requests failed in batch`);
+  }
+  return results;
+}
+
+// src/content/application/services/SocialService.ts
+var MULTI_PLATFORMS = [
+  "twitter",
+  "linkedin",
+  "instagram",
+  "threads",
+  "tiktok"
+];
+var DEFAULT_SOCIAL_RESULT = {
+  content: "",
+  platform: "twitter",
+  hashtags: [],
+  emojis: [],
+  characterCount: 0,
+  estimatedEngagement: 0
+};
+var SocialService = class {
+  constructor(executor) {
+    this.executor = executor;
+  }
+  executor;
+  async generateSocialContent(request) {
+    const topic = validateTopicText(request.topic);
+    const spec = resolvePlatformSpec(request.platform);
+    const maxLength = resolveMaxContentLength(request.platform, request.maxLength);
+    const prompt = PromptBuilder.socialPost({
+      topic,
+      platform: request.platform,
+      tone: request.tone,
+      style: spec.style,
+      maxLength,
+      includeHashtags: request.hashtags !== false,
+      includeCallToAction: Boolean(request.includeCallToAction)
+    });
+    const parsed = await this.executor.runJson(
+      prompt,
+      { ...DEFAULT_SOCIAL_RESULT, platform: request.platform },
+      { maxTokens: 500, temperature: 0.8 }
+    );
+    return {
+      ...parsed,
+      platform: request.platform,
+      characterCount: parsed.content?.length ?? 0
+    };
+  }
+  async generateForAllPlatforms(topic, tone) {
+    const requests = MULTI_PLATFORMS.map(
+      (platform) => () => this.generateSocialContent({ topic, platform, tone })
+    );
+    try {
+      return await batchRequest(requests, { concurrency: 2, stopOnError: false });
+    } catch (error) {
+      console.warn("Batch execution failed, falling back to sequential:", error);
+      const results = [];
+      for (const platform of MULTI_PLATFORMS) {
+        try {
+          results.push(await this.generateSocialContent({ topic, platform, tone }));
+        } catch (err) {
+          console.error(`Failed to generate for ${platform}:`, err);
+        }
+      }
+      return results;
+    }
+  }
+  async generateHashtags(content, count) {
+    const validated = validateHashtagCount(count);
+    const prompt = PromptBuilder.hashtags(content, validated);
+    const response = await this.executor.runText(prompt, { maxTokens: 200, temperature: 0.7 });
+    const hashtags = response.match(/#[\w-]+/g) || [];
+    return hashtags.slice(0, validated);
+  }
+  optimizeHashtags(hashtags, platform) {
+    const budget = resolveHashtagBudget(platform);
+    return rankAndTrimHashtags(hashtags, budget);
+  }
+};
+
+// src/content/application/services/VideoScriptService.ts
+var buildScriptResult = (parsed, duration) => {
+  const script = parsed.script ?? "";
+  if (!script) {
+    throw new Error("AI response missing script field");
+  }
+  const wordCount = script.trim().length === 0 ? 0 : script.trim().split(/\s+/).length;
+  return {
+    ...parsed,
+    script,
+    duration,
+    wordCount
+  };
+};
+var VideoScriptService = class {
+  constructor(executor) {
+    this.executor = executor;
+  }
+  executor;
+  async generateVideoScript(request) {
+    const topic = validateTopicText(request.topic);
+    const duration = validateDurationSeconds(request.duration);
+    const prompt = PromptBuilder.videoScript({
+      topic,
+      tone: request.tone,
+      duration,
+      targetAudience: request.targetAudience,
+      includeVisuals: request.includeVisuals,
+      includeCallToAction: request.includeCallToAction
+    });
+    const parsed = await this.executor.runJson(
+      prompt,
+      { script: "", visualCues: [], duration, wordCount: 0, estimatedEngagement: 0 },
+      { maxTokens: estimateTokenBudgetForDuration(duration), temperature: 0.8 }
+    );
+    return buildScriptResult(parsed, duration);
+  }
+  async generateVoiceScript(topic, emotion, duration) {
+    const validatedTopic = validateTopicText(topic);
+    const validatedDuration = validateDurationSeconds(duration);
+    const prompt = PromptBuilder.voiceScript({
+      topic: validatedTopic,
+      emotion,
+      duration: validatedDuration
+    });
+    const parsed = await this.executor.runJson(
+      prompt,
+      { script: "", visualCues: [], duration: validatedDuration, wordCount: 0, estimatedEngagement: 0 },
+      { maxTokens: estimateTokenBudgetForDuration(validatedDuration), temperature: 0.8 }
+    );
+    return buildScriptResult(parsed, validatedDuration);
+  }
+};
+
+// src/content/application/services/AnalysisService.ts
+var DEFAULT_SENTIMENT = {
+  sentiment: "neutral",
+  confidence: 0.5,
+  emotions: []
+};
+var DEFAULT_ANALYSIS = {
+  sentiment: DEFAULT_SENTIMENT,
+  keywords: [],
+  entities: [],
+  suggestedImprovements: [],
+  readabilityScore: 50,
+  estimatedEngagement: 50
+};
+var AnalysisService = class {
+  constructor(executor) {
+    this.executor = executor;
+  }
+  executor;
+  async analyzeSentiment(content) {
+    const validated = validateContentBody(content);
+    const prompt = PromptBuilder.sentiment(validated);
+    const result = await this.executor.runJson(
+      prompt,
+      DEFAULT_SENTIMENT,
+      { maxTokens: 200, temperature: 0.3 }
+    );
+    return {
+      ...result,
+      confidence: clampConfidenceToValidRange(result.confidence)
+    };
+  }
+  async analyzeContent(request) {
+    const validated = validateContentBody(request.content);
+    const sentimentResult = await this.analyzeSentiment(validated);
+    const prompt = PromptBuilder.contentAnalysis(validated);
+    const parsed = await this.executor.runJson(
+      prompt,
+      { ...DEFAULT_ANALYSIS, sentiment: sentimentResult },
+      { maxTokens: 300, temperature: 0.5 }
+    );
+    return {
+      sentiment: sentimentResult,
+      keywords: parsed.keywords ?? [],
+      entities: parsed.entities ?? [],
+      suggestedImprovements: parsed.suggestedImprovements ?? [],
+      readabilityScore: clampScoreToValidRange(parsed.readabilityScore),
+      estimatedEngagement: clampScoreToValidRange(parsed.estimatedEngagement)
+    };
+  }
+};
+
+// src/content/application/services/SeoService.ts
+var DEFAULT_SEO_SCORE = {
+  keywordDensity: 50,
+  readabilityScore: 50,
+  titleOptimization: 50,
+  metaDescription: 50,
+  headingStructure: 50,
+  internalLinking: 50,
+  overall: 50
+};
+var UNDERUTILIZED_SUGGESTION = "Consider using this keyword more frequently";
+var SeoService = class {
+  constructor(executor) {
+    this.executor = executor;
+  }
+  executor;
+  async optimizeSEO(request) {
+    const content = validateContentBody(request.content);
+    const keywords = validateKeywordList(request.keywords);
+    const prompt = PromptBuilder.seoOptimization(content, keywords);
+    const result = await this.executor.runJson(
+      prompt,
+      {
+        optimized: content,
+        score: 50,
+        suggestions: [],
+        addedKeywords: [],
+        removedFillerWords: 0,
+        readabilityImprovements: []
+      },
+      { maxTokens: 1e3, temperature: 0.7 }
+    );
+    return {
+      ...result,
+      score: clampScoreToValidRange(result.score)
+    };
+  }
+  async calculateSEOScore(content, keywords) {
+    const validatedContent = validateContentBody(content);
+    const validatedKeywords = validateKeywordList(keywords);
+    const prompt = PromptBuilder.seoOptimization(
+      truncateForSeoPreview(validatedContent),
+      validatedKeywords
+    );
+    const result = await this.executor.runJson(
+      prompt,
+      DEFAULT_SEO_SCORE,
+      { maxTokens: 200, temperature: 0.3 }
+    );
+    return {
+      keywordDensity: clampScoreToValidRange(result.keywordDensity),
+      readabilityScore: clampScoreToValidRange(result.readabilityScore),
+      titleOptimization: clampScoreToValidRange(result.titleOptimization),
+      metaDescription: clampScoreToValidRange(result.metaDescription),
+      headingStructure: clampScoreToValidRange(result.headingStructure),
+      internalLinking: clampScoreToValidRange(result.internalLinking),
+      overall: clampScoreToValidRange(result.overall)
+    };
+  }
+  analyzeKeywords(content, keywords) {
+    const validatedContent = validateContentBody(content);
+    const validatedKeywords = validateKeywordList(keywords);
+    return validatedKeywords.map((keyword) => {
+      const count = countKeywordOccurrences(validatedContent, keyword);
+      const density = calculateKeywordDensity(validatedContent, keyword);
+      return {
+        keyword,
+        count,
+        density,
+        prominence: classifyKeywordProminence(density),
+        suggestions: isUnderutilizedKeyword(density) ? [UNDERUTILIZED_SUGGESTION] : []
+      };
+    });
+  }
+};
+
+// src/content/application/services/ABTestService.ts
+var DEFAULT_PREDICTION = {
+  variantId: "",
+  predictedEngagement: 0,
+  predictedCTR: 0,
+  predictedConversions: 0,
+  confidence: 0,
+  reasoning: "",
+  strengths: [],
+  weaknesses: [],
+  suggestions: []
+};
+var VARIANT_A_ID = "A";
+var VARIANT_B_ID = "B";
+var FALLBACK_ENGAGEMENT = 50;
+var DEFAULT_RECOMMENDATIONS = [
+  "Test with larger audience",
+  "Monitor click-through rates"
+];
+var ABTestService = class {
+  constructor(executor) {
+    this.executor = executor;
+  }
+  executor;
+  async predictABTest(request) {
+    const predictions = [];
+    for (const variant of request.variants) {
+      const prompt = PromptBuilder.abTestVariant({
+        content: truncateForAbVariantPreview(variant.content),
+        contentType: variant.contentType,
+        tone: variant.tone,
+        targetAudience: request.targetAudience,
+        platform: request.platform,
+        goals: request.goals
+      });
+      const parsed = await this.executor.runJson(
+        prompt,
+        { ...DEFAULT_PREDICTION, variantId: variant.id },
+        { maxTokens: 300, temperature: 0.5 }
+      );
+      predictions.push({
+        variantId: variant.id,
+        predictedEngagement: clampScoreToValidRange(parsed.predictedEngagement),
+        predictedCTR: clampScoreToValidRange(parsed.predictedCTR),
+        predictedConversions: clampScoreToValidRange(parsed.predictedConversions),
+        confidence: clampConfidenceToValidRange(parsed.confidence),
+        reasoning: parsed.reasoning ?? "",
+        strengths: parsed.strengths ?? [],
+        weaknesses: parsed.weaknesses ?? [],
+        suggestions: parsed.suggestions ?? []
+      });
+    }
+    return predictions;
+  }
+  async compareVariants(variantA, variantB) {
+    const predictions = await this.predictABTest({
+      variants: [
+        { id: VARIANT_A_ID, content: variantA, contentType: "social", tone: "casual" },
+        { id: VARIANT_B_ID, content: variantB, contentType: "social", tone: "casual" }
+      ],
+      targetAudience: "general",
+      platform: "twitter",
+      goals: ["engagement", "clicks"]
+    });
+    const scoreA = predictions[0]?.predictedEngagement ?? FALLBACK_ENGAGEMENT;
+    const scoreB = predictions[1]?.predictedEngagement ?? FALLBACK_ENGAGEMENT;
+    const isTie = scoreA === scoreB;
+    const winner = selectHigherScoreVariantId(scoreA, scoreB, VARIANT_A_ID, VARIANT_B_ID);
+    const improvement = calculateImprovementPercentage(scoreA, scoreB);
+    return {
+      winner,
+      confidence: AB_TEST_DEFAULT_CONFIDENCE,
+      improvement: isTie ? "0%" : `+${improvement}% engagement`,
+      reasoning: isTie ? "Both variants have equal predicted engagement" : winner === VARIANT_A_ID ? "Variant A has more engaging content" : "Variant B has more engaging content",
+      recommendations: [...DEFAULT_RECOMMENDATIONS]
+    };
+  }
+};
+
+// src/content/application/services/ImagePromptService.ts
+var ImagePromptService = class {
+  constructor(executor) {
+    this.executor = executor;
+  }
+  executor;
+  async generateImagePrompt(description, style) {
+    const validated = validateTopicText(description);
+    const prompt = PromptBuilder.imagePrompt(validated, style);
+    return this.executor.runText(prompt, { maxTokens: 300, temperature: 0.8 });
+  }
+  async generateImagePromptsForBlog(blogContent) {
+    const truncated = truncateForBlogPromptPreview(validateContentBody(blogContent));
+    const prompt = PromptBuilder.blogImagePrompts(truncated);
+    const prompts = await this.executor.runJson(prompt, [], {
+      maxTokens: 500,
+      temperature: 0.8
+    });
+    return Array.isArray(prompts) ? prompts : [];
+  }
+};
+
+// src/content/application/services/ContentCalendarService.ts
+var toCalendarEntry = (item) => ({
+  date: resolveCalendarEntryDate(item.day),
+  topic: item.topic,
+  contentType: item.contentType,
+  platform: item.platform,
+  description: item.description,
+  estimatedEngagement: item.estimatedEngagement,
+  priority: item.priority
+});
+var ContentCalendarService = class {
+  constructor(executor) {
+    this.executor = executor;
+  }
+  executor;
+  async generateContentCalendar(niche, days) {
+    const validatedNiche = validateTopicText(niche);
+    const validatedDays = validateCalendarDays(days);
+    const prompt = PromptBuilder.contentCalendar(validatedNiche, validatedDays);
+    const data = await this.executor.runJson(
+      prompt,
+      [],
+      {
+        maxTokens: estimateTokenBudgetForCalendarDays(validatedDays),
+        temperature: 0.8
+      }
+    );
+    const items = Array.isArray(data) ? data : Array.isArray(data?.calendar) ? data.calendar : Array.isArray(data?.entries) ? data.entries : [];
+    return items.map(toCalendarEntry);
+  }
+};
+
+// src/content/application/services/ProviderServices.ts
+var wrapProviderError = (operation, error) => {
+  const message = error instanceof Error ? error.message : "Unknown error";
+  return new AIError(`${operation} failed: ${message}`, "PROVIDER_ERROR", error);
+};
+var ensureFactory = (factory, operation) => {
+  if (factory.getAllProviders().length === 0) {
+    throw new AIError(
+      `${operation} failed: No providers are registered. Provide a ProviderConfig with at least one enabled provider when constructing AIContentService.`,
+      "PROVIDER_UNAVAILABLE"
+    );
+  }
+};
+var MediaGenerationService = class {
+  constructor(providerFactory) {
+    this.providerFactory = providerFactory;
+  }
+  providerFactory;
+  generateImage(request) {
+    ensureFactory(this.providerFactory, "Image generation");
+    return this.providerFactory.generateImage(request).catch((err) => {
+      throw wrapProviderError("Image generation", err);
+    });
+  }
+  generateVideo(request) {
+    ensureFactory(this.providerFactory, "Video generation");
+    return this.providerFactory.generateVideo(request).catch((err) => {
+      throw wrapProviderError("Video generation", err);
+    });
+  }
+  convertImageToVideo(request) {
+    ensureFactory(this.providerFactory, "Image-to-video conversion");
+    return this.providerFactory.imageToVideo(request).catch((err) => {
+      throw wrapProviderError("Image-to-video conversion", err);
+    });
+  }
+  transformVideo(request) {
+    ensureFactory(this.providerFactory, "Video-to-video transformation");
+    return this.providerFactory.videoToVideo(request).catch((err) => {
+      throw wrapProviderError("Video-to-video transformation", err);
+    });
+  }
+};
+
+// src/content/infrastructure/utils/jsonParser.ts
+function repairCommonJsonDefects2(text) {
+  return text.replace(/(:\s*-?\d+(?:\.\d+)?)\s*"/g, "$1").replace(/(:\s*"[^"]*")"/g, "$1");
+}
+function safeJSONParse(text, fallback, onError) {
+  try {
+    return JSON.parse(text);
+  } catch (error) {
+    try {
+      return JSON.parse(repairCommonJsonDefects2(text));
+    } catch {
+    }
+    if (error instanceof SyntaxError) {
+      const positionMatch = error.message.match(/position (\d+)/);
+      const position = positionMatch ? parseInt(positionMatch[1], 10) : -1;
+      if (position > 0) {
+        text.substring(Math.max(0, position - 50), position + 50);
+      }
+    }
+    return fallback;
+  }
+}
+function extractJSON(text) {
+  const codeBlockMatch = text.match(/```(?:json)?\s*([\s\S]*?)```/);
+  if (codeBlockMatch && codeBlockMatch[1]) {
+    const candidate = codeBlockMatch[1].trim();
+    if (candidate.startsWith("{") || candidate.startsWith("[")) {
+      return candidate;
+    }
+  }
+  const objectMatch = text.match(/\{[\s\S]*\}/);
+  if (objectMatch) {
+    return objectMatch[0];
+  }
+  const arrayMatch = text.match(/\[[\s\S]*\]/);
+  if (arrayMatch) {
+    return arrayMatch[0];
+  }
+  return null;
+}
+function parseAIResponse(response, fallback, onError) {
+  const json = extractJSON(response);
+  if (!json) {
+    return fallback;
+  }
+  return safeJSONParse(json, fallback);
+}
+
+// src/content/application/services/GenerationExecutor.ts
+var GenerationExecutor = class {
+  constructor(generator) {
+    this.generator = generator;
+  }
+  generator;
+  async runJson(prompt, fallback, generationOptions = {}) {
+    const response = await this.generator.generateText(prompt, generationOptions);
+    return parseAIResponse(response, fallback);
+  }
+  runText(prompt, options = {}) {
+    return this.generator.generateText(prompt, options);
+  }
+  /** Usage-complete pass-through; requires a ProviderFactory engine. */
+  runChat(request) {
+    if (!(this.generator instanceof ProviderFactory)) {
+      throw new AIError(
+        "runChat requires a ProviderFactory engine \u2014 construct AIContentService with a provider config, not a custom ITextGenerator",
+        "PROVIDER_UNAVAILABLE"
+      );
+    }
+    return this.generator.chat(request);
+  }
+};
+
+// src/content/application/services/AIContentService.ts
+var isTextGenerator = (value) => typeof value === "object" && value !== null && typeof value.generateText === "function";
+function toAIProviderConfig(config) {
+  const legacy = config;
+  const modern = config;
+  const anthropic = modern.anthropic ?? (legacy.anthropic?.enabled ? {
+    apiKey: legacy.anthropic.apiKey,
+    baseUrl: legacy.anthropic.baseUrl,
+    timeoutMs: legacy.anthropic.timeout,
+    models: legacy.anthropic.models,
+    effort: legacy.anthropic.effort
+  } : void 0);
+  const groq = modern.groq ?? (legacy.groq?.enabled ? {
+    apiKey: legacy.groq.apiKey,
+    baseUrl: legacy.groq.baseUrl,
+    timeoutMs: legacy.groq.timeout,
+    // legacy {text, chat} model pins map onto the neutral tier slots
+    ...legacy.groq.models?.text ? { models: { balanced: legacy.groq.models.text } } : {}
+  } : void 0);
+  const gemini = modern.gemini ?? (legacy.gemini?.enabled ? { ...legacy.gemini } : void 0);
+  const fal = modern.fal ?? (legacy.fal?.enabled ? { ...legacy.fal } : void 0);
+  const pruna = modern.pruna ?? (legacy.pruna?.enabled ? { ...legacy.pruna } : void 0);
+  return {
+    priority: modern.priority,
+    fallbackEnabled: modern.fallbackEnabled,
+    defaultTier: modern.defaultTier,
+    ...anthropic ? { anthropic } : {},
+    ...groq ? { groq } : {},
+    ...gemini ? { gemini } : {},
+    ...fal ? { fal } : {},
+    ...pruna ? { pruna } : {}
+  };
+}
+var buildServices = (configOrGenerator) => {
+  if (isTextGenerator(configOrGenerator)) {
+    const executor2 = new GenerationExecutor(configOrGenerator);
+    const emptyFactory = new ProviderFactory({
+      priority: [],
+      fallbackEnabled: false
+    });
+    return {
+      providerFactory: emptyFactory,
+      blogService: new BlogService(executor2),
+      socialService: new SocialService(executor2),
+      videoScriptService: new VideoScriptService(executor2),
+      analysisService: new AnalysisService(executor2),
+      seoService: new SeoService(executor2),
+      abTestService: new ABTestService(executor2),
+      imagePromptService: new ImagePromptService(executor2),
+      contentCalendarService: new ContentCalendarService(executor2),
+      mediaGenerationService: new MediaGenerationService(emptyFactory)
+    };
+  }
+  const factory = createAI(toAIProviderConfig(configOrGenerator));
+  const executor = new GenerationExecutor(factory);
+  return {
+    providerFactory: factory,
+    blogService: new BlogService(executor),
+    socialService: new SocialService(executor),
+    videoScriptService: new VideoScriptService(executor),
+    analysisService: new AnalysisService(executor),
+    seoService: new SeoService(executor),
+    abTestService: new ABTestService(executor),
+    imagePromptService: new ImagePromptService(executor),
+    contentCalendarService: new ContentCalendarService(executor),
+    mediaGenerationService: new MediaGenerationService(factory)
+  };
+};
+var AIContentService = class {
+  providerFactory;
+  blogService;
+  socialService;
+  videoScriptService;
+  analysisService;
+  seoService;
+  abTestService;
+  imagePromptService;
+  contentCalendarService;
+  mediaGenerationService;
+  constructor(configOrGenerator) {
+    const bundle = buildServices(configOrGenerator);
+    this.providerFactory = bundle.providerFactory;
+    this.blogService = bundle.blogService;
+    this.socialService = bundle.socialService;
+    this.videoScriptService = bundle.videoScriptService;
+    this.analysisService = bundle.analysisService;
+    this.seoService = bundle.seoService;
+    this.abTestService = bundle.abTestService;
+    this.imagePromptService = bundle.imagePromptService;
+    this.contentCalendarService = bundle.contentCalendarService;
+    this.mediaGenerationService = bundle.mediaGenerationService;
+  }
+  /** The composed factory — chat()/chatStream() with usage, health, fallback. */
+  get providers() {
+    return this.providerFactory;
+  }
+  generateBlogPost(request) {
+    return this.blogService.generateBlogPost(request);
+  }
+  generateSocialContent(request) {
+    return this.socialService.generateSocialContent(request);
+  }
+  generateForAllPlatforms(topic, tone) {
+    return this.socialService.generateForAllPlatforms(topic, tone);
+  }
+  generateHashtags(content, count) {
+    return this.socialService.generateHashtags(content, count);
+  }
+  optimizeHashtags(hashtags, platform) {
+    return Promise.resolve(this.socialService.optimizeHashtags(hashtags, platform));
+  }
+  generateVideoScript(request) {
+    return this.videoScriptService.generateVideoScript(request);
+  }
+  generateVoiceScript(topic, emotion, duration) {
+    return this.videoScriptService.generateVoiceScript(topic, emotion, duration);
+  }
+  generateContentCalendar(niche, days) {
+    return this.contentCalendarService.generateContentCalendar(niche, days);
+  }
+  analyzeSentiment(content) {
+    return this.analysisService.analyzeSentiment(content);
+  }
+  analyzeContent(request) {
+    return this.analysisService.analyzeContent(request);
+  }
+  optimizeSEO(request) {
+    return this.seoService.optimizeSEO(request);
+  }
+  calculateSEOScore(content, keywords) {
+    return this.seoService.calculateSEOScore(content, keywords);
+  }
+  analyzeKeywords(content, keywords) {
+    return Promise.resolve(this.seoService.analyzeKeywords(content, keywords));
+  }
+  predictABTest(request) {
+    return this.abTestService.predictABTest(request);
+  }
+  compareVariants(variantA, variantB) {
+    return this.abTestService.compareVariants(variantA, variantB);
+  }
+  generateImagePrompt(description, style) {
+    return this.imagePromptService.generateImagePrompt(description, style);
+  }
+  generateImagePromptsForBlog(blogContent) {
+    return this.imagePromptService.generateImagePromptsForBlog(blogContent);
+  }
+  generateImage(request) {
+    return this.mediaGenerationService.generateImage(request);
+  }
+  generateVideo(request) {
+    return this.mediaGenerationService.generateVideo(request);
+  }
+  convertImageToVideo(request) {
+    return this.mediaGenerationService.convertImageToVideo(request);
+  }
+  transformVideo(request) {
+    return this.mediaGenerationService.transformVideo(request);
+  }
+};
+
+// 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}`);
+  }
+}
+
+exports.ABTestService = ABTestService;
+exports.AIContentService = AIContentService;
 exports.AIError = AIError;
 exports.AIErrorType = AIErrorType;
 exports.ANTHROPIC_API_VERSION = ANTHROPIC_API_VERSION;
@@ -4364,16 +6041,23 @@ exports.ANTHROPIC_DEFAULT_MAX_TOKENS = ANTHROPIC_DEFAULT_MAX_TOKENS;
 exports.ANTHROPIC_MODELS = ANTHROPIC_MODELS;
 exports.ANTHROPIC_TIERS = ANTHROPIC_TIERS;
 exports.API_ENDPOINTS = API_ENDPOINTS;
+exports.ASPECT_RATIO_OPTIONS = ASPECT_RATIO_OPTIONS;
+exports.ASPECT_RATIO_VALUES = ASPECT_RATIO_VALUES;
+exports.AnalysisService = AnalysisService;
 exports.AnthropicHttpTransport = AnthropicHttpTransport;
 exports.AnthropicProvider = AnthropicProvider;
 exports.AnthropicRequestBuilder = AnthropicRequestBuilder;
 exports.AuthenticationError = AuthenticationError;
+exports.BaseAIProvider = BaseProvider;
 exports.BaseProvider = BaseProvider;
+exports.BlogService = BlogService;
+exports.CONTENT_WIZARD_STEPS = CONTENT_WIZARD_STEPS;
 exports.CacheManager = CacheManager;
 exports.CancellationError = CancellationError;
 exports.ChatIdGenerator = ChatIdGenerator;
 exports.ChatService = ChatService;
 exports.CompositeExecutor = CompositeExecutor;
+exports.ContentCalendarService = ContentCalendarService;
 exports.DEFAULT_API_KEY_RULE = DEFAULT_API_KEY_RULE;
 exports.DEFAULT_BASE_URL = DEFAULT_BASE_URL;
 exports.DEFAULT_ERROR_CLASSIFICATION_RULE = DEFAULT_ERROR_CLASSIFICATION_RULE;
@@ -4390,9 +6074,11 @@ exports.DebounceManager = DebounceManager;
 exports.DedupeExecutor = DedupeExecutor;
 exports.FalProvider = FalProvider;
 exports.GEMINI_TIERS = GEMINI_TIERS;
+exports.GENERATION_COSTS = CREDIT_COSTS;
 exports.GROQ_MODELS = GROQ_MODELS;
 exports.GROQ_TIERS = GROQ_TIERS;
 exports.GeminiProvider = GeminiProvider;
+exports.GenerationExecutor = GenerationExecutor;
 exports.GenerationFailedError = GenerationFailedError;
 exports.GroqChatRequestBuilder = GroqChatRequestBuilder;
 exports.GroqConfigStore = GroqConfigStore;
@@ -4401,11 +6087,20 @@ exports.GroqErrorType = AIErrorType;
 exports.GroqHttpClient = GroqHttpClient;
 exports.GroqHttpTransport = GroqHttpTransport;
 exports.GroqProvider = GroqProvider;
+exports.IMAGE_QUALITY_OPTIONS = IMAGE_QUALITY_OPTIONS;
+exports.IMAGE_QUALITY_VALUES = IMAGE_QUALITY_VALUES;
+exports.IMAGE_WIZARD_STEPS = IMAGE_WIZARD_STEPS;
+exports.ImagePromptService = ImagePromptService;
 exports.JSON_CODE_BLOCK_PATTERN = JSON_CODE_BLOCK_PATTERN;
 exports.JSON_OBJECT_PATTERN = JSON_OBJECT_PATTERN;
 exports.JsonResponseParser = JsonResponseParser;
+exports.MOTION_OPTIONS = MOTION_OPTIONS;
+exports.MediaGenerationService = MediaGenerationService;
+exports.PromptBuilder = PromptBuilder;
 exports.ProviderError = ProviderError;
 exports.ProviderFactory = ProviderFactory;
+exports.ProviderQuotaExhaustedError = ProviderQuotaExhaustedError;
+exports.ProviderUnavailableError = ProviderUnavailableError;
 exports.PrunaProvider = PrunaProvider;
 exports.QueueExecutor = QueueExecutor;
 exports.RequestDeduplicator = RequestDeduplicator;
@@ -4415,6 +6110,9 @@ exports.RetryManager = RetryManager;
 exports.SSE_BRIDGE_EVENTS = SSE_BRIDGE_EVENTS;
 exports.SSE_DONE_MARKER = SSE_DONE_MARKER;
 exports.SSE_PREFIX = SSE_PREFIX;
+exports.STYLE_PRESETS = STYLE_PRESETS;
+exports.SeoService = SeoService;
+exports.SocialService = SocialService;
 exports.StreamingResponseParser = StreamingResponseParser;
 exports.StructuredPromptBuilder = StructuredPromptBuilder;
 exports.TEXT_TIERS = TEXT_TIERS;
@@ -4423,14 +6121,24 @@ exports.TextGenerationService = TextGenerationService;
 exports.ThrottleManager = ThrottleManager;
 exports.TimeoutError = TimeoutError;
 exports.USER_FRIENDLY_ERROR_MESSAGES = USER_FRIENDLY_ERROR_MESSAGES;
-exports.ValidationError = ValidationError;
+exports.VIDEO_DURATION_OPTIONS = VIDEO_DURATION_OPTIONS;
+exports.VIDEO_DURATION_OPTIONS_SECONDS = VIDEO_DURATION_OPTIONS_SECONDS;
+exports.VIDEO_QUALITY_OPTIONS = VIDEO_QUALITY_OPTIONS;
+exports.VIDEO_QUALITY_VALUES = VIDEO_QUALITY_VALUES;
+exports.VIDEO_WIZARD_STEPS = VIDEO_WIZARD_STEPS;
+exports.ValidationError = ValidationError2;
+exports.VideoScriptService = VideoScriptService;
 exports.asObjectArray = asObjectArray;
 exports.asRecord = asRecord;
 exports.asStringArray = asStringArray;
 exports.asTrimmedOptionalString = asTrimmedOptionalString;
 exports.buildCacheKey = buildCacheKey;
+exports.buildContentRequest = buildContentRequest;
 exports.buildHttpStatusFallback = buildHttpStatusFallback;
+exports.buildImageRequest = buildImageRequest;
+exports.buildVideoRequest = buildVideoRequest;
 exports.cacheManager = cacheManager;
+exports.calculateCreditCost = calculateContentCreditCost;
 exports.chatIdGenerator = chatIdGenerator;
 exports.clampScore = clampScore;
 exports.classifyHttpStatus = classifyHttpStatus;
@@ -4441,7 +6149,9 @@ exports.createAI = createAI;
 exports.createAssistantMessage = createAssistantMessage;
 exports.createFalProvider = createFalProvider;
 exports.createGeminiProvider = createGeminiProvider;
+exports.createGroqProvider = createGroqProvider;
 exports.createMessage = createMessage;
+exports.createProviderFactory = createProviderFactory;
 exports.createPrunaProvider = createPrunaProvider;
 exports.createSseResponse = createSseResponse;
 exports.createSystemMessage = createSystemMessage;
@@ -4465,7 +6175,9 @@ exports.formatMessagesForDisplay = formatMessagesForDisplay;
 exports.generateImageThenVideo = generateImageThenVideo;
 exports.generatePruna = generate;
 exports.generateWithPruna = generateWithPruna;
+exports.getDimensionsForAspectRatio = getDimensionsForAspectRatio;
 exports.getProvider = getProvider;
+exports.getRecommendedQuality = getRecommendedQuality;
 exports.isAuthErrorType = isAuthErrorType;
 exports.isMediaProvider = isMediaProvider;
 exports.isRetryableErrorType = isRetryableErrorType;