@umituz/web-ai 1.0.2 → 1.0.4

package/dist/index.js

@@ -1082,6 +1082,26 @@ function isMediaProvider(provider) {
   return provider.capabilities.includes("image") || provider.capabilities.includes("video");
 }
 
+// src/content/domain/errors/AIErrors.ts
+var ValidationError = class extends AIError {
+  constructor(message) {
+    super(message, "VALIDATION_ERROR");
+    this.name = "ValidationError";
+  }
+};
+var ProviderUnavailableError = class extends AIError {
+  constructor(providerId) {
+    super(`Provider ${providerId} is not available`, "PROVIDER_UNAVAILABLE");
+    this.name = "ProviderUnavailableError";
+  }
+};
+var ProviderQuotaExhaustedError = class extends AIError {
+  constructor(providerId) {
+    super(`Provider ${providerId} quota exhausted`, "PROVIDER_QUOTA_EXHAUSTED");
+    this.name = "ProviderQuotaExhaustedError";
+  }
+};
+
 // src/content/domain/limits/ProviderTimingConfig.ts
 var ProviderTimingConfig = {
   DEFAULT_TIMEOUT_MS: 3e4,
@@ -1424,6 +1444,9 @@ var ProviderFactory = class {
     );
   }
 };
+function createProviderFactory(config) {
+  return new ProviderFactory(config);
+}
 
 // src/providers/anthropic/anthropic.constants.ts
 var ANTHROPIC_MODELS = {
@@ -2453,6 +2476,9 @@ function toGroqMessages(messages, systemPrompt) {
   }
   return wire;
 }
