@umituz/web-ai 0.0.0-stage → 1.0.0

package/dist/content/index.cjs

@@ -0,0 +1,3769 @@
+'use strict';
+
+// 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/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/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/errors/AIErrors.ts
+var AIError = class _AIError extends Error {
+  code;
+  cause;
+  constructor(message, code, cause) {
+    super(message);
+    this.name = "AIError";
+    this.code = code;
+    this.cause = cause;
+  }
+  static from(error, fallbackCode = "UNKNOWN") {
+    if (error instanceof _AIError) return error;
+    if (error instanceof Error) {
+      return new _AIError(error.message, mapMessageToCode(error.message, fallbackCode), error);
+    }
+    return new _AIError(String(error), fallbackCode, error);
+  }
+};
+function mapMessageToCode(message, fallback) {
+  const lower = message.toLowerCase();
+  if (lower.includes("validation")) return "VALIDATION_ERROR";
+  if (lower.includes("quota")) return "PROVIDER_QUOTA_EXHAUSTED";
+  if (lower.includes("unavailable")) return "PROVIDER_UNAVAILABLE";
+  if (lower.includes("timeout") || lower.includes("aborted")) {
+    return lower.includes("aborted") ? "ABORTED" : "TIMEOUT";
+  }
+  if (lower.includes("parse") || lower.includes("json")) return "PARSE_ERROR";
+  if (lower.includes("no result")) return "NO_RESULT";
+  if (lower.includes("network") || lower.includes("fetch")) return "NETWORK_ERROR";
+  return fallback;
+}
+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/core/errors/ai-error.ts
+var AIError2 = class extends Error {
+  type;
+  cause;
+  metadata;
+  constructor(type, message, cause, metadata = {}) {
+    super(message);
+    this.name = "AIError";
+    this.type = type;
+    this.cause = cause;
+    this.metadata = metadata;
+  }
+  toString() {
+    const statusPart = typeof this.metadata.status === "number" ? ` (HTTP ${this.metadata.status})` : "";
+    return `${this.name} [${this.type}]: ${this.message}${statusPart}`;
+  }
+  toJSON() {
+    return {
+      name: this.name,
+      type: this.type,
+      message: this.message,
+      metadata: this.metadata
+    };
+  }
+};
+
+// src/core/errors/error-classifier.ts
+var DEFAULT_RETRYABLE_TYPES = /* @__PURE__ */ new Set([
+  "NETWORK_ERROR" /* NETWORK_ERROR */,
+  "RATE_LIMIT_ERROR" /* RATE_LIMIT_ERROR */,
+  "SERVER_ERROR" /* SERVER_ERROR */
+]);
+var DEFAULT_AUTH_TYPES = /* @__PURE__ */ new Set([
+  "INVALID_API_KEY" /* INVALID_API_KEY */
+]);
+var DEFAULT_ERROR_CLASSIFICATION_RULE = {
+  retryable: DEFAULT_RETRYABLE_TYPES,
+  auth: DEFAULT_AUTH_TYPES
+};
+function isRetryableErrorType(type, rule = DEFAULT_ERROR_CLASSIFICATION_RULE) {
+  return rule.retryable.has(type);
+}
+
+// src/core/errors/http-status-classifier.ts
+var DEFAULT_HTTP_STATUS_RULE = {
+  unauthorizedStatuses: /* @__PURE__ */ new Set([401, 403]),
+  rateLimitedStatus: 429,
+  serverErrorThreshold: 500,
+  clientErrorThreshold: 400
+};
+function classifyHttpStatus(status, rule = DEFAULT_HTTP_STATUS_RULE) {
+  if (rule.unauthorizedStatuses.has(status)) return "INVALID_API_KEY" /* INVALID_API_KEY */;
+  if (status === rule.rateLimitedStatus) return "RATE_LIMIT_ERROR" /* RATE_LIMIT_ERROR */;
+  if (status >= rule.serverErrorThreshold) return "SERVER_ERROR" /* SERVER_ERROR */;
+  if (status >= rule.clientErrorThreshold) return "CLIENT_ERROR" /* CLIENT_ERROR */;
+  return "UNKNOWN_ERROR" /* UNKNOWN_ERROR */;
+}
+
+// src/core/errors/response-error-message-extractor.ts
+function extractErrorMessageFromJsonBody(body) {
+  if (!body || typeof body !== "object") return null;
+  const candidate = body;
+  const message = candidate.error?.message ?? candidate.message;
+  if (typeof message === "string" && message.length > 0) return message;
+  return null;
+}
+function buildHttpStatusFallback(status, statusText) {
+  const trimmedStatusText = statusText.trim();
+  if (trimmedStatusText.length > 0) {
+    return `HTTP ${status}: ${trimmedStatusText}`;
+  }
+  return `HTTP ${status}`;
+}
+async function extractErrorMessageFromResponse(response) {
+  const body = await response.json().catch(() => null);
+  const fromBody = extractErrorMessageFromJsonBody(body);
+  if (fromBody) return fromBody;
+  return buildHttpStatusFallback(response.status, response.statusText);
+}
+
+// src/providers/base/provider.types.ts
+function isTextProvider(provider) {
+  return provider.capabilities.includes("text");
+}
+
+// src/content/domain/limits/ProviderTimingConfig.ts
+var ProviderTimingConfig = {
+  DEFAULT_TIMEOUT_MS: 3e4,
+  DEFAULT_RETRY_ATTEMPTS: 3,
+  FAL_TIMEOUT_MS: 12e4,
+  FAL_RETRY_ATTEMPTS: 2,
+  GEMINI_TIMEOUT_MS: 6e4,
+  GEMINI_RETRY_ATTEMPTS: 3,
+  HEALTH_CHECK_TTL_MS: 5 * 60 * 1e3,
+  RETRY_BACKOFF_BASE_MS: 1e3
+};
+
+// src/providers/factory/provider.factory.ts
+var ProviderFactory = class {
+  providers = /* @__PURE__ */ new Map();
+  healthCache = /* @__PURE__ */ new Map();
+  priority;
+  fallbackEnabled;
+  defaultTier;
+  constructor(config = {}) {
+    this.priority = config.priority ?? [];
+    this.fallbackEnabled = config.fallbackEnabled ?? true;
+    this.defaultTier = config.defaultTier ?? "balanced";
+  }
+  register(provider) {
+    this.providers.set(provider.id, provider);
+  }
+  getProvider(id) {
+    return this.providers.get(id);
+  }
+  getAllProviders() {
+    return Array.from(this.providers.values());
+  }
+  getByCapability(capability) {
+    return this.getAllProviders().filter(
+      (provider) => provider.capabilities.includes(capability)
+    );
+  }
+  getTextProviders() {
+    return this.getAllProviders().filter(isTextProvider);
+  }
+  hasTextProvider() {
+    return this.getByCapability("text").length > 0;
+  }
+  /* ---------- neutral text surface ---------- */
+  /**
+   * Single-chat entry point: resolves a healthy text provider by priority,
+   * injects the default tier when the request names neither model nor tier,
+   * and walks the fallback chain on failure. Providers map tiers onto their
+   * own models, so switching Groq→Anthropic is a config change.
+   */
+  async chat(request) {
+    const effective = request.model || request.tier ? request : { ...request, tier: this.defaultTier };
+    return this.executeWithFallback(
+      "text",
+      (provider) => provider.generate(effective)
+    );
+  }
+  async chatStream(request, callbacks) {
+    const effective = request.model || request.tier ? request : { ...request, tier: this.defaultTier };
+    let lastError;
+    const attemptCallbacks = {
+      onChunk: callbacks.onChunk,
+      onComplete: callbacks.onComplete
+    };
+    const providers = this.getByCapability("text");
+    if (providers.length === 0) {
+      throw this.noProviderError("text");
+    }
+    const ordered = this.orderByPriority(providers);
+    for (const provider of ordered) {
+      if (!this.isProviderHealthy(provider.id)) continue;
+      try {
+        return await provider.stream(effective, attemptCallbacks);
+      } catch (error) {
+        lastError = error;
+        this.markDegraded(provider.id);
+        if (!this.fallbackEnabled) {
+          callbacks.onError?.(error instanceof Error ? error : new Error(String(error)));
+          throw error;
+        }
+      }
+    }
+    const failure = new AIError2(
+      "SERVER_ERROR" /* SERVER_ERROR */,
+      `All providers failed for capability 'text'`,
+      lastError instanceof Error ? lastError : void 0
+    );
+    callbacks.onError?.(lastError instanceof Error ? lastError : failure);
+    throw failure;
+  }
+  /** AsyncGenerator adapter over chatStream — A's familiar consumption shape. */
+  async *streamText(request) {
+    const queue = [];
+    let wake = null;
+    let finished = false;
+    let failure;
+    const notify = () => {
+      const resolve = wake;
+      wake = null;
+      resolve?.();
+    };
+    const completion = this.chatStream(request, {
+      onChunk: (chunk) => {
+        queue.push(chunk);
+        notify();
+      }
+    }).then(
+      () => {
+        finished = true;
+        notify();
+      },
+      (error) => {
+        failure = error;
+        finished = true;
+        notify();
+      }
+    );
+    while (!finished || queue.length > 0) {
+      if (queue.length === 0 && !finished) {
+        await new Promise((resolve) => {
+          wake = resolve;
+        });
+      }
+      while (queue.length > 0) {
+        yield queue.shift();
+      }
+      if (failure) throw failure;
+    }
+    await completion;
+  }
+  async generateJson(request) {
+    const effective = request.model || request.tier ? request : { ...request, tier: this.defaultTier };
+    return this.executeWithFallback(
+      "text",
+      (provider) => provider.generateStructured(effective)
+    );
+  }
+  /* ---------- content-layer string facade (ITextGenerator) ---------- */
+  async generateText(prompt, options = {}) {
+    const result = await this.chat({
+      messages: [{ role: "user", content: prompt }],
+      model: options.model,
+      maxTokens: options.maxTokens,
+      temperature: options.temperature,
+      topP: options.topP
+    });
+    return result.text;
+  }
+  generateTextStream(prompt, options = {}) {
+    return this.streamText({
+      messages: [{ role: "user", content: prompt }],
+      model: options.model,
+      maxTokens: options.maxTokens,
+      temperature: options.temperature,
+      topP: options.topP
+    });
+  }
+  /* ---------- media surface ---------- */
+  async generateImage(request) {
+    return this.executeWithFallback(
+      "image",
+      (provider) => provider.generateImage(request)
+    );
+  }
+  async generateVideo(request) {
+    return this.executeWithFallback(
+      "video",
+      (provider) => provider.generateVideo(request)
+    );
+  }
+  async imageToVideo(request) {
+    return this.executeWithFallback(
+      "video",
+      (provider) => provider.imageToVideo(request)
+    );
+  }
+  async videoToVideo(request) {
+    return this.executeWithFallback(
+      "video",
+      (provider) => provider.videoToVideo(request)
+    );
+  }
+  /* ---------- health ---------- */
+  async checkProviderHealth(providerId, forceRefresh = false) {
+    const provider = this.providers.get(providerId);
+    if (!provider) {
+      return "unavailable";
+    }
+    const cached = this.healthCache.get(providerId);
+    const now = Date.now();
+    const ttl = ProviderTimingConfig.HEALTH_CHECK_TTL_MS;
+    if (!forceRefresh && cached && now - cached.timestamp < ttl) {
+      return cached.health;
+    }
+    try {
+      const health = await provider.healthCheck();
+      this.healthCache.set(providerId, { health, timestamp: now });
+      return health;
+    } catch {
+      this.healthCache.set(providerId, { health: "unavailable", timestamp: now });
+      return "unavailable";
+    }
+  }
+  isProviderHealthy(providerId) {
+    const cached = this.healthCache.get(providerId);
+    if (!cached) {
+      return true;
+    }
+    return cached.health === "healthy" || cached.health === "degraded";
+  }
+  async refreshAllHealth() {
+    await Promise.all(
+      Array.from(this.providers.keys()).map((id) => this.checkProviderHealth(id))
+    );
+  }
+  /* ---------- internals ---------- */
+  async executeWithFallback(capability, fn) {
+    const providers = this.getByCapability(capability);
+    if (providers.length === 0) {
+      throw this.noProviderError(capability);
+    }
+    let lastError;
+    for (const provider of this.orderByPriority(providers)) {
+      if (!this.isProviderHealthy(provider.id)) {
+        continue;
+      }
+      try {
+        return await fn(provider);
+      } catch (error) {
+        lastError = error;
+        this.markDegraded(provider.id);
+        if (!this.fallbackEnabled) {
+          throw error;
+        }
+      }
+    }
+    throw new AIError2(
+      "SERVER_ERROR" /* SERVER_ERROR */,
+      `All providers failed for capability '${capability}'`,
+      lastError instanceof Error ? lastError : void 0
+    );
+  }
+  orderByPriority(providers) {
+    if (this.priority.length === 0) {
+      return providers;
+    }
+    const ordered = [];
+    for (const providerId of this.priority) {
+      const provider = providers.find((p) => p.id === providerId);
+      if (provider) ordered.push(provider);
+    }
+    for (const provider of providers) {
+      if (!this.priority.includes(provider.id)) {
+        ordered.push(provider);
+      }
+    }
+    return ordered;
+  }
+  markDegraded(providerId) {
+    const cached = this.healthCache.get(providerId);
+    if (cached) {
+      this.healthCache.set(providerId, { health: "degraded", timestamp: cached.timestamp });
+    }
+  }
+  noProviderError(capability) {
+    return new AIError2(
+      "MISSING_CONFIG" /* MISSING_CONFIG */,
+      `No provider registered for capability '${capability}' \u2014 create one with createAI() and include its config block`
+    );
+  }
+};
+
+// src/core/constants/protocol.constants.ts
+var SSE_PREFIX = "data: ";
+var SSE_DONE_MARKER = "[DONE]";
+var JSON_CODE_BLOCK_PATTERN = /```json\n([\s\S]*?)\n```/;
+var JSON_OBJECT_PATTERN = /\{[\s\S]*\}/;
+
+// src/core/parsers/sse-lines.ts
+function isSseDataLine(line) {
+  return line.startsWith(SSE_PREFIX);
+}
+function extractSseDataPayload(line) {
+  return line.slice(SSE_PREFIX.length);
+}
+function isSseDoneMarker(payload) {
+  return payload === SSE_DONE_MARKER;
+}
+
+// src/core/parsers/json-content-extractor.ts
+function extractJsonFromCodeFence(content) {
+  const match = content.match(JSON_CODE_BLOCK_PATTERN);
+  if (match && match[1]) return match[1];
+  return null;
+}
+function extractJsonObject(content) {
+  const match = content.match(JSON_OBJECT_PATTERN);
+  if (match && match[0]) return match[0];
+  return null;
+}
+function extractJsonCandidate(content) {
+  return extractJsonFromCodeFence(content) ?? extractJsonObject(content) ?? content;
+}
+
+// src/core/parsers/json-response.parser.ts
+var JsonResponseParser = class {
+  parse(rawContent) {
+    const candidate = extractJsonCandidate(rawContent);
+    try {
+      return JSON.parse(candidate);
+    } catch (error) {
+      throw new AIError2(
+        "UNKNOWN_ERROR" /* UNKNOWN_ERROR */,
+        "Failed to parse structured response as JSON",
+        error instanceof Error ? error : void 0
+      );
+    }
+  }
+};
+
+// src/core/parsers/structured-prompt.builder.ts
+var StructuredPromptBuilder = class _StructuredPromptBuilder {
+  schema;
+  request;
+  constructor(request) {
+    this.request = request;
+  }
+  static for(request) {
+    return new _StructuredPromptBuilder(request);
+  }
+  withSchema(schema) {
+    this.schema = schema;
+    return this;
+  }
+  build() {
+    const schemaSection = this.schema ? `Expected JSON schema:
+${JSON.stringify(this.schema, null, 2)}
+
+` : "";
+    return "Please generate a JSON response for the following request.\n\n" + schemaSection + `Request:
+${this.request}
+
+Respond only with valid JSON, formatted as:
+\`\`\`json
+{...}
+\`\`\``;
+  }
+};
+
+// src/core/tiers/index.ts
+function resolveModel(tiers, tier, providerId) {
+  const model = tiers[tier] ?? tiers.balanced;
+  if (!model) {
+    throw new Error(
+      `${providerId} has no model configured for tier "${tier}" \u2014 pass an explicit model or configure the tier map`
+    );
+  }
+  return model;
+}
+function mergeTierOverrides(defaults, overrides) {
+  if (!overrides) return defaults;
+  return { ...defaults, ...overrides };
+}
+
+// src/providers/anthropic/anthropic.constants.ts
+var ANTHROPIC_MODELS = {
+  OPUS_5_5: "claude-opus-5-5",
+  SONNET_5_5: "claude-sonnet-5-5",
+  HAIKU_5_5: "claude-haiku-5-5"
+};
+var ANTHROPIC_TIERS = {
+  fast: ANTHROPIC_MODELS.HAIKU_5_5,
+  balanced: ANTHROPIC_MODELS.SONNET_5_5,
+  powerful: ANTHROPIC_MODELS.OPUS_5_5
+};
+var ANTHROPIC_API_VERSION = "2026-10-21";
+var ANTHROPIC_DEFAULT_MAX_TOKENS = 16e3;
+var ANTHROPIC_BASE_URL = "https://api.anthropic.com";
+var ANTHROPIC_MESSAGES_PATH = "/v1/messages";
+var ANTHROPIC_MODELS_PATH = "/v1/models";
+var ANTHROPIC_TIMEOUTS = {
+  DEFAULT: 6e4,
+  STREAMING: 12e4
+};
+var ANTHROPIC_HEADERS = {
+  CONTENT_TYPE: "Content-Type",
+  APPLICATION_JSON: "application/json",
+  API_KEY: "x-api-key",
+  VERSION: "anthropic-version"
+};
+var ANTHROPIC_DEFAULT_EFFORT = {
+  [ANTHROPIC_MODELS.OPUS_5_5]: "medium",
+  [ANTHROPIC_MODELS.SONNET_5_5]: "high",
+  [ANTHROPIC_MODELS.HAIKU_5_5]: "medium"
+};
+
+// src/providers/anthropic/anthropic-http.transport.ts
+var AnthropicHttpTransport = class {
+  constructor(config) {
+    this.config = config;
+  }
+  config;
+  async postMessages(request, options = {}) {
+    const url = `${this.baseUrl()}${ANTHROPIC_MESSAGES_PATH}`;
+    const timeout = this.config.timeoutMs ?? ANTHROPIC_TIMEOUTS.DEFAULT;
+    const controller = new AbortController();
+    const timeoutId = setTimeout(() => controller.abort(), timeout);
+    const onExternalAbort = () => controller.abort();
+    options.signal?.addEventListener("abort", onExternalAbort);
+    try {
+      const response = await fetch(url, {
+        method: "POST",
+        headers: this.buildHeaders(),
+        body: JSON.stringify({ ...request, stream: false }),
+        signal: controller.signal
+      });
+      if (!response.ok) await this.throwFromErrorResponse(response);
+      return await response.json();
+    } catch (error) {
+      throw this.normalizeError(error);
+    } finally {
+      clearTimeout(timeoutId);
+      options.signal?.removeEventListener("abort", onExternalAbort);
+    }
+  }
+  async streamMessages(request, options = {}) {
+    const url = `${this.baseUrl()}${ANTHROPIC_MESSAGES_PATH}`;
+    const timeout = this.config.timeoutMs ?? ANTHROPIC_TIMEOUTS.STREAMING;
+    const controller = new AbortController();
+    const timeoutId = setTimeout(() => controller.abort(), timeout);
+    const onExternalAbort = () => controller.abort();
+    options.signal?.addEventListener("abort", onExternalAbort);
+    try {
+      const response = await fetch(url, {
+        method: "POST",
+        headers: this.buildHeaders(),
+        body: JSON.stringify({ ...request, stream: true }),
+        signal: controller.signal
+      });
+      if (!response.ok) await this.throwFromErrorResponse(response);
+      if (!response.body) {
+        throw new AIError2("NETWORK_ERROR" /* NETWORK_ERROR */, "Response body is null");
+      }
+      return response.body;
+    } catch (error) {
+      options.signal?.removeEventListener("abort", onExternalAbort);
+      throw this.normalizeError(error);
+    } finally {
+      clearTimeout(timeoutId);
+    }
+  }
+  async listModels() {
+    const url = `${this.baseUrl()}${ANTHROPIC_MODELS_PATH}`;
+    return fetch(url, {
+      method: "GET",
+      headers: this.buildHeaders()
+    });
+  }
+  baseUrl() {
+    return this.config.baseUrl ?? ANTHROPIC_BASE_URL;
+  }
+  buildHeaders() {
+    return {
+      [ANTHROPIC_HEADERS.CONTENT_TYPE]: ANTHROPIC_HEADERS.APPLICATION_JSON,
+      [ANTHROPIC_HEADERS.API_KEY]: this.config.apiKey,
+      [ANTHROPIC_HEADERS.VERSION]: ANTHROPIC_API_VERSION
+    };
+  }
+  async throwFromErrorResponse(response) {
+    const errorMessage = await extractErrorMessageFromResponse(response);
+    const metadata = {
+      status: response.status,
+      url: response.url
+    };
+    throw new AIError2(
+      classifyHttpStatus(response.status),
+      errorMessage,
+      void 0,
+      metadata
+    );
+  }
+  normalizeError(error) {
+    if (error instanceof AIError2) return error;
+    if (error instanceof Error) {
+      if (error.name === "AbortError") {
+        return new AIError2(
+          "ABORT_ERROR" /* ABORT_ERROR */,
+          "Request was aborted by the client",
+          error
+        );
+      }
+      if (error.name === "TypeError" && error.message.toLowerCase().includes("network")) {
+        return new AIError2(
+          "NETWORK_ERROR" /* NETWORK_ERROR */,
+          "Network error: Unable to connect to the AI service",
+          error
+        );
+      }
+    }
+    return new AIError2(
+      "UNKNOWN_ERROR" /* UNKNOWN_ERROR */,
+      error instanceof Error ? error.message : "Unknown error occurred",
+      error instanceof Error ? error : void 0
+    );
+  }
+};
+
+// src/providers/anthropic/anthropic-request.builder.ts
+var AnthropicRequestBuilder = class _AnthropicRequestBuilder {
+  model;
+  messages = [];
+  systemPrompt;
+  maxTokens = ANTHROPIC_DEFAULT_MAX_TOKENS;
+  effort;
+  stopSequences;
+  streamEnabled = false;
+  constructor(model) {
+    this.model = model;
+  }
+  static for(model) {
+    return new _AnthropicRequestBuilder(model);
+  }
+  withRequest(request) {
+    this.messages = toAnthropicMessages(request.messages);
+    this.systemPrompt = request.systemPrompt;
+    if (request.maxTokens !== void 0) this.maxTokens = request.maxTokens;
+    if (request.stopSequences !== void 0 && request.stopSequences.length > 0) {
+      this.stopSequences = [...request.stopSequences];
+    }
+    return this;
+  }
+  withEffort(effort) {
+    this.effort = effort;
+    return this;
+  }
+  withStream(stream) {
+    this.streamEnabled = stream;
+    return this;
+  }
+  withSystemPromptOverride(systemPrompt) {
+    this.systemPrompt = systemPrompt;
+    return this;
+  }
+  withMessagesOverride(messages) {
+    this.messages = messages;
+    return this;
+  }
+  build() {
+    const request = {
+      model: this.model,
+      messages: this.messages,
+      max_tokens: this.maxTokens,
+      output_config: {
+        effort: this.effort ?? defaultEffortForModel(this.model)
+      }
+    };
+    if (this.systemPrompt !== void 0 && this.systemPrompt.length > 0) {
+      request.system = this.systemPrompt;
+    }
+    if (this.stopSequences !== void 0) {
+      request.stop_sequences = this.stopSequences;
+    }
+    if (this.streamEnabled) {
+      request.stream = true;
+    }
+    return request;
+  }
+};
+function toAnthropicMessages(messages) {
+  return messages.filter((message) => message.role !== "system" && message.content.length > 0).map((message) => ({
+    role: message.role,
+    content: message.content
+  }));
+}
+function defaultEffortForModel(model) {
+  return ANTHROPIC_DEFAULT_EFFORT[model] ?? "medium";
+}
+
+// src/providers/anthropic/anthropic-stream.parser.ts
+function mapAnthropicStopReason(reason) {
+  if (reason === "end_turn") return "stop";
+  if (reason === "stop_sequence") return "stop";
+  if (reason === "max_tokens") return "length";
+  if (reason === "refusal") return "refusal";
+  return void 0;
+}
+async function consumeAnthropicStream(stream, callbacks) {
+  const reader = stream.getReader();
+  const decoder = new TextDecoder();
+  const chunks = [];
+  let buffer = "";
+  let model = null;
+  let inputTokens;
+  let outputTokens;
+  let finishReason;
+  const consumeLine = (rawLine) => {
+    const line = rawLine.endsWith("\r") ? rawLine.slice(0, -1) : rawLine;
+    const trimmed = line.trim();
+    if (trimmed.length === 0 || !isSseDataLine(trimmed)) return;
+    const payload = extractSseDataPayload(trimmed);
+    let event;
+    try {
+      event = JSON.parse(payload);
+    } catch {
+      return;
+    }
+    switch (event.type) {
+      case "message_start":
+        model = event.message.model;
+        if (event.message.usage?.input_tokens !== void 0) {
+          inputTokens = event.message.usage.input_tokens;
+        }
+        break;
+      case "content_block_delta":
+        if (typeof event.delta.text === "string" && event.delta.text.length > 0) {
+          chunks.push(event.delta.text);
+          callbacks.onChunk?.(event.delta.text);
+        }
+        break;
+      case "message_delta":
+        if (event.delta?.stop_reason !== void 0 && event.delta.stop_reason !== null) {
+          finishReason = mapAnthropicStopReason(event.delta.stop_reason);
+        }
+        if (event.usage?.output_tokens !== void 0) {
+          outputTokens = event.usage.output_tokens;
+        }
+        break;
+      case "message_stop":
+        break;
+      case "error":
+        throw new AIError2(
+          event.error.type === "rate_limit_error" ? "RATE_LIMIT_ERROR" /* RATE_LIMIT_ERROR */ : "SERVER_ERROR" /* SERVER_ERROR */,
+          event.error.message || "Anthropic stream failed mid-flight"
+        );
+    }
+  };
+  try {
+    while (true) {
+      const { done, value } = await reader.read();
+      if (done) break;
+      buffer += decoder.decode(value, { stream: true });
+      const lines = buffer.split("\n");
+      buffer = lines.pop() ?? "";
+      for (const line of lines) consumeLine(line);
+    }
+    buffer += decoder.decode();
+    if (buffer.length > 0) consumeLine(buffer);
+  } catch (error) {
+    if (error instanceof AIError2) throw error;
+    throw new AIError2(
+      "NETWORK_ERROR" /* NETWORK_ERROR */,
+      "Stream was interrupted",
+      error instanceof Error ? error : void 0
+    );
+  } finally {
+    reader.releaseLock();
+  }
+  return {
+    text: chunks.join(""),
+    model,
+    inputTokens,
+    outputTokens,
+    finishReason
+  };
+}
+
+// src/providers/anthropic/anthropic.provider.ts
+var REFUSAL_FALLBACK_TEXT = "I'm not able to help with that request. Could you rephrase or ask something else?";
+var AnthropicProvider = class {
+  constructor(config) {
+    this.config = config;
+    this.transport = new AnthropicHttpTransport(config);
+    this.tiers = mergeTierOverrides(ANTHROPIC_TIERS, config.models);
+  }
+  config;
+  id = "anthropic";
+  name = "Anthropic";
+  capabilities = ["text"];
+  transport;
+  tiers;
+  jsonParser = new JsonResponseParser();
+  resolveModel(tier) {
+    return resolveModel(this.tiers, tier, this.id);
+  }
+  async healthCheck() {
+    if (!this.config.apiKey) return "unavailable";
+    try {
+      const response = await this.transport.listModels();
+      if (response.ok) return "healthy";
+      if (response.status === 401 || response.status === 403) return "unavailable";
+      return "degraded";
+    } catch {
+      return "unavailable";
+    }
+  }
+  async estimateCost() {
+    return 0;
+  }
+  async generate(request) {
+    const model = request.model ?? this.resolveModel(request.tier ?? "balanced");
+    const wireRequest = new AnthropicRequestBuilder(model).withRequest(request).withEffort(this.config.effort).build();
+    const response = await this.transport.postMessages(wireRequest, {
+      signal: request.signal
+    });
+    return this.toGenerationResult(response, model);
+  }
+  async generateStructured(request) {
+    const model = request.model ?? this.resolveModel(request.tier ?? "balanced");
+    const messages = [...request.messages];
+    const lastUserIndex = findLastIndex(messages, (m) => m.role === "user");
+    if (lastUserIndex === -1) {
+      throw new AIError2(
+        "UNKNOWN_ERROR" /* UNKNOWN_ERROR */,
+        "generateStructured requires at least one user message"
+      );
+    }
+    const structuredPrompt = new StructuredPromptBuilder(
+      messages[lastUserIndex].content
+    ).withSchema(request.schema).build();
+    messages[lastUserIndex] = { role: "user", content: structuredPrompt };
+    const wireRequest = new AnthropicRequestBuilder(model).withRequest({ ...request, messages }).withEffort(this.config.effort).build();
+    const response = await this.transport.postMessages(wireRequest, {
+      signal: request.signal
+    });
+    const result = this.toGenerationResult(response, model);
+    return { value: this.jsonParser.parse(result.text), result };
+  }
+  async stream(request, callbacks) {
+    const model = request.model ?? this.resolveModel(request.tier ?? "balanced");
+    const wireRequest = new AnthropicRequestBuilder(model).withRequest(request).withEffort(this.config.effort).withStream(true).build();
+    const streamBody = await this.transport.streamMessages(wireRequest, {
+      signal: request.signal
+    });
+    try {
+      const outcome = await consumeAnthropicStream(streamBody, callbacks);
+      const text = outcome.text.length > 0 ? outcome.text : refusalTextFor(outcome.finishReason);
+      const result = {
+        text,
+        usage: {
+          inputTokens: outcome.inputTokens ?? 0,
+          outputTokens: outcome.outputTokens ?? 0
+        },
+        model: outcome.model ?? model,
+        providerId: this.id,
+        finishReason: outcome.finishReason
+      };
+      callbacks.onComplete?.(result);
+      return result;
+    } catch (error) {
+      callbacks.onError?.(error instanceof Error ? error : new Error(String(error)));
+      throw error;
+    }
+  }
+  toGenerationResult(response, fallbackModel) {
+    const text = extractText(response.content);
+    const finishReason = mapAnthropicStopReason(response.stop_reason);
+    if (text.length === 0) {
+      if (finishReason === "refusal") {
+        return {
+          text: REFUSAL_FALLBACK_TEXT,
+          usage: mapAnthropicUsage(response.usage),
+          model: response.model || fallbackModel,
+          providerId: this.id,
+          finishReason
+        };
+      }
+      throw new AIError2(
+        "SERVER_ERROR" /* SERVER_ERROR */,
+        "No content generated from Anthropic API",
+        void 0,
+        { model: response.model || fallbackModel, stopReason: response.stop_reason ?? void 0 }
+      );
+    }
+    return {
+      text,
+      usage: mapAnthropicUsage(response.usage),
+      model: response.model || fallbackModel,
+      providerId: this.id,
+      finishReason
+    };
+  }
+};
+function extractText(blocks) {
+  return blocks.filter((block) => block.type === "text").map((block) => block.text).join("");
+}
+function refusalTextFor(finishReason) {
+  return finishReason === "refusal" ? REFUSAL_FALLBACK_TEXT : "";
+}
+function mapAnthropicUsage(usage) {
+  if (!usage) return void 0;
+  return {
+    inputTokens: usage.input_tokens,
+    outputTokens: usage.output_tokens
+  };
+}
+function findLastIndex(items, predicate) {
+  for (let i = items.length - 1; i >= 0; i--) {
+    if (predicate(items[i])) return i;
+  }
+  return -1;
+}
+
+// src/core/calculations/lru-key-selector.ts
+function selectLeastRecentlyUsedKey(entries) {
+  let oldestKey = null;
+  let oldestAccess = Number.POSITIVE_INFINITY;
+  for (const [key, entry] of entries.entries()) {
+    if (entry.lastAccess < oldestAccess) {
+      oldestAccess = entry.lastAccess;
+      oldestKey = key;
+    }
+  }
+  return oldestKey;
+}
+
+// src/core/calculations/cache-hit-rate.ts
+function calculateCacheHitRate(entries) {
+  if (entries.length === 0) return 0;
+  const totalAccess = entries.reduce((sum, e) => sum + e.accessCount, 0);
+  return totalAccess / entries.length;
+}
+
+// src/core/utils/cache-key-builder.ts
+function buildCacheKey(params) {
+  const sortedKeys = Object.keys(params).sort();
+  const sortedParams = {};
+  for (const key of sortedKeys) {
+    sortedParams[key] = params[key];
+  }
+  return JSON.stringify(sortedParams);
+}
+
+// src/core/utils/cache-manager.ts
+var DEFAULT_CACHE_MAX_SIZE = 100;
+var DEFAULT_CACHE_TTL_MS = 3e5;
+var CacheManager = class {
+  cache = /* @__PURE__ */ new Map();
+  maxSize;
+  ttl;
+  constructor(options = {}) {
+    this.maxSize = options.maxSize ?? DEFAULT_CACHE_MAX_SIZE;
+    this.ttl = options.ttl ?? DEFAULT_CACHE_TTL_MS;
+  }
+  get(key) {
+    const entry = this.cache.get(key);
+    if (!entry) return null;
+    if (this.isExpired(entry)) {
+      this.cache.delete(key);
+      return null;
+    }
+    entry.accessCount += 1;
+    entry.lastAccess = Date.now();
+    return entry.value;
+  }
+  set(key, value) {
+    if (this.cache.size >= this.maxSize && !this.cache.has(key)) {
+      const lruKey = selectLeastRecentlyUsedKey(this.cache);
+      if (lruKey !== null) this.cache.delete(lruKey);
+    }
+    this.cache.set(key, {
+      value,
+      timestamp: Date.now(),
+      accessCount: 1,
+      lastAccess: Date.now()
+    });
+  }
+  has(key) {
+    const entry = this.cache.get(key);
+    return entry !== void 0 && !this.isExpired(entry);
+  }
+  delete(key) {
+    return this.cache.delete(key);
+  }
+  clear() {
+    this.cache.clear();
+  }
+  generateKey(params) {
+    return buildCacheKey(params);
+  }
+  getStats() {
+    const now = Date.now();
+    const entries = Array.from(this.cache.entries()).map(([key, entry]) => ({
+      key,
+      accessCount: entry.accessCount,
+      ageMs: now - entry.timestamp
+    }));
+    const hitRate = calculateCacheHitRate(
+      Array.from(this.cache.values()).map((e) => ({ accessCount: e.accessCount }))
+    );
+    return {
+      size: this.cache.size,
+      maxSize: this.maxSize,
+      hitRate,
+      entries
+    };
+  }
+  isExpired(entry) {
+    return Date.now() - entry.timestamp > this.ttl;
+  }
+};
+new CacheManager();
+
+// src/core/calculations/exponential-backoff.ts
+function calculateExponentialBackoff(params) {
+  const {
+    attempt,
+    initialDelay,
+    maxDelay,
+    backoffMultiplier,
+    jitterFactor,
+    random = Math.random
+  } = params;
+  const base = initialDelay * Math.pow(backoffMultiplier, Math.max(0, attempt - 1));
+  const capped = Math.min(base, maxDelay);
+  const jitterMultiplier = random() * 2 - 1;
+  const jitter = capped * jitterFactor * jitterMultiplier;
+  return Math.max(0, capped + jitter);
+}
+
+// src/core/constants/identifier.constants.ts
+var QUEUE_PRIORITY_USER_REQUEST = 10;
+var DEFAULT_RETRY_MAX_ATTEMPTS = 3;
+var DEFAULT_RETRY_INITIAL_DELAY_MS = 1e3;
+var DEFAULT_RETRY_MAX_DELAY_MS = 1e4;
+var DEFAULT_RETRY_BACKOFF_MULTIPLIER = 2;
+var DEFAULT_RETRY_JITTER_FACTOR = 0.1;
+
+// src/core/utils/retry.ts
+var RETRYABLE_MESSAGE_KEYWORDS = [
+  "network",
+  "timeout",
+  "econnrefused",
+  "enotfound",
+  "etimedout"
+];
+var RetryManager = class {
+  defaults;
+  constructor() {
+    this.defaults = {
+      maxAttempts: DEFAULT_RETRY_MAX_ATTEMPTS,
+      initialDelay: DEFAULT_RETRY_INITIAL_DELAY_MS,
+      maxDelay: DEFAULT_RETRY_MAX_DELAY_MS,
+      backoffMultiplier: DEFAULT_RETRY_BACKOFF_MULTIPLIER,
+      jitterFactor: DEFAULT_RETRY_JITTER_FACTOR
+    };
+  }
+  async execute(fn, options = {}) {
+    const maxAttempts = options.maxAttempts ?? this.defaults.maxAttempts;
+    let lastError;
+    for (let attempt = 1; attempt <= maxAttempts; attempt++) {
+      try {
+        return await fn();
+      } catch (error) {
+        lastError = error instanceof Error ? error : new Error(String(error));
+        if (attempt >= maxAttempts || !this.shouldRetry(lastError, options)) {
+          throw lastError;
+        }
+        const delay = calculateExponentialBackoff({
+          attempt,
+          initialDelay: options.initialDelay ?? this.defaults.initialDelay,
+          maxDelay: options.maxDelay ?? this.defaults.maxDelay,
+          backoffMultiplier: options.backoffMultiplier ?? this.defaults.backoffMultiplier,
+          jitterFactor: options.jitterFactor ?? this.defaults.jitterFactor
+        });
+        await this.delay(delay);
+      }
+    }
+    throw lastError ?? new Error("Retry loop exited without result");
+  }
+  shouldRetry(error, options) {
+    if (options.shouldRetry) return options.shouldRetry(error);
+    if (error instanceof AIError2) {
+      return isRetryableErrorType(error.type, DEFAULT_ERROR_CLASSIFICATION_RULE);
+    }
+    const lower = error.message.toLowerCase();
+    return RETRYABLE_MESSAGE_KEYWORDS.some((kw) => lower.includes(kw));
+  }
+  delay(ms) {
+    return new Promise((resolve) => setTimeout(resolve, ms));
+  }
+};
+
+// src/core/utils/request-queue.util.ts
+var DEFAULT_MAX_CONCURRENT = 3;
+var DEFAULT_PRIORITY = 0;
+var DEFAULT_REQUEST_TIMEOUT_MS = 3e4;
+var RequestQueue = class {
+  queue = [];
+  activeRequests = /* @__PURE__ */ new Set();
+  maxConcurrent;
+  defaultPriority;
+  requestTimeout;
+  requestIdCounter = 0;
+  constructor(options = {}) {
+    this.maxConcurrent = options.maxConcurrent ?? DEFAULT_MAX_CONCURRENT;
+    this.defaultPriority = options.defaultPriority ?? DEFAULT_PRIORITY;
+    this.requestTimeout = options.requestTimeout ?? DEFAULT_REQUEST_TIMEOUT_MS;
+  }
+  add(requestFn, priority) {
+    return new Promise((resolve, reject) => {
+      const id = `req-${++this.requestIdCounter}`;
+      const queuedRequest = {
+        id,
+        priority: priority ?? this.defaultPriority,
+        requestFn,
+        resolve,
+        reject,
+        timestamp: Date.now()
+      };
+      this.queue.push(queuedRequest);
+      this.sortQueue();
+      this.process();
+    });
+  }
+  cancelAll() {
+    for (const request of this.queue) {
+      request.reject(new Error("Request was cancelled"));
+    }
+    this.queue = [];
+  }
+  sortQueue() {
+    this.queue.sort((a, b) => {
+      if (a.priority !== b.priority) {
+        return b.priority - a.priority;
+      }
+      return a.timestamp - b.timestamp;
+    });
+  }
+  process() {
+    while (this.queue.length > 0 && this.activeRequests.size < this.maxConcurrent) {
+      const request = this.queue.shift();
+      if (!request) break;
+      this.executeRequest(request);
+    }
+  }
+  executeRequest(request) {
+    this.activeRequests.add(request.id);
+    const timeoutId = setTimeout(() => {
+      this.activeRequests.delete(request.id);
+      request.reject(new Error(`Request ${request.id} timed out`));
+      this.process();
+    }, this.requestTimeout);
+    request.requestFn().then((result) => {
+      clearTimeout(timeoutId);
+      request.resolve(result);
+    }).catch((error) => {
+      clearTimeout(timeoutId);
+      request.reject(error);
+    }).finally(() => {
+      this.activeRequests.delete(request.id);
+      this.process();
+    });
+  }
+};
+new RequestQueue();
+
+// src/core/utils/request-deduplicator.util.ts
+var DEFAULT_DEDUPE_TTL_MS = 3e4;
+var RequestDeduplicator = class {
+  pendingRequests = /* @__PURE__ */ new Map();
+  ttl;
+  constructor(ttl = DEFAULT_DEDUPE_TTL_MS) {
+    this.ttl = ttl;
+  }
+  execute(key, requestFn) {
+    this.cleanup();
+    const existing = this.pendingRequests.get(key);
+    if (existing) {
+      return existing.promise;
+    }
+    const promise = requestFn();
+    this.pendingRequests.set(key, {
+      promise,
+      timestamp: Date.now()
+    });
+    promise.catch(() => void 0).then(() => {
+      this.pendingRequests.delete(key);
+    });
+    return promise;
+  }
+  cancelAll() {
+    this.pendingRequests.clear();
+  }
+  cleanup() {
+    const now = Date.now();
+    for (const [key, request] of this.pendingRequests.entries()) {
+      if (now - request.timestamp > this.ttl) {
+        this.pendingRequests.delete(key);
+      }
+    }
+  }
+};
+
+// src/providers/groq/groq.constants.ts
+var GROQ_MODELS = {
+  LLAMA_3_1_8B_INSTANT: "llama-3.1-8b-instant",
+  LLAMA_3_3_70B_VERSATILE: "llama-3.3-70b-versatile",
+  GPT_OSS_120B: "openai/gpt-oss-120b"};
+var GROQ_TIERS = {
+  fast: GROQ_MODELS.LLAMA_3_1_8B_INSTANT,
+  balanced: GROQ_MODELS.LLAMA_3_3_70B_VERSATILE,
+  powerful: GROQ_MODELS.GPT_OSS_120B
+};
+var DEFAULT_GENERATION_CONFIG = {
+  temperature: 0.7,
+  maxTokens: 1024,
+  topP: 1
+};
+var GROQ_BASE_URL = "https://api.groq.com/openai/v1";
+var CHAT_COMPLETIONS_PATH = "/chat/completions";
+var GROQ_TIMEOUTS = {
+  DEFAULT: 3e4,
+  STREAMING: 6e4
+};
+var HTTP_HEADERS = {
+  CONTENT_TYPE: "Content-Type",
+  APPLICATION_JSON: "application/json",
+  AUTHORIZATION: "Authorization",
+  BEARER_PREFIX: "Bearer "
+};
+
+// src/providers/groq/groq-request.builder.ts
+var GroqChatRequestBuilder = class _GroqChatRequestBuilder {
+  model;
+  messages = [];
+  generationConfig = {};
+  streamEnabled = false;
+  jsonResponse = false;
+  constructor(model) {
+    this.model = model;
+  }
+  static for(model) {
+    return new _GroqChatRequestBuilder(model);
+  }
+  withMessages(messages) {
+    this.messages = [...messages];
+    return this;
+  }
+  withConfig(config) {
+    this.generationConfig = config ? { ...config } : {};
+    return this;
+  }
+  withStream(stream) {
+    this.streamEnabled = stream;
+    return this;
+  }
+  withJsonResponse(enabled) {
+    this.jsonResponse = enabled;
+    return this;
+  }
+  build() {
+    const cfg = this.generationConfig;
+    const request = {
+      model: this.model,
+      messages: this.messages,
+      temperature: cfg.temperature ?? DEFAULT_GENERATION_CONFIG.temperature,
+      max_tokens: cfg.maxTokens ?? DEFAULT_GENERATION_CONFIG.maxTokens,
+      top_p: cfg.topP ?? DEFAULT_GENERATION_CONFIG.topP
+    };
+    if (cfg.n !== void 0) request.n = cfg.n;
+    if (cfg.stop !== void 0) request.stop = cfg.stop;
+    if (cfg.frequencyPenalty !== void 0) request.frequency_penalty = cfg.frequencyPenalty;
+    if (cfg.presencePenalty !== void 0) request.presence_penalty = cfg.presencePenalty;
+    if (cfg.reasoningEffort !== void 0) request.reasoning_effort = cfg.reasoningEffort;
+    if (this.jsonResponse) {
+      request.response_format = { type: "json_object" };
+    }
+    if (this.streamEnabled) request.stream = true;
+    return request;
+  }
+};
+
+// src/providers/groq/groq-http-transport.ts
+var GroqHttpTransport = class {
+  constructor(config) {
+    this.config = config;
+  }
+  config;
+  pendingAbortControllers = /* @__PURE__ */ new Set();
+  cancelPendingRequests() {
+    for (const controller of this.pendingAbortControllers) {
+      controller.abort();
+    }
+    this.pendingAbortControllers.clear();
+  }
+  async postChatCompletion(request) {
+    return this.request(CHAT_COMPLETIONS_PATH, {
+      ...request,
+      stream: false
+    });
+  }
+  async streamChatCompletion(request, options = {}) {
+    const url = `${this.baseUrl()}${CHAT_COMPLETIONS_PATH}`;
+    const timeout = this.config.timeoutMs ?? GROQ_TIMEOUTS.STREAMING;
+    const controller = new AbortController();
+    const timeoutId = setTimeout(() => controller.abort(), timeout);
+    const onExternalAbort = () => controller.abort();
+    options.signal?.addEventListener("abort", onExternalAbort);
+    this.pendingAbortControllers.add(controller);
+    try {
+      const response = await fetch(url, {
+        method: "POST",
+        headers: this.buildHeaders(),
+        body: JSON.stringify({ ...request, stream: true }),
+        signal: controller.signal
+      });
+      if (!response.ok) await this.throwFromErrorResponse(response);
+      if (!response.body) {
+        throw new AIError2("NETWORK_ERROR" /* NETWORK_ERROR */, "Response body is null");
+      }
+      return response.body;
+    } catch (error) {
+      options.signal?.removeEventListener("abort", onExternalAbort);
+      throw this.normalizeError(error);
+    } finally {
+      clearTimeout(timeoutId);
+      this.pendingAbortControllers.delete(controller);
+    }
+  }
+  baseUrl() {
+    return this.config.baseUrl ?? GROQ_BASE_URL;
+  }
+  async request(endpoint, body) {
+    const url = `${this.baseUrl()}${endpoint}`;
+    const timeout = this.config.timeoutMs ?? GROQ_TIMEOUTS.DEFAULT;
+    const controller = new AbortController();
+    const timeoutId = setTimeout(() => controller.abort(), timeout);
+    this.pendingAbortControllers.add(controller);
+    try {
+      const response = await fetch(url, {
+        method: "POST",
+        headers: this.buildHeaders(),
+        body: JSON.stringify(body),
+        signal: controller.signal
+      });
+      if (!response.ok) await this.throwFromErrorResponse(response);
+      return await response.json();
+    } catch (error) {
+      throw this.normalizeError(error);
+    } finally {
+      clearTimeout(timeoutId);
+      this.pendingAbortControllers.delete(controller);
+    }
+  }
+  buildHeaders() {
+    return {
+      [HTTP_HEADERS.CONTENT_TYPE]: HTTP_HEADERS.APPLICATION_JSON,
+      [HTTP_HEADERS.AUTHORIZATION]: `${HTTP_HEADERS.BEARER_PREFIX}${this.config.apiKey}`
+    };
+  }
+  async throwFromErrorResponse(response) {
+    const errorMessage = await extractErrorMessageFromResponse(response);
+    const metadata = {
+      status: response.status,
+      url: response.url
+    };
+    throw new AIError2(
+      classifyHttpStatus(response.status),
+      errorMessage,
+      void 0,
+      metadata
+    );
+  }
+  normalizeError(error) {
+    if (error instanceof AIError2) return error;
+    if (error instanceof Error) {
+      if (error.name === "AbortError") {
+        return new AIError2(
+          "ABORT_ERROR" /* ABORT_ERROR */,
+          "Request was aborted by the client",
+          error
+        );
+      }
+      if (error.name === "TypeError" && error.message.toLowerCase().includes("network")) {
+        return new AIError2(
+          "NETWORK_ERROR" /* NETWORK_ERROR */,
+          "Network error: Unable to connect to the AI service",
+          error
+        );
+      }
+    }
+    return new AIError2(
+      "UNKNOWN_ERROR" /* UNKNOWN_ERROR */,
+      error instanceof Error ? error.message : "Unknown error occurred",
+      error instanceof Error ? error : void 0
+    );
+  }
+};
+
+// src/core/executor/retry-executor.strategy.ts
+var RetryExecutor = class {
+  constructor(retryManager2, options) {
+    this.retryManager = retryManager2;
+    this.options = options;
+  }
+  retryManager;
+  options;
+  execute(fn, ...args) {
+    return this.retryManager.execute(() => fn(...args), this.options);
+  }
+};
+
+// src/core/executor/queue-executor.strategy.ts
+var QueueExecutor = class {
+  constructor(queue, priority) {
+    this.queue = queue;
+    this.priority = priority;
+  }
+  queue;
+  priority;
+  execute(fn, ...args) {
+    return this.queue.add(() => fn(...args), this.priority);
+  }
+};
+
+// src/core/executor/dedupe-executor.strategy.ts
+var DedupeExecutor = class {
+  constructor(deduplicator, options) {
+    this.deduplicator = deduplicator;
+    this.options = options;
+  }
+  deduplicator;
+  options;
+  execute(fn, ...args) {
+    const key = this.options.generateKey(...args);
+    return this.deduplicator.execute(key, () => fn(...args));
+  }
+};
+
+// src/core/executor/composite-executor.strategy.ts
+var CompositeExecutor = class {
+  executors;
+  constructor(executors) {
+    this.executors = executors;
+  }
+  execute(fn, ...args) {
+    const composed = this.compress(fn);
+    return composed(...args);
+  }
+  compress(fn) {
+    return this.executors.reduceRight(
+      (innerFn, executor) => (...a) => executor.execute(innerFn, ...a),
+      fn
+    );
+  }
+};
+
+// src/providers/groq/groq-http-client.ts
+var GroqHttpClient = class {
+  transport;
+  executor;
+  constructor(config, deps = {}) {
+    this.transport = deps.transport ?? new GroqHttpTransport(config);
+    const retryManager2 = deps.retryManager ?? new RetryManager();
+    const queue = deps.queue ?? new RequestQueue();
+    const deduplicator = deps.deduplicator ?? new RequestDeduplicator();
+    this.executor = new CompositeExecutor([
+      new DedupeExecutor(deduplicator, {
+        generateKey: (request) => deduplicatorKey(request, config.apiKey)
+      }),
+      new RetryExecutor(retryManager2),
+      new QueueExecutor(queue, QUEUE_PRIORITY_USER_REQUEST)
+    ]);
+  }
+  cancelPendingRequests() {
+    this.transport.cancelPendingRequests();
+  }
+  postChatCompletion(request) {
+    return this.executor.execute(
+      (req) => this.transport.postChatCompletion(req),
+      request
+    );
+  }
+  streamChatCompletion(request, options) {
+    return this.transport.streamChatCompletion(request, options);
+  }
+};
+function deduplicatorKey(request, apiKey) {
+  const { model, messages, stream: _stream, ...rest } = request;
+  const stable = JSON.stringify({
+    apiKey,
+    model,
+    messages: messages.map((m) => ({ role: m.role, content: m.content })),
+    ...rest
+  });
+  return stable;
+}
+
+// src/providers/groq/groq-sse.ts
+function mapGroqFinishReason(reason) {
+  if (reason === "stop") return "stop";
+  if (reason === "length") return "length";
+  if (reason === "content_filter") return "content_filter";
+  return void 0;
+}
+function mapGroqUsage(usage) {
+  if (!usage) return void 0;
+  return {
+    inputTokens: usage.prompt_tokens,
+    outputTokens: usage.completion_tokens,
+    totalTokens: usage.total_tokens
+  };
+}
+async function consumeGroqStream(stream, callbacks) {
+  const reader = stream.getReader();
+  const decoder = new TextDecoder();
+  const chunks = [];
+  let buffer = "";
+  let model = null;
+  let finishReason;
+  let usage;
+  const consumeLine = (rawLine) => {
+    const line = rawLine.endsWith("\r") ? rawLine.slice(0, -1) : rawLine;
+    const trimmed = line.trim();
+    if (trimmed.length === 0 || !isSseDataLine(trimmed)) return;
+    const payload = extractSseDataPayload(trimmed);
+    if (isSseDoneMarker(payload)) return;
+    let chunk;
+    try {
+      chunk = JSON.parse(payload);
+    } catch {
+      return;
+    }
+    if (chunk.model) model = chunk.model;
+    const choice = chunk.choices?.[0];
+    const delta = choice?.delta?.content;
+    if (typeof delta === "string" && delta.length > 0) {
+      chunks.push(delta);
+      callbacks.onChunk?.(delta);
+    }
+    if (choice?.finish_reason) {
+      finishReason = mapGroqFinishReason(choice.finish_reason);
+    }
+    const tailUsage = chunk.x_groq?.usage;
+    if (tailUsage) {
+      usage = mapGroqUsage(tailUsage);
+    }
+    const errorBody = chunk.error;
+    if (errorBody) {
+      throw new AIError2(
+        "SERVER_ERROR" /* SERVER_ERROR */,
+        errorBody.message || "Groq stream failed mid-flight"
+      );
+    }
+  };
+  try {
+    while (true) {
+      const { done, value } = await reader.read();
+      if (done) break;
+      buffer += decoder.decode(value, { stream: true });
+      const lines = buffer.split("\n");
+      buffer = lines.pop() ?? "";
+      for (const line of lines) consumeLine(line);
+    }
+    buffer += decoder.decode();
+    if (buffer.length > 0) consumeLine(buffer);
+  } catch (error) {
+    if (error instanceof AIError2) throw error;
+    throw new AIError2(
+      "NETWORK_ERROR" /* NETWORK_ERROR */,
+      "Stream was interrupted",
+      error instanceof Error ? error : void 0
+    );
+  } finally {
+    reader.releaseLock();
+  }
+  return { text: chunks.join(""), model, finishReason, usage };
+}
+
+// src/providers/groq/groq.provider.ts
+var CACHE_LAYOUT_VERSION = 2;
+var STRUCTURED_TEMPERATURE = 0.1;
+var GroqProvider = class {
+  constructor(config) {
+    this.config = config;
+    this.client = new GroqHttpClient(config);
+    this.tiers = mergeTierOverrides(GROQ_TIERS, config.models);
+  }
+  config;
+  id = "groq";
+  name = "Groq";
+  capabilities = ["text"];
+  client;
+  tiers;
+  cache = new CacheManager();
+  jsonParser = new JsonResponseParser();
+  resolveModel(tier) {
+    return resolveModel(this.tiers, tier, this.id);
+  }
+  async healthCheck() {
+    return this.config.apiKey ? "healthy" : "unavailable";
+  }
+  async estimateCost() {
+    return 0;
+  }
+  async generate(request) {
+    const model = request.model ?? this.resolveModel(request.tier ?? "balanced");
+    const cacheKey = this.cache.generateKey({
+      v: CACHE_LAYOUT_VERSION,
+      provider: this.id,
+      op: "generate",
+      model,
+      messages: request.messages,
+      systemPrompt: request.systemPrompt ?? null,
+      temperature: request.temperature ?? null,
+      maxTokens: request.maxTokens ?? null,
+      topP: request.topP ?? null
+    });
+    const cached = this.cache.get(cacheKey);
+    if (cached) return cached;
+    const response = await this.client.postChatCompletion(
+      this.buildWireRequest(model, request)
+    );
+    const choice = response.choices?.[0];
+    const text = choice?.message?.content ?? "";
+    if (text.length === 0) {
+      throw new AIError2(
+        "SERVER_ERROR" /* SERVER_ERROR */,
+        "No content generated from Groq API",
+        void 0,
+        { model }
+      );
+    }
+    const result = {
+      text,
+      usage: mapGroqUsage(response.usage),
+      model: response.model || model,
+      providerId: this.id,
+      finishReason: mapGroqFinishReason(choice?.finish_reason)
+    };
+    this.cache.set(cacheKey, result);
+    return result;
+  }
+  async generateStructured(request) {
+    const model = request.model ?? this.resolveModel(request.tier ?? "balanced");
+    const messages = toGroqMessages(request.messages, request.systemPrompt);
+    const lastUserIndex = findLastIndex2(messages, (m) => m.role === "user");
+    if (lastUserIndex === -1) {
+      throw new AIError2(
+        "UNKNOWN_ERROR" /* UNKNOWN_ERROR */,
+        "generateStructured requires at least one user message"
+      );
+    }
+    const structuredPrompt = new StructuredPromptBuilder(
+      messages[lastUserIndex].content
+    ).withSchema(request.schema).build();
+    messages[lastUserIndex] = { role: "user", content: structuredPrompt };
+    const wireRequest = GroqChatRequestBuilder.for(model).withMessages(messages).withConfig(this.generationConfig(request, STRUCTURED_TEMPERATURE)).withJsonResponse(true).build();
+    const response = await this.client.postChatCompletion(wireRequest);
+    const choice = response.choices?.[0];
+    const text = choice?.message?.content ?? "";
+    if (text.length === 0) {
+      throw new AIError2(
+        "SERVER_ERROR" /* SERVER_ERROR */,
+        "No content generated from Groq API",
+        void 0,
+        { model }
+      );
+    }
+    return {
+      value: this.jsonParser.parse(text),
+      result: {
+        text,
+        usage: mapGroqUsage(response.usage),
+        model: response.model || model,
+        providerId: this.id,
+        finishReason: mapGroqFinishReason(choice?.finish_reason)
+      }
+    };
+  }
+  async stream(request, callbacks) {
+    const model = request.model ?? this.resolveModel(request.tier ?? "balanced");
+    const streamBody = await this.client.streamChatCompletion(
+      this.buildWireRequest(model, request),
+      { signal: request.signal }
+    );
+    try {
+      const outcome = await consumeGroqStream(streamBody, callbacks);
+      if (outcome.text.length === 0) {
+        throw new AIError2(
+          "SERVER_ERROR" /* SERVER_ERROR */,
+          "No content generated from Groq API",
+          void 0,
+          { model }
+        );
+      }
+      const result = {
+        text: outcome.text,
+        usage: outcome.usage,
+        model: outcome.model ?? model,
+        providerId: this.id,
+        finishReason: outcome.finishReason
+      };
+      callbacks.onComplete?.(result);
+      return result;
+    } catch (error) {
+      callbacks.onError?.(error instanceof Error ? error : new Error(String(error)));
+      throw error;
+    }
+  }
+  getCacheStats() {
+    return this.cache.getStats();
+  }
+  clearCache() {
+    this.cache.clear();
+  }
+  cancelPendingRequests() {
+    this.client.cancelPendingRequests();
+  }
+  buildWireRequest(model, request) {
+    return GroqChatRequestBuilder.for(model).withMessages(toGroqMessages(request.messages, request.systemPrompt)).withConfig(this.generationConfig(request)).build();
+  }
+  generationConfig(request, temperatureOverride) {
+    return {
+      ...request.temperature !== void 0 ? { temperature: request.temperature } : {},
+      ...temperatureOverride !== void 0 ? { temperature: temperatureOverride } : {},
+      ...request.maxTokens !== void 0 ? { maxTokens: request.maxTokens } : {},
+      ...request.topP !== void 0 ? { topP: request.topP } : {},
+      ...request.stopSequences !== void 0 && request.stopSequences.length > 0 ? { stop: [...request.stopSequences] } : {}
+    };
+  }
+};
+function toGroqMessages(messages, systemPrompt) {
+  const wire = [];
+  if (systemPrompt && systemPrompt.length > 0) {
+    wire.push({ role: "system", content: systemPrompt });
+  }
+  for (const message of messages) {
+    if (message.role === "system") {
+      wire.push({ role: "system", content: message.content });
+      continue;
+    }
+    wire.push({ role: message.role, content: message.content });
+  }
+  return wire;
+}
+function findLastIndex2(items, predicate) {
+  for (let i = items.length - 1; i >= 0; i--) {
+    if (predicate(items[i])) return i;
+  }
+  return -1;
+}
+
+// src/content/domain/calculations/RetryBackoffDelay.ts
+function calculateRetryBackoffDelayMs(attemptIndex) {
+  return ProviderTimingConfig.RETRY_BACKOFF_BASE_MS * Math.pow(2, attemptIndex);
+}
+
+// src/providers/base/base.provider.ts
+var BaseProvider = class {
+  config;
+  constructor(config) {
+    this.config = config;
+  }
+  async healthCheck() {
+    if (!this.config.apiKey) {
+      return "unavailable";
+    }
+    return "healthy";
+  }
+  async estimateCost(_request) {
+    return 0;
+  }
+  async fetchWithTimeout(url, options, timeout) {
+    const effectiveTimeout = timeout ?? this.config.timeout ?? ProviderTimingConfig.DEFAULT_TIMEOUT_MS;
+    const controller = new AbortController();
+    const timeoutId = setTimeout(() => controller.abort(), effectiveTimeout);
+    try {
+      const response = await fetch(url, {
+        ...options,
+        signal: controller.signal
+      });
+      clearTimeout(timeoutId);
+      return response;
+    } catch (error) {
+      clearTimeout(timeoutId);
+      throw error;
+    }
+  }
+  async withRetry(fn, maxAttempts) {
+    const attempts = maxAttempts ?? this.config.retryAttempts ?? ProviderTimingConfig.DEFAULT_RETRY_ATTEMPTS;
+    let lastError;
+    for (let i = 0; i < attempts; i++) {
+      try {
+        return await fn();
+      } catch (error) {
+        lastError = error;
+        if (i < attempts - 1) {
+          await new Promise((resolve) => setTimeout(resolve, calculateRetryBackoffDelayMs(i)));
+        }
+      }
+    }
+    throw lastError || new Error("Retry attempts exhausted");
+  }
+};
+
+// src/content/domain/predicates/ProviderCostEstimator.ts
+var FAL_FIXED_COST = 1;
+var GEMINI_IMAGE_COST = 0.02;
+var GEMINI_TEXT_PER_1K_CHARS_COST = 1e-4;
+function estimateFalGenerationCost(_request) {
+  return FAL_FIXED_COST;
+}
+function estimateGeminiGenerationCost(request) {
+  if (request.type === "image") return GEMINI_IMAGE_COST;
+  return GEMINI_TEXT_PER_1K_CHARS_COST;
+}
+
+// src/content/domain/limits/ModelDefaults.ts
+var ModelDefaults = {
+  FAL_IMAGE: "fal-ai/flux/schnell",
+  FAL_VIDEO: "fal-ai/hunyuan-video/1",
+  FAL_IMAGE_TO_VIDEO: "fal-ai/fast-animatediff/image-to-video",
+  GEMINI_TEXT: "gemini-2.0-flash",
+  GEMINI_IMAGE: "imagen-4.0-generate-001"};
+
+// src/providers/gemini/gemini.provider.ts
+var GEMINI_TIERS = {
+  fast: "gemini-2.0-flash-lite",
+  balanced: ModelDefaults.GEMINI_TEXT,
+  powerful: "gemini-2.5-pro"
+};
+var GeminiProvider = class extends BaseProvider {
+  id = "gemini";
+  name = "Google Gemini";
+  capabilities = ["text", "image"];
+  models;
+  tiers;
+  jsonParser = new JsonResponseParser();
+  constructor(config) {
+    super({
+      apiKey: config.apiKey,
+      baseUrl: config.baseUrl || "https://generativelanguage.googleapis.com/v1beta",
+      timeout: config.timeout || ProviderTimingConfig.GEMINI_TIMEOUT_MS,
+      retryAttempts: config.retryAttempts || ProviderTimingConfig.GEMINI_RETRY_ATTEMPTS
+    });
+    this.models = {
+      text: ModelDefaults.GEMINI_TEXT,
+      image: ModelDefaults.GEMINI_IMAGE
+    };
+    if (config.models) {
+      this.models = { ...this.models, ...config.models };
+    }
+    this.tiers = mergeTierOverrides(
+      GEMINI_TIERS,
+      config.models ? { balanced: config.models.text } : void 0
+    );
+  }
+  resolveModel(tier) {
+    return resolveModel(this.tiers, tier, this.id);
+  }
+  async healthCheck() {
+    try {
+      if (!this.config.apiKey) {
+        return "unavailable";
+      }
+      const response = await this.fetchWithTimeout(
+        `${this.config.baseUrl}/models`,
+        {
+          method: "GET",
+          headers: this.authHeaders()
+        }
+      );
+      return response.ok ? "healthy" : "unavailable";
+    } catch {
+      return "unavailable";
+    }
+  }
+  async estimateCost(request) {
+    return estimateGeminiGenerationCost(request);
+  }
+  async generate(request) {
+    try {
+      const model = request.model ?? this.resolveModel(request.tier ?? "balanced");
+      const response = await this.withRetry(async () => {
+        return await this.fetchWithTimeout(
+          `${this.config.baseUrl}/models/${model}:generateContent`,
+          {
+            method: "POST",
+            headers: this.authHeaders(),
+            body: JSON.stringify({
+              systemInstruction: request.systemPrompt && request.systemPrompt.length > 0 ? { parts: [{ text: request.systemPrompt }] } : void 0,
+              contents: toGeminiContents(request.messages),
+              generationConfig: {
+                temperature: request.temperature || 0.7,
+                maxOutputTokens: request.maxTokens || 2048,
+                topP: request.topP || 0.9
+              }
+            })
+          }
+        );
+      });
+      if (!response.ok) {
+        throw new Error(`Gemini API error: ${response.statusText}`);
+      }
+      const data = await response.json();
+      const text = data.candidates[0]?.content?.parts?.map((part) => part.text ?? "").join("") ?? "";
+      if (text.length === 0) {
+        throw new AIError2("SERVER_ERROR" /* SERVER_ERROR */, "No content generated from Gemini API", void 0, { model });
+      }
+      return {
+        text,
+        usage: data.usageMetadata ? {
+          inputTokens: data.usageMetadata.promptTokenCount,
+          outputTokens: data.usageMetadata.candidatesTokenCount,
+          totalTokens: data.usageMetadata.totalTokenCount
+        } : void 0,
+        model,
+        providerId: this.id,
+        finishReason: mapGeminiFinishReason(data.candidates[0]?.finishReason)
+      };
+    } catch (error) {
+      if (error instanceof AIError2) throw error;
+      throw new AIError2(
+        "UNKNOWN_ERROR" /* UNKNOWN_ERROR */,
+        `Gemini text generation failed: ${error instanceof Error ? error.message : "Unknown error"}`,
+        error instanceof Error ? error : void 0
+      );
+    }
+  }
+  async generateStructured(request) {
+    const messages = [...request.messages];
+    const lastUserIndex = findLastIndex3(messages, (m) => m.role === "user");
+    if (lastUserIndex === -1) {
+      throw new AIError2(
+        "UNKNOWN_ERROR" /* UNKNOWN_ERROR */,
+        "generateStructured requires at least one user message"
+      );
+    }
+    messages[lastUserIndex] = {
+      role: "user",
+      content: new StructuredPromptBuilder(messages[lastUserIndex].content).withSchema(request.schema).build()
+    };
+    const result = await this.generate({ ...request, messages, temperature: 0.1 });
+    return { value: this.jsonParser.parse(result.text), result };
+  }
+  async stream(request, callbacks) {
+    const result = await this.generate(request);
+    callbacks.onChunk?.(result.text);
+    callbacks.onComplete?.(result);
+    return result;
+  }
+  async generateImage(request) {
+    try {
+      const response = await this.withRetry(async () => {
+        return await this.fetchWithTimeout(
+          `${this.config.baseUrl}/models/${this.models.image}:generateContent`,
+          {
+            method: "POST",
+            headers: this.authHeaders(),
+            body: JSON.stringify({
+              contents: [{
+                parts: [{
+                  text: this.buildImagePrompt(request)
+                }]
+              }]
+            })
+          }
+        );
+      });
+      if (!response.ok) {
+        throw new Error(`Gemini API error: ${response.statusText}`);
+      }
+      const data = await response.json();
+      const imageData = data.candidates[0]?.content?.parts[0]?.inlineData;
+      if (!imageData) {
+        throw new Error("No image data in response");
+      }
+      const url = `data:${imageData.mimeType};base64,${imageData.data}`;
+      return {
+        id: Date.now().toString(),
+        type: "image",
+        url,
+        metadata: {
+          provider: "gemini",
+          model: this.models.image,
+          mimeType: imageData.mimeType
+        },
+        createdAt: (/* @__PURE__ */ new Date()).toISOString()
+      };
+    } catch (error) {
+      throw new Error(`Gemini image generation failed: ${error instanceof Error ? error.message : "Unknown error"}`);
+    }
+  }
+  async generateVideo(_request) {
+    throw new Error("Gemini provider does not support video generation");
+  }
+  async imageToVideo(_request) {
+    throw new Error("Gemini provider does not support image-to-video conversion");
+  }
+  async videoToVideo(_request) {
+    throw new Error("Gemini provider does not support video-to-video conversion");
+  }
+  authHeaders() {
+    return {
+      "Content-Type": "application/json",
+      "x-goog-api-key": this.config.apiKey
+    };
+  }
+  buildImagePrompt(request) {
+    let prompt = request.prompt;
+    if (request.style) {
+      const styles = {
+        realistic: "photorealistic, highly detailed, 8k resolution",
+        cartoon: "cartoon style, colorful, animated",
+        abstract: "abstract art, modern, artistic",
+        minimalist: "minimalist, clean, simple",
+        vintage: "vintage style, retro, classic"
+      };
+      prompt += `, ${styles[request.style]}`;
+    }
+    if (request.quality === "ultra") {
+      prompt += ", ultra high quality, masterpiece";
+    }
+    return prompt;
+  }
+};
+function toGeminiContents(messages) {
+  return messages.filter((message) => message.role !== "system" && message.content.length > 0).map((message) => ({
+    role: message.role === "assistant" ? "model" : "user",
+    parts: [{ text: message.content }]
+  }));
+}
+function mapGeminiFinishReason(reason) {
+  if (reason === "STOP") return "stop";
+  if (reason === "MAX_TOKENS") return "length";
+  if (reason === "SAFETY" || reason === "PROHIBITED_CONTENT") return "content_filter";
+  return void 0;
+}
+function findLastIndex3(items, predicate) {
+  for (let i = items.length - 1; i >= 0; i--) {
+    if (predicate(items[i])) return i;
+  }
+  return -1;
+}
+
+// src/content/domain/predicates/KeywordProminenceClassifier.ts
+var HIGH_DENSITY_THRESHOLD = 2;
+var MEDIUM_DENSITY_THRESHOLD = 1;
+function classifyKeywordProminence(densityPercent) {
+  if (densityPercent > HIGH_DENSITY_THRESHOLD) return "high";
+  if (densityPercent > MEDIUM_DENSITY_THRESHOLD) return "medium";
+  return "low";
+}
+function isUnderutilizedKeyword(densityPercent) {
+  return densityPercent < 1;
+}
+
+// src/content/domain/types/index.ts
+var PLATFORM_SPECS = {
+  twitter: {
+    maxLength: 280,
+    style: "concise, engaging, thread-friendly",
+    emojiSupport: true,
+    hashtagSupport: true,
+    imageSupport: true,
+    videoSupport: true,
+    maxHashtags: 5
+  },
+  linkedin: {
+    maxLength: 3e3,
+    style: "professional, insightful, industry-focused",
+    emojiSupport: true,
+    hashtagSupport: true,
+    imageSupport: true,
+    videoSupport: true,
+    maxHashtags: 5
+  },
+  instagram: {
+    maxLength: 2200,
+    style: "visual, engaging, emoji-rich",
+    emojiSupport: true,
+    hashtagSupport: true,
+    imageSupport: true,
+    videoSupport: true,
+    maxHashtags: 30
+  },
+  threads: {
+    maxLength: 500,
+    style: "conversational, community-driven",
+    emojiSupport: true,
+    hashtagSupport: true,
+    imageSupport: true,
+    videoSupport: true,
+    maxHashtags: 5
+  },
+  tiktok: {
+    maxLength: 150,
+    style: "catchy, trending, short-form",
+    emojiSupport: true,
+    hashtagSupport: true,
+    imageSupport: false,
+    videoSupport: true,
+    maxHashtags: 5
+  },
+  facebook: {
+    maxLength: 63206,
+    style: "conversational, engaging, shareable",
+    emojiSupport: true,
+    hashtagSupport: true,
+    imageSupport: true,
+    videoSupport: true,
+    maxHashtags: 5
+  }
+};
+
+// src/content/domain/predicates/HashtagPriorityRanker.ts
+var DEFAULT_HASHTAG_BUDGET = Number.MAX_SAFE_INTEGER;
+function resolveHashtagBudget(platform) {
+  return PLATFORM_SPECS[platform]?.maxHashtags ?? DEFAULT_HASHTAG_BUDGET;
+}
+function rankAndTrimHashtags(hashtags, budget) {
+  if (hashtags.length <= budget) return [...hashtags];
+  return [...hashtags].sort((a, b) => b.length - a.length).slice(0, budget);
+}
+
+// src/content/domain/predicates/PlatformSpecResolver.ts
+var FALLBACK_SPEC = {
+  maxLength: 280,
+  style: "concise, engaging, audience-friendly",
+  emojiSupport: true,
+  hashtagSupport: true,
+  imageSupport: true,
+  videoSupport: true,
+  maxHashtags: 5
+};
+function resolvePlatformSpec(platform) {
+  return PLATFORM_SPECS[platform] ?? FALLBACK_SPEC;
+}
+function resolveMaxContentLength(platform, override) {
+  return override ?? resolvePlatformSpec(platform).maxLength;
+}
+
+// src/content/domain/predicates/ScoreRangeGuard.ts
+var SCORE_MIN = 0;
+var SCORE_MAX = 100;
+var SCORE_FALLBACK = 50;
+var CONFIDENCE_MIN = 0;
+var CONFIDENCE_MAX = 1;
+var CONFIDENCE_FALLBACK = 0.5;
+function clampScoreToValidRange(score, fallback = SCORE_FALLBACK) {
+  if (!Number.isFinite(score)) return fallback;
+  return Math.max(SCORE_MIN, Math.min(SCORE_MAX, score));
+}
+function clampConfidenceToValidRange(confidence, fallback = CONFIDENCE_FALLBACK) {
+  if (!Number.isFinite(confidence)) return fallback;
+  return Math.max(CONFIDENCE_MIN, Math.min(CONFIDENCE_MAX, confidence));
+}
+
+// src/content/domain/predicates/AbTestConfidence.ts
+var AB_TEST_DEFAULT_CONFIDENCE = 0.7;
+
+// src/content/domain/predicates/FalImageRenderingOptions.ts
+var FAL_FORMAT_TO_IMAGE_SIZE = {
+  square: "square_hd",
+  landscape: "landscape_16_9",
+  portrait: "portrait_9_16",
+  story: "portrait_9_16",
+  banner: "landscape_16_9"
+};
+var FAL_DEFAULT_IMAGE_SIZE = "square_hd";
+var FAL_QUALITY_TO_STEPS = {
+  standard: 4,
+  high: 6,
+  ultra: 8
+};
+var FAL_DEFAULT_QUALITY_STEPS = 6;
+function resolveFalImageSize(format) {
+  if (!format) return FAL_DEFAULT_IMAGE_SIZE;
+  return FAL_FORMAT_TO_IMAGE_SIZE[format] ?? FAL_DEFAULT_IMAGE_SIZE;
+}
+function resolveFalInferenceSteps(quality) {
+  if (!quality) return FAL_DEFAULT_QUALITY_STEPS;
+  return FAL_QUALITY_TO_STEPS[quality] ?? FAL_DEFAULT_QUALITY_STEPS;
+}
+
+// src/providers/fal/fal.provider.ts
+var FalProvider = class extends BaseProvider {
+  id = "fal";
+  name = "FAL";
+  capabilities = ["image", "video"];
+  models;
+  constructor(config) {
+    super({
+      apiKey: config.apiKey,
+      baseUrl: config.baseUrl || "https://queue.fal.run",
+      timeout: config.timeout || ProviderTimingConfig.FAL_TIMEOUT_MS,
+      retryAttempts: config.retryAttempts || ProviderTimingConfig.FAL_RETRY_ATTEMPTS
+    });
+    this.models = {
+      image: ModelDefaults.FAL_IMAGE,
+      video: ModelDefaults.FAL_VIDEO,
+      imageToVideo: ModelDefaults.FAL_IMAGE_TO_VIDEO
+    };
+    if (config.models) {
+      this.models = { ...this.models, ...config.models };
+    }
+  }
+  async healthCheck() {
+    try {
+      if (!this.config.apiKey) {
+        return "unavailable";
+      }
+      const response = await this.fetchWithTimeout(
+        `${this.config.baseUrl}/fal-ai/flux/schnell/status`,
+        {
+          method: "HEAD",
+          headers: {
+            "Authorization": `Key ${this.config.apiKey}`
+          }
+        }
+      );
+      return response.ok ? "healthy" : "degraded";
+    } catch {
+      return "unavailable";
+    }
+  }
+  async estimateCost(request) {
+    return estimateFalGenerationCost();
+  }
+  async generateImage(request) {
+    try {
+      const response = await this.withRetry(async () => {
+        return await this.fetchWithTimeout(
+          `${this.config.baseUrl}/${this.models.image}`,
+          {
+            method: "POST",
+            headers: {
+              "Authorization": `Key ${this.config.apiKey}`,
+              "Content-Type": "application/json"
+            },
+            body: JSON.stringify({
+              prompt: request.prompt,
+              image_size: resolveFalImageSize(request.format),
+              num_inference_steps: resolveFalInferenceSteps(request.quality),
+              num_images: request.quantity || 1
+            })
+          }
+        );
+      });
+      if (!response.ok) {
+        throw new Error(`FAL API error: ${response.statusText}`);
+      }
+      const data = await response.json();
+      if (data.error) {
+        throw new Error(data.error);
+      }
+      return {
+        id: Date.now().toString(),
+        type: "image",
+        url: data.images?.[0]?.url,
+        metadata: {
+          provider: "fal",
+          model: this.models.image
+        },
+        createdAt: (/* @__PURE__ */ new Date()).toISOString()
+      };
+    } catch (error) {
+      throw new Error(`FAL image generation failed: ${error instanceof Error ? error.message : "Unknown error"}`);
+    }
+  }
+  async generateVideo(request) {
+    try {
+      const response = await this.withRetry(async () => {
+        return await this.fetchWithTimeout(
+          `${this.config.baseUrl}/${this.models.video}`,
+          {
+            method: "POST",
+            headers: {
+              "Authorization": `Key ${this.config.apiKey}`,
+              "Content-Type": "application/json"
+            },
+            body: JSON.stringify({
+              prompt: request.prompt,
+              aspect_ratio: request.aspectRatio || "16:9"
+            })
+          }
+        );
+      });
+      if (!response.ok) {
+        throw new Error(`FAL API error: ${response.statusText}`);
+      }
+      const data = await response.json();
+      if (data.error) {
+        throw new Error(data.error);
+      }
+      return {
+        id: Date.now().toString(),
+        type: "video",
+        url: data.video?.url,
+        metadata: {
+          provider: "fal",
+          model: this.models.video
+        },
+        createdAt: (/* @__PURE__ */ new Date()).toISOString()
+      };
+    } catch (error) {
+      throw new Error(`FAL video generation failed: ${error instanceof Error ? error.message : "Unknown error"}`);
+    }
+  }
+  async imageToVideo(request) {
+    try {
+      const response = await this.withRetry(async () => {
+        return await this.fetchWithTimeout(
+          `${this.config.baseUrl}/${this.models.imageToVideo}`,
+          {
+            method: "POST",
+            headers: {
+              "Authorization": `Key ${this.config.apiKey}`,
+              "Content-Type": "application/json"
+            },
+            body: JSON.stringify({
+              image_url: request.imageUrl,
+              motion: request.motion || "medium",
+              prompt: request.prompt
+            })
+          }
+        );
+      });
+      if (!response.ok) {
+        throw new Error(`FAL API error: ${response.statusText}`);
+      }
+      const data = await response.json();
+      if (data.error) {
+        throw new Error(data.error);
+      }
+      return {
+        id: Date.now().toString(),
+        type: "video",
+        url: data.video?.url,
+        metadata: {
+          provider: "fal",
+          model: this.models.imageToVideo
+        },
+        createdAt: (/* @__PURE__ */ new Date()).toISOString()
+      };
+    } catch (error) {
+      throw new Error(`FAL image-to-video failed: ${error instanceof Error ? error.message : "Unknown error"}`);
+    }
+  }
+  async videoToVideo(_request) {
+    throw new Error("FAL provider does not support video-to-video conversion");
+  }
+};
+
+// src/providers/pruna/pruna.provider.ts
+var PrunaProvider = class {
+  constructor(config) {
+    this.config = config;
+  }
+  config;
+  id = "pruna";
+  name = "Pruna AI";
+  capabilities = ["image", "video"];
+  async healthCheck() {
+    return this.config.apiKey ? "healthy" : "unavailable";
+  }
+  async estimateCost(_request) {
+    return 1;
+  }
+  async generateImage(_request) {
+    throw new AIError2("UNKNOWN_ERROR" /* UNKNOWN_ERROR */, "Use generateWithPruna instead");
+  }
+  async generateVideo(_request) {
+    throw new AIError2("UNKNOWN_ERROR" /* UNKNOWN_ERROR */, "Use generateWithPruna instead");
+  }
+  async imageToVideo(_request) {
+    throw new AIError2("UNKNOWN_ERROR" /* UNKNOWN_ERROR */, "Use generateWithPruna instead");
+  }
+  async videoToVideo(_request) {
+    throw new AIError2("UNKNOWN_ERROR" /* UNKNOWN_ERROR */, "Use generateWithPruna instead");
+  }
+};
+
+// src/providers/factory/create-ai.ts
+function createAI(config = {}) {
+  const factory = new ProviderFactory({
+    priority: config.priority,
+    fallbackEnabled: config.fallbackEnabled,
+    defaultTier: config.defaultTier
+  });
+  if (config.anthropic?.apiKey) {
+    factory.register(new AnthropicProvider(config.anthropic));
+  }
+  if (config.groq?.apiKey) {
+    factory.register(new GroqProvider(config.groq));
+  }
+  if (config.gemini?.apiKey) {
+    factory.register(new GeminiProvider({ ...config.gemini, enabled: true }));
+  }
+  if (config.fal?.apiKey) {
+    factory.register(new FalProvider({ ...config.fal, enabled: true }));
+  }
+  if (config.pruna?.apiKey) {
+    factory.register(new PrunaProvider({ ...config.pruna, enabled: true }));
+  }
+  return factory;
+}
+
+// src/content/domain/limits/SpeechPaceConfig.ts
+var SpeechPaceConfig = {
+  WORDS_PER_SECOND: 2.5,
+  TOKENS_PER_SECOND: 10,
+  JSON_TOKEN_OVERHEAD: 500,
+  TOKENS_PER_CALENDAR_DAY: 150
+};
+
+// src/content/domain/calculations/SpeechPaceEstimate.ts
+function estimateWordCountForDuration(durationSeconds) {
+  return Math.floor(durationSeconds * SpeechPaceConfig.WORDS_PER_SECOND);
+}
+function estimateTokenBudgetForDuration(durationSeconds) {
+  return durationSeconds * SpeechPaceConfig.TOKENS_PER_SECOND + SpeechPaceConfig.JSON_TOKEN_OVERHEAD;
+}
+function estimateTokenBudgetForCalendarDays(days) {
+  return days * SpeechPaceConfig.TOKENS_PER_CALENDAR_DAY + SpeechPaceConfig.JSON_TOKEN_OVERHEAD;
+}
+
+// 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/domain/limits/ValidationLimits.ts
+var ValidationLimits = {
+  TOPIC: {
+    MIN: 1,
+    MAX: 500
+  },
+  CONTENT: {
+    MIN: 1,
+    MAX: 1e4
+  },
+  KEYWORD: {
+    MAX_COUNT: 20,
+    MAX_LENGTH: 50
+  },
+  DURATION_SECONDS: {
+    MIN: 10,
+    MAX: 600
+  },
+  CALENDAR_DAYS: {
+    MIN: 1,
+    MAX: 90
+  },
+  HASHTAG_COUNT: {
+    MIN: 1,
+    MAX: 50
+  },
+  SEO_CONTENT_PREVIEW: 500,
+  BLOG_PROMPT_PREVIEW: 1e3,
+  AB_VARIANT_CONTENT_PREVIEW: 200
+};
+
+// src/content/domain/validation/TopicTextValidator.ts
+function validateTopicText(topic) {
+  if (typeof topic !== "string" || topic.trim().length < ValidationLimits.TOPIC.MIN) {
+    throw new ValidationError("Topic cannot be empty");
+  }
+  const trimmed = topic.trim();
+  if (trimmed.length > ValidationLimits.TOPIC.MAX) {
+    throw new ValidationError(`Topic exceeds maximum length of ${ValidationLimits.TOPIC.MAX} characters`);
+  }
+  return trimmed;
+}
+
+// src/content/domain/validation/KeywordListValidator.ts
+function validateKeywordList(keywords) {
+  if (!Array.isArray(keywords)) {
+    throw new ValidationError("Keywords must be an array");
+  }
+  if (keywords.length > ValidationLimits.KEYWORD.MAX_COUNT) {
+    throw new ValidationError(`Cannot process more than ${ValidationLimits.KEYWORD.MAX_COUNT} keywords`);
+  }
+  return keywords.filter((k) => typeof k === "string" && k.trim().length > 0).map((keyword) => {
+    const trimmed = keyword.trim();
+    if (trimmed.length > ValidationLimits.KEYWORD.MAX_LENGTH) {
+      const preview = trimmed.substring(0, 20);
+      throw new ValidationError(
+        `Keyword "${preview}..." exceeds maximum length of ${ValidationLimits.KEYWORD.MAX_LENGTH} characters`
+      );
+    }
+    return trimmed;
+  });
+}
+
+// src/content/domain/utils/IdGenerator.ts
+function generateId(prefix) {
+  const id = typeof crypto !== "undefined" && typeof crypto.randomUUID === "function" ? crypto.randomUUID() : `${Date.now().toString(36)}-${Math.random().toString(36).slice(2, 11)}`;
+  return prefix ? `${prefix}-${id}` : id;
+}
+
+// src/content/application/services/BlogService.ts
+var BlogService = class {
+  constructor(executor) {
+    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/domain/validation/HashtagCountValidator.ts
+function validateHashtagCount(count) {
+  if (!Number.isFinite(count)) {
+    throw new ValidationError(
+      `Hashtag count must be between ${ValidationLimits.HASHTAG_COUNT.MIN} and ${ValidationLimits.HASHTAG_COUNT.MAX}`
+    );
+  }
+  if (count < ValidationLimits.HASHTAG_COUNT.MIN || count > ValidationLimits.HASHTAG_COUNT.MAX) {
+    throw new ValidationError(
+      `Hashtag count must be between ${ValidationLimits.HASHTAG_COUNT.MIN} and ${ValidationLimits.HASHTAG_COUNT.MAX}`
+    );
+  }
+  return Math.floor(count);
+}
+
+// src/content/application/services/SocialService.ts
+var MULTI_PLATFORMS = [
+  "twitter",
+  "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/domain/validation/DurationSecondsValidator.ts
+function validateDurationSeconds(duration) {
+  if (!Number.isFinite(duration)) {
+    throw new ValidationError(
+      `Duration must be between ${ValidationLimits.DURATION_SECONDS.MIN} and ${ValidationLimits.DURATION_SECONDS.MAX} seconds`
+    );
+  }
+  if (duration < ValidationLimits.DURATION_SECONDS.MIN || duration > ValidationLimits.DURATION_SECONDS.MAX) {
+    throw new ValidationError(
+      `Duration must be between ${ValidationLimits.DURATION_SECONDS.MIN} and ${ValidationLimits.DURATION_SECONDS.MAX} seconds`
+    );
+  }
+  return duration;
+}
+
+// src/content/application/services/VideoScriptService.ts
+var buildScriptResult = (parsed, duration) => {
+  const script = parsed.script ?? "";
+  if (!script) {
+    throw new Error("AI response missing script field");
+  }
+  return {
+    ...parsed,
+    script,
+    duration,
+    wordCount: script.split(" ").length
+  };
+};
+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/domain/validation/ContentBodyValidator.ts
+function validateContentBody(content) {
+  if (typeof content !== "string" || content.trim().length < ValidationLimits.CONTENT.MIN) {
+    throw new ValidationError("Content cannot be empty");
+  }
+  const trimmed = content.trim();
+  if (trimmed.length > ValidationLimits.CONTENT.MAX) {
+    throw new ValidationError(`Content exceeds maximum length of ${ValidationLimits.CONTENT.MAX} characters`);
+  }
+  return trimmed;
+}
+function truncateForSeoPreview(content) {
+  return content.substring(0, ValidationLimits.SEO_CONTENT_PREVIEW);
+}
+function truncateForBlogPromptPreview(content) {
+  return content.substring(0, ValidationLimits.BLOG_PROMPT_PREVIEW);
+}
+function truncateForAbVariantPreview(content) {
+  return content.substring(0, ValidationLimits.AB_VARIANT_CONTENT_PREVIEW);
+}
+
+// src/content/application/services/AnalysisService.ts
+var DEFAULT_SENTIMENT = {
+  sentiment: "neutral",
+  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/domain/calculations/SeoKeywordDensity.ts
+function countKeywordOccurrences(content, keyword) {
+  if (!keyword) return 0;
+  const escaped = keyword.replace(/[.*+?^${}()|[\]\\]/g, "\\$&");
+  const matches = content.match(new RegExp(escaped, "gi"));
+  return matches ? matches.length : 0;
+}
+function countWordsInContent(content) {
+  const tokens = content.split(/\s+/).filter(Boolean);
+  return tokens.length || 1;
+}
+function calculateKeywordDensity(content, keyword) {
+  const totalWords = countWordsInContent(content);
+  const occurrences = countKeywordOccurrences(content, keyword);
+  return occurrences / totalWords * 100;
+}
+
+// src/content/application/services/SeoService.ts
+var DEFAULT_SEO_SCORE = {
+  keywordDensity: 50,
+  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);
+    void countWordsInContent(validatedContent);
+    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/domain/calculations/AbTestImprovementRatio.ts
+function calculateImprovementPercentage(scoreA, scoreB) {
+  const higher = Math.max(scoreA, scoreB);
+  const lower = Math.min(scoreA, scoreB);
+  if (lower <= 0) {
+    return "100";
+  }
+  const delta = (higher / lower - 1) * 100;
+  return Math.abs(delta).toFixed(0);
+}
+function selectHigherScoreVariantId(scoreA, scoreB, idA = "A", idB = "B") {
+  return scoreA > scoreB ? idA : idB;
+}
+
+// src/content/application/services/ABTestService.ts
+var DEFAULT_PREDICTION = {
+  variantId: "",
+  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 winner = selectHigherScoreVariantId(scoreA, scoreB, VARIANT_A_ID, VARIANT_B_ID);
+    const improvement = calculateImprovementPercentage(scoreA, scoreB);
+    return {
+      winner,
+      confidence: AB_TEST_DEFAULT_CONFIDENCE,
+      improvement: `+${improvement}% engagement`,
+      reasoning: winner === VARIANT_A_ID ? "Variant A has more engaging content" : "Variant B has more engaging content",
+      recommendations: [...DEFAULT_RECOMMENDATIONS]
+    };
+  }
+};
+
+// src/content/infrastructure/utils/jsonParser.ts
+function repairCommonJsonDefects(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(repairCommonJsonDefects(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/ImagePromptService.ts
+var JSON_ARRAY_PATTERN = /\[[\s\S]*\]/;
+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 response = await this.executor.runText(prompt, { maxTokens: 500, temperature: 0.8 });
+    const jsonMatch = response.match(JSON_ARRAY_PATTERN);
+    if (!jsonMatch) return [];
+    return safeJSONParse(jsonMatch[0], []);
+  }
+};
+
+// src/content/domain/validation/CalendarDaysValidator.ts
+function validateCalendarDays(days) {
+  if (!Number.isFinite(days)) {
+    throw new ValidationError(
+      `Days must be between ${ValidationLimits.CALENDAR_DAYS.MIN} and ${ValidationLimits.CALENDAR_DAYS.MAX}`
+    );
+  }
+  if (days < ValidationLimits.CALENDAR_DAYS.MIN || days > ValidationLimits.CALENDAR_DAYS.MAX) {
+    throw new ValidationError(
+      `Days must be between ${ValidationLimits.CALENDAR_DAYS.MIN} and ${ValidationLimits.CALENDAR_DAYS.MAX}`
+    );
+  }
+  return days;
+}
+
+// src/content/domain/calculations/ContentCalendarDateOffset.ts
+var ONE_DAY_MS = 24 * 60 * 60 * 1e3;
+function resolveCalendarEntryDate(dayIndex, baseTimestamp = Date.now()) {
+  return new Date(baseTimestamp + (dayIndex - 1) * ONE_DAY_MS);
+}
+
+// src/content/application/services/ContentCalendarService.ts
+var toCalendarEntry = (item) => ({
+  date: resolveCalendarEntryDate(item.day),
+  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
+    });
+    return data.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/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 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: modern.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);
+  }
+};
+
+exports.ABTestService = ABTestService;
+exports.AIContentService = AIContentService;
+exports.AIError = AIError;
+exports.ASPECT_RATIO_OPTIONS = ASPECT_RATIO_OPTIONS;
+exports.ASPECT_RATIO_VALUES = ASPECT_RATIO_VALUES;
+exports.AnalysisService = AnalysisService;
+exports.BlogService = BlogService;
+exports.ContentCalendarService = ContentCalendarService;
+exports.GENERATION_COSTS = CREDIT_COSTS;
+exports.GenerationExecutor = GenerationExecutor;
+exports.IMAGE_QUALITY_OPTIONS = IMAGE_QUALITY_OPTIONS;
+exports.IMAGE_QUALITY_VALUES = IMAGE_QUALITY_VALUES;
+exports.ImagePromptService = ImagePromptService;
+exports.MOTION_OPTIONS = MOTION_OPTIONS;
+exports.MediaGenerationService = MediaGenerationService;
+exports.PromptBuilder = PromptBuilder;
+exports.ProviderQuotaExhaustedError = ProviderQuotaExhaustedError;
+exports.ProviderUnavailableError = ProviderUnavailableError;
+exports.STYLE_PRESETS = STYLE_PRESETS;
+exports.SeoService = SeoService;
+exports.SocialService = SocialService;
+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.ValidationError = ValidationError;
+exports.VideoScriptService = VideoScriptService;
+exports.calculateCreditCost = calculateContentCreditCost;
+exports.getDimensionsForAspectRatio = getDimensionsForAspectRatio;
+exports.getRecommendedQuality = getRecommendedQuality;
+//# sourceMappingURL=index.cjs.map
+//# sourceMappingURL=index.cjs.map