@umituz/web-ai 1.0.3 → 1.0.4

package/dist/index.js

@@ -1082,6 +1082,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,
@@ -1424,6 +1444,9 @@ var ProviderFactory = class {
     );
   }
 };
+function createProviderFactory(config) {
+  return new ProviderFactory(config);
+}
 
 // src/providers/anthropic/anthropic.constants.ts
 var ANTHROPIC_MODELS = {
@@ -2453,6 +2476,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;
@@ -2719,6 +2745,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",
@@ -2989,7 +3137,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;
@@ -3274,21 +3422,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
@@ -3305,7 +3453,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
@@ -3313,14 +3461,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
@@ -3344,7 +3492,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
@@ -3360,7 +3508,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
@@ -3377,7 +3525,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
@@ -3390,21 +3538,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
@@ -3421,7 +3569,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
@@ -4355,6 +4503,1533 @@ function resetProvider() {
   container = null;
 }
 
-export { AIError, AIErrorType, ANTHROPIC_API_VERSION, ANTHROPIC_DEFAULT_MAX_TOKENS, ANTHROPIC_MODELS, ANTHROPIC_TIERS, API_ENDPOINTS, AnthropicHttpTransport, AnthropicProvider, AnthropicRequestBuilder, AuthenticationError, BaseProvider, CacheManager, CancellationError, ChatIdGenerator, ChatService, CompositeExecutor, DEFAULT_API_KEY_RULE, DEFAULT_BASE_URL, DEFAULT_ERROR_CLASSIFICATION_RULE, DEFAULT_GENERATION_CONFIG, DEFAULT_HTTP_STATUS_RULE, DEFAULT_MODELS, DEFAULT_PROMPT_STRATEGY, DEFAULT_RETRY_BACKOFF_MULTIPLIER, DEFAULT_RETRY_INITIAL_DELAY_MS, DEFAULT_RETRY_JITTER_FACTOR, DEFAULT_RETRY_MAX_ATTEMPTS, DEFAULT_RETRY_MAX_DELAY_MS, DebounceManager, DedupeExecutor, FalProvider, GEMINI_TIERS, GROQ_MODELS, GROQ_TIERS, GeminiProvider, GenerationFailedError, GroqChatRequestBuilder, GroqConfigStore, GroqError, AIErrorType as GroqErrorType, GroqHttpClient, GroqHttpTransport, GroqProvider, JSON_CODE_BLOCK_PATTERN, JSON_OBJECT_PATTERN, JsonResponseParser, ProviderError, ProviderFactory, PrunaProvider, QueueExecutor, RequestDeduplicator, RequestQueue, RetryExecutor, RetryManager, SSE_BRIDGE_EVENTS, SSE_DONE_MARKER, SSE_PREFIX, StreamingResponseParser, StructuredPromptBuilder, TEXT_TIERS, TIMEOUTS, TextGenerationService, ThrottleManager, TimeoutError, USER_FRIENDLY_ERROR_MESSAGES, ValidationError, asObjectArray, asRecord, asStringArray, asTrimmedOptionalString, buildCacheKey, buildHttpStatusFallback, cacheManager, chatIdGenerator, clampScore, classifyHttpStatus, configureProvider, consumeAnthropicStream, consumeGroqStream, createAI, createAssistantMessage, createFalProvider, createGeminiProvider, createMessage, createPrunaProvider, createSseResponse, createSystemMessage, createUserMessage, debounce, debounceManager, defaultEffortForModel, describeAIErrorType, extractContentFromSsePayload, extractErrorMessageFromJsonBody, extractErrorMessageFromResponse, extractJsonArray, extractJsonCandidate, extractJsonFromCodeFence, extractJsonObject, extractSseDataPayload, extractTextFromMessages, extractTokenUsage, formatErrorForLogging, formatMessagesForDisplay, generateImageThenVideo, generate as generatePruna, generateWithPruna, getProvider, isAuthErrorType, isMediaProvider, isRetryableErrorType, isSseDataLine, isSseDoneMarker, isTextProvider, isTextTier, isValidApiKey, mapAnthropicStopReason, mergeTierOverrides, messageFormatter, normalizeSseChunk, oneOfCatalog, pollForResult, promptToMessages, repairCommonJsonDefects, requestDeduplicator, requestQueue, requestStructuredJson, resetProvider, resolveModel, resolveUserFriendlyErrorMessage, resolveUserFriendlyMessage, retryManager, splitSseLines, submitPrediction, throttle, throttleManager, toGroqMessages, uploadImage, validateApiKey, withRetry };
+// 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}`);
+  }
+}
+
+export { ABTestService, AIContentService, AIError, AIErrorType, ANTHROPIC_API_VERSION, ANTHROPIC_DEFAULT_MAX_TOKENS, ANTHROPIC_MODELS, ANTHROPIC_TIERS, API_ENDPOINTS, ASPECT_RATIO_OPTIONS, ASPECT_RATIO_VALUES, AnalysisService, AnthropicHttpTransport, AnthropicProvider, AnthropicRequestBuilder, AuthenticationError, BaseProvider as BaseAIProvider, BaseProvider, BlogService, CONTENT_WIZARD_STEPS, CacheManager, CancellationError, ChatIdGenerator, ChatService, CompositeExecutor, ContentCalendarService, DEFAULT_API_KEY_RULE, DEFAULT_BASE_URL, DEFAULT_ERROR_CLASSIFICATION_RULE, DEFAULT_GENERATION_CONFIG, DEFAULT_HTTP_STATUS_RULE, DEFAULT_MODELS, DEFAULT_PROMPT_STRATEGY, DEFAULT_RETRY_BACKOFF_MULTIPLIER, DEFAULT_RETRY_INITIAL_DELAY_MS, DEFAULT_RETRY_JITTER_FACTOR, DEFAULT_RETRY_MAX_ATTEMPTS, DEFAULT_RETRY_MAX_DELAY_MS, DebounceManager, DedupeExecutor, FalProvider, GEMINI_TIERS, CREDIT_COSTS as GENERATION_COSTS, GROQ_MODELS, GROQ_TIERS, GeminiProvider, GenerationExecutor, GenerationFailedError, GroqChatRequestBuilder, GroqConfigStore, GroqError, AIErrorType as GroqErrorType, GroqHttpClient, GroqHttpTransport, GroqProvider, IMAGE_QUALITY_OPTIONS, IMAGE_QUALITY_VALUES, IMAGE_WIZARD_STEPS, ImagePromptService, JSON_CODE_BLOCK_PATTERN, JSON_OBJECT_PATTERN, JsonResponseParser, MOTION_OPTIONS, MediaGenerationService, PromptBuilder, ProviderError, ProviderFactory, ProviderQuotaExhaustedError, ProviderUnavailableError, PrunaProvider, QueueExecutor, RequestDeduplicator, RequestQueue, RetryExecutor, RetryManager, SSE_BRIDGE_EVENTS, SSE_DONE_MARKER, SSE_PREFIX, STYLE_PRESETS, SeoService, SocialService, StreamingResponseParser, StructuredPromptBuilder, TEXT_TIERS, TIMEOUTS, TextGenerationService, ThrottleManager, TimeoutError, USER_FRIENDLY_ERROR_MESSAGES, VIDEO_DURATION_OPTIONS, VIDEO_DURATION_OPTIONS_SECONDS, VIDEO_QUALITY_OPTIONS, VIDEO_QUALITY_VALUES, VIDEO_WIZARD_STEPS, ValidationError2 as ValidationError, VideoScriptService, asObjectArray, asRecord, asStringArray, asTrimmedOptionalString, buildCacheKey, buildContentRequest, buildHttpStatusFallback, buildImageRequest, buildVideoRequest, cacheManager, calculateContentCreditCost as calculateCreditCost, chatIdGenerator, clampScore, classifyHttpStatus, configureProvider, consumeAnthropicStream, consumeGroqStream, createAI, createAssistantMessage, createFalProvider, createGeminiProvider, createGroqProvider, createMessage, createProviderFactory, createPrunaProvider, createSseResponse, createSystemMessage, createUserMessage, debounce, debounceManager, defaultEffortForModel, describeAIErrorType, extractContentFromSsePayload, extractErrorMessageFromJsonBody, extractErrorMessageFromResponse, extractJsonArray, extractJsonCandidate, extractJsonFromCodeFence, extractJsonObject, extractSseDataPayload, extractTextFromMessages, extractTokenUsage, formatErrorForLogging, formatMessagesForDisplay, generateImageThenVideo, generate as generatePruna, generateWithPruna, getDimensionsForAspectRatio, getProvider, getRecommendedQuality, isAuthErrorType, isMediaProvider, isRetryableErrorType, isSseDataLine, isSseDoneMarker, isTextProvider, isTextTier, isValidApiKey, mapAnthropicStopReason, mergeTierOverrides, messageFormatter, normalizeSseChunk, oneOfCatalog, pollForResult, promptToMessages, repairCommonJsonDefects, requestDeduplicator, requestQueue, requestStructuredJson, resetProvider, resolveModel, resolveUserFriendlyErrorMessage, resolveUserFriendlyMessage, retryManager, splitSseLines, submitPrediction, throttle, throttleManager, toGroqMessages, uploadImage, validateApiKey, withRetry };
 //# sourceMappingURL=index.js.map
 //# sourceMappingURL=index.js.map