+function createGroqProvider(config) {
+  return new GroqProvider(config);
+}
 function findLastIndex2(items, predicate) {
   for (let i = items.length - 1; i >= 0; i--) {
     if (predicate(items[i])) return i;
@@ -2719,6 +2745,128 @@ function createGeminiProvider(config) {
   return new GeminiProvider(config);
 }
 
+// src/content/domain/predicates/KeywordProminenceClassifier.ts
+var HIGH_DENSITY_THRESHOLD = 2;
+var MEDIUM_DENSITY_THRESHOLD = 1;
+function classifyKeywordProminence(densityPercent) {
+  if (densityPercent > HIGH_DENSITY_THRESHOLD) return "high";
+  if (densityPercent > MEDIUM_DENSITY_THRESHOLD) return "medium";
+  return "low";
+}
+function isUnderutilizedKeyword(densityPercent) {
+  return densityPercent < 1;
+}
+
+// src/content/domain/types/index.ts
+var PLATFORM_SPECS = {
+  twitter: {
+    maxLength: 280,
+    style: "concise, engaging, thread-friendly",
+    emojiSupport: true,
+    hashtagSupport: true,
+    imageSupport: true,
+    videoSupport: true,
+    maxHashtags: 5
+  },
+  linkedin: {
+    maxLength: 3e3,
+    style: "professional, insightful, industry-focused",
+    emojiSupport: true,
+    hashtagSupport: true,
+    imageSupport: true,
+    videoSupport: true,
+    maxHashtags: 5
+  },
+  instagram: {
+    maxLength: 2200,
+    style: "visual, engaging, emoji-rich",
+    emojiSupport: true,
+    hashtagSupport: true,
+    imageSupport: true,
+    videoSupport: true,
+    maxHashtags: 30
+  },
+  threads: {
+    maxLength: 500,
+    style: "conversational, community-driven",
+    emojiSupport: true,
+    hashtagSupport: true,
+    imageSupport: true,
+    videoSupport: true,
+    maxHashtags: 5
+  },
+  tiktok: {
+    maxLength: 150,
+    style: "catchy, trending, short-form",
+    emojiSupport: true,
+    hashtagSupport: true,
+    imageSupport: false,
+    videoSupport: true,
+    maxHashtags: 5
+  },
+  facebook: {
+    maxLength: 63206,
+    style: "conversational, engaging, shareable",
+    emojiSupport: true,
+    hashtagSupport: true,
+    imageSupport: true,
+    videoSupport: true,
+    maxHashtags: 5
+  }
+};
+
+// src/content/domain/predicates/HashtagPriorityRanker.ts
+var DEFAULT_HASHTAG_BUDGET = Number.MAX_SAFE_INTEGER;
+function resolveHashtagBudget(platform) {
+  return PLATFORM_SPECS[platform]?.maxHashtags ?? DEFAULT_HASHTAG_BUDGET;
+}
+function rankAndTrimHashtags(hashtags, budget) {
+  if (hashtags.length <= budget) return [...hashtags];
+  return [...hashtags].sort((a, b) => b.length - a.length).slice(0, budget);
+}
+
+// src/content/domain/predicates/QualityRecommenderByRatio.ts
+var WIDE_RATIOS = /* @__PURE__ */ new Set(["16:9", "4:3"]);
+function recommendQualityForAspectRatio(ratio) {
+  return WIDE_RATIOS.has(ratio) ? "hd" : "standard";
+}
+
+// src/content/domain/predicates/PlatformSpecResolver.ts
+var FALLBACK_SPEC = {
+  maxLength: 280,
+  style: "concise, engaging, audience-friendly",
+  emojiSupport: true,
+  hashtagSupport: true,
+  imageSupport: true,
+  videoSupport: true,
+  maxHashtags: 5
+};
+function resolvePlatformSpec(platform) {
+  return PLATFORM_SPECS[platform] ?? FALLBACK_SPEC;
+}
+function resolveMaxContentLength(platform, override) {
+  return override ?? resolvePlatformSpec(platform).maxLength;
+}
+
+// src/content/domain/predicates/ScoreRangeGuard.ts
+var SCORE_MIN = 0;
+var SCORE_MAX = 100;
+var SCORE_FALLBACK = 50;
+var CONFIDENCE_MIN = 0;
+var CONFIDENCE_MAX = 1;
+var CONFIDENCE_FALLBACK = 0.5;
+function clampScoreToValidRange(score, fallback = SCORE_FALLBACK) {
+  if (!Number.isFinite(score)) return fallback;
+  return Math.max(SCORE_MIN, Math.min(SCORE_MAX, score));
+}
+function clampConfidenceToValidRange(confidence, fallback = CONFIDENCE_FALLBACK) {
+  if (!Number.isFinite(confidence)) return fallback;
+  return Math.max(CONFIDENCE_MIN, Math.min(CONFIDENCE_MAX, confidence));
+}
+
+// src/content/domain/predicates/AbTestConfidence.ts
+var AB_TEST_DEFAULT_CONFIDENCE = 0.7;
+
 // src/content/domain/predicates/FalImageRenderingOptions.ts
 var FAL_FORMAT_TO_IMAGE_SIZE = {
   square: "square_hd",
@@ -2915,674 +3063,2973 @@ function createFalProvider(config) {
   return new FalProvider(config);
 }
 
-// src/providers/pruna/pruna-generate.ts
-var prunaCorePromise = null;
-async function loadPrunaCore() {
-  if (!prunaCorePromise) {
-    const specifier = "@umituz/pruna-provider/core";
-    prunaCorePromise = import(specifier);
+// src/providers/pruna/client/core/constants/limits.ts
+var DEFAULT_ASPECT_RATIO = "16:9";
+var P_VIDEO_DEFAULTS = {
+  duration: 5,
+  resolution: "720p",
+  fps: 24,
+  draft: false,
+  promptUpsampling: true
+};
+var POLL_DEFAULTS = {
+  intervalMs: 3e3,
+  maxAttempts: 120,
+  maxIntervalMs: 1e4,
+  backoffBase: 1.5,
+  jitterPercent: 0.1
+};
+var DEFAULT_DEDUPLICATOR_TTL_MS = 3e4;
+var DEDUPLICATOR_CLEANUP_GRACE_MS = 100;
+
+// src/providers/pruna/client/core/constants/network.ts
+var HTTPS_PREFIX = "https://";
+var HTTP_PREFIX = "http://";
+var BASE64_MARKER = "base64,";
+var PRUNA_BASE_URL = "https://api.pruna.ai";
+var PRUNA_PREDICTIONS_URL = `${PRUNA_BASE_URL}/v1/predictions`;
+var PRUNA_FILES_URL = `${PRUNA_BASE_URL}/v1/files`;
+var AUTH_FAILURE_STATUSES = [401, 403];
+var MIN_API_KEY_LENGTH = 1;
+var MAX_API_KEY_LENGTH = 256;
+
+// src/providers/pruna/client/core/constants/mime-types.ts
+var MIME_PNG = "image/png";
+var MIME_JPEG = "image/jpeg";
+var MIME_WEBP = "image/webp";
+var DEFAULT_IMAGE_MIME = MIME_PNG;
+var MIME_FILE_EXTENSION = {
+  [MIME_PNG]: "png",
+  [MIME_JPEG]: "jpg",
+  [MIME_WEBP]: "webp"
+};
+var IMAGE_SIGNATURES = {
+  PNG: [137, 80],
+  JPEG: [255, 216],
+  WEBP_RIFF: [82, 73]
+};
+
+// src/providers/pruna/client/core/errors/cancellation-error.ts
+var CANCELLATION_MESSAGE = "Request cancelled by user";
+var CancellationError = class extends Error {
+  constructor(message = CANCELLATION_MESSAGE) {
+    super(message);
+    this.name = "CancellationError";
+  }
+};
+
+// src/providers/pruna/client/core/errors/authentication-error.ts
+var AUTHENTICATION_MESSAGE = "Authentication failed. Please check your API key.";
+var AuthenticationError = class extends Error {
+  constructor(message = AUTHENTICATION_MESSAGE) {
+    super(message);
+    this.name = "AuthenticationError";
+  }
+};
+
+// src/providers/pruna/client/core/errors/timeout-error.ts
+var TIMEOUT_MESSAGE = "Generation timed out. Maximum polling attempts reached.";
+var TimeoutError = class extends Error {
+  constructor(message = TIMEOUT_MESSAGE) {
+    super(message);
+    this.name = "TimeoutError";
+  }
+};
+
+// src/providers/pruna/client/core/errors/validation-error.ts
+var ValidationError2 = class extends Error {
+  field;
+  reason;
+  receivedValue;
+  constructor(context) {
+    super(`Invalid ${context.field}: ${context.reason}`);
+    this.name = "ValidationError";
+    this.field = context.field;
+    this.reason = context.reason;
+    this.receivedValue = context.receivedValue;
+  }
+};
+
+// src/providers/pruna/client/core/utils/base64.ts
+var globalScope = globalThis;
+var hasBuffer = typeof globalScope.Buffer?.from === "function";
+function base64ToBytes(raw) {
+  if (hasBuffer) {
+    const bufferFactory = globalScope.Buffer;
+    if (!bufferFactory) {
+      throw new Error("Buffer unavailable despite detection flag");
+    }
+    const buf = bufferFactory.from(raw, "base64");
+    return new Uint8Array(buf.buffer, buf.byteOffset, buf.byteLength);
   }
-  return prunaCorePromise;
+  const decoded = atob(raw);
+  return Uint8Array.from(decoded, (char) => char.charCodeAt(0));
 }
-async function* generateWithPruna(request, apiKey, signal, onProgress) {
-  const prunaCore = await loadPrunaCore();
-  if (prunaCore.generateWithPruna) {
-    yield* prunaCore.generateWithPruna(request, apiKey, signal, onProgress);
-    return;
-  }
-  if (!prunaCore.submitPrediction || !prunaCore.pollForResult) {
-    throw new Error("@umituz/pruna-provider/core does not export required functions");
-  }
-  const modelId = request.model || (request.image ? "p-image-edit" : "p-image");
-  const prediction = await prunaCore.submitPrediction(modelId, request, apiKey, signal, onProgress);
-  if (prediction.output && typeof prediction.output === "object" && "url" in prediction.output) {
-    yield {
-      stage: "predicting",
-      result: { url: prediction.output.url, model: modelId }
-    };
-    return;
+
+// src/providers/pruna/client/core/utils/mime-detector.ts
+var MIN_SIGNATURE_BYTES = 2;
+function matchesSignature(bytes, signature) {
+  if (bytes.length < signature.length) return false;
+  return signature.every((value, index) => bytes[index] === value);
+}
+function detectImageMime(bytes) {
+  if (bytes.length < MIN_SIGNATURE_BYTES) return DEFAULT_IMAGE_MIME;
+  if (matchesSignature(bytes, IMAGE_SIGNATURES.PNG)) return MIME_PNG;
+  if (matchesSignature(bytes, IMAGE_SIGNATURES.JPEG)) return MIME_JPEG;
+  if (matchesSignature(bytes, IMAGE_SIGNATURES.WEBP_RIFF)) return MIME_WEBP;
+  return DEFAULT_IMAGE_MIME;
+}
+
+// src/providers/pruna/client/core/utils/api-error-parser.ts
+async function parseApiError(response, fallback) {
+  const payload = await response.json().catch(() => ({ message: response.statusText }));
+  const message = payload.message ?? `${fallback}: ${response.status}`;
+  const error = new Error(message);
+  error.statusCode = response.status;
+  return error;
+}
+
+// src/providers/pruna/client/core/protocol/http-status.ts
+function isAuthFailureStatus(status) {
+  return AUTH_FAILURE_STATUSES.includes(status);
+}
+
+// src/providers/pruna/client/core/protocol/job-status.ts
+var TERMINAL_SUCCESS_STATUSES = ["succeeded", "completed"];
+var TERMINAL_FAILURE_STATUSES = ["failed"];
+function isTerminalSuccessStatus(status) {
+  if (!status) return false;
+  return TERMINAL_SUCCESS_STATUSES.includes(status);
+}
+function isTerminalFailureStatus(status) {
+  if (!status) return false;
+  return TERMINAL_FAILURE_STATUSES.includes(status);
+}
+
+// src/providers/pruna/client/core/protocol/abort-signal-classifier.ts
+function isAbortError(err) {
+  if (err instanceof DOMException && err.code === DOMException.ABORT_ERR) return true;
+  if (err instanceof Error && err.name === "AbortError") return true;
+  return false;
+}
+
+// src/providers/pruna/client/core/protocol/pruna-url-builder.ts
+function isAbsoluteHttpUrl(value) {
+  return value.startsWith(HTTPS_PREFIX) || value.startsWith(HTTP_PREFIX);
+}
+function isHttpsUrl(value) {
+  return value.startsWith(HTTPS_PREFIX);
+}
+function buildPrunaApiUrl(pathOrUrl) {
+  if (isAbsoluteHttpUrl(pathOrUrl)) return pathOrUrl;
+  return `${PRUNA_BASE_URL}${pathOrUrl}`;
+}
+function buildFileUrlById(fileId) {
+  return `${PRUNA_FILES_URL}/${fileId}`;
+}
+
+// src/providers/pruna/client/core/math/exponential-backoff.ts
+function calculateExponentialBackoff2(inputs) {
+  const {
+    attempt,
+    baseIntervalMs,
+    maxIntervalMs = POLL_DEFAULTS.maxIntervalMs,
+    jitterPercent = POLL_DEFAULTS.jitterPercent,
+    growthBase = POLL_DEFAULTS.backoffBase
+  } = inputs;
+  const safeAttempt = Math.max(0, attempt);
+  const safeBase = Math.max(0, baseIntervalMs);
+  const exponentialDelay = Math.min(safeBase * Math.pow(growthBase, safeAttempt), maxIntervalMs);
+  const jitter = exponentialDelay * jitterPercent * Math.random();
+  return exponentialDelay + jitter;
+}
+
+// src/providers/pruna/client/core/utils/uri-resolver.ts
+var uriCache = /* @__PURE__ */ new WeakMap();
+function stripBase64Prefix(image) {
+  if (isHttpsUrl(image)) return image;
+  const base64Index = image.indexOf(BASE64_MARKER);
+  return base64Index !== -1 ? image.slice(base64Index + BASE64_MARKER.length) : image;
+}
+function readOutput(output) {
+  if (typeof output === "string") return output;
+  if (Array.isArray(output) && output.length > 0) return output[0] ?? null;
+  if (output !== null && typeof output === "object" && "url" in output) {
+    return output.url;
   }
-  const pollUrl = prediction.status_url || prediction.generation_url;
-  if (!pollUrl) {
-    throw new Error("Pruna prediction response missing polling URL");
+  return null;
+}
+function extractUri(data) {
+  const cached = uriCache.get(data);
+  if (cached !== void 0) return cached;
+  if (!isTerminalSuccessStatus(data.status)) {
+    uriCache.set(data, null);
+    return null;
   }
-  const resultUrl = await prunaCore.pollForResult(pollUrl, apiKey, 60, 2e3, signal, onProgress);
-  yield { stage: "polling", result: { url: resultUrl, model: modelId } };
+  const result = data.generation_url ?? readOutput(data.output) ?? data.video_url ?? data.data ?? null;
+  uriCache.set(data, result);
+  return result;
+}
+function resolveUri(uri) {
+  return uri.startsWith("/") ? `${PRUNA_BASE_URL}${uri}` : uri;
 }
 
-// src/providers/pruna/pruna.provider.ts
-var PrunaProvider = class {
-  constructor(config) {
-    this.config = config;
+// src/providers/pruna/client/core/services/pruna-client.service.ts
+function buildFileExtension(mime) {
+  return MIME_FILE_EXTENSION[mime] ?? "bin";
+}
+async function uploadImage(base64OrUrl, apiKey, onProgress) {
+  if (isHttpsUrl(base64OrUrl)) return base64OrUrl;
+  if (base64OrUrl.startsWith(HTTP_PREFIX)) {
+    throw new Error("Only HTTPS URLs are supported for security.");
+  }
+  onProgress?.("uploading");
+  const raw = stripBase64Prefix(base64OrUrl);
+  let bytes;
+  try {
+    bytes = base64ToBytes(raw);
+  } catch {
+    throw new Error("Invalid image format. Provide base64 or a valid HTTPS URL.");
   }
-  config;
-  id = "pruna";
-  name = "Pruna AI";
-  capabilities = ["image", "video"];
-  async healthCheck() {
-    return this.config.apiKey ? "healthy" : "unavailable";
+  const mime = detectImageMime(bytes);
+  const buffer = bytes.buffer.slice(
+    bytes.byteOffset,
+    bytes.byteOffset + bytes.byteLength
+  );
+  const blob = new Blob([buffer], { type: mime });
+  const formData = new FormData();
+  formData.append("content", blob, `upload.${buildFileExtension(mime)}`);
+  const res = await fetch(PRUNA_FILES_URL, {
+    method: "POST",
+    headers: { apikey: apiKey },
+    body: formData
+  });
+  if (!res.ok) {
+    throw await parseApiError(res, "File upload error");
   }
-  async estimateCost(_request) {
-    return 1;
+  const data = await res.json();
+  return data.urls?.get ?? buildFileUrlById(data.id ?? "");
+}
+async function submitPrediction(model, input, apiKey, signal, onProgress) {
+  onProgress?.("predicting");
+  const res = await fetch(PRUNA_PREDICTIONS_URL, {
+    method: "POST",
+    headers: {
+      apikey: apiKey,
+      Model: model,
+      "Try-Sync": "true",
+      "Content-Type": "application/json"
+    },
+    body: JSON.stringify({ input }),
+    signal
+  });
+  if (!res.ok) {
+    throw await parseApiError(res, "API error");
   }
-  async generateImage(request) {
-    let finalUrl;
-    const model = this.config.models?.textToImage;
-    for await (const stage of generateWithPruna(
-      { prompt: request.prompt, model, quality: request.quality },
-      this.config.apiKey
-    )) {
-      if (stage.error) throw stage.error;
-      if (stage.result?.url) finalUrl = stage.result.url;
-    }
-    if (!finalUrl) {
-      throw new AIError("SERVER_ERROR" /* SERVER_ERROR */, "No image generated by Pruna AI");
-    }
-    return {
-      id: Date.now().toString(),
-      type: "image",
-      url: finalUrl,
-      metadata: { provider: this.id, model: model ?? "p-image" },
-      createdAt: (/* @__PURE__ */ new Date()).toISOString()
-    };
+  return res.json();
+}
+var GenerationFailedError = class extends Error {
+  constructor(message) {
+    super(message);
+    this.name = "GenerationFailedError";
   }
-  async generateVideo(request) {
-    let finalUrl;
-    const model = this.config.models?.textToVideo;
-    for await (const stage of generateWithPruna(
-      { prompt: request.prompt, model, duration: request.duration, aspectRatio: request.aspectRatio },
-      this.config.apiKey
-    )) {
-      if (stage.error) throw stage.error;
-      if (stage.result?.url) finalUrl = stage.result.url;
-    }
-    if (!finalUrl) {
-      throw new AIError("SERVER_ERROR" /* SERVER_ERROR */, "No video generated by Pruna AI");
-    }
-    return {
-      id: Date.now().toString(),
-      type: "video",
-      url: finalUrl,
-      metadata: { provider: this.id, model: model ?? "p-video" },
-      createdAt: (/* @__PURE__ */ new Date()).toISOString()
-    };
+};
+async function attemptPoll(fullUrl, apiKey, signal) {
+  let res;
+  try {
+    res = await fetch(fullUrl, { headers: { apikey: apiKey }, signal });
+  } catch (err) {
+    if (isAbortError(err)) throw new CancellationError();
+    return { outcome: "transient-failure" };
   }
-  async imageToVideo(request) {
-    let finalUrl;
-    for await (const stage of generateWithPruna(
-      { image: request.imageUrl, prompt: request.prompt, duration: request.duration, motion: request.motion },
-      this.config.apiKey
-    )) {
-      if (stage.error) throw stage.error;
-      if (stage.result?.url) finalUrl = stage.result.url;
-    }
-    if (!finalUrl) {
-      throw new AIError("SERVER_ERROR" /* SERVER_ERROR */, "No video generated from image by Pruna AI");
+  if (!res.ok) {
+    if (isAuthFailureStatus(res.status)) throw new AuthenticationError();
+    return { outcome: "transient-failure" };
+  }
+  let data;
+  try {
+    data = await res.json();
+  } catch {
+    return { outcome: "transient-failure" };
+  }
+  if (isTerminalSuccessStatus(data.status)) {
+    const uri = extractUri(data);
+    if (uri) return { outcome: "succeeded", uri: resolveUri(uri) };
+    return { outcome: "transient-failure" };
+  }
+  if (isTerminalFailureStatus(data.status)) {
+    throw new GenerationFailedError(data.error ?? "Generation failed during processing.");
+  }
+  return { outcome: "continue" };
+}
+async function pollForResult(pollUrl, apiKey, maxAttempts = POLL_DEFAULTS.maxAttempts, intervalMs = POLL_DEFAULTS.intervalMs, signal, onProgress) {
+  const fullUrl = isAbsoluteHttpUrl(pollUrl) ? pollUrl : buildPrunaApiUrl(pollUrl);
+  const controller = new AbortController();
+  const onExternalAbort = () => controller.abort();
+  signal?.addEventListener("abort", onExternalAbort);
+  try {
+    for (let i = 0; i < maxAttempts; i++) {
+      if (signal?.aborted) throw new CancellationError();
+      const delay = calculateExponentialBackoff2({ attempt: i, baseIntervalMs: intervalMs });
+      await new Promise((resolve) => setTimeout(resolve, delay));
+      if (signal?.aborted) throw new CancellationError();
+      onProgress?.("polling", i + 1);
+      const result = await attemptPoll(fullUrl, apiKey, controller.signal);
+      if (result.outcome === "succeeded" && result.uri) {
+        return result.uri;
+      }
     }
-    return {
-      id: Date.now().toString(),
-      type: "video",
-      url: finalUrl,
-      metadata: { provider: this.id, model: "p-image-to-video" },
-      createdAt: (/* @__PURE__ */ new Date()).toISOString()
-    };
+    throw new TimeoutError();
+  } finally {
+    signal?.removeEventListener("abort", onExternalAbort);
+    controller.abort();
   }
-  async videoToVideo(_request) {
-    throw new AIError("CLIENT_ERROR" /* CLIENT_ERROR */, "Pruna AI provider does not support video-to-video conversion");
+}
+
+// src/providers/pruna/client/core/math/comparison-hash.ts
+function sortKeysDeep(value) {
+  if (Array.isArray(value)) {
+    return value.map(sortKeysDeep);
+  }
+  if (value !== null && typeof value === "object") {
+    const record = value;
+    return Object.keys(record).sort().reduce((acc, key) => {
+      acc[key] = sortKeysDeep(record[key]);
+      return acc;
+    }, {});
   }
-};
-function createPrunaProvider(config) {
-  return new PrunaProvider(config);
+  return value;
+}
+function hashValue(value) {
+  if (value === null || typeof value !== "object") {
+    return String(value);
+  }
+  try {
+    return JSON.stringify(sortKeysDeep(value));
+  } catch {
+    return String(value);
+  }
+}
+function compositeHash(...values) {
+  return values.map(hashValue).join("|");
 }
 
-// src/providers/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));
+// src/providers/pruna/client/core/math/cache-key-derivation.ts
+function deriveGenerationCacheKey(apiKey, input) {
+  return `${apiKey}:${compositeHash(input)}`;
+}
+
+// src/providers/pruna/client/core/validation/api-key-validator.ts
+function assertValidApiKey(apiKey) {
+  if (typeof apiKey !== "string") {
+    throw new ValidationError2({
+      field: "apiKey",
+      reason: "must be a string",
+      receivedValue: typeof apiKey
+    });
   }
-  if (config.groq?.apiKey) {
-    factory.register(new GroqProvider(config.groq));
+  if (apiKey.length < MIN_API_KEY_LENGTH) {
+    throw new ValidationError2({
+      field: "apiKey",
+      reason: "must not be empty",
+      receivedValue: apiKey
+    });
   }
-  if (config.gemini?.apiKey) {
-    factory.register(new GeminiProvider({ ...config.gemini, enabled: true }));
+  if (apiKey.length > MAX_API_KEY_LENGTH) {
+    throw new ValidationError2({
+      field: "apiKey",
+      reason: `exceeds maximum length of ${MAX_API_KEY_LENGTH}`,
+      receivedValue: apiKey.length
+    });
   }
-  if (config.fal?.apiKey) {
-    factory.register(new FalProvider({ ...config.fal, enabled: true }));
+}
+
+// src/providers/pruna/client/core/validation/image-source-validator.ts
+function classifyImageSource(source) {
+  if (source.startsWith(HTTPS_PREFIX)) return "https-url";
+  if (source.startsWith(HTTP_PREFIX)) return "http-url";
+  if (source.includes(BASE64_MARKER) || /^[A-Za-z0-9+/=]+$/.test(source)) return "base64";
+  return "unknown";
+}
+function assertSecureImageSource(image, fieldName = "image") {
+  if (typeof image !== "string") {
+    throw new ValidationError2({
+      field: fieldName,
+      reason: "must be a string",
+      receivedValue: typeof image
+    });
   }
-  if (config.pruna?.apiKey) {
-    factory.register(new PrunaProvider({ ...config.pruna, enabled: true }));
+  const kind = classifyImageSource(image);
+  if (kind === "http-url") {
+    throw new ValidationError2({
+      field: fieldName,
+      reason: "HTTP URLs are not supported; use HTTPS or a base64 data URI",
+      receivedValue: image
+    });
+  }
+  if (kind === "unknown") {
+    throw new ValidationError2({
+      field: fieldName,
+      reason: "must be an HTTPS URL or a base64 data URI",
+      receivedValue: typeof image
+    });
   }
-  return factory;
 }
 
-// src/providers/groq/groq-messages.ts
-var createUserMessage = (content) => ({
-  role: "user",
-  content
-});
-var createAssistantMessage = (content) => ({
-  role: "assistant",
-  content
-});
-var createSystemMessage = (content) => ({
-  role: "system",
-  content
-});
-var createMessage = (role, content) => ({
-  role,
-  content
-});
-var promptToMessages = (prompt) => [
-  createUserMessage(prompt)
+// src/providers/pruna/client/core/validation/aspect-ratio-validator.ts
+var SUPPORTED_ASPECT_RATIOS = [
+  "16:9",
+  "9:16",
+  "1:1",
+  "4:3",
+  "3:4",
+  "3:2",
+  "2:3"
 ];
-var extractTextFromMessages = (messages) => messages.map((m) => m.content).join("\n\n");
-var formatMessagesForDisplay = (messages) => messages.map((m) => `[${m.role.toUpperCase()}]: ${m.content}`).join("\n\n---\n\n");
+function isSupportedAspectRatio(value) {
+  return typeof value === "string" && SUPPORTED_ASPECT_RATIOS.includes(value);
+}
+function assertValidAspectRatio(value, fieldName = "aspect_ratio") {
+  if (value === void 0 || value === null) return;
+  if (!isSupportedAspectRatio(value)) {
+    throw new ValidationError2({
+      field: fieldName,
+      reason: `must be one of ${SUPPORTED_ASPECT_RATIOS.join(", ")}`,
+      receivedValue: value
+    });
+  }
+}
 
-// src/providers/groq/groq-structured-json.ts
-async function requestStructuredJson(client, request) {
-  const chatRequest = {
-    model: request.model,
-    messages: [createUserMessage(request.instructions)],
-    temperature: request.temperature,
-    max_tokens: request.maxTokens,
-    response_format: { type: "json_object" },
-    ...request.reasoningEffort !== void 0 ? { reasoning_effort: request.reasoningEffort } : {}
-  };
-  const response = await client.postChatCompletion(chatRequest);
-  const content = response.choices[0]?.message?.content ?? "";
-  const candidate = extractJsonCandidate(content);
-  try {
-    return JSON.parse(candidate);
-  } catch (err) {
-    throw new GroqError(
-      "UNKNOWN_ERROR" /* UNKNOWN_ERROR */,
-      "model response contained no parsable json object",
-      err instanceof Error ? err : void 0
-    );
+// src/providers/pruna/client/core/validation/resolution-validator.ts
+var SUPPORTED_RESOLUTIONS = ["720p", "1080p"];
+function isSupportedResolution(value) {
+  return typeof value === "string" && SUPPORTED_RESOLUTIONS.includes(value);
+}
+function assertValidResolution(value, fieldName = "resolution") {
+  if (value === void 0 || value === null) return;
+  if (!isSupportedResolution(value)) {
+    throw new ValidationError2({
+      field: fieldName,
+      reason: `must be one of ${SUPPORTED_RESOLUTIONS.join(", ")}`,
+      receivedValue: value
+    });
   }
 }
 
-// src/providers/groq/text-generation.service.ts
-var STRUCTURED_OUTPUT_TEMPERATURE = 0.1;
-var TextGenerationService = class {
-  constructor(httpClient, cache = new CacheManager(), defaultModel = DEFAULT_MODELS.TEXT) {
-    this.httpClient = httpClient;
-    this.cache = cache;
-    this.defaultModel = defaultModel;
+// src/providers/pruna/client/core/validation/duration-validator.ts
+var MIN_VIDEO_DURATION_SECONDS = 1;
+var MAX_VIDEO_DURATION_SECONDS = 30;
+function isValidDuration(value) {
+  return typeof value === "number" && Number.isFinite(value) && value >= MIN_VIDEO_DURATION_SECONDS && value <= MAX_VIDEO_DURATION_SECONDS && Number.isInteger(value);
+}
+function assertValidDuration(value, fieldName = "duration") {
+  if (value === void 0 || value === null) return;
+  if (!isValidDuration(value)) {
+    throw new ValidationError2({
+      field: fieldName,
+      reason: `must be an integer between ${MIN_VIDEO_DURATION_SECONDS} and ${MAX_VIDEO_DURATION_SECONDS} seconds`,
+      receivedValue: value
+    });
   }
-  httpClient;
-  cache;
-  defaultModel;
-  id = "groq-text-generation";
-  name = "Groq Text Generation";
-  capabilities = ["text"];
-  jsonParser = new JsonResponseParser();
-  generateCompletion(prompt, options = {}) {
-    const model = options.model ?? this.defaultModel;
-    return this.executeWithCache(
-      {
-        type: CACHE_KEY_TYPE_COMPLETION,
-        model,
-        prompt,
-        config: options.generationConfig
-      },
-      async () => {
-        const request = GroqChatRequestBuilder.for(model).withMessages([createUserMessage(prompt)]).withConfig(options.generationConfig).build();
-        const response = await this.httpClient.postChatCompletion(request);
-        return this.extractContent(response.choices[0]?.message?.content);
+}
+
+// src/providers/pruna/client/core/validation/prompt-validator.ts
+var MIN_PROMPT_LENGTH = 1;
+var MAX_PROMPT_LENGTH = 4e3;
+function assertValidPrompt(value, fieldName = "prompt") {
+  if (typeof value !== "string") {
+    throw new ValidationError2({
+      field: fieldName,
+      reason: "must be a string",
+      receivedValue: typeof value
+    });
+  }
+  if (value.trim().length < MIN_PROMPT_LENGTH) {
+    throw new ValidationError2({
+      field: fieldName,
+      reason: "must not be empty or whitespace-only",
+      receivedValue: value
+    });
+  }
+  if (value.length > MAX_PROMPT_LENGTH) {
+    throw new ValidationError2({
+      field: fieldName,
+      reason: `exceeds maximum length of ${MAX_PROMPT_LENGTH} characters`,
+      receivedValue: value.length
+    });
+  }
+}
+
+// src/providers/pruna/client/core/validation/seed-validator.ts
+var MIN_SEED = -2147483648;
+var MAX_SEED = 2147483647;
+function isValidSeed(value) {
+  return typeof value === "number" && Number.isFinite(value) && Number.isInteger(value) && value >= MIN_SEED && value <= MAX_SEED;
+}
+function assertValidSeed(value, fieldName = "seed") {
+  if (value === void 0 || value === null) return;
+  if (!isValidSeed(value)) {
+    throw new ValidationError2({
+      field: fieldName,
+      reason: `must be an integer in [${MIN_SEED}, ${MAX_SEED}]`,
+      receivedValue: value
+    });
+  }
+}
+
+// src/providers/pruna/client/core/protocol/input-type-guard.ts
+function isTextToImageInput(input) {
+  return input.model === "p-image";
+}
+function isImageToImageInput(input) {
+  return input.model === "p-image-edit";
+}
+function isImageToVideoInput(input) {
+  return input.model === "p-video";
+}
+
+// src/providers/pruna/client/core/utils/request-deduplicator.ts
+var RequestDeduplicator2 = class {
+  pendingRequests = /* @__PURE__ */ new Map();
+  ttl;
+  constructor(ttl = DEFAULT_DEDUPLICATOR_TTL_MS) {
+    this.ttl = ttl;
+  }
+  execute(key, fn) {
+    const existing = this.pendingRequests.get(key);
+    if (existing) {
+      if (Date.now() - existing.timestamp < this.ttl) {
+        return existing.promise;
       }
-    );
+      this.pendingRequests.delete(key);
+    }
+    const promise = fn().finally(() => {
+      setTimeout(() => {
+        this.pendingRequests.delete(key);
+      }, DEDUPLICATOR_CLEANUP_GRACE_MS);
+    });
+    this.pendingRequests.set(key, { promise, timestamp: Date.now() });
+    return promise;
   }
-  generateChatCompletion(messages, options = {}) {
-    const model = options.model ?? this.defaultModel;
-    return this.executeWithCache(
-      {
-        type: CACHE_KEY_TYPE_CHAT,
-        model,
-        messages: [...messages],
-        config: options.generationConfig
-      },
-      async () => {
-        const request = GroqChatRequestBuilder.for(model).withMessages(messages).withConfig(options.generationConfig).build();
-        const response = await this.httpClient.postChatCompletion(request);
-        return this.extractContent(response.choices[0]?.message?.content);
+  clear() {
+    this.pendingRequests.clear();
+  }
+  size() {
+    this.purgeExpired();
+    return this.pendingRequests.size;
+  }
+  purgeExpired() {
+    const now = Date.now();
+    for (const [key, value] of this.pendingRequests) {
+      if (now - value.timestamp >= this.ttl) {
+        this.pendingRequests.delete(key);
       }
+    }
+  }
+};
+var globalDeduplicator = new RequestDeduplicator2();
+
+// src/providers/pruna/client/generation/builders/text-to-image.builder.ts
+var TextToImageInputBuilder = class {
+  model = "p-image";
+  build(input, _context) {
+    const payload = {
+      prompt: input.prompt,
+      aspect_ratio: input.aspect_ratio ?? DEFAULT_ASPECT_RATIO
+    };
+    if (input.seed !== void 0) {
+      payload.seed = input.seed;
+    }
+    return Promise.resolve(payload);
+  }
+};
+
+// src/providers/pruna/client/generation/builders/image-to-image.builder.ts
+var ImageToImageInputBuilder = class {
+  model = "p-image-edit";
+  build(input, _context) {
+    const payload = {
+      images: [stripBase64Prefix(input.image)],
+      prompt: input.prompt,
+      aspect_ratio: input.aspect_ratio ?? DEFAULT_ASPECT_RATIO
+    };
+    if (input.seed !== void 0) {
+      payload.seed = input.seed;
+    }
+    return Promise.resolve(payload);
+  }
+};
+
+// src/providers/pruna/client/generation/builders/image-to-video.builder.ts
+var ImageToVideoInputBuilder = class {
+  model = "p-video";
+  async build(input, context) {
+    if (context.signal?.aborted) {
+      throw new CancellationError();
+    }
+    const fileUrl = await uploadImage(
+      input.image,
+      context.apiKey,
+      context.onProgress
     );
+    return {
+      image: fileUrl,
+      prompt: input.prompt,
+      duration: input.duration ?? P_VIDEO_DEFAULTS.duration,
+      resolution: input.resolution ?? P_VIDEO_DEFAULTS.resolution,
+      fps: P_VIDEO_DEFAULTS.fps,
+      draft: input.draft ?? P_VIDEO_DEFAULTS.draft,
+      aspect_ratio: input.aspect_ratio ?? DEFAULT_ASPECT_RATIO,
+      prompt_upsampling: P_VIDEO_DEFAULTS.promptUpsampling
+    };
   }
-  generateStructured(promptOrRequest, options) {
-    if (typeof promptOrRequest === "string") {
-      const model2 = options?.model ?? this.defaultModel;
-      const jsonPrompt = StructuredPromptBuilder.for(promptOrRequest).withSchema(options?.schema).build();
-      const request = GroqChatRequestBuilder.for(model2).withMessages([createUserMessage(jsonPrompt)]).withConfig({
-        ...options?.generationConfig,
-        temperature: STRUCTURED_OUTPUT_TEMPERATURE
-      }).build();
-      return this.httpClient.postChatCompletion(request).then((response) => {
-        const content = this.extractContent(response.choices[0]?.message?.content);
-        return this.jsonParser.parse(content);
+};
+
+// src/providers/pruna/client/generation/builders/model-input-builder.ts
+var ModelInputBuilderRegistry = class {
+  builders = /* @__PURE__ */ new Map();
+  register(builder) {
+    this.builders.set(builder.model, builder);
+    return this;
+  }
+  resolve(model) {
+    const builder = this.builders.get(model);
+    if (!builder) {
+      throw new Error(`No input builder registered for model: ${model}`);
+    }
+    return builder;
+  }
+};
+
+// src/providers/pruna/client/generation/builders/builder-factory.ts
+function createDefaultBuilderRegistry() {
+  return new ModelInputBuilderRegistry().register(new TextToImageInputBuilder()).register(new ImageToImageInputBuilder()).register(new ImageToVideoInputBuilder());
+}
+
+// src/providers/pruna/client/generation/services/generation.service.ts
+var builderRegistry = createDefaultBuilderRegistry();
+function validateGenerateInput(input) {
+  assertValidPrompt(input.prompt, `${input.model}.prompt`);
+  assertValidAspectRatio(input.aspect_ratio, `${input.model}.aspect_ratio`);
+  if (isTextToImageInput(input)) {
+    assertValidSeed(input.seed, `${input.model}.seed`);
+  } else if (isImageToImageInput(input)) {
+    assertSecureImageSource(input.image, `${input.model}.image`);
+    assertValidSeed(input.seed, `${input.model}.seed`);
+  } else if (isImageToVideoInput(input)) {
+    assertSecureImageSource(input.image, `${input.model}.image`);
+    assertValidDuration(input.duration, `${input.model}.duration`);
+    assertValidResolution(input.resolution, `${input.model}.resolution`);
+  }
+}
+async function generate(apiKey, input, options = {}) {
+  assertValidApiKey(apiKey);
+  validateGenerateInput(input);
+  const { signal, onProgress, useCache = true } = options;
+  if (useCache) {
+    const cacheKey = deriveGenerationCacheKey(apiKey, input);
+    return globalDeduplicator.execute(
+      cacheKey,
+      () => generateInternal(apiKey, input, { signal, onProgress })
+    );
+  }
+  return generateInternal(apiKey, input, { signal, onProgress });
+}
+async function generateInternal(apiKey, input, options) {
+  const { signal, onProgress } = options;
+  const builder = builderRegistry.resolve(input.model);
+  const modelInput = await builder.build(input, { apiKey, signal, onProgress });
+  const response = await submitPrediction(input.model, modelInput, apiKey, signal, onProgress);
+  const syncUri = extractUri(response);
+  if (syncUri) {
+    return { url: resolveUri(syncUri), model: input.model };
+  }
+  const pollUrl = response.get_url ?? response.status_url;
+  if (!pollUrl) {
+    throw new Error("Pruna API returned no result and no polling URL.");
+  }
+  const url = await pollForResult(
+    pollUrl,
+    apiKey,
+    POLL_DEFAULTS.maxAttempts,
+    POLL_DEFAULTS.intervalMs,
+    signal,
+    onProgress
+  );
+  return { url, model: input.model };
+}
+async function generateImageThenVideo(apiKey, input, options = {}) {
+  assertValidApiKey(apiKey);
+  assertValidPrompt(input.prompt, "text-to-video.prompt");
+  assertValidAspectRatio(input.aspect_ratio, "text-to-video.aspect_ratio");
+  assertValidDuration(input.duration, "text-to-video.duration");
+  assertValidResolution(input.resolution, "text-to-video.resolution");
+  const { signal, onProgress } = options;
+  const aspectRatio = input.aspect_ratio ?? DEFAULT_ASPECT_RATIO;
+  onProgress?.("predicting", 1);
+  const imageResult = await generate(
+    apiKey,
+    { model: "p-image", prompt: input.prompt, aspect_ratio: aspectRatio },
+    { signal }
+  );
+  onProgress?.("predicting", 2);
+  return generate(
+    apiKey,
+    {
+      model: "p-video",
+      prompt: input.prompt,
+      image: imageResult.url,
+      duration: input.duration ?? P_VIDEO_DEFAULTS.duration,
+      resolution: input.resolution ?? P_VIDEO_DEFAULTS.resolution,
+      aspect_ratio: aspectRatio,
+      draft: input.draft ?? P_VIDEO_DEFAULTS.draft
+    },
+    { signal, onProgress }
+  );
+}
+
+// src/providers/pruna/pruna-generate.ts
+async function* generateWithPruna(request, apiKey, signal, onProgress) {
+  const stages = [];
+  let notify = null;
+  let done = false;
+  const wake = () => {
+    const fn = notify;
+    if (fn) {
+      notify = null;
+      fn();
+    }
+  };
+  const handleProgress = (stage) => {
+    stages.push({ stage });
+    onProgress?.(stage);
+    wake();
+  };
+  const promise = (async () => {
+    try {
+      const model = request.model ?? (request.image ? "p-image-edit" : "p-image");
+      if (model === "p-video" && !request.image && request.prompt) {
+        const videoRes = await generateImageThenVideo(
+          apiKey,
+          {
+            prompt: request.prompt,
+            duration: request.duration ?? 5,
+            aspect_ratio: request.aspectRatio ?? request.aspect_ratio ?? "16:9"
+          },
+          { signal, onProgress: handleProgress }
+        );
+        stages.push({
+          stage: "polling",
+          result: { url: videoRes.url, model: "p-video" }
+        });
+        return;
+      }
+      const input = {
+        model,
+        prompt: request.prompt ?? "",
+        aspect_ratio: request.aspectRatio ?? request.aspect_ratio ?? "1:1",
+        ...request.image ? { image: request.image } : {},
+        ...request.duration ? { duration: request.duration } : {},
+        ...request.resolution ? { resolution: request.resolution } : {},
+        ...request.seed !== void 0 ? { seed: request.seed } : {}
+      };
+      const res = await generate(apiKey, input, {
+        signal,
+        onProgress: handleProgress
+      });
+      stages.push({
+        stage: "polling",
+        result: { url: res.url, model: res.model }
+      });
+    } catch (err) {
+      stages.push({
+        stage: "processing",
+        error: err instanceof Error ? err : new Error(String(err))
       });
+    } finally {
+      done = true;
+      wake();
     }
-    const req = promptOrRequest;
-    const model = req.model ?? (req.tier ? this.resolveModel(req.tier) : this.defaultModel);
-    const schemaObj = req.schema;
-    const messages = [];
-    if (req.systemPrompt) {
-      messages.push({ role: "system", content: req.systemPrompt });
+  })();
+  while (!done || stages.length > 0) {
+    if (stages.length === 0 && !done) {
+      await new Promise((resolve) => {
+        notify = resolve;
+      });
+      notify = null;
     }
-    for (const m of req.messages) {
-      messages.push({ role: m.role, content: m.content });
+    while (stages.length > 0) {
+      const nextStage = stages.shift();
+      if (!nextStage) continue;
+      yield nextStage;
+      if (nextStage.error) {
+        throw nextStage.error;
+      }
     }
-    const lastMsg = messages[messages.length - 1];
-    if (lastMsg) {
-      const structuredPrompt = StructuredPromptBuilder.for(lastMsg.content).withSchema(schemaObj).build();
-      messages[messages.length - 1] = { ...lastMsg, content: structuredPrompt };
+  }
+  await promise;
+}
+
+// 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) {
+    let finalUrl;
+    const model = this.config.models?.textToImage;
+    for await (const stage of generateWithPruna(
+      { prompt: request.prompt, model, quality: request.quality },
+      this.config.apiKey
+    )) {
+      if (stage.error) throw stage.error;
+      if (stage.result?.url) finalUrl = stage.result.url;
     }
-    const groqReq = GroqChatRequestBuilder.for(model).withMessages(messages).withConfig({
-      temperature: req.temperature ?? STRUCTURED_OUTPUT_TEMPERATURE,
-      maxTokens: req.maxTokens
-    }).build();
-    return this.httpClient.postChatCompletion(groqReq).then((response) => {
-      const content = this.extractContent(response.choices[0]?.message?.content);
-      const parsed = this.jsonParser.parse(content);
-      const genResult = {
-        text: content,
-        model: response.model,
-        providerId: this.id,
-        finishReason: response.choices[0]?.finish_reason ?? "stop",
-        usage: response.usage ? {
-          inputTokens: response.usage.prompt_tokens,
-          outputTokens: response.usage.completion_tokens,
-          totalTokens: response.usage.total_tokens
-        } : void 0
-      };
-      return { value: parsed, result: genResult };
+    if (!finalUrl) {
+      throw new AIError("SERVER_ERROR" /* SERVER_ERROR */, "No image generated by Pruna AI");
+    }
+    return {
+      id: Date.now().toString(),
+      type: "image",
+      url: finalUrl,
+      metadata: { provider: this.id, model: model ?? "p-image" },
+      createdAt: (/* @__PURE__ */ new Date()).toISOString()
+    };
+  }
+  async generateVideo(request) {
+    let finalUrl;
+    const model = this.config.models?.textToVideo;
+    for await (const stage of generateWithPruna(
+      { prompt: request.prompt, model, duration: request.duration, aspectRatio: request.aspectRatio },
+      this.config.apiKey
+    )) {
+      if (stage.error) throw stage.error;
+      if (stage.result?.url) finalUrl = stage.result.url;
+    }
+    if (!finalUrl) {
+      throw new AIError("SERVER_ERROR" /* SERVER_ERROR */, "No video generated by Pruna AI");
+    }
+    return {
+      id: Date.now().toString(),
+      type: "video",
+      url: finalUrl,
+      metadata: { provider: this.id, model: model ?? "p-video" },
+      createdAt: (/* @__PURE__ */ new Date()).toISOString()
+    };
+  }
+  async imageToVideo(request) {
+    let finalUrl;
+    for await (const stage of generateWithPruna(
+      { image: request.imageUrl, prompt: request.prompt, duration: request.duration, motion: request.motion },
+      this.config.apiKey
+    )) {
+      if (stage.error) throw stage.error;
+      if (stage.result?.url) finalUrl = stage.result.url;
+    }
+    if (!finalUrl) {
+      throw new AIError("SERVER_ERROR" /* SERVER_ERROR */, "No video generated from image by Pruna AI");
+    }
+    return {
+      id: Date.now().toString(),
+      type: "video",
+      url: finalUrl,
+      metadata: { provider: this.id, model: "p-image-to-video" },
+      createdAt: (/* @__PURE__ */ new Date()).toISOString()
+    };
+  }
+  async videoToVideo(_request) {
+    throw new AIError("CLIENT_ERROR" /* CLIENT_ERROR */, "Pruna AI provider does not support video-to-video conversion");
+  }
+};
+function createPrunaProvider(config) {
+  return new PrunaProvider(config);
+}
+
+// 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/providers/groq/groq-messages.ts
+var createUserMessage = (content) => ({
+  role: "user",
+  content
+});
+var createAssistantMessage = (content) => ({
+  role: "assistant",
+  content
+});
+var createSystemMessage = (content) => ({
+  role: "system",
+  content
+});
+var createMessage = (role, content) => ({
+  role,
+  content
+});
+var promptToMessages = (prompt) => [
+  createUserMessage(prompt)
+];
+var extractTextFromMessages = (messages) => messages.map((m) => m.content).join("\n\n");
+var formatMessagesForDisplay = (messages) => messages.map((m) => `[${m.role.toUpperCase()}]: ${m.content}`).join("\n\n---\n\n");
+
+// src/providers/groq/groq-structured-json.ts
+async function requestStructuredJson(client, request) {
+  const chatRequest = {
+    model: request.model,
+    messages: [createUserMessage(request.instructions)],
+    temperature: request.temperature,
+    max_tokens: request.maxTokens,
+    response_format: { type: "json_object" },
+    ...request.reasoningEffort !== void 0 ? { reasoning_effort: request.reasoningEffort } : {}
+  };
+  const response = await client.postChatCompletion(chatRequest);
+  const content = response.choices[0]?.message?.content ?? "";
+  const candidate = extractJsonCandidate(content);
+  try {
+    return JSON.parse(candidate);
+  } catch (err) {
+    throw new GroqError(
+      "UNKNOWN_ERROR" /* UNKNOWN_ERROR */,
+      "model response contained no parsable json object",
+      err instanceof Error ? err : void 0
+    );
+  }
+}
+
+// src/providers/groq/text-generation.service.ts
+var STRUCTURED_OUTPUT_TEMPERATURE = 0.1;
+var TextGenerationService = class {
+  constructor(httpClient, cache = new CacheManager(), defaultModel = DEFAULT_MODELS.TEXT) {
+    this.httpClient = httpClient;
+    this.cache = cache;
+    this.defaultModel = defaultModel;
+  }
+  httpClient;
+  cache;
+  defaultModel;
+  id = "groq-text-generation";
+  name = "Groq Text Generation";
+  capabilities = ["text"];
+  jsonParser = new JsonResponseParser();
+  generateCompletion(prompt, options = {}) {
+    const model = options.model ?? this.defaultModel;
+    return this.executeWithCache(
+      {
+        type: CACHE_KEY_TYPE_COMPLETION,
+        model,
+        prompt,
+        config: options.generationConfig
+      },
+      async () => {
+        const request = GroqChatRequestBuilder.for(model).withMessages([createUserMessage(prompt)]).withConfig(options.generationConfig).build();
+        const response = await this.httpClient.postChatCompletion(request);
+        return this.extractContent(response.choices[0]?.message?.content);
+      }
+    );
+  }
+  generateChatCompletion(messages, options = {}) {
+    const model = options.model ?? this.defaultModel;
+    return this.executeWithCache(
+      {
+        type: CACHE_KEY_TYPE_CHAT,
+        model,
+        messages: [...messages],
+        config: options.generationConfig
+      },
+      async () => {
+        const request = GroqChatRequestBuilder.for(model).withMessages(messages).withConfig(options.generationConfig).build();
+        const response = await this.httpClient.postChatCompletion(request);
+        return this.extractContent(response.choices[0]?.message?.content);
+      }
+    );
+  }
+  generateStructured(promptOrRequest, options) {
+    if (typeof promptOrRequest === "string") {
+      const model2 = options?.model ?? this.defaultModel;
+      const jsonPrompt = StructuredPromptBuilder.for(promptOrRequest).withSchema(options?.schema).build();
+      const request = GroqChatRequestBuilder.for(model2).withMessages([createUserMessage(jsonPrompt)]).withConfig({
+        ...options?.generationConfig,
+        temperature: STRUCTURED_OUTPUT_TEMPERATURE
+      }).build();
+      return this.httpClient.postChatCompletion(request).then((response) => {
+        const content = this.extractContent(response.choices[0]?.message?.content);
+        return this.jsonParser.parse(content);
+      });
+    }
+    const req = promptOrRequest;
+    const model = req.model ?? (req.tier ? this.resolveModel(req.tier) : this.defaultModel);
+    const schemaObj = req.schema;
+    const messages = [];
+    if (req.systemPrompt) {
+      messages.push({ role: "system", content: req.systemPrompt });
+    }
+    for (const m of req.messages) {
+      messages.push({ role: m.role, content: m.content });
+    }
+    const lastMsg = messages[messages.length - 1];
+    if (lastMsg) {
+      const structuredPrompt = StructuredPromptBuilder.for(lastMsg.content).withSchema(schemaObj).build();
+      messages[messages.length - 1] = { ...lastMsg, content: structuredPrompt };
+    }
+    const groqReq = GroqChatRequestBuilder.for(model).withMessages(messages).withConfig({
+      temperature: req.temperature ?? STRUCTURED_OUTPUT_TEMPERATURE,
+      maxTokens: req.maxTokens
+    }).build();
+    return this.httpClient.postChatCompletion(groqReq).then((response) => {
+      const content = this.extractContent(response.choices[0]?.message?.content);
+      const parsed = this.jsonParser.parse(content);
+      const genResult = {
+        text: content,
+        model: response.model,
+        providerId: this.id,
+        finishReason: response.choices[0]?.finish_reason ?? "stop",
+        usage: response.usage ? {
+          inputTokens: response.usage.prompt_tokens,
+          outputTokens: response.usage.completion_tokens,
+          totalTokens: response.usage.total_tokens
+        } : void 0
+      };
+      return { value: parsed, result: genResult };
+    });
+  }
+  streamCompletion(prompt, callbacks, options = {}) {
+    return this.streamChatCompletion([createUserMessage(prompt)], callbacks, options);
+  }
+  async streamChatCompletion(messages, callbacks, options = {}) {
+    const model = options.model ?? this.defaultModel;
+    const request = GroqChatRequestBuilder.for(model).withMessages(messages).withConfig(options.generationConfig).withStream(true).build();
+    const parser = new StreamingResponseParser(
+      {
+        onChunk: (chunk) => callbacks.onChunk?.(chunk)
+      },
+      extractContentFromSsePayload
+    );
+    try {
+      const stream = await this.httpClient.streamChatCompletion(request, {
+        signal: options.signal
+      });
+      const fullText = await parser.parse(stream);
+      callbacks.onComplete?.(fullText);
+      return fullText;
+    } catch (error) {
+      const err = error instanceof Error ? error : new Error(String(error));
+      callbacks.onError?.(err);
+      throw err;
+    }
+  }
+  clearCache() {
+    this.cache.clear();
+  }
+  // --- ITextProvider implementation ---
+  resolveModel(tier) {
+    return GROQ_TIERS[tier] ?? this.defaultModel;
+  }
+  async generate(request) {
+    const messages = [];
+    if (request.systemPrompt) {
+      messages.push({ role: "system", content: request.systemPrompt });
+    }
+    for (const m of request.messages) {
+      messages.push({ role: m.role, content: m.content });
+    }
+    const model = request.model ?? (request.tier ? this.resolveModel(request.tier) : this.defaultModel);
+    const groqReq = GroqChatRequestBuilder.for(model).withMessages(messages).withConfig({
+      temperature: request.temperature,
+      maxTokens: request.maxTokens
+    }).build();
+    const resp = await this.httpClient.postChatCompletion(groqReq);
+    const content = resp.choices[0]?.message?.content ?? "";
+    return {
+      text: content,
+      finishReason: resp.choices[0]?.finish_reason ?? "stop",
+      model: resp.model,
+      providerId: this.id,
+      usage: resp.usage ? {
+        inputTokens: resp.usage.prompt_tokens,
+        outputTokens: resp.usage.completion_tokens,
+        totalTokens: resp.usage.total_tokens
+      } : void 0
+    };
+  }
+  async stream(request, callbacks) {
+    const messages = [];
+    if (request.systemPrompt) {
+      messages.push({ role: "system", content: request.systemPrompt });
+    }
+    for (const m of request.messages) {
+      messages.push({ role: m.role, content: m.content });
+    }
+    const model = request.model ?? (request.tier ? this.resolveModel(request.tier) : this.defaultModel);
+    const text = await this.streamChatCompletion(
+      messages,
+      {
+        onChunk: callbacks.onChunk,
+        onError: callbacks.onError
+      },
+      {
+        model,
+        signal: request.signal,
+        generationConfig: {
+          temperature: request.temperature,
+          maxTokens: request.maxTokens
+        }
+      }
+    );
+    const result = {
+      text,
+      finishReason: "stop",
+      model,
+      providerId: this.id
+    };
+    callbacks.onComplete?.(result);
+    return result;
+  }
+  async countTokens(text) {
+    return Math.max(1, Math.ceil(text.length / 4));
+  }
+  async estimateCost(_request) {
+    return 0;
+  }
+  async healthCheck() {
+    try {
+      await this.generateCompletion("ping", {
+        generationConfig: { maxTokens: 1 }
+      });
+      return "healthy";
+    } catch {
+      return "unavailable";
+    }
+  }
+  async executeWithCache(params, factory) {
+    const key = this.cache.generateKey(params);
+    const cached = this.cache.get(key);
+    if (cached !== null) {
+      return cached;
+    }
+    const result = await factory();
+    this.cache.set(key, result);
+    return result;
+  }
+  extractContent(content) {
+    if (!content) {
+      throw new GroqError(
+        "UNKNOWN_ERROR" /* UNKNOWN_ERROR */,
+        "No content generated from Groq API"
+      );
+    }
+    return content;
+  }
+};
+
+// src/core/calculations/random-base36-suffix.ts
+var BASE_36_RADIX = 36;
+var DECIMAL_OFFSET = 2;
+function generateRandomBase36Suffix(length, random = Math.random) {
+  if (length <= 0) return "";
+  const raw = random().toString(BASE_36_RADIX).slice(DECIMAL_OFFSET);
+  if (raw.length >= length) return raw.slice(0, length);
+  let result = raw;
+  while (result.length < length) {
+    result += random().toString(BASE_36_RADIX).slice(DECIMAL_OFFSET);
+  }
+  return result.slice(0, length);
+}
+
+// src/chat/utils/chat-id-generator.ts
+var ID_PART_DELIMITER = "-";
+var ChatIdGenerator = class {
+  counter = 0;
+  randomLength;
+  constructor(randomLength = CHAT_MESSAGE_ID_SUFFIX_LENGTH) {
+    this.randomLength = randomLength;
+  }
+  next(sender) {
+    this.counter += 1;
+    const random = generateRandomBase36Suffix(this.randomLength);
+    return [
+      MESSAGE_ID_PREFIX,
+      Date.now(),
+      sender,
+      this.counter,
+      random
+    ].join(ID_PART_DELIMITER);
+  }
+};
+var chatIdGenerator = new ChatIdGenerator();
+
+// src/chat/utils/message-formatter.ts
+var MessageFormatter = class {
+  constructor(idGenerator = chatIdGenerator) {
+    this.idGenerator = idGenerator;
+  }
+  idGenerator;
+  /** Maps chat-domain history to neutral core messages; system senders are
+   *  dropped — the system prompt travels on the request's own slot. */
+  toCoreMessages(messages) {
+    const coreMessages = [];
+    for (const message of messages) {
+      if (message.sender === "system") continue;
+      coreMessages.push({
+        role: message.sender === "user" ? USER_ROLE : ASSISTANT_ROLE,
+        content: message.content
+      });
+    }
+    return coreMessages;
+  }
+  toChatMessage(content, sender) {
+    return {
+      id: this.idGenerator.next(sender),
+      sender,
+      content: content.trim(),
+      timestamp: (/* @__PURE__ */ new Date()).toISOString(),
+      type: "text"
+    };
+  }
+};
+var messageFormatter = new MessageFormatter();
+
+// src/chat/utils/prompt-strategy.ts
+var DEFAULT_PROMPT_STRATEGY = {
+  resolve: (config) => {
+    if (config.systemPrompt && config.systemPrompt.length > 0) {
+      return config.systemPrompt;
+    }
+    return void 0;
+  }
+};
+
+// src/chat/services/chat.service.ts
+var DEFAULT_CONFIG = {
+  temperature: 0.8,
+  maxTokens: 500
+};
+var ChatService = class {
+  constructor(engine) {
+    this.engine = engine;
+  }
+  engine;
+  config = DEFAULT_CONFIG;
+  promptStrategy = DEFAULT_PROMPT_STRATEGY;
+  storage = null;
+  initialize(config) {
+    this.config = { ...DEFAULT_CONFIG, ...config };
+  }
+  updateConfig(config) {
+    this.config = { ...this.config, ...config };
+  }
+  setPromptStrategy(strategy) {
+    this.promptStrategy = strategy;
+  }
+  setStorage(storage) {
+    this.storage = storage;
+  }
+  async getConversation(conversationId) {
+    const storage = this.requireStorage();
+    const messages = await storage.getMessages(conversationId);
+    if (messages.length === 0) return null;
+    const last = messages[messages.length - 1];
+    const first = messages[0];
+    const companionId = String(first.metadata?.["companionId"] ?? "unknown");
+    const companionName = String(first.metadata?.["companionName"] ?? "Unknown");
+    return {
+      id: conversationId,
+      companionId,
+      companionName,
+      lastMessage: last,
+      messageCount: messages.length,
+      updatedAt: last.timestamp
+    };
+  }
+  async getConversations() {
+    if (this.storage && "getConversations" in this.storage && typeof this.storage.getConversations === "function") {
+      return this.storage.getConversations();
+    }
+    return [];
+  }
+  async sendMessage(input, signal) {
+    const userMessage = {
+      ...messageFormatter.toChatMessage(input.text, "user"),
+      type: input.type ?? "text",
+      ...input.imageUrl !== void 0 ? { imageUrl: input.imageUrl } : {}
+    };
+    const aiResponse = await this.generateAIResponse(
+      input.companionId,
+      input.text,
+      [],
+      signal
+    );
+    return { userMessage, aiResponse };
+  }
+  async generateAIResponse(companionId, userMessage, context = [], signal) {
+    const result = await this.run({
+      ...this.buildRequest(userMessage, context, signal)
+    });
+    return {
+      ...messageFormatter.toChatMessage(result.text, "assistant"),
+      metadata: {
+        companionId,
+        model: result.model,
+        usage: {
+          input_tokens: result.usage?.inputTokens,
+          output_tokens: result.usage?.outputTokens,
+          total_tokens: result.usage?.totalTokens
+        },
+        finishReason: result.finishReason
+      }
+    };
+  }
+  async generateStreamingResponse(userMessage, context, onChunk, signal) {
+    const request = this.buildRequest(userMessage, context, signal);
+    const result = await this.runStream(request, { onChunk });
+    return result.text;
+  }
+  buildRequest(userMessage, context, signal) {
+    const messages = messageFormatter.toCoreMessages(context);
+    messages.push({ role: "user", content: userMessage });
+    return {
+      messages,
+      systemPrompt: this.resolveSystemPrompt(),
+      model: this.config.model,
+      tier: this.config.tier,
+      temperature: this.config.temperature,
+      maxTokens: this.config.maxTokens,
+      ...signal !== void 0 ? { signal } : {}
+    };
+  }
+  resolveSystemPrompt() {
+    const prompt = this.promptStrategy.resolve(this.config);
+    return prompt && prompt.length > 0 ? prompt : void 0;
+  }
+  async run(request) {
+    if (this.engine instanceof ProviderFactory) {
+      return this.engine.chat(request);
+    }
+    return this.engine.generate(request);
+  }
+  async runStream(request, callbacks) {
+    if (this.engine instanceof ProviderFactory) {
+      return this.engine.chatStream(request, callbacks);
+    }
+    return this.engine.stream(request, callbacks);
+  }
+  requireStorage() {
+    if (!this.storage) {
+      throw new AIError(
+        "MISSING_CONFIG" /* MISSING_CONFIG */,
+        "ChatService.getConversation requires setStorage() to be called first."
+      );
+    }
+    return this.storage;
+  }
+};
+function extractTokenUsage(message) {
+  const meta = message.metadata;
+  if (!meta) return null;
+  const usage = meta["usage"];
+  if (!usage || typeof usage !== "object") return null;
+  const u = usage;
+  const inputTokens = readNumber(u, ["input_tokens", "prompt_tokens"]);
+  const outputTokens = readNumber(u, ["output_tokens", "completion_tokens"]);
+  const totalTokens = readNumber(u, ["total_tokens"]);
+  if (inputTokens === null || outputTokens === null || totalTokens === null) {
+    return null;
+  }
+  return {
+    promptTokens: inputTokens,
+    completionTokens: outputTokens,
+    totalTokens
+  };
+}
+function readNumber(source, keys) {
+  for (const key of keys) {
+    const value = source[key];
+    if (typeof value === "number") return value;
+  }
+  return null;
+}
+
+// src/providers/groq/groq-container.ts
+var container = null;
+function configureProvider(config) {
+  const configStore = new GroqConfigStore();
+  const transport = new GroqHttpTransport(configStore);
+  const httpClient = new GroqHttpClient({ configStore, transport });
+  httpClient.initialize(config);
+  const textGeneration = new TextGenerationService(
+    httpClient,
+    new CacheManager(),
+    config.textModel
+  );
+  const chat = new ChatService(textGeneration);
+  container = { groqHttpClient: httpClient, textGeneration, chat };
+  return container;
+}
+function getProvider() {
+  return container;
+}
+function resetProvider() {
+  container?.groqHttpClient.reset();
+  container = null;
+}
+
+// src/content/domain/calculations/ContentCreditCost.ts
+var CREDIT_COSTS = {
+  "text-to-image": { standard: 1, hd: 2, "4k": 4 },
+  "image-to-image": { standard: 1, hd: 2, "4k": 4 },
+  "image-to-video": { standard: 3, hd: 5, "4k": 8 },
+  "text-to-video": { standard: 5, hd: 8, "4k": 12 }
+};
+var DEFAULT_CREDIT_COST = 0;
+function toQualityTier(quality) {
+  if (quality === "4k") return "4k";
+  if (quality === "hd" || quality === "1080p") return "hd";
+  return "standard";
+}
+function calculateContentCreditCost(type, quality = "standard") {
+  const tierCosts = CREDIT_COSTS[type];
+  if (!tierCosts) return DEFAULT_CREDIT_COST;
+  return tierCosts[toQualityTier(quality)] ?? tierCosts.standard;
+}
+
+// src/content/domain/limits/ImageFormatOptions.ts
+var ASPECT_RATIO_OPTIONS = [
+  { value: "1:1", label: "Square", width: 1024, height: 1024 },
+  { value: "16:9", label: "Landscape", width: 1920, height: 1080 },
+  { value: "9:16", label: "Portrait", width: 1080, height: 1920 },
+  { value: "4:3", label: "Standard", width: 1440, height: 1080 },
+  { value: "3:4", label: "Tall", width: 1080, height: 1440 }
+];
+var IMAGE_QUALITY_OPTIONS = [
+  { value: "standard", label: "Standard", description: "1024x1024, good quality", resolution: "1024x1024" },
+  { value: "hd", label: "HD", description: "1920x1080, high quality", resolution: "1920x1080" },
+  { value: "4k", label: "4K", description: "3840x2160, ultra quality", resolution: "3840x2160" }
+];
+var VIDEO_QUALITY_OPTIONS = [
+  { value: "720p", label: "720p HD", resolution: "1280x720" },
+  { value: "1080p", label: "1080p Full HD", resolution: "1920x1080" },
+  { value: "4k", label: "4K Ultra HD", resolution: "3840x2160" }
+];
+var VIDEO_DURATION_OPTIONS_SECONDS = [2, 3, 4, 5, 6, 7, 8, 9, 10];
+var MOTION_OPTIONS = [
+  { value: "slow", label: "Slow", description: "Gentle movement" },
+  { value: "medium", label: "Medium", description: "Balanced motion" },
+  { value: "fast", label: "Fast", description: "Dynamic movement" }
+];
+var STYLE_PRESETS = [
+  { value: "realistic", label: "Realistic", promptFragment: "realistic, photograph, detailed" },
+  { value: "artistic", label: "Artistic", promptFragment: "artistic, painting, creative" },
+  { value: "anime", label: "Anime", promptFragment: "anime style, manga, vibrant colors" },
+  { value: "cinematic", label: "Cinematic", promptFragment: "cinematic, movie scene, dramatic lighting" },
+  { value: "vintage", label: "Vintage", promptFragment: "vintage, retro, film grain" },
+  { value: "fantasy", label: "Fantasy", promptFragment: "fantasy, magical, ethereal" },
+  { value: "minimalist", label: "Minimalist", promptFragment: "minimalist, clean, simple" },
+  { value: "abstract", label: "Abstract", promptFragment: "abstract, geometric, artistic" }
+];
+
+// src/content/domain/calculations/AspectRatioDimensions.ts
+var FALLBACK_DIMENSIONS = { width: 1024, height: 1024 };
+function resolveDimensionsForAspectRatio(ratio) {
+  const match = ASPECT_RATIO_OPTIONS.find((option) => option.value === ratio);
+  return match ? { width: match.width, height: match.height } : FALLBACK_DIMENSIONS;
+}
+
+// src/content/domain/constants/GenerationConstants.ts
+var ASPECT_RATIO_VALUES = ASPECT_RATIO_OPTIONS.map((o) => o.value);
+var IMAGE_QUALITY_VALUES = IMAGE_QUALITY_OPTIONS.map((o) => o.value);
+var VIDEO_QUALITY_VALUES = VIDEO_QUALITY_OPTIONS.map((o) => o.value);
+var VIDEO_DURATION_OPTIONS = VIDEO_DURATION_OPTIONS_SECONDS;
+var getDimensionsForAspectRatio = resolveDimensionsForAspectRatio;
+var getRecommendedQuality = recommendQualityForAspectRatio;
+
+// src/content/domain/limits/ValidationLimits.ts
+var ValidationLimits = {
+  TOPIC: {
+    MIN: 1,
+    MAX: 500
+  },
+  CONTENT: {
+    MIN: 1,
+    MAX: 1e4
+  },
+  KEYWORD: {
+    MAX_COUNT: 20,
+    MAX_LENGTH: 50
+  },
+  DURATION_SECONDS: {
+    MIN: 10,
+    MAX: 600
+  },
+  CALENDAR_DAYS: {
+    MIN: 1,
+    MAX: 90
+  },
+  HASHTAG_COUNT: {
+    MIN: 1,
+    MAX: 50
+  },
+  SEO_CONTENT_PREVIEW: 500,
+  BLOG_PROMPT_PREVIEW: 1e3,
+  AB_VARIANT_CONTENT_PREVIEW: 200
+};
+
+// src/content/domain/limits/SpeechPaceConfig.ts
+var SpeechPaceConfig = {
+  WORDS_PER_SECOND: 2.5,
+  TOKENS_PER_SECOND: 10,
+  JSON_TOKEN_OVERHEAD: 500,
+  TOKENS_PER_CALENDAR_DAY: 150
+};
+
+// src/content/domain/calculations/SpeechPaceEstimate.ts
+function estimateWordCountForDuration(durationSeconds) {
+  return Math.floor(durationSeconds * SpeechPaceConfig.WORDS_PER_SECOND);
+}
+function estimateTokenBudgetForDuration(durationSeconds) {
+  return durationSeconds * SpeechPaceConfig.TOKENS_PER_SECOND + SpeechPaceConfig.JSON_TOKEN_OVERHEAD;
+}
+function estimateTokenBudgetForCalendarDays(days) {
+  return days * SpeechPaceConfig.TOKENS_PER_CALENDAR_DAY + SpeechPaceConfig.JSON_TOKEN_OVERHEAD;
+}
+
+// src/content/domain/calculations/SeoKeywordDensity.ts
+function countKeywordOccurrences(content, keyword) {
+  if (!keyword) return 0;
+  const escaped = keyword.replace(/[.*+?^${}()|[\]\\]/g, "\\$&");
+  const matches = content.match(new RegExp(escaped, "gi"));
+  return matches ? matches.length : 0;
+}
+function countWordsInContent(content) {
+  const tokens = content.split(/\s+/).filter(Boolean);
+  return tokens.length || 1;
+}
+function calculateKeywordDensity(content, keyword) {
+  const totalWords = countWordsInContent(content);
+  const occurrences = countKeywordOccurrences(content, keyword);
+  return occurrences / totalWords * 100;
+}
+
+// src/content/domain/calculations/AbTestImprovementRatio.ts
+function calculateImprovementPercentage(scoreA, scoreB) {
+  const higher = Math.max(scoreA, scoreB);
+  const lower = Math.min(scoreA, scoreB);
+  if (lower <= 0) {
+    return "100";
+  }
+  const delta = (higher / lower - 1) * 100;
+  return Math.abs(delta).toFixed(0);
+}
+function selectHigherScoreVariantId(scoreA, scoreB, idA = "A", idB = "B") {
+  return scoreA > scoreB ? idA : idB;
+}
+
+// src/content/domain/calculations/ContentCalendarDateOffset.ts
+var ONE_DAY_MS = 24 * 60 * 60 * 1e3;
+function resolveCalendarEntryDate(dayIndex, baseTimestamp = Date.now()) {
+  return new Date(baseTimestamp + (dayIndex - 1) * ONE_DAY_MS);
+}
+
+// src/content/domain/validation/TopicTextValidator.ts
+function validateTopicText(topic) {
+  if (typeof topic !== "string" || topic.trim().length < ValidationLimits.TOPIC.MIN) {
+    throw new ValidationError("Topic cannot be empty");
+  }
+  const trimmed = topic.trim();
+  if (trimmed.length > ValidationLimits.TOPIC.MAX) {
+    throw new ValidationError(`Topic exceeds maximum length of ${ValidationLimits.TOPIC.MAX} characters`);
+  }
+  return trimmed;
+}
+
+// src/content/domain/validation/ContentBodyValidator.ts
+function validateContentBody(content) {
+  if (typeof content !== "string" || content.trim().length < ValidationLimits.CONTENT.MIN) {
+    throw new ValidationError("Content cannot be empty");
+  }
+  const trimmed = content.trim();
+  if (trimmed.length > ValidationLimits.CONTENT.MAX) {
+    throw new ValidationError(`Content exceeds maximum length of ${ValidationLimits.CONTENT.MAX} characters`);
+  }
+  return trimmed;
+}
+function truncateForSeoPreview(content) {
+  return content.substring(0, ValidationLimits.SEO_CONTENT_PREVIEW);
+}
+function truncateForBlogPromptPreview(content) {
+  return content.substring(0, ValidationLimits.BLOG_PROMPT_PREVIEW);
+}
+function truncateForAbVariantPreview(content) {
+  return content.substring(0, ValidationLimits.AB_VARIANT_CONTENT_PREVIEW);
+}
+
+// src/content/domain/validation/KeywordListValidator.ts
+function validateKeywordList(keywords) {
+  if (!Array.isArray(keywords)) {
+    throw new ValidationError("Keywords must be an array");
+  }
+  if (keywords.length > ValidationLimits.KEYWORD.MAX_COUNT) {
+    throw new ValidationError(`Cannot process more than ${ValidationLimits.KEYWORD.MAX_COUNT} keywords`);
+  }
+  return keywords.filter((k) => typeof k === "string" && k.trim().length > 0).map((keyword) => {
+    const trimmed = keyword.trim();
+    if (trimmed.length > ValidationLimits.KEYWORD.MAX_LENGTH) {
+      const preview = trimmed.substring(0, 20);
+      throw new ValidationError(
+        `Keyword "${preview}..." exceeds maximum length of ${ValidationLimits.KEYWORD.MAX_LENGTH} characters`
+      );
+    }
+    return trimmed;
+  });
+}
+
+// src/content/domain/validation/DurationSecondsValidator.ts
+function validateDurationSeconds(duration) {
+  if (!Number.isFinite(duration)) {
+    throw new ValidationError(
+      `Duration must be between ${ValidationLimits.DURATION_SECONDS.MIN} and ${ValidationLimits.DURATION_SECONDS.MAX} seconds`
+    );
+  }
+  if (duration < ValidationLimits.DURATION_SECONDS.MIN || duration > ValidationLimits.DURATION_SECONDS.MAX) {
+    throw new ValidationError(
+      `Duration must be between ${ValidationLimits.DURATION_SECONDS.MIN} and ${ValidationLimits.DURATION_SECONDS.MAX} seconds`
+    );
+  }
+  return duration;
+}
+
+// src/content/domain/validation/CalendarDaysValidator.ts
+function validateCalendarDays(days) {
+  if (!Number.isFinite(days)) {
+    throw new ValidationError(
+      `Days must be between ${ValidationLimits.CALENDAR_DAYS.MIN} and ${ValidationLimits.CALENDAR_DAYS.MAX}`
+    );
+  }
+  if (days < ValidationLimits.CALENDAR_DAYS.MIN || days > ValidationLimits.CALENDAR_DAYS.MAX) {
+    throw new ValidationError(
+      `Days must be between ${ValidationLimits.CALENDAR_DAYS.MIN} and ${ValidationLimits.CALENDAR_DAYS.MAX}`
+    );
+  }
+  return days;
+}
+
+// src/content/domain/validation/HashtagCountValidator.ts
+function validateHashtagCount(count) {
+  if (!Number.isFinite(count)) {
+    throw new ValidationError(
+      `Hashtag count must be between ${ValidationLimits.HASHTAG_COUNT.MIN} and ${ValidationLimits.HASHTAG_COUNT.MAX}`
+    );
+  }
+  if (count < ValidationLimits.HASHTAG_COUNT.MIN || count > ValidationLimits.HASHTAG_COUNT.MAX) {
+    throw new ValidationError(
+      `Hashtag count must be between ${ValidationLimits.HASHTAG_COUNT.MIN} and ${ValidationLimits.HASHTAG_COUNT.MAX}`
+    );
+  }
+  return Math.floor(count);
+}
+
+// src/content/domain/utils/IdGenerator.ts
+function generateId(prefix) {
+  const id = typeof crypto !== "undefined" && typeof crypto.randomUUID === "function" ? crypto.randomUUID() : `${Date.now().toString(36)}-${Math.random().toString(36).slice(2, 11)}`;
+  return prefix ? `${prefix}-${id}` : id;
+}
+
+// src/content/application/prompts/PromptBuilder.ts
+var PromptBuilder = class {
+  static blogPost(input) {
+    return `
+As an expert SEO Content Strategist and Copywriter, generate a high-quality, comprehensive blog post.
+
+TOPIC: ${input.topic}
+TYPE: ${input.blogType}
+KEYWORDS: ${input.keywords.join(", ")}
+TONE: ${input.tone}
+TARGET AUDIENCE: ${input.targetAudience}
+WORD COUNT: ${input.wordCount}
+LANGUAGE: ${input.language || "English"}
+
+OPTIMIZATION REQUIREMENTS:
+- SEO Optimization: ${input.seoOptimization ? "ON (Include semantic keywords, LSI, and proper H1-H3 structure)" : "OFF"}
+- Include Schema Markup: ${input.includeSchema ? "ON (Generate JSON-LD for this blog type)" : "OFF"}
+- Image Suggestions: ${input.includeImages ? "ON (Provide DALL-E/Midjourney style prompts for contextually relevant images)" : "OFF"}
+
+RESPONSE FORMAT (STRICT JSON ONLY):
+{
+  "title": "Compelling, Click-worthy Title",
+  "content": "Full markdown-formatted blog content with headers",
+  "metaDescription": "SEO-optimized description (150-160 chars)",
+  "seoScore": 0-100,
+  "readabilityScore": 0-100,
+  "keywords": ["list", "of", "optimized", "keywords"],
+  "performance": {
+    "readingTime": minutes (number),
+    "shareability": 0-10 (number),
+    "seoRank": 0-10 (number)
+  },
+  "schemaMarkup": "JSON-LD string (if requested)",
+  "imagePrompts": ["Prompt 1", "Prompt 2"] (if requested)
+}
+`;
+  }
+  static socialPost(input) {
+    return `
+Write a ${input.tone} social media post about: ${input.topic}
+
+Platform: ${input.platform}
+Style: ${input.style}
+Maximum length: ${input.maxLength} characters
+${input.includeHashtags ? "Include relevant hashtags" : "No hashtags"}
+${input.includeCallToAction ? "Include a call-to-action" : ""}
+
+Requirements:
+- Platform-optimized formatting
+- Engaging hook in first sentence
+- Natural, conversational tone
+- Platform-appropriate emoji usage
+
+Generate the post in JSON format:
+{
+  "content": "The post content",
+  "hashtags": ["hashtag1", "hashtag2"],
+  "emojis": ["emoji1", "emoji2"],
+  "estimatedEngagement": 0-100
+}
+`;
+  }
+  static videoScript(input) {
+    return `
+Create a ${input.tone} video script about: ${input.topic}
+
+Duration: ${input.duration} seconds
+Target Audience: ${input.targetAudience}
+Include Visual Cues: ${input.includeVisuals ? "Yes" : "No"}
+Include CTA: ${input.includeCallToAction ? "Yes" : "No"}
+
+Approximate word count: ${estimateWordCountForDuration(input.duration)} words
+
+Generate in JSON format:
+{
+  "script": "Full script with dialogue and narration",
+  "visualCues": ["Visual cue 1", "Visual cue 2"],
+  "callToAction": "Call to action text (if requested)",
+  "estimatedEngagement": 0-100
+}
+`;
+  }
+  static voiceScript(input) {
+    return `
+Create a ${input.emotion} voice script about: ${input.topic}
+
+Duration: ${input.duration} seconds
+Emotion: ${input.emotion}
+
+The script should:
+- Evoke the specified emotion
+- Be suitable for voice recording with emotion control
+- Include natural speech patterns
+- Have appropriate pacing for the emotion
+- Include emotional cues in brackets where needed
+
+Approximate word count: ${estimateWordCountForDuration(input.duration)} words
+
+Generate in JSON format:
+{
+  "script": "Full script with emotional cues",
+  "visualCues": ["Visual cue 1", "Visual cue 2"],
+  "estimatedEngagement": 0-100
+}
+`;
+  }
+  static contentCalendar(niche, days) {
+    return `
+Generate a ${days}-day content calendar for: ${niche}
+
+For each day, provide:
+- Topic
+- Content type (blog, video, social, email, caption, script)
+- Best platform for this content
+- Brief description
+- Estimated engagement (0-100)
+- Priority level (high, medium, low)
+
+Format as JSON array:
+[
+  {
+    "day": 1,
+    "topic": "...",
+    "contentType": "blog|video|social|email|caption|script",
+    "platform": "twitter|linkedin|instagram|threads|tiktok|facebook",
+    "description": "...",
+    "estimatedEngagement": 0-100,
+    "priority": "high|medium|low"
+  }
+]
+
+Requirements:
+- Mix of content types across platforms
+- Platform-appropriate suggestions
+- Engaging, varied topics
+- Realistic posting schedule
+`;
+  }
+  static sentiment(content) {
+    return `
+Analyze the sentiment of this social media post:
+
+"${content}"
+
+Provide analysis in JSON format:
+{
+  "sentiment": "positive|neutral|negative",
+  "confidence": 0-1,
+  "emotions": [
+    {"emotion": "happy|excited|calm|sad|angry|surprised|fearful|disgusted|neutral", "score": 0-1}
+  ]
+}
+
+Return only the JSON:
+`;
+  }
+  static contentAnalysis(content) {
+    return `
+Analyze this content:
+
+"${content}"
+
+Provide analysis in JSON format:
+{
+  "keywords": ["keyword1", "keyword2", ...],
+  "entities": ["entity1", "entity2", ...],
+  "suggestedImprovements": ["suggestion1", ...],
+  "readabilityScore": 0-100,
+  "estimatedEngagement": 0-100
+}
+
+Return only the JSON:
+`;
+  }
+  static seoOptimization(content, keywords) {
+    return `
+Optimize this content for SEO:
+
+Content: "${content}"
+Keywords: ${keywords.join(", ")}
+
+Tasks:
+1. Incorporate keywords naturally
+2. Improve engagement potential
+3. Add relevant call-to-action if appropriate
+4. Optimize for readability
+5. Enhance heading structure
+
+Return JSON:
+{
+  "optimized": "...",
+  "score": 0-100,
+  "suggestions": ["suggestion1", ...],
+  "addedKeywords": ["keyword1", ...],
+  "removedFillerWords": number,
+  "readabilityImprovements": ["improvement1", ...],
+  "metaDescription": "SEO-optimized meta description",
+  "titleSuggestions": ["title1", ...]
+}
+
+Return only the JSON:
+`;
+  }
+  static seoScore(content, keywords) {
+    return `
+Calculate SEO score for this content:
+
+Content: "${content}"
+Keywords: ${keywords.join(", ")}
+
+Provide breakdown in JSON:
+{
+  "keywordDensity": 0-100,
+  "readabilityScore": 0-100,
+  "titleOptimization": 0-100,
+  "metaDescription": 0-100,
+  "headingStructure": 0-100,
+  "internalLinking": 0-100,
+  "overall": 0-100
+}
+
+Return only the JSON:
+`;
+  }
+  static abTestVariant(input) {
+    return `
+Predict performance for this content variant:
+
+Content: "${input.content}"
+Content Type: ${input.contentType}
+Tone: ${input.tone}
+Target Audience: ${input.targetAudience}
+Platform: ${input.platform}
+Goals: ${input.goals.join(", ")}
+
+Provide prediction in JSON:
+{
+  "predictedEngagement": 0-100,
+  "predictedCTR": 0-100,
+  "predictedConversions": 0-100,
+  "confidence": 0-1,
+  "reasoning": "...",
+  "strengths": ["strength1", ...],
+  "weaknesses": ["weakness1", ...],
+  "suggestions": ["suggestion1", ...]
+}
+
+Return only the JSON:
+`;
+  }
+  static hashtags(content, count) {
+    return `
+Generate ${count} relevant hashtags for this content:
+
+"${content}"
+
+Requirements:
+- Mix of popular and niche hashtags
+- Industry-specific when possible
+- Trending if relevant
+- No duplicated words
+- Format: #hashtag (one per line)
+
+Return only the hashtags:
+`;
+  }
+  static imagePrompt(description, style) {
+    return `
+Generate a detailed AI image generation prompt for:
+
+Description: ${description}
+Style: ${style || "realistic"}
+
+Create a detailed, descriptive prompt that includes:
+- Subject details
+- Mood and atmosphere
+- Lighting
+- Composition
+- Art style reference
+- Technical specifications (aspect ratio, quality)
+
+The prompt should be optimized for models like Midjourney, DALL-E, or Stable Diffusion.
+
+Generate the prompt:
+`;
+  }
+  static blogImagePrompts(blogContent) {
+    return `
+Analyze this blog content and generate 3-5 detailed image prompts for illustrative images:
+
+Blog Content: "${blogContent}"
+
+For each image prompt, provide:
+- Subject description
+- Mood and atmosphere
+- Style reference
+- Composition details
+- Technical specs
+
+Return as JSON array:
+["prompt1", "prompt2", "prompt3", ...]
+
+Return only the JSON:
+`;
+  }
+  static maxTokensForDuration(durationSeconds) {
+    return estimateTokenBudgetForDuration(durationSeconds);
+  }
+};
+
+// src/content/application/services/BlogService.ts
+var BlogService = class {
+  constructor(executor) {
+    this.executor = executor;
+  }
+  executor;
+  async generateBlogPost(request) {
+    const topic = validateTopicText(request.topic);
+    const keywords = validateKeywordList(request.targetKeywords);
+    const prompt = PromptBuilder.blogPost({
+      topic,
+      blogType: request.blogType,
+      keywords,
+      tone: request.tone,
+      targetAudience: request.targetAudience,
+      wordCount: request.wordCount,
+      language: request.language,
+      seoOptimization: request.seoOptimization,
+      includeSchema: request.includeSchema,
+      includeImages: request.includeImages
     });
+    const parsed = await this.executor.runJson(
+      prompt,
+      {},
+      { maxTokens: request.wordCount * 2, temperature: 0.7 }
+    );
+    return {
+      id: generateId("blog"),
+      ...parsed,
+      blogType: request.blogType,
+      tone: request.tone,
+      wordCount: request.wordCount,
+      createdAt: (/* @__PURE__ */ new Date()).toISOString()
+    };
   }
-  streamCompletion(prompt, callbacks, options = {}) {
-    return this.streamChatCompletion([createUserMessage(prompt)], callbacks, options);
+};
+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}`
+          );
+        }
+      }
+    }
   }
-  async streamChatCompletion(messages, callbacks, options = {}) {
-    const model = options.model ?? this.defaultModel;
-    const request = GroqChatRequestBuilder.for(model).withMessages(messages).withConfig(options.generationConfig).withStream(true).build();
-    const parser = new StreamingResponseParser(
-      {
-        onChunk: (chunk) => callbacks.onChunk?.(chunk)
-      },
-      extractContentFromSsePayload
+  if (errors.length > 0 && !stopOnError) {
+    console.warn(`${errors.length} requests failed in batch`);
+  }
+  return results;
+}
+
+// src/content/application/services/SocialService.ts
+var MULTI_PLATFORMS = [
+  "twitter",
+  "linkedin",
+  "instagram",
+  "threads",
+  "tiktok"
+];
+var DEFAULT_SOCIAL_RESULT = {
+  content: "",
+  platform: "twitter",
+  hashtags: [],
+  emojis: [],
+  characterCount: 0,
+  estimatedEngagement: 0
+};
+var SocialService = class {
+  constructor(executor) {
+    this.executor = executor;
+  }
+  executor;
+  async generateSocialContent(request) {
+    const topic = validateTopicText(request.topic);
+    const spec = resolvePlatformSpec(request.platform);
+    const maxLength = resolveMaxContentLength(request.platform, request.maxLength);
+    const prompt = PromptBuilder.socialPost({
+      topic,
+      platform: request.platform,
+      tone: request.tone,
+      style: spec.style,
+      maxLength,
+      includeHashtags: request.hashtags !== false,
+      includeCallToAction: Boolean(request.includeCallToAction)
+    });
+    const parsed = await this.executor.runJson(
+      prompt,
+      { ...DEFAULT_SOCIAL_RESULT, platform: request.platform },
+      { maxTokens: 500, temperature: 0.8 }
+    );
+    return {
+      ...parsed,
+      platform: request.platform,
+      characterCount: parsed.content?.length ?? 0
+    };
+  }
+  async generateForAllPlatforms(topic, tone) {
+    const requests = MULTI_PLATFORMS.map(
+      (platform) => () => this.generateSocialContent({ topic, platform, tone })
     );
     try {
-      const stream = await this.httpClient.streamChatCompletion(request, {
-        signal: options.signal
-      });
-      const fullText = await parser.parse(stream);
-      callbacks.onComplete?.(fullText);
-      return fullText;
+      return await batchRequest(requests, { concurrency: 2, stopOnError: false });
     } catch (error) {
-      const err = error instanceof Error ? error : new Error(String(error));
-      callbacks.onError?.(err);
-      throw err;
+      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;
     }
   }
-  clearCache() {
-    this.cache.clear();
+  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);
   }
-  // --- ITextProvider implementation ---
-  resolveModel(tier) {
-    return GROQ_TIERS[tier] ?? this.defaultModel;
+  optimizeHashtags(hashtags, platform) {
+    const budget = resolveHashtagBudget(platform);
+    return rankAndTrimHashtags(hashtags, budget);
   }
-  async generate(request) {
-    const messages = [];
-    if (request.systemPrompt) {
-      messages.push({ role: "system", content: request.systemPrompt });
-    }
-    for (const m of request.messages) {
-      messages.push({ role: m.role, content: m.content });
-    }
-    const model = request.model ?? (request.tier ? this.resolveModel(request.tier) : this.defaultModel);
-    const groqReq = GroqChatRequestBuilder.for(model).withMessages(messages).withConfig({
-      temperature: request.temperature,
-      maxTokens: request.maxTokens
-    }).build();
-    const resp = await this.httpClient.postChatCompletion(groqReq);
-    const content = resp.choices[0]?.message?.content ?? "";
+};
+
+// src/content/application/services/VideoScriptService.ts
+var buildScriptResult = (parsed, duration) => {
+  const script = parsed.script ?? "";
+  if (!script) {
+    throw new Error("AI response missing script field");
+  }
+  const wordCount = script.trim().length === 0 ? 0 : script.trim().split(/\s+/).length;
+  return {
+    ...parsed,
+    script,
+    duration,
+    wordCount
+  };
+};
+var VideoScriptService = class {
+  constructor(executor) {
+    this.executor = executor;
+  }
+  executor;
+  async generateVideoScript(request) {
+    const topic = validateTopicText(request.topic);
+    const duration = validateDurationSeconds(request.duration);
+    const prompt = PromptBuilder.videoScript({
+      topic,
+      tone: request.tone,
+      duration,
+      targetAudience: request.targetAudience,
+      includeVisuals: request.includeVisuals,
+      includeCallToAction: request.includeCallToAction
+    });
+    const parsed = await this.executor.runJson(
+      prompt,
+      { script: "", visualCues: [], duration, wordCount: 0, estimatedEngagement: 0 },
+      { maxTokens: estimateTokenBudgetForDuration(duration), temperature: 0.8 }
+    );
+    return buildScriptResult(parsed, duration);
+  }
+  async generateVoiceScript(topic, emotion, duration) {
+    const validatedTopic = validateTopicText(topic);
+    const validatedDuration = validateDurationSeconds(duration);
+    const prompt = PromptBuilder.voiceScript({
+      topic: validatedTopic,
+      emotion,
+      duration: validatedDuration
+    });
+    const parsed = await this.executor.runJson(
+      prompt,
+      { script: "", visualCues: [], duration: validatedDuration, wordCount: 0, estimatedEngagement: 0 },
+      { maxTokens: estimateTokenBudgetForDuration(validatedDuration), temperature: 0.8 }
+    );
+    return buildScriptResult(parsed, validatedDuration);
+  }
+};
+
+// src/content/application/services/AnalysisService.ts
+var DEFAULT_SENTIMENT = {
+  sentiment: "neutral",
+  confidence: 0.5,
+  emotions: []
+};
+var DEFAULT_ANALYSIS = {
+  sentiment: DEFAULT_SENTIMENT,
+  keywords: [],
+  entities: [],
+  suggestedImprovements: [],
+  readabilityScore: 50,
+  estimatedEngagement: 50
+};
+var AnalysisService = class {
+  constructor(executor) {
+    this.executor = executor;
+  }
+  executor;
+  async analyzeSentiment(content) {
+    const validated = validateContentBody(content);
+    const prompt = PromptBuilder.sentiment(validated);
+    const result = await this.executor.runJson(
+      prompt,
+      DEFAULT_SENTIMENT,
+      { maxTokens: 200, temperature: 0.3 }
+    );
     return {
-      text: content,
-      finishReason: resp.choices[0]?.finish_reason ?? "stop",
-      model: resp.model,
-      providerId: this.id,
-      usage: resp.usage ? {
-        inputTokens: resp.usage.prompt_tokens,
-        outputTokens: resp.usage.completion_tokens,
-        totalTokens: resp.usage.total_tokens
-      } : void 0
+      ...result,
+      confidence: clampConfidenceToValidRange(result.confidence)
     };
   }
-  async stream(request, callbacks) {
-    const messages = [];
-    if (request.systemPrompt) {
-      messages.push({ role: "system", content: request.systemPrompt });
-    }
-    for (const m of request.messages) {
-      messages.push({ role: m.role, content: m.content });
-    }
-    const model = request.model ?? (request.tier ? this.resolveModel(request.tier) : this.defaultModel);
-    const text = await this.streamChatCompletion(
-      messages,
+  async analyzeContent(request) {
+    const validated = validateContentBody(request.content);
+    const sentimentResult = await this.analyzeSentiment(validated);
+    const prompt = PromptBuilder.contentAnalysis(validated);
+    const parsed = await this.executor.runJson(
+      prompt,
+      { ...DEFAULT_ANALYSIS, sentiment: sentimentResult },
+      { maxTokens: 300, temperature: 0.5 }
+    );
+    return {
+      sentiment: sentimentResult,
+      keywords: parsed.keywords ?? [],
+      entities: parsed.entities ?? [],
+      suggestedImprovements: parsed.suggestedImprovements ?? [],
+      readabilityScore: clampScoreToValidRange(parsed.readabilityScore),
+      estimatedEngagement: clampScoreToValidRange(parsed.estimatedEngagement)
+    };
+  }
+};
+
+// src/content/application/services/SeoService.ts
+var DEFAULT_SEO_SCORE = {
+  keywordDensity: 50,
+  readabilityScore: 50,
+  titleOptimization: 50,
+  metaDescription: 50,
+  headingStructure: 50,
+  internalLinking: 50,
+  overall: 50
+};
+var UNDERUTILIZED_SUGGESTION = "Consider using this keyword more frequently";
+var SeoService = class {
+  constructor(executor) {
+    this.executor = executor;
+  }
+  executor;
+  async optimizeSEO(request) {
+    const content = validateContentBody(request.content);
+    const keywords = validateKeywordList(request.keywords);
+    const prompt = PromptBuilder.seoOptimization(content, keywords);
+    const result = await this.executor.runJson(
+      prompt,
       {
-        onChunk: callbacks.onChunk,
-        onError: callbacks.onError
+        optimized: content,
+        score: 50,
+        suggestions: [],
+        addedKeywords: [],
+        removedFillerWords: 0,
+        readabilityImprovements: []
       },
-      {
-        model,
-        signal: request.signal,
-        generationConfig: {
-          temperature: request.temperature,
-          maxTokens: request.maxTokens
-        }
-      }
+      { maxTokens: 1e3, temperature: 0.7 }
     );
-    const result = {
-      text,
-      finishReason: "stop",
-      model,
-      providerId: this.id
+    return {
+      ...result,
+      score: clampScoreToValidRange(result.score)
     };
-    callbacks.onComplete?.(result);
-    return result;
   }
-  async countTokens(text) {
-    return Math.max(1, Math.ceil(text.length / 4));
+  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)
+    };
   }
-  async estimateCost(_request) {
-    return 0;
+  analyzeKeywords(content, keywords) {
+    const validatedContent = validateContentBody(content);
+    const validatedKeywords = validateKeywordList(keywords);
+    return validatedKeywords.map((keyword) => {
+      const count = countKeywordOccurrences(validatedContent, keyword);
+      const density = calculateKeywordDensity(validatedContent, keyword);
+      return {
+        keyword,
+        count,
+        density,
+        prominence: classifyKeywordProminence(density),
+        suggestions: isUnderutilizedKeyword(density) ? [UNDERUTILIZED_SUGGESTION] : []
+      };
+    });
   }
-  async healthCheck() {
-    try {
-      await this.generateCompletion("ping", {
-        generationConfig: { maxTokens: 1 }
+};
+
+// 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 "healthy";
-    } catch {
-      return "unavailable";
     }
+    return predictions;
+  }
+  async compareVariants(variantA, variantB) {
+    const predictions = await this.predictABTest({
+      variants: [
+        { id: VARIANT_A_ID, content: variantA, contentType: "social", tone: "casual" },
+        { id: VARIANT_B_ID, content: variantB, contentType: "social", tone: "casual" }
+      ],
+      targetAudience: "general",
+      platform: "twitter",
+      goals: ["engagement", "clicks"]
+    });
+    const scoreA = predictions[0]?.predictedEngagement ?? FALLBACK_ENGAGEMENT;
+    const scoreB = predictions[1]?.predictedEngagement ?? FALLBACK_ENGAGEMENT;
+    const isTie = scoreA === scoreB;
+    const winner = selectHigherScoreVariantId(scoreA, scoreB, VARIANT_A_ID, VARIANT_B_ID);
+    const improvement = calculateImprovementPercentage(scoreA, scoreB);
+    return {
+      winner,
+      confidence: AB_TEST_DEFAULT_CONFIDENCE,
+      improvement: isTie ? "0%" : `+${improvement}% engagement`,
+      reasoning: isTie ? "Both variants have equal predicted engagement" : winner === VARIANT_A_ID ? "Variant A has more engaging content" : "Variant B has more engaging content",
+      recommendations: [...DEFAULT_RECOMMENDATIONS]
+    };
   }
-  async executeWithCache(params, factory) {
-    const key = this.cache.generateKey(params);
-    const cached = this.cache.get(key);
-    if (cached !== null) {
-      return cached;
-    }
-    const result = await factory();
-    this.cache.set(key, result);
-    return result;
+};
+
+// src/content/application/services/ImagePromptService.ts
+var ImagePromptService = class {
+  constructor(executor) {
+    this.executor = executor;
   }
-  extractContent(content) {
-    if (!content) {
-      throw new GroqError(
-        "UNKNOWN_ERROR" /* UNKNOWN_ERROR */,
-        "No content generated from Groq API"
-      );
-    }
-    return content;
+  executor;
+  async generateImagePrompt(description, style) {
+    const validated = validateTopicText(description);
+    const prompt = PromptBuilder.imagePrompt(validated, style);
+    return this.executor.runText(prompt, { maxTokens: 300, temperature: 0.8 });
+  }
+  async generateImagePromptsForBlog(blogContent) {
+    const truncated = truncateForBlogPromptPreview(validateContentBody(blogContent));
+    const prompt = PromptBuilder.blogImagePrompts(truncated);
+    const prompts = await this.executor.runJson(prompt, [], {
+      maxTokens: 500,
+      temperature: 0.8
+    });
+    return Array.isArray(prompts) ? prompts : [];
   }
 };
 
-// src/core/calculations/random-base36-suffix.ts
-var BASE_36_RADIX = 36;
-var DECIMAL_OFFSET = 2;
-function generateRandomBase36Suffix(length, random = Math.random) {
-  if (length <= 0) return "";
-  const raw = random().toString(BASE_36_RADIX).slice(DECIMAL_OFFSET);
-  if (raw.length >= length) return raw.slice(0, length);
-  let result = raw;
-  while (result.length < length) {
-    result += random().toString(BASE_36_RADIX).slice(DECIMAL_OFFSET);
+// 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;
   }
-  return result.slice(0, length);
-}
+  executor;
+  async generateContentCalendar(niche, days) {
+    const validatedNiche = validateTopicText(niche);
+    const validatedDays = validateCalendarDays(days);
+    const prompt = PromptBuilder.contentCalendar(validatedNiche, validatedDays);
+    const data = await this.executor.runJson(
+      prompt,
+      [],
+      {
+        maxTokens: estimateTokenBudgetForCalendarDays(validatedDays),
+        temperature: 0.8
+      }
+    );
+    const items = Array.isArray(data) ? data : Array.isArray(data?.calendar) ? data.calendar : Array.isArray(data?.entries) ? data.entries : [];
+    return items.map(toCalendarEntry);
+  }
+};
 
-// src/chat/utils/chat-id-generator.ts
-var ID_PART_DELIMITER = "-";
-var ChatIdGenerator = class {
-  counter = 0;
-  randomLength;
-  constructor(randomLength = CHAT_MESSAGE_ID_SUFFIX_LENGTH) {
-    this.randomLength = randomLength;
+// 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"
+    );
   }
-  next(sender) {
-    this.counter += 1;
-    const random = generateRandomBase36Suffix(this.randomLength);
-    return [
-      MESSAGE_ID_PREFIX,
-      Date.now(),
-      sender,
-      this.counter,
-      random
-    ].join(ID_PART_DELIMITER);
+};
+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);
+    });
   }
 };
-var chatIdGenerator = new ChatIdGenerator();
 
-// src/chat/utils/message-formatter.ts
-var MessageFormatter = class {
-  constructor(idGenerator = chatIdGenerator) {
-    this.idGenerator = idGenerator;
+// src/content/infrastructure/utils/jsonParser.ts
+function repairCommonJsonDefects2(text) {
+  return text.replace(/(:\s*-?\d+(?:\.\d+)?)\s*"/g, "$1").replace(/(:\s*"[^"]*")"/g, "$1");
+}
+function safeJSONParse(text, fallback, onError) {
+  try {
+    return JSON.parse(text);
+  } catch (error) {
+    try {
+      return JSON.parse(repairCommonJsonDefects2(text));
+    } catch {
+    }
+    if (error instanceof SyntaxError) {
+      const positionMatch = error.message.match(/position (\d+)/);
+      const position = positionMatch ? parseInt(positionMatch[1], 10) : -1;
+      if (position > 0) {
+        text.substring(Math.max(0, position - 50), position + 50);
+      }
+    }
+    return fallback;
   }
-  idGenerator;
-  /** Maps chat-domain history to neutral core messages; system senders are
-   *  dropped — the system prompt travels on the request's own slot. */
-  toCoreMessages(messages) {
-    const coreMessages = [];
-    for (const message of messages) {
-      if (message.sender === "system") continue;
-      coreMessages.push({
-        role: message.sender === "user" ? USER_ROLE : ASSISTANT_ROLE,
-        content: message.content
-      });
+}
+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;
     }
-    return coreMessages;
   }
-  toChatMessage(content, sender) {
-    return {
-      id: this.idGenerator.next(sender),
-      sender,
-      content: content.trim(),
-      timestamp: (/* @__PURE__ */ new Date()).toISOString(),
-      type: "text"
-    };
+  const objectMatch = text.match(/\{[\s\S]*\}/);
+  if (objectMatch) {
+    return objectMatch[0];
   }
-};
-var messageFormatter = new MessageFormatter();
+  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/chat/utils/prompt-strategy.ts
-var DEFAULT_PROMPT_STRATEGY = {
-  resolve: (config) => {
-    if (config.systemPrompt && config.systemPrompt.length > 0) {
-      return config.systemPrompt;
+// 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 void 0;
+    return this.generator.chat(request);
   }
 };
 
-// src/chat/services/chat.service.ts
-var DEFAULT_CONFIG = {
-  temperature: 0.8,
-  maxTokens: 500
+// src/content/application/services/AIContentService.ts
+var isTextGenerator = (value) => typeof value === "object" && value !== null && typeof value.generateText === "function";
+function toAIProviderConfig(config) {
+  const legacy = config;
+  const modern = config;
+  const anthropic = modern.anthropic ?? (legacy.anthropic?.enabled ? {
+    apiKey: legacy.anthropic.apiKey,
+    baseUrl: legacy.anthropic.baseUrl,
+    timeoutMs: legacy.anthropic.timeout,
+    models: legacy.anthropic.models,
+    effort: legacy.anthropic.effort
+  } : void 0);
+  const groq = modern.groq ?? (legacy.groq?.enabled ? {
+    apiKey: legacy.groq.apiKey,
+    baseUrl: legacy.groq.baseUrl,
+    timeoutMs: legacy.groq.timeout,
+    // legacy {text, chat} model pins map onto the neutral tier slots
+    ...legacy.groq.models?.text ? { models: { balanced: legacy.groq.models.text } } : {}
+  } : void 0);
+  const gemini = modern.gemini ?? (legacy.gemini?.enabled ? { ...legacy.gemini } : void 0);
+  const fal = modern.fal ?? (legacy.fal?.enabled ? { ...legacy.fal } : void 0);
+  const pruna = modern.pruna ?? (legacy.pruna?.enabled ? { ...legacy.pruna } : void 0);
+  return {
+    priority: modern.priority,
+    fallbackEnabled: modern.fallbackEnabled,
+    defaultTier: modern.defaultTier,
+    ...anthropic ? { anthropic } : {},
+    ...groq ? { groq } : {},
+    ...gemini ? { gemini } : {},
+    ...fal ? { fal } : {},
+    ...pruna ? { pruna } : {}
+  };
+}
+var buildServices = (configOrGenerator) => {
+  if (isTextGenerator(configOrGenerator)) {
+    const executor2 = new GenerationExecutor(configOrGenerator);
+    const emptyFactory = new ProviderFactory({
+      priority: [],
+      fallbackEnabled: false
+    });
+    return {
+      providerFactory: emptyFactory,
+      blogService: new BlogService(executor2),
+      socialService: new SocialService(executor2),
+      videoScriptService: new VideoScriptService(executor2),
+      analysisService: new AnalysisService(executor2),
+      seoService: new SeoService(executor2),
+      abTestService: new ABTestService(executor2),
+      imagePromptService: new ImagePromptService(executor2),
+      contentCalendarService: new ContentCalendarService(executor2),
+      mediaGenerationService: new MediaGenerationService(emptyFactory)
+    };
+  }
+  const factory = createAI(toAIProviderConfig(configOrGenerator));
+  const executor = new GenerationExecutor(factory);
+  return {
+    providerFactory: factory,
+    blogService: new BlogService(executor),
+    socialService: new SocialService(executor),
+    videoScriptService: new VideoScriptService(executor),
+    analysisService: new AnalysisService(executor),
+    seoService: new SeoService(executor),
+    abTestService: new ABTestService(executor),
+    imagePromptService: new ImagePromptService(executor),
+    contentCalendarService: new ContentCalendarService(executor),
+    mediaGenerationService: new MediaGenerationService(factory)
+  };
 };
-var ChatService = class {
-  constructor(engine) {
-    this.engine = engine;
+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;
   }
-  engine;
-  config = DEFAULT_CONFIG;
-  promptStrategy = DEFAULT_PROMPT_STRATEGY;
-  storage = null;
-  initialize(config) {
-    this.config = { ...DEFAULT_CONFIG, ...config };
+  /** The composed factory — chat()/chatStream() with usage, health, fallback. */
+  get providers() {
+    return this.providerFactory;
   }
-  updateConfig(config) {
-    this.config = { ...this.config, ...config };
+  generateBlogPost(request) {
+    return this.blogService.generateBlogPost(request);
   }
-  setPromptStrategy(strategy) {
-    this.promptStrategy = strategy;
+  generateSocialContent(request) {
+    return this.socialService.generateSocialContent(request);
   }
-  setStorage(storage) {
-    this.storage = storage;
+  generateForAllPlatforms(topic, tone) {
+    return this.socialService.generateForAllPlatforms(topic, tone);
   }
-  async getConversation(conversationId) {
-    const storage = this.requireStorage();
-    const messages = await storage.getMessages(conversationId);
-    if (messages.length === 0) return null;
-    const last = messages[messages.length - 1];
-    const first = messages[0];
-    const companionId = String(first.metadata?.["companionId"] ?? "unknown");
-    const companionName = String(first.metadata?.["companionName"] ?? "Unknown");
-    return {
-      id: conversationId,
-      companionId,
-      companionName,
-      lastMessage: last,
-      messageCount: messages.length,
-      updatedAt: last.timestamp
-    };
+  generateHashtags(content, count) {
+    return this.socialService.generateHashtags(content, count);
   }
-  async getConversations() {
-    if (this.storage && "getConversations" in this.storage && typeof this.storage.getConversations === "function") {
-      return this.storage.getConversations();
-    }
-    return [];
+  optimizeHashtags(hashtags, platform) {
+    return Promise.resolve(this.socialService.optimizeHashtags(hashtags, platform));
   }
-  async sendMessage(input, signal) {
-    const userMessage = {
-      ...messageFormatter.toChatMessage(input.text, "user"),
-      type: input.type ?? "text",
-      ...input.imageUrl !== void 0 ? { imageUrl: input.imageUrl } : {}
-    };
-    const aiResponse = await this.generateAIResponse(
-      input.companionId,
-      input.text,
-      [],
-      signal
-    );
-    return { userMessage, aiResponse };
+  generateVideoScript(request) {
+    return this.videoScriptService.generateVideoScript(request);
   }
-  async generateAIResponse(companionId, userMessage, context = [], signal) {
-    const result = await this.run({
-      ...this.buildRequest(userMessage, context, signal)
-    });
-    return {
-      ...messageFormatter.toChatMessage(result.text, "assistant"),
-      metadata: {
-        companionId,
-        model: result.model,
-        usage: {
-          input_tokens: result.usage?.inputTokens,
-          output_tokens: result.usage?.outputTokens,
-          total_tokens: result.usage?.totalTokens
-        },
-        finishReason: result.finishReason
-      }
-    };
+  generateVoiceScript(topic, emotion, duration) {
+    return this.videoScriptService.generateVoiceScript(topic, emotion, duration);
   }
-  async generateStreamingResponse(userMessage, context, onChunk, signal) {
-    const request = this.buildRequest(userMessage, context, signal);
-    const result = await this.runStream(request, { onChunk });
-    return result.text;
+  generateContentCalendar(niche, days) {
+    return this.contentCalendarService.generateContentCalendar(niche, days);
   }
-  buildRequest(userMessage, context, signal) {
-    const messages = messageFormatter.toCoreMessages(context);
-    messages.push({ role: "user", content: userMessage });
-    return {
-      messages,
-      systemPrompt: this.resolveSystemPrompt(),
-      model: this.config.model,
-      tier: this.config.tier,
-      temperature: this.config.temperature,
-      maxTokens: this.config.maxTokens,
-      ...signal !== void 0 ? { signal } : {}
-    };
+  analyzeSentiment(content) {
+    return this.analysisService.analyzeSentiment(content);
   }
-  resolveSystemPrompt() {
-    const prompt = this.promptStrategy.resolve(this.config);
-    return prompt && prompt.length > 0 ? prompt : void 0;
+  analyzeContent(request) {
+    return this.analysisService.analyzeContent(request);
   }
-  async run(request) {
-    if (this.engine instanceof ProviderFactory) {
-      return this.engine.chat(request);
-    }
-    return this.engine.generate(request);
+  optimizeSEO(request) {
+    return this.seoService.optimizeSEO(request);
   }
-  async runStream(request, callbacks) {
-    if (this.engine instanceof ProviderFactory) {
-      return this.engine.chatStream(request, callbacks);
-    }
-    return this.engine.stream(request, callbacks);
+  calculateSEOScore(content, keywords) {
+    return this.seoService.calculateSEOScore(content, keywords);
   }
-  requireStorage() {
-    if (!this.storage) {
-      throw new AIError(
-        "MISSING_CONFIG" /* MISSING_CONFIG */,
-        "ChatService.getConversation requires setStorage() to be called first."
-      );
-    }
-    return this.storage;
+  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);
   }
 };
-function extractTokenUsage(message) {
-  const meta = message.metadata;
-  if (!meta) return null;
-  const usage = meta["usage"];
-  if (!usage || typeof usage !== "object") return null;
-  const u = usage;
-  const inputTokens = readNumber(u, ["input_tokens", "prompt_tokens"]);
-  const outputTokens = readNumber(u, ["output_tokens", "completion_tokens"]);
-  const totalTokens = readNumber(u, ["total_tokens"]);
-  if (inputTokens === null || outputTokens === null || totalTokens === null) {
-    return null;
+
+// src/wizard/content.wizard.ts
+var CONTENT_WIZARD_STEPS = [
+  {
+    id: "select-type",
+    label: "Select Type",
+    icon: "Layers",
+    description: "Choose the type of content you want to generate",
+    validate: (data) => Boolean(data.contentType)
+  },
+  {
+    id: "input-topic",
+    label: "Topic",
+    icon: "Lightbulb",
+    description: "Enter your topic or idea",
+    validate: (data) => {
+      const topic = data.topic;
+      return typeof topic === "string" && topic.length > 0;
+    }
+  },
+  {
+    id: "configure",
+    label: "Configure",
+    icon: "Settings",
+    description: "Set tone, audience, and platform",
+    validate: (data) => {
+      const d = data;
+      return Boolean(d.tone && d.targetAudience);
+    }
+  },
+  {
+    id: "advanced",
+    label: "Advanced",
+    icon: "Sliders",
+    description: "Additional options and optimizations",
+    optional: true
+  },
+  {
+    id: "preview",
+    label: "Preview",
+    icon: "Eye",
+    description: "Review your settings before generation"
+  },
+  {
+    id: "generating",
+    label: "Generating",
+    icon: "Sparkles",
+    description: "AI is generating your content"
+  },
+  {
+    id: "results",
+    label: "Results",
+    icon: "CheckCircle",
+    description: "Your generated content is ready"
   }
-  return {
-    promptTokens: inputTokens,
-    completionTokens: outputTokens,
-    totalTokens
-  };
-}
-function readNumber(source, keys) {
-  for (const key of keys) {
-    const value = source[key];
-    if (typeof value === "number") return value;
+];
+function buildContentRequest(data) {
+  switch (data.contentType) {
+    case "blog":
+      return {
+        topic: data.topic ?? "",
+        blogType: "tutorial",
+        targetKeywords: data.keywords ?? [],
+        tone: data.tone ?? "professional",
+        wordCount: data.wordCount ?? 1e3,
+        targetAudience: data.targetAudience ?? "",
+        seoOptimization: data.seoOptimization ?? false,
+        includeImages: data.includeImages ?? false,
+        includeSchema: false
+      };
+    case "social":
+      return {
+        topic: data.topic ?? "",
+        platform: data.platform ?? "twitter",
+        tone: data.tone ?? "casual",
+        hashtags: true,
+        targetAudience: data.targetAudience,
+        includeCallToAction: data.includeCallToAction
+      };
+    case "script":
+      return {
+        topic: data.topic ?? "",
+        tone: data.tone ?? "professional",
+        duration: data.duration ?? 60,
+        targetAudience: data.targetAudience ?? "",
+        includeVisuals: true,
+        includeCallToAction: data.includeCallToAction ?? false
+      };
+    default:
+      throw new Error(`Unsupported content type: ${data.contentType}`);
   }
-  return null;
 }
 
-// src/providers/groq/groq-container.ts
-var container = null;
-function configureProvider(config) {
-  const configStore = new GroqConfigStore();
-  const transport = new GroqHttpTransport(configStore);
-  const httpClient = new GroqHttpClient({ configStore, transport });
-  httpClient.initialize(config);
-  const textGeneration = new TextGenerationService(
-    httpClient,
-    new CacheManager(),
-    config.textModel
-  );
-  const chat = new ChatService(textGeneration);
-  container = { groqHttpClient: httpClient, textGeneration, chat };
-  return container;
-}
-function getProvider() {
-  return container;
+// src/wizard/image.wizard.ts
+var IMAGE_WIZARD_STEPS = [
+  {
+    id: "input-prompt",
+    label: "Describe Image",
+    icon: "Image",
+    description: "Describe the image you want to create",
+    validate: (data) => {
+      const prompt = data.prompt;
+      return typeof prompt === "string" && prompt.length > 0;
+    }
+  },
+  {
+    id: "select-style",
+    label: "Style",
+    icon: "Palette",
+    description: "Choose the artistic style",
+    validate: (data) => Boolean(data.style)
+  },
+  {
+    id: "configure",
+    label: "Configure",
+    icon: "Settings",
+    description: "Set format, quality, and quantity",
+    validate: (data) => {
+      const d = data;
+      return Boolean(d.format && d.quality);
+    }
+  },
+  {
+    id: "advanced",
+    label: "Advanced",
+    icon: "Sliders",
+    description: "Color palette and platform optimization",
+    optional: true
+  },
+  { id: "preview", label: "Preview", icon: "Eye", description: "Review your settings" },
+  { id: "generating", label: "Generating", icon: "Sparkles", description: "AI is creating your image" },
+  { id: "results", label: "Results", icon: "Image", description: "Your generated image is ready" }
+];
+function buildImageRequest(data) {
+  return {
+    type: "image",
+    prompt: data.prompt ?? "",
+    style: data.style,
+    format: data.format,
+    quality: data.quality,
+    quantity: data.quantity ?? 1
+  };
 }
-function resetProvider() {
-  container?.groqHttpClient.reset();
-  container = null;
+
+// src/wizard/video.wizard.ts
+var validateSource = (data) => {
+  const d = data;
+  if (d.generationType === "text-to-video") {
+    return typeof d.prompt === "string" && d.prompt.length > 0;
+  }
+  if (d.generationType === "image-to-video") {
+    return typeof d.imageUrl === "string" && d.imageUrl.length > 0;
+  }
+  if (d.generationType === "video-to-video") {
+    return typeof d.sourceVideoUrl === "string" && d.sourceVideoUrl.length > 0 && typeof d.prompt === "string" && d.prompt.length > 0;
+  }
+  return false;
+};
+var VIDEO_WIZARD_STEPS = [
+  {
+    id: "select-type",
+    label: "Select Type",
+    icon: "Video",
+    description: "Choose video generation type",
+    validate: (data) => Boolean(data.generationType)
+  },
+  {
+    id: "input-source",
+    label: "Source",
+    icon: "FileInput",
+    description: "Provide your source (prompt, image, or video)",
+    validate: validateSource
+  },
+  {
+    id: "configure",
+    label: "Configure",
+    icon: "Settings",
+    description: "Set duration, aspect ratio, and style",
+    validate: (data) => {
+      const d = data;
+      return Boolean(d.duration && d.aspectRatio);
+    }
+  },
+  { id: "advanced", label: "Advanced", icon: "Sliders", description: "Additional video options", optional: true },
+  { id: "preview", label: "Preview", icon: "Eye", description: "Review your settings" },
+  { id: "generating", label: "Generating", icon: "Sparkles", description: "AI is creating your video" },
+  { id: "results", label: "Results", icon: "Video", description: "Your generated video is ready" }
+];
+function buildVideoRequest(data) {
+  switch (data.generationType) {
+    case "text-to-video":
+      return {
+        type: "video",
+        prompt: data.prompt ?? "",
+        duration: data.duration ?? 5,
+        aspectRatio: data.aspectRatio ?? "16:9",
+        style: data.style,
+        quality: data.quality
+      };
+    case "image-to-video":
+      return {
+        type: "video",
+        imageUrl: data.imageUrl ?? "",
+        prompt: data.prompt,
+        duration: data.duration ?? 5,
+        motion: data.motion ?? "medium",
+        camera: data.camera ?? "static"
+      };
+    case "video-to-video":
+      return {
+        type: "video",
+        sourceVideoUrl: data.sourceVideoUrl ?? "",
+        prompt: data.prompt ?? "",
+        styleTransfer: data.styleTransfer,
+        enhanceQuality: data.enhanceQuality
+      };
+    default:
+      throw new Error(`Unsupported generation type: ${data.generationType}`);
+  }
 }
 
-export { AIError, AIErrorType, ANTHROPIC_API_VERSION, ANTHROPIC_DEFAULT_MAX_TOKENS, ANTHROPIC_MODELS, ANTHROPIC_TIERS, API_ENDPOINTS, AnthropicHttpTransport, AnthropicProvider, AnthropicRequestBuilder, BaseProvider, CacheManager, ChatIdGenerator, ChatService, CompositeExecutor, DEFAULT_API_KEY_RULE, DEFAULT_BASE_URL, DEFAULT_ERROR_CLASSIFICATION_RULE, DEFAULT_GENERATION_CONFIG, DEFAULT_HTTP_STATUS_RULE, DEFAULT_MODELS, DEFAULT_PROMPT_STRATEGY, DEFAULT_RETRY_BACKOFF_MULTIPLIER, DEFAULT_RETRY_INITIAL_DELAY_MS, DEFAULT_RETRY_JITTER_FACTOR, DEFAULT_RETRY_MAX_ATTEMPTS, DEFAULT_RETRY_MAX_DELAY_MS, DebounceManager, DedupeExecutor, FalProvider, GEMINI_TIERS, GROQ_MODELS, GROQ_TIERS, GeminiProvider, GroqChatRequestBuilder, GroqConfigStore, GroqError, AIErrorType as GroqErrorType, GroqHttpClient, GroqHttpTransport, GroqProvider, JSON_CODE_BLOCK_PATTERN, JSON_OBJECT_PATTERN, JsonResponseParser, ProviderError, ProviderFactory, PrunaProvider, QueueExecutor, RequestDeduplicator, RequestQueue, RetryExecutor, RetryManager, SSE_BRIDGE_EVENTS, SSE_DONE_MARKER, SSE_PREFIX, StreamingResponseParser, StructuredPromptBuilder, TEXT_TIERS, TIMEOUTS, TextGenerationService, ThrottleManager, USER_FRIENDLY_ERROR_MESSAGES, asObjectArray, asRecord, asStringArray, asTrimmedOptionalString, buildCacheKey, buildHttpStatusFallback, cacheManager, chatIdGenerator, clampScore, classifyHttpStatus, configureProvider, consumeAnthropicStream, consumeGroqStream, createAI, createAssistantMessage, createFalProvider, createGeminiProvider, createMessage, createPrunaProvider, createSseResponse, createSystemMessage, createUserMessage, debounce, debounceManager, defaultEffortForModel, describeAIErrorType, extractContentFromSsePayload, extractErrorMessageFromJsonBody, extractErrorMessageFromResponse, extractJsonArray, extractJsonCandidate, extractJsonFromCodeFence, extractJsonObject, extractSseDataPayload, extractTextFromMessages, extractTokenUsage, formatErrorForLogging, formatMessagesForDisplay, generateWithPruna, getProvider, isAuthErrorType, isMediaProvider, isRetryableErrorType, isSseDataLine, isSseDoneMarker, isTextProvider, isTextTier, isValidApiKey, mapAnthropicStopReason, mergeTierOverrides, messageFormatter, normalizeSseChunk, oneOfCatalog, promptToMessages, repairCommonJsonDefects, requestDeduplicator, requestQueue, requestStructuredJson, resetProvider, resolveModel, resolveUserFriendlyErrorMessage, resolveUserFriendlyMessage, retryManager, splitSseLines, throttle, throttleManager, toGroqMessages, validateApiKey, withRetry };
+export { ABTestService, AIContentService, AIError, AIErrorType, ANTHROPIC_API_VERSION, ANTHROPIC_DEFAULT_MAX_TOKENS, ANTHROPIC_MODELS, ANTHROPIC_TIERS, API_ENDPOINTS, ASPECT_RATIO_OPTIONS, ASPECT_RATIO_VALUES, AnalysisService, AnthropicHttpTransport, AnthropicProvider, AnthropicRequestBuilder, AuthenticationError, BaseProvider as BaseAIProvider, BaseProvider, BlogService, CONTENT_WIZARD_STEPS, CacheManager, CancellationError, ChatIdGenerator, ChatService, CompositeExecutor, ContentCalendarService, DEFAULT_API_KEY_RULE, DEFAULT_BASE_URL, DEFAULT_ERROR_CLASSIFICATION_RULE, DEFAULT_GENERATION_CONFIG, DEFAULT_HTTP_STATUS_RULE, DEFAULT_MODELS, DEFAULT_PROMPT_STRATEGY, DEFAULT_RETRY_BACKOFF_MULTIPLIER, DEFAULT_RETRY_INITIAL_DELAY_MS, DEFAULT_RETRY_JITTER_FACTOR, DEFAULT_RETRY_MAX_ATTEMPTS, DEFAULT_RETRY_MAX_DELAY_MS, DebounceManager, DedupeExecutor, FalProvider, GEMINI_TIERS, CREDIT_COSTS as GENERATION_COSTS, GROQ_MODELS, GROQ_TIERS, GeminiProvider, GenerationExecutor, GenerationFailedError, GroqChatRequestBuilder, GroqConfigStore, GroqError, AIErrorType as GroqErrorType, GroqHttpClient, GroqHttpTransport, GroqProvider, IMAGE_QUALITY_OPTIONS, IMAGE_QUALITY_VALUES, IMAGE_WIZARD_STEPS, ImagePromptService, JSON_CODE_BLOCK_PATTERN, JSON_OBJECT_PATTERN, JsonResponseParser, MOTION_OPTIONS, MediaGenerationService, PromptBuilder, ProviderError, ProviderFactory, ProviderQuotaExhaustedError, ProviderUnavailableError, PrunaProvider, QueueExecutor, RequestDeduplicator, RequestQueue, RetryExecutor, RetryManager, SSE_BRIDGE_EVENTS, SSE_DONE_MARKER, SSE_PREFIX, STYLE_PRESETS, SeoService, SocialService, StreamingResponseParser, StructuredPromptBuilder, TEXT_TIERS, TIMEOUTS, TextGenerationService, ThrottleManager, TimeoutError, USER_FRIENDLY_ERROR_MESSAGES, VIDEO_DURATION_OPTIONS, VIDEO_DURATION_OPTIONS_SECONDS, VIDEO_QUALITY_OPTIONS, VIDEO_QUALITY_VALUES, VIDEO_WIZARD_STEPS, ValidationError2 as ValidationError, VideoScriptService, asObjectArray, asRecord, asStringArray, asTrimmedOptionalString, buildCacheKey, buildContentRequest, buildHttpStatusFallback, buildImageRequest, buildVideoRequest, cacheManager, calculateContentCreditCost as calculateCreditCost, chatIdGenerator, clampScore, classifyHttpStatus, configureProvider, consumeAnthropicStream, consumeGroqStream, createAI, createAssistantMessage, createFalProvider, createGeminiProvider, createGroqProvider, createMessage, createProviderFactory, createPrunaProvider, createSseResponse, createSystemMessage, createUserMessage, debounce, debounceManager, defaultEffortForModel, describeAIErrorType, extractContentFromSsePayload, extractErrorMessageFromJsonBody, extractErrorMessageFromResponse, extractJsonArray, extractJsonCandidate, extractJsonFromCodeFence, extractJsonObject, extractSseDataPayload, extractTextFromMessages, extractTokenUsage, formatErrorForLogging, formatMessagesForDisplay, generateImageThenVideo, generate as generatePruna, generateWithPruna, getDimensionsForAspectRatio, getProvider, getRecommendedQuality, isAuthErrorType, isMediaProvider, isRetryableErrorType, isSseDataLine, isSseDoneMarker, isTextProvider, isTextTier, isValidApiKey, mapAnthropicStopReason, mergeTierOverrides, messageFormatter, normalizeSseChunk, oneOfCatalog, pollForResult, promptToMessages, repairCommonJsonDefects, requestDeduplicator, requestQueue, requestStructuredJson, resetProvider, resolveModel, resolveUserFriendlyErrorMessage, resolveUserFriendlyMessage, retryManager, splitSseLines, submitPrediction, throttle, throttleManager, toGroqMessages, uploadImage, validateApiKey, withRetry };
 //# sourceMappingURL=index.js.map
 //# sourceMappingURL=index.js.map