@infuro/cms-core 1.0.18 → 1.0.20

package/dist/index.cjs

@@ -653,6 +653,7 @@ __export(src_exports, {
   FormSubmission: () => FormSubmission,
   KnowledgeBaseChunk: () => KnowledgeBaseChunk,
   KnowledgeBaseDocument: () => KnowledgeBaseDocument,
+  LlmAgent: () => LlmAgent,
   LlmService: () => LlmService,
   Media: () => Media,
   MessageTemplate: () => MessageTemplate,
@@ -702,6 +703,7 @@ __export(src_exports, {
   createForgotPasswordHandler: () => createForgotPasswordHandler,
   createFormBySlugHandler: () => createFormBySlugHandler,
   createInviteAcceptHandler: () => createInviteAcceptHandler,
+  createLlmAgentKnowledgeHandlers: () => createLlmAgentKnowledgeHandlers,
   createMediaZipExtractHandler: () => createMediaZipExtractHandler,
   createOtpChallenge: () => createOtpChallenge,
   createSetPasswordHandler: () => createSetPasswordHandler,
@@ -735,13 +737,17 @@ __export(src_exports, {
   isZipMedia: () => isZipMedia,
   joinRecipientsForSend: () => joinRecipientsForSend,
   linkUnclaimedContactToUser: () => linkUnclaimedContactToUser,
+  llmAgentToChatAgentOptions: () => llmAgentToChatAgentOptions,
   llmPlugin: () => llmPlugin,
   loadPublicThemeSettings: () => loadPublicThemeSettings,
   localStoragePlugin: () => localStoragePlugin,
   mergeEmailLayoutCompanyDetails: () => mergeEmailLayoutCompanyDetails,
+  mergeGuardrailsIntoSystemPrompt: () => mergeGuardrailsIntoSystemPrompt,
   mergeSeoBySlug: () => mergeSeoBySlug,
   normalizePhoneE164: () => normalizePhoneE164,
   parseEmailRecipientsFromConfig: () => parseEmailRecipientsFromConfig,
+  parseHfInferenceEmbeddingBody: () => parseHfInferenceEmbeddingBody,
+  parseLlmAgentValidationRules: () => parseLlmAgentValidationRules,
   paymentPlugin: () => paymentPlugin,
   permissionRowsToRecord: () => permissionRowsToRecord,
   queueEmail: () => queueEmail,
@@ -773,6 +779,8 @@ __export(src_exports, {
   smsPlugin: () => smsPlugin,
   truncateText: () => truncateText,
   validateSlug: () => validateSlug,
+  validateUserMessageAgainstAgentRules: () => validateUserMessageAgainstAgentRules,
+  validateUserMessageAgainstStructuredRules: () => validateUserMessageAgainstStructuredRules,
   verifyAndConsumeOtpChallenge: () => verifyAndConsumeOtpChallenge,
   verifyOtpCodeHash: () => verifyOtpCodeHash
 });
@@ -2605,29 +2613,111 @@ function localStoragePlugin(config = {}) {
 }
 
 // src/plugins/llm/llm-service.ts
+function parseHfInferenceEmbeddingBody(data) {
+  if (data === null || data === void 0) return null;
+  if (Array.isArray(data)) {
+    if (data.length === 0) return null;
+    const first = data[0];
+    if (typeof first === "number") return data;
+    if (Array.isArray(first) && first.length > 0 && typeof first[0] === "number") {
+      return first;
+    }
+    if (Array.isArray(first) && Array.isArray(first[0]) && typeof first[0][0] === "number") {
+      return first[0];
+    }
+    return null;
+  }
+  if (typeof data === "object" && data !== null && !Array.isArray(data)) {
+    const o = data;
+    if (typeof o.error === "string") return null;
+    if ("embeddings" in o) return parseHfInferenceEmbeddingBody(o.embeddings);
+  }
+  return null;
+}
 var LlmService = class _LlmService {
-  constructor(baseURL, apiKey, defaultEmbeddingModel) {
-    this.baseURL = baseURL;
+  static embedHttpErrorLogged = false;
+  static embedShapeErrorLogged = false;
+  static embedSuccessLogged = false;
+  static hfDimensionMismatchWarned = false;
+  baseURL;
+  apiKey;
+  defaultEmbeddingModel;
+  embeddingProvider;
+  hfInferenceBaseURL;
+  embeddingApiKey;
+  constructor(baseURL, apiKey, defaultEmbeddingModel, embedOpts) {
+    this.baseURL = baseURL.replace(/\/$/, "");
     this.apiKey = apiKey;
     this.defaultEmbeddingModel = defaultEmbeddingModel;
+    const p = (embedOpts?.embeddingProvider ?? "openai").toLowerCase();
+    this.embeddingProvider = p === "huggingface" ? "huggingface" : "openai";
+    this.hfInferenceBaseURL = (embedOpts?.hfInferenceBaseUrl ?? "https://api-inference.huggingface.co").replace(
+      /\/$/,
+      ""
+    );
+    this.embeddingApiKey = (embedOpts?.embeddingApiKey ?? apiKey).trim();
   }
-  static embedWarned = false;
   get base() {
     return this.baseURL.replace(/\/$/, "");
   }
   get url() {
     return `${this.base}/v1/chat/completions`;
   }
-  /**
-   * OpenAI-compatible embeddings. Returns [] if endpoint not available or unexpected response.
-   * Server must implement: POST /v1/embeddings
-   * Body: { model: string, input: string }
-   * Response: { data: [ { embedding: number[] } ] } or { embedding: number[] }
-   */
+  llmDebugEnabled() {
+    const v = process.env.LLM_DEBUG?.toLowerCase();
+    return v === "1" || v === "true" || v === "yes";
+  }
+  /** Per-request embedding logs (noisy with many chunks). Set `LLM_EMBED_DEBUG=1`. */
+  embedDebugEnabled() {
+    const v = process.env.LLM_EMBED_DEBUG?.toLowerCase();
+    return v === "1" || v === "true" || v === "yes";
+  }
+  logAgentComposition(options) {
+    if (!this.llmDebugEnabled()) return;
+    const { systemPrompt, context, history = [], userPrompt, model, temperature, max_tokens } = options;
+    console.log("\n[LLM chatAgent] composing request");
+    if (systemPrompt?.trim()) {
+      console.log("[System instruction]\n", systemPrompt.trim());
+    }
+    if (context?.trim()) {
+      console.log("[Context \u2014 merged into system message by chatAgent]\n", context.trim());
+    }
+    if (history.length > 0) {
+      console.log("[Conversation so far]");
+      for (const m of history) {
+        console.log(`  ${m.role}: ${m.content}`);
+      }
+    }
+    console.log("[Current user message]\n", userPrompt);
+    if (model !== void 0 || temperature !== void 0 || max_tokens !== void 0) {
+      console.log("[Agent options]", { model, temperature, max_tokens });
+    }
+  }
+  logChatCompletionsRequest(kind, messages, options, stream) {
+    if (!this.llmDebugEnabled()) return;
+    const model = options.model ?? "meta-llama/Meta-Llama-3-8B-Instruct";
+    console.log(`
+[LLM ${kind}] POST`, this.url);
+    console.log("[Request options]", {
+      model,
+      temperature: options.temperature,
+      max_tokens: options.max_tokens,
+      stream
+    });
+    console.log("[Messages \u2014 wire payload]\n", JSON.stringify(messages, null, 2));
+  }
   async embed(text, options = {}) {
-    const model = options.model ?? this.defaultEmbeddingModel ?? "text-embedding-3-small";
     const input = text.slice(0, 8e3);
-    const res = await fetch(`${this.base}/v1/embeddings`, {
+    if (this.embeddingProvider === "huggingface") {
+      const model2 = options.model ?? this.defaultEmbeddingModel ?? "sentence-transformers/all-MiniLM-L6-v2";
+      return this.embedHuggingFaceInference(input, model2);
+    }
+    const model = options.model ?? this.defaultEmbeddingModel ?? "text-embedding-3-small";
+    const embedUrl = `${this.base}/v1/embeddings`;
+    if (this.embedDebugEnabled()) {
+      console.info("[LLM embed] request", { url: embedUrl, model, inputChars: input.length });
+    }
+    const res = await fetch(embedUrl, {
       method: "POST",
       headers: {
         "Content-Type": "application/json",
@@ -2640,9 +2730,17 @@ var LlmService = class _LlmService {
     });
     if (!res.ok) {
       const body = await res.text();
-      if (!_LlmService.embedWarned) {
-        _LlmService.embedWarned = true;
-        console.warn(`[LLM embed] ${res.status} ${res.statusText}: ${body.slice(0, 400)}`);
+      const hint404 = res.status === 404 ? "This base URL does not expose OpenAI-compatible POST /v1/embeddings (e.g. router.huggingface.co). Set EMBEDDING_PROVIDER=huggingface and EMBEDDING_MODEL to a HF Inference\u2013supported embedding model, or use a host with /v1/embeddings." : "Embeddings HTTP error \u2014 knowledge_base_chunks.embedding will stay NULL for failed calls.";
+      if (!_LlmService.embedHttpErrorLogged) {
+        _LlmService.embedHttpErrorLogged = true;
+        console.error("[LLM embed]", hint404, {
+          url: embedUrl,
+          status: res.status,
+          statusText: res.statusText,
+          bodyPreview: body.slice(0, 800)
+        });
+      } else if (this.embedDebugEnabled()) {
+        console.warn("[LLM embed] repeat HTTP error", { status: res.status, bodyPreview: body.slice(0, 200) });
       }
       return [];
     }
@@ -2650,7 +2748,10 @@ var LlmService = class _LlmService {
     try {
       data = await res.json();
     } catch {
-      console.warn("[LLM embed] Response is not JSON");
+      if (!_LlmService.embedShapeErrorLogged) {
+        _LlmService.embedShapeErrorLogged = true;
+        console.error("[LLM embed] Response body is not JSON \u2014 treating as no embedding.");
+      }
       return [];
     }
     let embedding = data?.data?.[0]?.embedding;
@@ -2661,13 +2762,154 @@ var LlmService = class _LlmService {
       const first = data.data[0];
       embedding = Array.isArray(first) ? first : first?.embedding;
     }
-    if (!Array.isArray(embedding) && !_LlmService.embedWarned) {
-      _LlmService.embedWarned = true;
-      console.warn("[LLM embed] Unexpected response shape. Keys:", Object.keys(data), "data[0] type:", Array.isArray(data?.data) ? typeof data.data[0] : "n/a");
+    if (!Array.isArray(embedding)) {
+      if (!_LlmService.embedShapeErrorLogged) {
+        _LlmService.embedShapeErrorLogged = true;
+        console.error(
+          "[LLM embed] Response OK but no parseable embedding array (OpenAI shape expected). knowledge_base_chunks will not update.",
+          {
+            url: embedUrl,
+            topKeys: Object.keys(data),
+            data0Type: Array.isArray(data?.data) ? typeof data.data[0] : "n/a"
+          }
+        );
+      }
+      return [];
+    }
+    if (!_LlmService.embedSuccessLogged) {
+      _LlmService.embedSuccessLogged = true;
+      console.info("[LLM embed] first success", { dimension: embedding.length, model });
+    } else if (this.embedDebugEnabled()) {
+      console.info("[LLM embed] ok", { dimension: embedding.length });
+    }
+    return embedding;
+  }
+  async embedHuggingFaceInference(input, model) {
+    const normalizedBase = this.hfInferenceBaseURL.replace(/\/$/, "");
+    const baseWithProvider = /router\.huggingface\.co\/hf-inference$/i.test(normalizedBase) ? normalizedBase : /router\.huggingface\.co$/i.test(normalizedBase) ? `${normalizedBase}/hf-inference` : normalizedBase;
+    const requestBody = JSON.stringify({
+      inputs: input,
+      options: { wait_for_model: true }
+    });
+    const pipelineUrl = `${baseWithProvider}/pipeline/feature-extraction/${model}`;
+    const modelUrl = `${baseWithProvider}/models/${model}`;
+    if (this.embedDebugEnabled()) {
+      console.info("[LLM embed HF]", { url: pipelineUrl, model, inputChars: input.length });
+    }
+    let embedUrl = pipelineUrl;
+    let res = await fetch(embedUrl, {
+      method: "POST",
+      headers: {
+        "Content-Type": "application/json",
+        Authorization: `Bearer ${this.embeddingApiKey}`
+      },
+      body: requestBody
+    });
+    let bodyText = await res.text();
+    if (res.status === 404) {
+      embedUrl = modelUrl;
+      if (this.embedDebugEnabled()) {
+        console.warn("[LLM embed HF] /pipeline route returned 404; retrying with /models.", {
+          model,
+          fallbackUrl: embedUrl
+        });
+      }
+      res = await fetch(embedUrl, {
+        method: "POST",
+        headers: {
+          "Content-Type": "application/json",
+          Authorization: `Bearer ${this.embeddingApiKey}`
+        },
+        body: requestBody
+      });
+      bodyText = await res.text();
+    }
+    if (!res.ok) {
+      if (!_LlmService.embedHttpErrorLogged) {
+        _LlmService.embedHttpErrorLogged = true;
+        console.error(
+          "[LLM embed HF] Hugging Face Inference request failed \u2014 knowledge chunks stay without vectors.",
+          {
+            url: embedUrl,
+            status: res.status,
+            statusText: res.statusText,
+            bodyPreview: bodyText.slice(0, 800),
+            hint: res.status === 410 || res.status === 404 ? "Model or route unavailable on Inference API; pick another EMBEDDING_MODEL (e.g. sentence-transformers/all-MiniLM-L6-v2)." : void 0
+          }
+        );
+      } else if (this.embedDebugEnabled()) {
+        console.warn("[LLM embed HF] repeat HTTP error", { status: res.status, bodyPreview: bodyText.slice(0, 200) });
+      }
+      return [];
+    }
+    let data;
+    try {
+      data = JSON.parse(bodyText);
+    } catch {
+      if (!_LlmService.embedShapeErrorLogged) {
+        _LlmService.embedShapeErrorLogged = true;
+        console.error("[LLM embed HF] Response is not JSON \u2014 treating as no embedding.");
+      }
+      return [];
+    }
+    const embedding = parseHfInferenceEmbeddingBody(data);
+    if (!embedding?.length) {
+      if (!_LlmService.embedShapeErrorLogged) {
+        _LlmService.embedShapeErrorLogged = true;
+        const preview = typeof data === "object" && data !== null && !Array.isArray(data) ? Object.keys(data) : typeof data;
+        console.error("[LLM embed HF] Unrecognized embedding shape from Inference API.", { url: embedUrl, preview });
+      }
+      return [];
+    }
+    if (!_LlmService.embedSuccessLogged) {
+      _LlmService.embedSuccessLogged = true;
+      console.info("[LLM embed HF] first success", { dimension: embedding.length, model });
+      if (!_LlmService.hfDimensionMismatchWarned && embedding.length !== 1536) {
+        _LlmService.hfDimensionMismatchWarned = true;
+        console.warn(
+          `[LLM embed HF] Embedding dimensions=${embedding.length}; default CMS migration uses vector(1536). If pgvector updates fail, alter the column, e.g. ALTER TABLE knowledge_base_chunks ALTER COLUMN embedding TYPE vector(${embedding.length});`
+        );
+      }
+    } else if (this.embedDebugEnabled()) {
+      console.info("[LLM embed HF] ok", { dimension: embedding.length });
+    }
+    return embedding;
+  }
+  buildAgentMessages(options) {
+    const { systemPrompt, userPrompt, history = [], context } = options;
+    const messages = [];
+    let systemContent = systemPrompt?.trim();
+    if (context) {
+      systemContent = systemContent ? `${systemContent}
+
+Context:
+${context}` : `Use the following context to answer:
+
+${context}`;
+    }
+    if (systemContent) {
+      messages.push({ role: "system", content: systemContent });
     }
-    return Array.isArray(embedding) ? embedding : [];
+    if (history.length > 0) {
+      messages.push(...history);
+    }
+    messages.push({ role: "user", content: userPrompt });
+    return messages;
+  }
+  async chatAgent(options) {
+    this.logAgentComposition(options);
+    const messages = this.buildAgentMessages(options);
+    const { model, temperature, max_tokens } = options;
+    return this.chat(messages, { model, temperature, max_tokens });
+  }
+  async *streamChatAgent(options) {
+    this.logAgentComposition(options);
+    const messages = this.buildAgentMessages(options);
+    const { model, temperature, max_tokens } = options;
+    yield* this.streamChat(messages, { model, temperature, max_tokens });
   }
   async chat(messages, options = {}) {
+    this.logChatCompletionsRequest("chat", messages, options, false);
     const res = await fetch(this.url, {
       method: "POST",
       headers: {
@@ -2675,7 +2917,7 @@ var LlmService = class _LlmService {
         Authorization: `Bearer ${this.apiKey}`
       },
       body: JSON.stringify({
-        model: options.model ?? "qwen2.5:3b-instruct",
+        model: options.model ?? "meta-llama/Meta-Llama-3-8B-Instruct",
         messages,
         stream: false,
         temperature: options.temperature,
@@ -2688,9 +2930,13 @@ var LlmService = class _LlmService {
     }
     const data = await res.json();
     const content = data.choices?.[0]?.message?.content ?? "";
+    if (this.llmDebugEnabled()) {
+      console.log("\n[LLM chat] assistant reply\n", content);
+    }
     return { content };
   }
   async *streamChat(messages, options = {}) {
+    this.logChatCompletionsRequest("streamChat", messages, options, true);
     const res = await fetch(this.url, {
       method: "POST",
       headers: {
@@ -2698,7 +2944,7 @@ var LlmService = class _LlmService {
         Authorization: `Bearer ${this.apiKey}`
       },
       body: JSON.stringify({
-        model: options.model ?? "qwen2.5:3b-instruct",
+        model: options.model ?? "meta-llama/Meta-Llama-3-8B-Instruct",
         messages,
         stream: true,
         temperature: options.temperature,
@@ -2713,6 +2959,8 @@ var LlmService = class _LlmService {
     if (!reader) return;
     const decoder = new TextDecoder();
     let buffer = "";
+    const debug = this.llmDebugEnabled();
+    let streamedReply = "";
     while (true) {
       const { value, done } = await reader.read();
       if (done) break;
@@ -2724,16 +2972,28 @@ var LlmService = class _LlmService {
           try {
             const json = JSON.parse(line.slice(6));
             const content = json.choices?.[0]?.delta?.content;
-            if (content) yield content;
+            if (content) {
+              if (debug) streamedReply += content;
+              yield content;
+            }
           } catch {
           }
         }
       }
     }
+    if (debug) {
+      console.log("\n[LLM streamChat] assistant reply (full)\n", streamedReply);
+    }
   }
 };
 
 // src/plugins/llm/index.ts
+function normalizeEmbeddingProvider(raw) {
+  if (!raw) return "openai";
+  const s = raw.toLowerCase().trim();
+  if (s === "huggingface" || s === "hf" || s === "hf_inference" || s === "inference") return "huggingface";
+  return "openai";
+}
 function llmPlugin(config = {}) {
   return {
     name: "llm",
@@ -2746,7 +3006,16 @@ function llmPlugin(config = {}) {
         return void 0;
       }
       const embeddingModel = config.embeddingModel ?? context.config.EMBEDDING_MODEL;
-      return new LlmService(baseURL.replace(/\/$/, ""), apiKey, embeddingModel);
+      const embeddingProvider = normalizeEmbeddingProvider(
+        config.embeddingProvider ?? context.config.EMBEDDING_PROVIDER
+      );
+      const hfInferenceBaseUrl = config.hfInferenceBaseUrl ?? context.config.HF_INFERENCE_URL;
+      const embeddingApiKey = config.embeddingApiKey ?? context.config.EMBEDDING_API_KEY;
+      return new LlmService(baseURL.replace(/\/$/, ""), apiKey, embeddingModel, {
+        embeddingProvider,
+        hfInferenceBaseUrl,
+        embeddingApiKey
+      });
     }
   };
 }
@@ -3606,10 +3875,90 @@ async function seedDefaultAdmin(ds, entityMap, opts) {
 }
 
 // src/api/cms-handlers.ts
-var import_typeorm5 = require("typeorm");
+var import_typeorm6 = require("typeorm");
 init_email_queue();
 init_erp_queue();
 
+// src/entities/llm-agent.entity.ts
+var import_typeorm4 = require("typeorm");
+var LlmAgent = class {
+  id;
+  name;
+  slug;
+  systemInstruction;
+  model;
+  temperature;
+  maxTokens;
+  validationRules;
+  enabled;
+  createdAt;
+  updatedAt;
+  deletedAt;
+  deleted;
+  createdBy;
+  updatedBy;
+  deletedBy;
+};
+__decorateClass([
+  (0, import_typeorm4.PrimaryGeneratedColumn)()
+], LlmAgent.prototype, "id", 2);
+__decorateClass([
+  (0, import_typeorm4.Column)("varchar")
+], LlmAgent.prototype, "name", 2);
+__decorateClass([
+  (0, import_typeorm4.Column)("varchar")
+], LlmAgent.prototype, "slug", 2);
+__decorateClass([
+  (0, import_typeorm4.Column)("text", { name: "system_instruction", default: "" })
+], LlmAgent.prototype, "systemInstruction", 2);
+__decorateClass([
+  (0, import_typeorm4.Column)("varchar", { nullable: true })
+], LlmAgent.prototype, "model", 2);
+__decorateClass([
+  (0, import_typeorm4.Column)("double precision", { name: "temperature", nullable: true })
+], LlmAgent.prototype, "temperature", 2);
+__decorateClass([
+  (0, import_typeorm4.Column)("int", { name: "max_tokens", nullable: true })
+], LlmAgent.prototype, "maxTokens", 2);
+__decorateClass([
+  (0, import_typeorm4.Column)("text", { name: "validation_rules", nullable: true })
+], LlmAgent.prototype, "validationRules", 2);
+__decorateClass([
+  (0, import_typeorm4.Column)("boolean", { default: true })
+], LlmAgent.prototype, "enabled", 2);
+__decorateClass([
+  (0, import_typeorm4.Column)({ type: "timestamp", default: () => "CURRENT_TIMESTAMP" })
+], LlmAgent.prototype, "createdAt", 2);
+__decorateClass([
+  (0, import_typeorm4.Column)({ type: "timestamp", default: () => "CURRENT_TIMESTAMP" })
+], LlmAgent.prototype, "updatedAt", 2);
+__decorateClass([
+  (0, import_typeorm4.Column)({ type: "timestamp", nullable: true })
+], LlmAgent.prototype, "deletedAt", 2);
+__decorateClass([
+  (0, import_typeorm4.Column)("boolean", { default: false })
+], LlmAgent.prototype, "deleted", 2);
+__decorateClass([
+  (0, import_typeorm4.Column)("int", { nullable: true })
+], LlmAgent.prototype, "createdBy", 2);
+__decorateClass([
+  (0, import_typeorm4.Column)("int", { nullable: true })
+], LlmAgent.prototype, "updatedBy", 2);
+__decorateClass([
+  (0, import_typeorm4.Column)("int", { nullable: true })
+], LlmAgent.prototype, "deletedBy", 2);
+LlmAgent = __decorateClass([
+  (0, import_typeorm4.Entity)("llm_agents")
+], LlmAgent);
+function llmAgentToChatAgentOptions(agent) {
+  return {
+    systemPrompt: agent.systemInstruction?.trim() || void 0,
+    model: agent.model?.trim() || void 0,
+    temperature: agent.temperature ?? void 0,
+    max_tokens: agent.maxTokens ?? void 0
+  };
+}
+
 // src/lib/media-folder-path.ts
 function sanitizeMediaFolderPath(input) {
   if (input == null) return "";
@@ -3641,7 +3990,7 @@ async function relativePathFromMediaParentId(dataSource, entityMap, parentId) {
 }
 
 // src/lib/media-zip-extract.ts
-var import_typeorm4 = require("typeorm");
+var import_typeorm5 = require("typeorm");
 var ZIP_MIME_TYPES = /* @__PURE__ */ new Set(["application/zip", "application/x-zip-compressed"]);
 var MAX_ENTRIES = 2e3;
 var MAX_TOTAL_UNCOMPRESSED = 80 * 1024 * 1024;
@@ -3692,7 +4041,7 @@ function guessMimeType(fileName) {
 async function findOrCreateFolder(dataSource, entityMap, parentId, name) {
   const safe = sanitizeStorageSegment(name);
   const repo = dataSource.getRepository(entityMap.media);
-  const where = parentId == null ? { kind: "folder", filename: safe, parentId: (0, import_typeorm4.IsNull)() } : { kind: "folder", filename: safe, parentId };
+  const where = parentId == null ? { kind: "folder", filename: safe, parentId: (0, import_typeorm5.IsNull)() } : { kind: "folder", filename: safe, parentId };
   const existing = await repo.findOne({ where });
   if (existing) return existing.id;
   const row = await repo.save(
@@ -3799,6 +4148,82 @@ async function extractZipMediaIntoParentTree(opts) {
 }
 
 // src/api/cms-handlers.ts
+function historyBeforeCurrentUser(history, currentUserContent) {
+  const last = history[history.length - 1];
+  if (last?.role === "user" && last.content === currentUserContent) {
+    return history.slice(0, -1);
+  }
+  return [...history];
+}
+function pickStructuredRules(rules) {
+  return {
+    maxUserChars: rules.maxUserChars,
+    maxMessageLength: rules.maxMessageLength,
+    minUserChars: rules.minUserChars,
+    minMessageLength: rules.minMessageLength,
+    blockedSubstrings: rules.blockedSubstrings
+  };
+}
+function guardrailsTextFromJsonObject(rules) {
+  const g = typeof rules.guardrails === "string" && rules.guardrails.trim() || typeof rules.outputRules === "string" && rules.outputRules.trim() || typeof rules.outputInstructions === "string" && rules.outputInstructions.trim() || "";
+  return g || null;
+}
+function parseLlmAgentValidationRules(validationRulesText) {
+  const raw = validationRulesText?.trim();
+  if (!raw) return { structured: {}, guardrailsForPrompt: null };
+  try {
+    const parsed = JSON.parse(raw);
+    if (typeof parsed === "string") {
+      const s = parsed.trim();
+      return { structured: {}, guardrailsForPrompt: s || null };
+    }
+    if (!parsed || typeof parsed !== "object" || Array.isArray(parsed)) {
+      return { structured: {}, guardrailsForPrompt: raw };
+    }
+    const rules = parsed;
+    return {
+      structured: pickStructuredRules(rules),
+      guardrailsForPrompt: guardrailsTextFromJsonObject(rules)
+    };
+  } catch {
+    return { structured: {}, guardrailsForPrompt: raw };
+  }
+}
+function validateUserMessageAgainstStructuredRules(message, structured) {
+  const maxLen = structured.maxUserChars ?? structured.maxMessageLength;
+  if (typeof maxLen === "number" && Number.isFinite(maxLen) && maxLen >= 0 && message.length > maxLen) {
+    return { ok: false, error: `Message exceeds maximum length (${maxLen} characters)` };
+  }
+  const minLen = structured.minUserChars ?? structured.minMessageLength;
+  if (typeof minLen === "number" && Number.isFinite(minLen) && minLen > 0 && message.length < minLen) {
+    return { ok: false, error: `Message is shorter than minimum length (${minLen} characters)` };
+  }
+  const blocked = structured.blockedSubstrings;
+  if (Array.isArray(blocked) && blocked.length > 0) {
+    const lower = message.toLowerCase();
+    for (const s of blocked) {
+      if (typeof s !== "string" || !s.trim()) continue;
+      if (lower.includes(s.toLowerCase())) {
+        return { ok: false, error: "Message contains disallowed content" };
+      }
+    }
+  }
+  return { ok: true };
+}
+function validateUserMessageAgainstAgentRules(message, validationRulesText) {
+  const { structured } = parseLlmAgentValidationRules(validationRulesText);
+  return validateUserMessageAgainstStructuredRules(message, structured);
+}
+function mergeGuardrailsIntoSystemPrompt(baseSystem, guardrailsForPrompt) {
+  const g = guardrailsForPrompt?.trim();
+  const b = (baseSystem ?? "").trim();
+  if (!g) return b;
+  const block = `### Output guardrails (follow in every reply)
+${g}`;
+  return b ? `${b}
+
+${block}` : block;
+}
 function createDashboardStatsHandler(config) {
   const { dataSource, entityMap, json, requireAuth, requirePermission, requireEntityPermission } = config;
   return async function GET(req) {
@@ -3821,8 +4246,8 @@ function createDashboardStatsHandler(config) {
         repo("form_submissions")?.count() ?? 0,
         repo("users")?.count({ where: { deleted: false } }) ?? 0,
         repo("blogs")?.count({ where: { deleted: false } }) ?? 0,
-        repo("contacts")?.count({ where: { createdAt: (0, import_typeorm5.MoreThanOrEqual)(sevenDaysAgo) } }) ?? 0,
-        repo("form_submissions")?.count({ where: { createdAt: (0, import_typeorm5.MoreThanOrEqual)(sevenDaysAgo) } }) ?? 0,
+        repo("contacts")?.count({ where: { createdAt: (0, import_typeorm6.MoreThanOrEqual)(sevenDaysAgo) } }) ?? 0,
+        repo("form_submissions")?.count({ where: { createdAt: (0, import_typeorm6.MoreThanOrEqual)(sevenDaysAgo) } }) ?? 0,
         repo("contacts")?.createQueryBuilder("c").select("COALESCE(NULLIF(TRIM(c.type), ''), 'unknown')", "type").addSelect("COUNT(*)", "count").where("c.deleted = :deleted", { deleted: false }).groupBy("COALESCE(NULLIF(TRIM(c.type), ''), 'unknown')").getRawMany() ?? []
       ]);
       return json({
@@ -3871,19 +4296,19 @@ function createEcommerceAnalyticsHandler(config) {
       const productRepo = dataSource.getRepository(entityMap.products);
       const [salesOrders, returnOrders, replacementOrders, payments, products] = await Promise.all([
         orderRepo.find({
-          where: { deleted: false, createdAt: (0, import_typeorm5.MoreThanOrEqual)(start), orderKind: "sale", status: (0, import_typeorm5.In)(["confirmed", "processing", "completed"]) },
+          where: { deleted: false, createdAt: (0, import_typeorm6.MoreThanOrEqual)(start), orderKind: "sale", status: (0, import_typeorm6.In)(["confirmed", "processing", "completed"]) },
           select: ["id", "contactId", "createdAt", "subtotal", "discount", "tax", "total", "status"]
         }),
         orderRepo.find({
-          where: { deleted: false, createdAt: (0, import_typeorm5.MoreThanOrEqual)(start), orderKind: "return" },
+          where: { deleted: false, createdAt: (0, import_typeorm6.MoreThanOrEqual)(start), orderKind: "return" },
           select: ["id", "createdAt", "total"]
         }),
         orderRepo.find({
-          where: { deleted: false, createdAt: (0, import_typeorm5.MoreThanOrEqual)(start), orderKind: "replacement" },
+          where: { deleted: false, createdAt: (0, import_typeorm6.MoreThanOrEqual)(start), orderKind: "replacement" },
           select: ["id", "createdAt", "total"]
         }),
         paymentRepo.find({
-          where: { deleted: false, createdAt: (0, import_typeorm5.MoreThanOrEqual)(start) },
+          where: { deleted: false, createdAt: (0, import_typeorm6.MoreThanOrEqual)(start) },
           select: ["id", "status", "method", "amount", "createdAt"]
         }),
         productRepo.find({
@@ -3893,7 +4318,7 @@ function createEcommerceAnalyticsHandler(config) {
       ]);
       const saleOrderIds = salesOrders.map((o) => o.id);
       const orderItems = saleOrderIds.length ? await itemRepo.find({
-        where: { orderId: (0, import_typeorm5.In)(saleOrderIds) },
+        where: { orderId: (0, import_typeorm6.In)(saleOrderIds) },
         select: ["id", "orderId", "productId", "quantity", "total"]
       }) : [];
       const grossSales = salesOrders.reduce((sum, o) => sum + toNum(o.subtotal), 0);
@@ -4581,8 +5006,8 @@ function createUsersApiHandlers(config) {
         const sortOrder = url.searchParams.get("sortOrder") === "desc" ? "DESC" : "ASC";
         const search = url.searchParams.get("search");
         const where = search ? [
-          { name: (0, import_typeorm5.ILike)(`%${search}%`), deleted: false },
-          { email: (0, import_typeorm5.ILike)(`%${search}%`), deleted: false }
+          { name: (0, import_typeorm6.ILike)(`%${search}%`), deleted: false },
+          { email: (0, import_typeorm6.ILike)(`%${search}%`), deleted: false }
         ] : { deleted: false };
         const [data, total] = await userRepo().findAndCount({
           skip,
@@ -4880,9 +5305,24 @@ function createSettingsApiHandlers(config) {
 }
 var KB_CHUNK_LIMIT = 10;
 var KB_CONTEXT_MAX_CHARS = 4e3;
+var RAG_LOG = "[rag-context]";
 function getQueryTerms(message) {
   return message.replace(/[^\w\s]/g, " ").split(/\s+/).filter((w) => w.length > 2).slice(0, 6);
 }
+function normalizeChatModeSetting(raw) {
+  if (raw === "external" || raw === "llm") return raw;
+  return "whatsapp";
+}
+async function loadLlmSettingsMap(dataSource, entityMap) {
+  if (!entityMap.configs) return {};
+  const repo = dataSource.getRepository(entityMap.configs);
+  const rows = await repo.find({ where: { settings: "llm", deleted: false } });
+  const out = {};
+  for (const row of rows) {
+    out[row.key] = row.value;
+  }
+  return out;
+}
 function createChatHandlers(config) {
   const { dataSource, entityMap, json, getCms } = config;
   const contactRepo = () => dataSource.getRepository(entityMap.contacts);
@@ -4890,6 +5330,26 @@ function createChatHandlers(config) {
   const msgRepo = () => dataSource.getRepository(entityMap.chat_messages);
   const chunkRepo = () => dataSource.getRepository(entityMap.knowledge_base_chunks);
   return {
+    async publicConfig(_req) {
+      try {
+        const map = await loadLlmSettingsMap(dataSource, entityMap);
+        const mode = normalizeChatModeSetting(map.chatMode);
+        const body = {
+          enabled: map.enabled !== "false",
+          chatMode: mode,
+          agentSlug: mode === "llm" ? (map.attachedAgentSlug ?? "").trim() : "",
+          botName: map.botName ?? "",
+          icon: map.icon ?? "",
+          iconImageUrl: map.iconImageUrl ?? "",
+          iconBackgroundColor: map.iconBackgroundColor ?? "#6366f1",
+          headerColor: map.headerColor ?? "#6366f1",
+          whatsappPhone: map.whatsappPhone ?? ""
+        };
+        return json(body);
+      } catch {
+        return json({ error: "Failed to load chat config" }, { status: 500 });
+      }
+    },
     async identify(req) {
       try {
         const body = await req.json();
@@ -4937,20 +5397,78 @@ function createChatHandlers(config) {
           relations: ["messages"]
         });
         if (!conv) return json({ error: "Conversation not found" }, { status: 404 });
-        const msgRepoInst = msgRepo();
-        await msgRepoInst.save(msgRepoInst.create({ conversationId, role: "user", content: message }));
         const cms = await getCms();
         const llm = cms.getPlugin("llm");
         if (!llm?.chat) return json({ error: "LLM not configured" }, { status: 503 });
+        const llmSettings = await loadLlmSettingsMap(dataSource, entityMap);
+        const supportMode = normalizeChatModeSetting(llmSettings.chatMode);
+        let effectiveSlug = (body?.agentSlug ?? "").trim();
+        if (!effectiveSlug && supportMode === "llm" && entityMap.llm_agents) {
+          effectiveSlug = (llmSettings.attachedAgentSlug ?? "").trim();
+        }
+        let agentRow = null;
+        if (effectiveSlug) {
+          if (!entityMap.llm_agents) {
+            return json({ error: "LLM agents are not configured on this deployment" }, { status: 400 });
+          }
+          const agentRepo = dataSource.getRepository(
+            entityMap.llm_agents
+          );
+          agentRow = await agentRepo.findOne({
+            where: { slug: effectiveSlug, deleted: false, enabled: true }
+          });
+          if (!agentRow && (body?.agentSlug ?? "").trim()) {
+            return json({ error: "Agent not found or disabled", agentSlug: effectiveSlug }, { status: 404 });
+          }
+        }
+        console.info(RAG_LOG, "step 1 | resolve agent", {
+          agentSlug: effectiveSlug || "(none)",
+          agentFound: !!agentRow,
+          agentId: agentRow?.id ?? null
+        });
+        const parsedValidation = agentRow ? parseLlmAgentValidationRules(agentRow.validationRules) : { structured: {}, guardrailsForPrompt: null };
+        if (agentRow) {
+          const v = validateUserMessageAgainstStructuredRules(message, parsedValidation.structured);
+          if (!v.ok) return json({ error: v.error, reason: "validation_failed" }, { status: 400 });
+        }
+        let kbDocumentScope;
+        const Junction = entityMap.llm_agent_knowledge_documents;
+        if (agentRow && Junction) {
+          const linkRepo = dataSource.getRepository(Junction);
+          const links = await linkRepo.find({ where: { agentId: agentRow.id } });
+          const ids = [...new Set(links.map((l) => l.documentId))];
+          if (ids.length > 0) kbDocumentScope = ids;
+        }
+        console.info(RAG_LOG, "step 2 | knowledge scope", {
+          scopedDocumentIds: kbDocumentScope ?? "(all documents)",
+          documentCount: kbDocumentScope?.length ?? "all"
+        });
+        const msgRepoInst = msgRepo();
+        await msgRepoInst.save(msgRepoInst.create({ conversationId, role: "user", content: message }));
         let contextParts = [];
+        console.info(RAG_LOG, "step 3 | embed user query", {
+          messageChars: message.length,
+          embedAvailable: !!llm.embed
+        });
         const queryEmbedding = llm.embed ? await llm.embed(message) : null;
+        console.info(RAG_LOG, "step 4 | query embedding result", {
+          dimensions: queryEmbedding?.length ?? 0,
+          hasEmbedding: !!(queryEmbedding && queryEmbedding.length > 0)
+        });
         if (queryEmbedding && queryEmbedding.length > 0) {
           const vectorStr = "[" + queryEmbedding.join(",") + "]";
           try {
-            const rows = await dataSource.query(
+            const rows = kbDocumentScope?.length ? await dataSource.query(
+              `SELECT id, content FROM knowledge_base_chunks WHERE embedding IS NOT NULL AND "documentId" = ANY($3::int[]) ORDER BY embedding <=> $1::vector LIMIT $2`,
+              [vectorStr, KB_CHUNK_LIMIT, kbDocumentScope]
+            ) : await dataSource.query(
               `SELECT id, content FROM knowledge_base_chunks WHERE embedding IS NOT NULL ORDER BY embedding <=> $1::vector LIMIT $2`,
               [vectorStr, KB_CHUNK_LIMIT]
             );
+            console.info(RAG_LOG, "step 5 | vector search results", {
+              rowsReturned: rows.length,
+              chunkIds: rows.map((r) => r.id)
+            });
             let totalLen = 0;
             for (const r of rows) {
               const text = (r.content ?? "").trim();
@@ -4958,13 +5476,24 @@ function createChatHandlers(config) {
               contextParts.push(text);
               totalLen += text.length;
             }
-          } catch {
+            console.info(RAG_LOG, "step 5a | vector context selected", {
+              chunksUsed: contextParts.length,
+              totalChars: totalLen
+            });
+          } catch (vecErr) {
+            console.warn(RAG_LOG, "step 5 | vector search failed; falling back to keyword", {
+              err: vecErr instanceof Error ? vecErr.message : String(vecErr)
+            });
           }
         }
         if (contextParts.length === 0) {
           const terms = getQueryTerms(message);
+          console.info(RAG_LOG, "step 6 | keyword fallback", {
+            reason: !(queryEmbedding && queryEmbedding.length > 0) ? "no embedding" : "vector search returned nothing",
+            searchTerms: terms
+          });
           if (terms.length > 0) {
-            const conditions = terms.map((t) => ({ content: (0, import_typeorm5.ILike)(`%${t}%`) }));
+            const conditions = kbDocumentScope?.length ? terms.map((t) => ({ content: (0, import_typeorm6.ILike)(`%${t}%`), documentId: (0, import_typeorm6.In)(kbDocumentScope) })) : terms.map((t) => ({ content: (0, import_typeorm6.ILike)(`%${t}%`) }));
             const chunks = await chunkRepo().find({
               where: conditions,
               take: KB_CHUNK_LIMIT,
@@ -4979,19 +5508,66 @@ function createChatHandlers(config) {
               contextParts.push(text);
               totalLen += text.length;
             }
+            console.info(RAG_LOG, "step 6a | keyword results", {
+              chunksFound: chunks.length,
+              chunksUsed: contextParts.length,
+              totalChars: totalLen
+            });
           }
         }
-        const history = (conv.messages ?? []).sort((a, b) => new Date(a.createdAt ?? 0).getTime() - new Date(b.createdAt ?? 0).getTime()).map((m) => ({ role: m.role, content: m.content }));
-        const systemContent = contextParts.length > 0 ? `Use the following context about the company and its products to answer. If the answer is not in the context, say so.
+        const historyRaw = (conv.messages ?? []).sort((a, b) => new Date(a.createdAt ?? 0).getTime() - new Date(b.createdAt ?? 0).getTime()).map((m) => ({ role: m.role, content: m.content }));
+        const history = historyBeforeCurrentUser(historyRaw, message);
+        let content;
+        const ragContext = contextParts.length > 0 ? contextParts.join("\n\n") : void 0;
+        console.info(RAG_LOG, "step 7 | final context", {
+          method: contextParts.length > 0 ? "rag" : "none",
+          contextChunks: contextParts.length,
+          contextChars: ragContext?.length ?? 0,
+          contextPreview: ragContext ? ragContext.slice(0, 200) + (ragContext.length > 200 ? "\u2026" : "") : "(no context)"
+        });
+        if (agentRow && llm.chatAgent) {
+          const fromAgent = llmAgentToChatAgentOptions(agentRow);
+          const systemPrompt = mergeGuardrailsIntoSystemPrompt(
+            fromAgent.systemPrompt,
+            parsedValidation.guardrailsForPrompt
+          );
+          const res = await llm.chatAgent({
+            ...fromAgent,
+            systemPrompt: systemPrompt || void 0,
+            context: ragContext,
+            history,
+            userPrompt: message
+          });
+          content = res.content;
+        } else {
+          const ragSystem = contextParts.length > 0 ? `Use the following context about the company and its products to answer. If the answer is not in the context, say so.
 
 Context:
-${contextParts.join("\n\n")}` : "You are a helpful assistant for the company. If you do not have specific information, say so.";
-        const messages = [
-          { role: "system", content: systemContent },
-          ...history,
-          { role: "user", content: message }
-        ];
-        const { content } = await llm.chat(messages);
+${contextParts.join("\n\n")}` : "";
+          const defaultSystem = "You are a helpful assistant for the company. If you do not have specific information, say so.";
+          let systemContent;
+          if (agentRow) {
+            const base = agentRow.systemInstruction?.trim() || "";
+            systemContent = mergeGuardrailsIntoSystemPrompt(
+              [base, ragSystem].filter(Boolean).join("\n\n") || defaultSystem,
+              parsedValidation.guardrailsForPrompt
+            );
+          } else {
+            systemContent = ragSystem || defaultSystem;
+          }
+          const messages = [
+            { role: "system", content: systemContent },
+            ...history,
+            { role: "user", content: message }
+          ];
+          const chatOpts = agentRow ? {
+            model: agentRow.model ?? void 0,
+            temperature: agentRow.temperature ?? void 0,
+            max_tokens: agentRow.maxTokens ?? void 0
+          } : {};
+          const res = await llm.chat(messages, chatOpts);
+          content = res.content;
+        }
         await msgRepoInst.save(msgRepoInst.create({ conversationId, role: "assistant", content }));
         return json({ content });
       } catch (err) {
@@ -5050,13 +5626,13 @@ async function loadPublicThemeSettings(config) {
 }
 
 // src/entities/user.entity.ts
-var import_typeorm8 = require("typeorm");
+var import_typeorm9 = require("typeorm");
 
 // src/entities/user-group.entity.ts
-var import_typeorm7 = require("typeorm");
+var import_typeorm8 = require("typeorm");
 
 // src/entities/permission.entity.ts
-var import_typeorm6 = require("typeorm");
+var import_typeorm7 = require("typeorm");
 var Permission = class {
   id;
   groupId;
@@ -5075,53 +5651,53 @@ var Permission = class {
   group;
 };
 __decorateClass([
-  (0, import_typeorm6.PrimaryGeneratedColumn)()
+  (0, import_typeorm7.PrimaryGeneratedColumn)()
 ], Permission.prototype, "id", 2);
 __decorateClass([
-  (0, import_typeorm6.Column)("int")
+  (0, import_typeorm7.Column)("int")
 ], Permission.prototype, "groupId", 2);
 __decorateClass([
-  (0, import_typeorm6.Column)("varchar")
+  (0, import_typeorm7.Column)("varchar")
 ], Permission.prototype, "entity", 2);
 __decorateClass([
-  (0, import_typeorm6.Column)("boolean", { default: false })
+  (0, import_typeorm7.Column)("boolean", { default: false })
 ], Permission.prototype, "canCreate", 2);
 __decorateClass([
-  (0, import_typeorm6.Column)("boolean", { default: false })
+  (0, import_typeorm7.Column)("boolean", { default: false })
 ], Permission.prototype, "canRead", 2);
 __decorateClass([
-  (0, import_typeorm6.Column)("boolean", { default: false })
+  (0, import_typeorm7.Column)("boolean", { default: false })
 ], Permission.prototype, "canUpdate", 2);
 __decorateClass([
-  (0, import_typeorm6.Column)("boolean", { default: false })
+  (0, import_typeorm7.Column)("boolean", { default: false })
 ], Permission.prototype, "canDelete", 2);
 __decorateClass([
-  (0, import_typeorm6.Column)({ type: "timestamp", default: () => "CURRENT_TIMESTAMP" })
+  (0, import_typeorm7.Column)({ type: "timestamp", default: () => "CURRENT_TIMESTAMP" })
 ], Permission.prototype, "createdAt", 2);
 __decorateClass([
-  (0, import_typeorm6.Column)({ type: "timestamp", default: () => "CURRENT_TIMESTAMP" })
+  (0, import_typeorm7.Column)({ type: "timestamp", default: () => "CURRENT_TIMESTAMP" })
 ], Permission.prototype, "updatedAt", 2);
 __decorateClass([
-  (0, import_typeorm6.Column)({ type: "timestamp", nullable: true })
+  (0, import_typeorm7.Column)({ type: "timestamp", nullable: true })
 ], Permission.prototype, "deletedAt", 2);
 __decorateClass([
-  (0, import_typeorm6.Column)("boolean", { default: false })
+  (0, import_typeorm7.Column)("boolean", { default: false })
 ], Permission.prototype, "deleted", 2);
 __decorateClass([
-  (0, import_typeorm6.Column)("int", { nullable: true })
+  (0, import_typeorm7.Column)("int", { nullable: true })
 ], Permission.prototype, "createdBy", 2);
 __decorateClass([
-  (0, import_typeorm6.Column)("int", { nullable: true })
+  (0, import_typeorm7.Column)("int", { nullable: true })
 ], Permission.prototype, "updatedBy", 2);
 __decorateClass([
-  (0, import_typeorm6.Column)("int", { nullable: true })
+  (0, import_typeorm7.Column)("int", { nullable: true })
 ], Permission.prototype, "deletedBy", 2);
 __decorateClass([
-  (0, import_typeorm6.ManyToOne)(() => UserGroup, (g) => g.permissions, { onDelete: "CASCADE" }),
-  (0, import_typeorm6.JoinColumn)({ name: "groupId" })
+  (0, import_typeorm7.ManyToOne)(() => UserGroup, (g) => g.permissions, { onDelete: "CASCADE" }),
+  (0, import_typeorm7.JoinColumn)({ name: "groupId" })
 ], Permission.prototype, "group", 2);
 Permission = __decorateClass([
-  (0, import_typeorm6.Entity)("permissions")
+  (0, import_typeorm7.Entity)("permissions")
 ], Permission);
 
 // src/entities/user-group.entity.ts
@@ -5139,40 +5715,40 @@ var UserGroup = class {
   users;
 };
 __decorateClass([
-  (0, import_typeorm7.PrimaryGeneratedColumn)()
+  (0, import_typeorm8.PrimaryGeneratedColumn)()
 ], UserGroup.prototype, "id", 2);
 __decorateClass([
-  (0, import_typeorm7.Column)("varchar", { unique: true })
+  (0, import_typeorm8.Column)("varchar", { unique: true })
 ], UserGroup.prototype, "name", 2);
 __decorateClass([
-  (0, import_typeorm7.Column)({ type: "timestamp", default: () => "CURRENT_TIMESTAMP" })
+  (0, import_typeorm8.Column)({ type: "timestamp", default: () => "CURRENT_TIMESTAMP" })
 ], UserGroup.prototype, "createdAt", 2);
 __decorateClass([
-  (0, import_typeorm7.Column)({ type: "timestamp", default: () => "CURRENT_TIMESTAMP" })
+  (0, import_typeorm8.Column)({ type: "timestamp", default: () => "CURRENT_TIMESTAMP" })
 ], UserGroup.prototype, "updatedAt", 2);
 __decorateClass([
-  (0, import_typeorm7.Column)({ type: "timestamp", nullable: true })
+  (0, import_typeorm8.Column)({ type: "timestamp", nullable: true })
 ], UserGroup.prototype, "deletedAt", 2);
 __decorateClass([
-  (0, import_typeorm7.Column)("boolean", { default: false })
+  (0, import_typeorm8.Column)("boolean", { default: false })
 ], UserGroup.prototype, "deleted", 2);
 __decorateClass([
-  (0, import_typeorm7.Column)("int", { nullable: true })
+  (0, import_typeorm8.Column)("int", { nullable: true })
 ], UserGroup.prototype, "createdBy", 2);
 __decorateClass([
-  (0, import_typeorm7.Column)("int", { nullable: true })
+  (0, import_typeorm8.Column)("int", { nullable: true })
 ], UserGroup.prototype, "updatedBy", 2);
 __decorateClass([
-  (0, import_typeorm7.Column)("int", { nullable: true })
+  (0, import_typeorm8.Column)("int", { nullable: true })
 ], UserGroup.prototype, "deletedBy", 2);
 __decorateClass([
-  (0, import_typeorm7.OneToMany)(() => Permission, (p) => p.group)
+  (0, import_typeorm8.OneToMany)(() => Permission, (p) => p.group)
 ], UserGroup.prototype, "permissions", 2);
 __decorateClass([
-  (0, import_typeorm7.OneToMany)(() => User, (u) => u.group)
+  (0, import_typeorm8.OneToMany)(() => User, (u) => u.group)
 ], UserGroup.prototype, "users", 2);
 UserGroup = __decorateClass([
-  (0, import_typeorm7.Entity)("user_groups")
+  (0, import_typeorm8.Entity)("user_groups")
 ], UserGroup);
 
 // src/entities/user.entity.ts
@@ -5197,66 +5773,66 @@ var User = class {
   group;
 };
 __decorateClass([
-  (0, import_typeorm8.PrimaryGeneratedColumn)()
+  (0, import_typeorm9.PrimaryGeneratedColumn)()
 ], User.prototype, "id", 2);
 __decorateClass([
-  (0, import_typeorm8.Column)("varchar")
+  (0, import_typeorm9.Column)("varchar")
 ], User.prototype, "name", 2);
 __decorateClass([
-  (0, import_typeorm8.Column)("varchar", { unique: true })
+  (0, import_typeorm9.Column)("varchar", { unique: true })
 ], User.prototype, "email", 2);
 __decorateClass([
-  (0, import_typeorm8.Column)("varchar", { nullable: true })
+  (0, import_typeorm9.Column)("varchar", { nullable: true })
 ], User.prototype, "phone", 2);
 __decorateClass([
-  (0, import_typeorm8.Column)({ type: "timestamp", nullable: true })
+  (0, import_typeorm9.Column)({ type: "timestamp", nullable: true })
 ], User.prototype, "phoneVerifiedAt", 2);
 __decorateClass([
-  (0, import_typeorm8.Column)({ type: "timestamp", nullable: true })
+  (0, import_typeorm9.Column)({ type: "timestamp", nullable: true })
 ], User.prototype, "emailVerifiedAt", 2);
 __decorateClass([
-  (0, import_typeorm8.Column)("varchar", { nullable: true })
+  (0, import_typeorm9.Column)("varchar", { nullable: true })
 ], User.prototype, "password", 2);
 __decorateClass([
-  (0, import_typeorm8.Column)("boolean", { default: false })
+  (0, import_typeorm9.Column)("boolean", { default: false })
 ], User.prototype, "blocked", 2);
 __decorateClass([
-  (0, import_typeorm8.Column)("boolean", { default: false })
+  (0, import_typeorm9.Column)("boolean", { default: false })
 ], User.prototype, "adminAccess", 2);
 __decorateClass([
-  (0, import_typeorm8.Column)("int", { nullable: true })
+  (0, import_typeorm9.Column)("int", { nullable: true })
 ], User.prototype, "groupId", 2);
 __decorateClass([
-  (0, import_typeorm8.Column)({ type: "timestamp", default: () => "CURRENT_TIMESTAMP" })
+  (0, import_typeorm9.Column)({ type: "timestamp", default: () => "CURRENT_TIMESTAMP" })
 ], User.prototype, "createdAt", 2);
 __decorateClass([
-  (0, import_typeorm8.Column)({ type: "timestamp", default: () => "CURRENT_TIMESTAMP" })
+  (0, import_typeorm9.Column)({ type: "timestamp", default: () => "CURRENT_TIMESTAMP" })
 ], User.prototype, "updatedAt", 2);
 __decorateClass([
-  (0, import_typeorm8.Column)({ type: "timestamp", nullable: true })
+  (0, import_typeorm9.Column)({ type: "timestamp", nullable: true })
 ], User.prototype, "deletedAt", 2);
 __decorateClass([
-  (0, import_typeorm8.Column)("boolean", { default: false })
+  (0, import_typeorm9.Column)("boolean", { default: false })
 ], User.prototype, "deleted", 2);
 __decorateClass([
-  (0, import_typeorm8.Column)("int", { nullable: true })
+  (0, import_typeorm9.Column)("int", { nullable: true })
 ], User.prototype, "createdBy", 2);
 __decorateClass([
-  (0, import_typeorm8.Column)("int", { nullable: true })
+  (0, import_typeorm9.Column)("int", { nullable: true })
 ], User.prototype, "updatedBy", 2);
 __decorateClass([
-  (0, import_typeorm8.Column)("int", { nullable: true })
+  (0, import_typeorm9.Column)("int", { nullable: true })
 ], User.prototype, "deletedBy", 2);
 __decorateClass([
-  (0, import_typeorm8.ManyToOne)(() => UserGroup, (g) => g.users, { onDelete: "SET NULL" }),
-  (0, import_typeorm8.JoinColumn)({ name: "groupId" })
+  (0, import_typeorm9.ManyToOne)(() => UserGroup, (g) => g.users, { onDelete: "SET NULL" }),
+  (0, import_typeorm9.JoinColumn)({ name: "groupId" })
 ], User.prototype, "group", 2);
 User = __decorateClass([
-  (0, import_typeorm8.Entity)("users")
+  (0, import_typeorm9.Entity)("users")
 ], User);
 
 // src/entities/otp-challenge.entity.ts
-var import_typeorm9 = require("typeorm");
+var import_typeorm10 = require("typeorm");
 var OtpChallenge = class {
   id;
   purpose;
@@ -5269,39 +5845,39 @@ var OtpChallenge = class {
   createdAt;
 };
 __decorateClass([
-  (0, import_typeorm9.PrimaryGeneratedColumn)()
+  (0, import_typeorm10.PrimaryGeneratedColumn)()
 ], OtpChallenge.prototype, "id", 2);
 __decorateClass([
-  (0, import_typeorm9.Column)("varchar")
+  (0, import_typeorm10.Column)("varchar")
 ], OtpChallenge.prototype, "purpose", 2);
 __decorateClass([
-  (0, import_typeorm9.Column)("varchar")
+  (0, import_typeorm10.Column)("varchar")
 ], OtpChallenge.prototype, "channel", 2);
 __decorateClass([
-  (0, import_typeorm9.Column)("varchar")
+  (0, import_typeorm10.Column)("varchar")
 ], OtpChallenge.prototype, "identifier", 2);
 __decorateClass([
-  (0, import_typeorm9.Column)("varchar")
+  (0, import_typeorm10.Column)("varchar")
 ], OtpChallenge.prototype, "codeHash", 2);
 __decorateClass([
-  (0, import_typeorm9.Column)({ type: "timestamp" })
+  (0, import_typeorm10.Column)({ type: "timestamp" })
 ], OtpChallenge.prototype, "expiresAt", 2);
 __decorateClass([
-  (0, import_typeorm9.Column)("int", { default: 0 })
+  (0, import_typeorm10.Column)("int", { default: 0 })
 ], OtpChallenge.prototype, "attempts", 2);
 __decorateClass([
-  (0, import_typeorm9.Column)({ type: "timestamp", nullable: true })
+  (0, import_typeorm10.Column)({ type: "timestamp", nullable: true })
 ], OtpChallenge.prototype, "consumedAt", 2);
 __decorateClass([
-  (0, import_typeorm9.Column)({ type: "timestamp", default: () => "CURRENT_TIMESTAMP" })
+  (0, import_typeorm10.Column)({ type: "timestamp", default: () => "CURRENT_TIMESTAMP" })
 ], OtpChallenge.prototype, "createdAt", 2);
 OtpChallenge = __decorateClass([
-  (0, import_typeorm9.Entity)("otp_challenges"),
-  (0, import_typeorm9.Index)(["purpose", "identifier"])
+  (0, import_typeorm10.Entity)("otp_challenges"),
+  (0, import_typeorm10.Index)(["purpose", "identifier"])
 ], OtpChallenge);
 
 // src/entities/password-reset-token.entity.ts
-var import_typeorm10 = require("typeorm");
+var import_typeorm11 = require("typeorm");
 var PasswordResetToken = class {
   id;
   email;
@@ -5310,29 +5886,29 @@ var PasswordResetToken = class {
   createdAt;
 };
 __decorateClass([
-  (0, import_typeorm10.PrimaryGeneratedColumn)()
+  (0, import_typeorm11.PrimaryGeneratedColumn)()
 ], PasswordResetToken.prototype, "id", 2);
 __decorateClass([
-  (0, import_typeorm10.Column)("varchar")
+  (0, import_typeorm11.Column)("varchar")
 ], PasswordResetToken.prototype, "email", 2);
 __decorateClass([
-  (0, import_typeorm10.Column)("varchar", { unique: true })
+  (0, import_typeorm11.Column)("varchar", { unique: true })
 ], PasswordResetToken.prototype, "token", 2);
 __decorateClass([
-  (0, import_typeorm10.Column)({ type: "timestamp", default: () => "CURRENT_TIMESTAMP" })
+  (0, import_typeorm11.Column)({ type: "timestamp", default: () => "CURRENT_TIMESTAMP" })
 ], PasswordResetToken.prototype, "expiresAt", 2);
 __decorateClass([
-  (0, import_typeorm10.Column)({ type: "timestamp", default: () => "CURRENT_TIMESTAMP" })
+  (0, import_typeorm11.Column)({ type: "timestamp", default: () => "CURRENT_TIMESTAMP" })
 ], PasswordResetToken.prototype, "createdAt", 2);
 PasswordResetToken = __decorateClass([
-  (0, import_typeorm10.Entity)("password_reset_tokens")
+  (0, import_typeorm11.Entity)("password_reset_tokens")
 ], PasswordResetToken);
 
 // src/entities/blog.entity.ts
-var import_typeorm15 = require("typeorm");
+var import_typeorm16 = require("typeorm");
 
 // src/entities/category.entity.ts
-var import_typeorm11 = require("typeorm");
+var import_typeorm12 = require("typeorm");
 var Category = class {
   id;
   name;
@@ -5346,41 +5922,41 @@ var Category = class {
   blogs;
 };
 __decorateClass([
-  (0, import_typeorm11.PrimaryGeneratedColumn)()
+  (0, import_typeorm12.PrimaryGeneratedColumn)()
 ], Category.prototype, "id", 2);
 __decorateClass([
-  (0, import_typeorm11.Column)("varchar", { unique: true })
+  (0, import_typeorm12.Column)("varchar", { unique: true })
 ], Category.prototype, "name", 2);
 __decorateClass([
-  (0, import_typeorm11.Column)({ type: "timestamp", default: () => "CURRENT_TIMESTAMP" })
+  (0, import_typeorm12.Column)({ type: "timestamp", default: () => "CURRENT_TIMESTAMP" })
 ], Category.prototype, "createdAt", 2);
 __decorateClass([
-  (0, import_typeorm11.Column)({ type: "timestamp", default: () => "CURRENT_TIMESTAMP" })
+  (0, import_typeorm12.Column)({ type: "timestamp", default: () => "CURRENT_TIMESTAMP" })
 ], Category.prototype, "updatedAt", 2);
 __decorateClass([
-  (0, import_typeorm11.Column)({ type: "timestamp", nullable: true })
+  (0, import_typeorm12.Column)({ type: "timestamp", nullable: true })
 ], Category.prototype, "deletedAt", 2);
 __decorateClass([
-  (0, import_typeorm11.Column)("boolean", { default: false })
+  (0, import_typeorm12.Column)("boolean", { default: false })
 ], Category.prototype, "deleted", 2);
 __decorateClass([
-  (0, import_typeorm11.Column)("int", { nullable: true })
+  (0, import_typeorm12.Column)("int", { nullable: true })
 ], Category.prototype, "createdBy", 2);
 __decorateClass([
-  (0, import_typeorm11.Column)("int", { nullable: true })
+  (0, import_typeorm12.Column)("int", { nullable: true })
 ], Category.prototype, "updatedBy", 2);
 __decorateClass([
-  (0, import_typeorm11.Column)("int", { nullable: true })
+  (0, import_typeorm12.Column)("int", { nullable: true })
 ], Category.prototype, "deletedBy", 2);
 __decorateClass([
-  (0, import_typeorm11.OneToMany)("Blog", "category")
+  (0, import_typeorm12.OneToMany)("Blog", "category")
 ], Category.prototype, "blogs", 2);
 Category = __decorateClass([
-  (0, import_typeorm11.Entity)("categories")
+  (0, import_typeorm12.Entity)("categories")
 ], Category);
 
 // src/entities/seo.entity.ts
-var import_typeorm12 = require("typeorm");
+var import_typeorm13 = require("typeorm");
 var Seo = class {
   id;
   title;
@@ -5400,59 +5976,59 @@ var Seo = class {
   blogs;
 };
 __decorateClass([
-  (0, import_typeorm12.PrimaryGeneratedColumn)()
+  (0, import_typeorm13.PrimaryGeneratedColumn)()
 ], Seo.prototype, "id", 2);
 __decorateClass([
-  (0, import_typeorm12.Column)("varchar", { nullable: true })
+  (0, import_typeorm13.Column)("varchar", { nullable: true })
 ], Seo.prototype, "title", 2);
 __decorateClass([
-  (0, import_typeorm12.Column)("varchar", { nullable: true })
+  (0, import_typeorm13.Column)("varchar", { nullable: true })
 ], Seo.prototype, "description", 2);
 __decorateClass([
-  (0, import_typeorm12.Column)("varchar", { nullable: true })
+  (0, import_typeorm13.Column)("varchar", { nullable: true })
 ], Seo.prototype, "keywords", 2);
 __decorateClass([
-  (0, import_typeorm12.Column)("varchar", { nullable: true })
+  (0, import_typeorm13.Column)("varchar", { nullable: true })
 ], Seo.prototype, "ogTitle", 2);
 __decorateClass([
-  (0, import_typeorm12.Column)("varchar", { nullable: true })
+  (0, import_typeorm13.Column)("varchar", { nullable: true })
 ], Seo.prototype, "ogDescription", 2);
 __decorateClass([
-  (0, import_typeorm12.Column)("varchar", { nullable: true })
+  (0, import_typeorm13.Column)("varchar", { nullable: true })
 ], Seo.prototype, "ogImage", 2);
 __decorateClass([
-  (0, import_typeorm12.Column)("varchar", { unique: true })
+  (0, import_typeorm13.Column)("varchar", { unique: true })
 ], Seo.prototype, "slug", 2);
 __decorateClass([
-  (0, import_typeorm12.Column)({ type: "timestamp", default: () => "CURRENT_TIMESTAMP" })
+  (0, import_typeorm13.Column)({ type: "timestamp", default: () => "CURRENT_TIMESTAMP" })
 ], Seo.prototype, "createdAt", 2);
 __decorateClass([
-  (0, import_typeorm12.Column)({ type: "timestamp", default: () => "CURRENT_TIMESTAMP" })
+  (0, import_typeorm13.Column)({ type: "timestamp", default: () => "CURRENT_TIMESTAMP" })
 ], Seo.prototype, "updatedAt", 2);
 __decorateClass([
-  (0, import_typeorm12.Column)({ type: "timestamp", nullable: true })
+  (0, import_typeorm13.Column)({ type: "timestamp", nullable: true })
 ], Seo.prototype, "deletedAt", 2);
 __decorateClass([
-  (0, import_typeorm12.Column)("boolean", { default: false })
+  (0, import_typeorm13.Column)("boolean", { default: false })
 ], Seo.prototype, "deleted", 2);
 __decorateClass([
-  (0, import_typeorm12.Column)("int", { nullable: true })
+  (0, import_typeorm13.Column)("int", { nullable: true })
 ], Seo.prototype, "createdBy", 2);
 __decorateClass([
-  (0, import_typeorm12.Column)("int", { nullable: true })
+  (0, import_typeorm13.Column)("int", { nullable: true })
 ], Seo.prototype, "updatedBy", 2);
 __decorateClass([
-  (0, import_typeorm12.Column)("int", { nullable: true })
+  (0, import_typeorm13.Column)("int", { nullable: true })
 ], Seo.prototype, "deletedBy", 2);
 __decorateClass([
-  (0, import_typeorm12.OneToMany)(() => Blog, (blog) => blog.seo)
+  (0, import_typeorm13.OneToMany)(() => Blog, (blog) => blog.seo)
 ], Seo.prototype, "blogs", 2);
 Seo = __decorateClass([
-  (0, import_typeorm12.Entity)("seos")
+  (0, import_typeorm13.Entity)("seos")
 ], Seo);
 
 // src/entities/comment.entity.ts
-var import_typeorm13 = require("typeorm");
+var import_typeorm14 = require("typeorm");
 var Comment = class {
   id;
   content;
@@ -5469,52 +6045,52 @@ var Comment = class {
   blog;
 };
 __decorateClass([
-  (0, import_typeorm13.PrimaryGeneratedColumn)()
+  (0, import_typeorm14.PrimaryGeneratedColumn)()
 ], Comment.prototype, "id", 2);
 __decorateClass([
-  (0, import_typeorm13.Column)("text")
+  (0, import_typeorm14.Column)("text")
 ], Comment.prototype, "content", 2);
 __decorateClass([
-  (0, import_typeorm13.Column)("int")
+  (0, import_typeorm14.Column)("int")
 ], Comment.prototype, "blogId", 2);
 __decorateClass([
-  (0, import_typeorm13.Column)("int")
+  (0, import_typeorm14.Column)("int")
 ], Comment.prototype, "authorId", 2);
 __decorateClass([
-  (0, import_typeorm13.Column)({ type: "timestamp", default: () => "CURRENT_TIMESTAMP" })
+  (0, import_typeorm14.Column)({ type: "timestamp", default: () => "CURRENT_TIMESTAMP" })
 ], Comment.prototype, "createdAt", 2);
 __decorateClass([
-  (0, import_typeorm13.Column)({ type: "timestamp", default: () => "CURRENT_TIMESTAMP" })
+  (0, import_typeorm14.Column)({ type: "timestamp", default: () => "CURRENT_TIMESTAMP" })
 ], Comment.prototype, "updatedAt", 2);
 __decorateClass([
-  (0, import_typeorm13.Column)({ type: "timestamp", nullable: true })
+  (0, import_typeorm14.Column)({ type: "timestamp", nullable: true })
 ], Comment.prototype, "deletedAt", 2);
 __decorateClass([
-  (0, import_typeorm13.Column)("boolean", { default: false })
+  (0, import_typeorm14.Column)("boolean", { default: false })
 ], Comment.prototype, "deleted", 2);
 __decorateClass([
-  (0, import_typeorm13.Column)("int", { nullable: true })
+  (0, import_typeorm14.Column)("int", { nullable: true })
 ], Comment.prototype, "createdBy", 2);
 __decorateClass([
-  (0, import_typeorm13.Column)("int", { nullable: true })
+  (0, import_typeorm14.Column)("int", { nullable: true })
 ], Comment.prototype, "updatedBy", 2);
 __decorateClass([
-  (0, import_typeorm13.Column)("int", { nullable: true })
+  (0, import_typeorm14.Column)("int", { nullable: true })
 ], Comment.prototype, "deletedBy", 2);
 __decorateClass([
-  (0, import_typeorm13.ManyToOne)(() => User, { onDelete: "CASCADE" }),
-  (0, import_typeorm13.JoinColumn)({ name: "authorId" })
+  (0, import_typeorm14.ManyToOne)(() => User, { onDelete: "CASCADE" }),
+  (0, import_typeorm14.JoinColumn)({ name: "authorId" })
 ], Comment.prototype, "author", 2);
 __decorateClass([
-  (0, import_typeorm13.ManyToOne)(() => Blog, (b) => b.comments, { onDelete: "CASCADE" }),
-  (0, import_typeorm13.JoinColumn)({ name: "blogId" })
+  (0, import_typeorm14.ManyToOne)(() => Blog, (b) => b.comments, { onDelete: "CASCADE" }),
+  (0, import_typeorm14.JoinColumn)({ name: "blogId" })
 ], Comment.prototype, "blog", 2);
 Comment = __decorateClass([
-  (0, import_typeorm13.Entity)("comments")
+  (0, import_typeorm14.Entity)("comments")
 ], Comment);
 
 // src/entities/tag.entity.ts
-var import_typeorm14 = require("typeorm");
+var import_typeorm15 = require("typeorm");
 var Tag = class {
   id;
   name;
@@ -5528,37 +6104,37 @@ var Tag = class {
   blogs;
 };
 __decorateClass([
-  (0, import_typeorm14.PrimaryGeneratedColumn)()
+  (0, import_typeorm15.PrimaryGeneratedColumn)()
 ], Tag.prototype, "id", 2);
 __decorateClass([
-  (0, import_typeorm14.Column)("varchar", { unique: true })
+  (0, import_typeorm15.Column)("varchar", { unique: true })
 ], Tag.prototype, "name", 2);
 __decorateClass([
-  (0, import_typeorm14.Column)({ type: "timestamp", default: () => "CURRENT_TIMESTAMP" })
+  (0, import_typeorm15.Column)({ type: "timestamp", default: () => "CURRENT_TIMESTAMP" })
 ], Tag.prototype, "createdAt", 2);
 __decorateClass([
-  (0, import_typeorm14.Column)({ type: "timestamp", default: () => "CURRENT_TIMESTAMP" })
+  (0, import_typeorm15.Column)({ type: "timestamp", default: () => "CURRENT_TIMESTAMP" })
 ], Tag.prototype, "updatedAt", 2);
 __decorateClass([
-  (0, import_typeorm14.Column)({ type: "timestamp", nullable: true })
+  (0, import_typeorm15.Column)({ type: "timestamp", nullable: true })
 ], Tag.prototype, "deletedAt", 2);
 __decorateClass([
-  (0, import_typeorm14.Column)("boolean", { default: false })
+  (0, import_typeorm15.Column)("boolean", { default: false })
 ], Tag.prototype, "deleted", 2);
 __decorateClass([
-  (0, import_typeorm14.Column)("int", { nullable: true })
+  (0, import_typeorm15.Column)("int", { nullable: true })
 ], Tag.prototype, "createdBy", 2);
 __decorateClass([
-  (0, import_typeorm14.Column)("int", { nullable: true })
+  (0, import_typeorm15.Column)("int", { nullable: true })
 ], Tag.prototype, "updatedBy", 2);
 __decorateClass([
-  (0, import_typeorm14.Column)("int", { nullable: true })
+  (0, import_typeorm15.Column)("int", { nullable: true })
 ], Tag.prototype, "deletedBy", 2);
 __decorateClass([
-  (0, import_typeorm14.ManyToMany)(() => Blog, (blog) => blog.tags)
+  (0, import_typeorm15.ManyToMany)(() => Blog, (blog) => blog.tags)
 ], Tag.prototype, "blogs", 2);
 Tag = __decorateClass([
-  (0, import_typeorm14.Entity)("tags")
+  (0, import_typeorm15.Entity)("tags")
 ], Tag);
 
 // src/entities/blog.entity.ts
@@ -5586,91 +6162,91 @@ var Blog = class {
   tags;
 };
 __decorateClass([
-  (0, import_typeorm15.PrimaryGeneratedColumn)()
+  (0, import_typeorm16.PrimaryGeneratedColumn)()
 ], Blog.prototype, "id", 2);
 __decorateClass([
-  (0, import_typeorm15.Column)("varchar")
+  (0, import_typeorm16.Column)("varchar")
 ], Blog.prototype, "title", 2);
 __decorateClass([
-  (0, import_typeorm15.Column)("text")
+  (0, import_typeorm16.Column)("text")
 ], Blog.prototype, "content", 2);
 __decorateClass([
-  (0, import_typeorm15.Column)("varchar", { nullable: true })
+  (0, import_typeorm16.Column)("varchar", { nullable: true })
 ], Blog.prototype, "coverImage", 2);
 __decorateClass([
-  (0, import_typeorm15.Column)("int")
+  (0, import_typeorm16.Column)("int")
 ], Blog.prototype, "authorId", 2);
 __decorateClass([
-  (0, import_typeorm15.Column)("int", { nullable: true })
+  (0, import_typeorm16.Column)("int", { nullable: true })
 ], Blog.prototype, "categoryId", 2);
 __decorateClass([
-  (0, import_typeorm15.Column)("int", { nullable: true })
+  (0, import_typeorm16.Column)("int", { nullable: true })
 ], Blog.prototype, "seoId", 2);
 __decorateClass([
-  (0, import_typeorm15.Column)("boolean", { default: false })
+  (0, import_typeorm16.Column)("boolean", { default: false })
 ], Blog.prototype, "published", 2);
 __decorateClass([
-  (0, import_typeorm15.Column)({ type: "timestamp", default: () => "CURRENT_TIMESTAMP" })
+  (0, import_typeorm16.Column)({ type: "timestamp", default: () => "CURRENT_TIMESTAMP" })
 ], Blog.prototype, "createdAt", 2);
 __decorateClass([
-  (0, import_typeorm15.Column)({ type: "timestamp", default: () => "CURRENT_TIMESTAMP" })
+  (0, import_typeorm16.Column)({ type: "timestamp", default: () => "CURRENT_TIMESTAMP" })
 ], Blog.prototype, "updatedAt", 2);
 __decorateClass([
-  (0, import_typeorm15.Column)({ type: "timestamp", nullable: true })
+  (0, import_typeorm16.Column)({ type: "timestamp", nullable: true })
 ], Blog.prototype, "deletedAt", 2);
 __decorateClass([
-  (0, import_typeorm15.Column)("boolean", { default: false })
+  (0, import_typeorm16.Column)("boolean", { default: false })
 ], Blog.prototype, "deleted", 2);
 __decorateClass([
-  (0, import_typeorm15.Column)("int", { nullable: true })
+  (0, import_typeorm16.Column)("int", { nullable: true })
 ], Blog.prototype, "createdBy", 2);
 __decorateClass([
-  (0, import_typeorm15.Column)("int", { nullable: true })
+  (0, import_typeorm16.Column)("int", { nullable: true })
 ], Blog.prototype, "updatedBy", 2);
 __decorateClass([
-  (0, import_typeorm15.Column)("int", { nullable: true })
+  (0, import_typeorm16.Column)("int", { nullable: true })
 ], Blog.prototype, "deletedBy", 2);
 __decorateClass([
-  (0, import_typeorm15.Column)("varchar", { unique: true })
+  (0, import_typeorm16.Column)("varchar", { unique: true })
 ], Blog.prototype, "slug", 2);
 __decorateClass([
-  (0, import_typeorm15.ManyToOne)(() => User, { onDelete: "CASCADE" }),
-  (0, import_typeorm15.JoinColumn)({ name: "authorId" })
+  (0, import_typeorm16.ManyToOne)(() => User, { onDelete: "CASCADE" }),
+  (0, import_typeorm16.JoinColumn)({ name: "authorId" })
 ], Blog.prototype, "author", 2);
 __decorateClass([
-  (0, import_typeorm15.ManyToOne)(() => Category, (c) => c.blogs, { onDelete: "SET NULL" }),
-  (0, import_typeorm15.JoinColumn)({ name: "categoryId" })
+  (0, import_typeorm16.ManyToOne)(() => Category, (c) => c.blogs, { onDelete: "SET NULL" }),
+  (0, import_typeorm16.JoinColumn)({ name: "categoryId" })
 ], Blog.prototype, "category", 2);
 __decorateClass([
-  (0, import_typeorm15.ManyToOne)(() => Seo, (s) => s.blogs, { onDelete: "SET NULL" }),
-  (0, import_typeorm15.JoinColumn)({ name: "seoId" })
+  (0, import_typeorm16.ManyToOne)(() => Seo, (s) => s.blogs, { onDelete: "SET NULL" }),
+  (0, import_typeorm16.JoinColumn)({ name: "seoId" })
 ], Blog.prototype, "seo", 2);
 __decorateClass([
-  (0, import_typeorm15.OneToMany)(() => Comment, (c) => c.blog)
+  (0, import_typeorm16.OneToMany)(() => Comment, (c) => c.blog)
 ], Blog.prototype, "comments", 2);
 __decorateClass([
-  (0, import_typeorm15.ManyToMany)(() => Tag, (t) => t.blogs),
-  (0, import_typeorm15.JoinTable)({
+  (0, import_typeorm16.ManyToMany)(() => Tag, (t) => t.blogs),
+  (0, import_typeorm16.JoinTable)({
     name: "blog_tags",
     joinColumn: { name: "blogId", referencedColumnName: "id" },
     inverseJoinColumn: { name: "tagId", referencedColumnName: "id" }
   })
 ], Blog.prototype, "tags", 2);
 Blog = __decorateClass([
-  (0, import_typeorm15.Entity)("blogs")
+  (0, import_typeorm16.Entity)("blogs")
 ], Blog);
 
 // src/entities/contact.entity.ts
-var import_typeorm24 = require("typeorm");
+var import_typeorm25 = require("typeorm");
 
 // src/entities/form-submission.entity.ts
-var import_typeorm18 = require("typeorm");
+var import_typeorm19 = require("typeorm");
 
 // src/entities/form.entity.ts
-var import_typeorm17 = require("typeorm");
+var import_typeorm18 = require("typeorm");
 
 // src/entities/form-field.entity.ts
-var import_typeorm16 = require("typeorm");
+var import_typeorm17 = require("typeorm");
 var FormField = class {
   id;
   formId;
@@ -5693,65 +6269,65 @@ var FormField = class {
   form;
 };
 __decorateClass([
-  (0, import_typeorm16.PrimaryGeneratedColumn)()
+  (0, import_typeorm17.PrimaryGeneratedColumn)()
 ], FormField.prototype, "id", 2);
 __decorateClass([
-  (0, import_typeorm16.Column)("int")
+  (0, import_typeorm17.Column)("int")
 ], FormField.prototype, "formId", 2);
 __decorateClass([
-  (0, import_typeorm16.Column)("varchar")
+  (0, import_typeorm17.Column)("varchar")
 ], FormField.prototype, "label", 2);
 __decorateClass([
-  (0, import_typeorm16.Column)("varchar")
+  (0, import_typeorm17.Column)("varchar")
 ], FormField.prototype, "type", 2);
 __decorateClass([
-  (0, import_typeorm16.Column)("varchar", { nullable: true })
+  (0, import_typeorm17.Column)("varchar", { nullable: true })
 ], FormField.prototype, "placeholder", 2);
 __decorateClass([
-  (0, import_typeorm16.Column)("varchar", { nullable: true })
+  (0, import_typeorm17.Column)("varchar", { nullable: true })
 ], FormField.prototype, "options", 2);
 __decorateClass([
-  (0, import_typeorm16.Column)("boolean", { default: false })
+  (0, import_typeorm17.Column)("boolean", { default: false })
 ], FormField.prototype, "required", 2);
 __decorateClass([
-  (0, import_typeorm16.Column)("varchar", { nullable: true })
+  (0, import_typeorm17.Column)("varchar", { nullable: true })
 ], FormField.prototype, "validation", 2);
 __decorateClass([
-  (0, import_typeorm16.Column)("int")
+  (0, import_typeorm17.Column)("int")
 ], FormField.prototype, "order", 2);
 __decorateClass([
-  (0, import_typeorm16.Column)("int", { default: 1 })
+  (0, import_typeorm17.Column)("int", { default: 1 })
 ], FormField.prototype, "groupId", 2);
 __decorateClass([
-  (0, import_typeorm16.Column)("int", { default: 12 })
+  (0, import_typeorm17.Column)("int", { default: 12 })
 ], FormField.prototype, "columnWidth", 2);
 __decorateClass([
-  (0, import_typeorm16.Column)({ type: "timestamp", default: () => "CURRENT_TIMESTAMP" })
+  (0, import_typeorm17.Column)({ type: "timestamp", default: () => "CURRENT_TIMESTAMP" })
 ], FormField.prototype, "createdAt", 2);
 __decorateClass([
-  (0, import_typeorm16.Column)({ type: "timestamp", default: () => "CURRENT_TIMESTAMP" })
+  (0, import_typeorm17.Column)({ type: "timestamp", default: () => "CURRENT_TIMESTAMP" })
 ], FormField.prototype, "updatedAt", 2);
 __decorateClass([
-  (0, import_typeorm16.Column)({ type: "timestamp", nullable: true })
+  (0, import_typeorm17.Column)({ type: "timestamp", nullable: true })
 ], FormField.prototype, "deletedAt", 2);
 __decorateClass([
-  (0, import_typeorm16.Column)("boolean", { default: false })
+  (0, import_typeorm17.Column)("boolean", { default: false })
 ], FormField.prototype, "deleted", 2);
 __decorateClass([
-  (0, import_typeorm16.Column)("int", { nullable: true })
+  (0, import_typeorm17.Column)("int", { nullable: true })
 ], FormField.prototype, "createdBy", 2);
 __decorateClass([
-  (0, import_typeorm16.Column)("int", { nullable: true })
+  (0, import_typeorm17.Column)("int", { nullable: true })
 ], FormField.prototype, "updatedBy", 2);
 __decorateClass([
-  (0, import_typeorm16.Column)("int", { nullable: true })
+  (0, import_typeorm17.Column)("int", { nullable: true })
 ], FormField.prototype, "deletedBy", 2);
 __decorateClass([
-  (0, import_typeorm16.ManyToOne)(() => Form, (f) => f.fields, { onDelete: "CASCADE" }),
-  (0, import_typeorm16.JoinColumn)({ name: "formId" })
+  (0, import_typeorm17.ManyToOne)(() => Form, (f) => f.fields, { onDelete: "CASCADE" }),
+  (0, import_typeorm17.JoinColumn)({ name: "formId" })
 ], FormField.prototype, "form", 2);
 FormField = __decorateClass([
-  (0, import_typeorm16.Entity)("form_fields")
+  (0, import_typeorm17.Entity)("form_fields")
 ], FormField);
 
 // src/entities/form.entity.ts
@@ -5773,52 +6349,52 @@ var Form = class {
   submissions;
 };
 __decorateClass([
-  (0, import_typeorm17.PrimaryGeneratedColumn)()
+  (0, import_typeorm18.PrimaryGeneratedColumn)()
 ], Form.prototype, "id", 2);
 __decorateClass([
-  (0, import_typeorm17.Column)("varchar")
+  (0, import_typeorm18.Column)("varchar")
 ], Form.prototype, "name", 2);
 __decorateClass([
-  (0, import_typeorm17.Column)("text", { nullable: true })
+  (0, import_typeorm18.Column)("text", { nullable: true })
 ], Form.prototype, "description", 2);
 __decorateClass([
-  (0, import_typeorm17.Column)("varchar", { nullable: true })
+  (0, import_typeorm18.Column)("varchar", { nullable: true })
 ], Form.prototype, "campaign", 2);
 __decorateClass([
-  (0, import_typeorm17.Column)("varchar", { unique: true })
+  (0, import_typeorm18.Column)("varchar", { unique: true })
 ], Form.prototype, "slug", 2);
 __decorateClass([
-  (0, import_typeorm17.Column)("boolean", { default: false })
+  (0, import_typeorm18.Column)("boolean", { default: false })
 ], Form.prototype, "published", 2);
 __decorateClass([
-  (0, import_typeorm17.Column)({ type: "timestamp", default: () => "CURRENT_TIMESTAMP" })
+  (0, import_typeorm18.Column)({ type: "timestamp", default: () => "CURRENT_TIMESTAMP" })
 ], Form.prototype, "createdAt", 2);
 __decorateClass([
-  (0, import_typeorm17.Column)({ type: "timestamp", default: () => "CURRENT_TIMESTAMP" })
+  (0, import_typeorm18.Column)({ type: "timestamp", default: () => "CURRENT_TIMESTAMP" })
 ], Form.prototype, "updatedAt", 2);
 __decorateClass([
-  (0, import_typeorm17.Column)({ type: "timestamp", nullable: true })
+  (0, import_typeorm18.Column)({ type: "timestamp", nullable: true })
 ], Form.prototype, "deletedAt", 2);
 __decorateClass([
-  (0, import_typeorm17.Column)("boolean", { default: false })
+  (0, import_typeorm18.Column)("boolean", { default: false })
 ], Form.prototype, "deleted", 2);
 __decorateClass([
-  (0, import_typeorm17.Column)("int", { nullable: true })
+  (0, import_typeorm18.Column)("int", { nullable: true })
 ], Form.prototype, "createdBy", 2);
 __decorateClass([
-  (0, import_typeorm17.Column)("int", { nullable: true })
+  (0, import_typeorm18.Column)("int", { nullable: true })
 ], Form.prototype, "updatedBy", 2);
 __decorateClass([
-  (0, import_typeorm17.Column)("int", { nullable: true })
+  (0, import_typeorm18.Column)("int", { nullable: true })
 ], Form.prototype, "deletedBy", 2);
 __decorateClass([
-  (0, import_typeorm17.OneToMany)(() => FormField, (f) => f.form)
+  (0, import_typeorm18.OneToMany)(() => FormField, (f) => f.form)
 ], Form.prototype, "fields", 2);
 __decorateClass([
-  (0, import_typeorm17.OneToMany)(() => FormSubmission, (s) => s.form)
+  (0, import_typeorm18.OneToMany)(() => FormSubmission, (s) => s.form)
 ], Form.prototype, "submissions", 2);
 Form = __decorateClass([
-  (0, import_typeorm17.Entity)("forms")
+  (0, import_typeorm18.Entity)("forms")
 ], Form);
 
 // src/entities/form-submission.entity.ts
@@ -5835,43 +6411,43 @@ var FormSubmission = class {
   contact;
 };
 __decorateClass([
-  (0, import_typeorm18.PrimaryGeneratedColumn)()
+  (0, import_typeorm19.PrimaryGeneratedColumn)()
 ], FormSubmission.prototype, "id", 2);
 __decorateClass([
-  (0, import_typeorm18.Column)("int")
+  (0, import_typeorm19.Column)("int")
 ], FormSubmission.prototype, "formId", 2);
 __decorateClass([
-  (0, import_typeorm18.Column)("int", { nullable: true })
+  (0, import_typeorm19.Column)("int", { nullable: true })
 ], FormSubmission.prototype, "contactId", 2);
 __decorateClass([
-  (0, import_typeorm18.Column)("jsonb")
+  (0, import_typeorm19.Column)("jsonb")
 ], FormSubmission.prototype, "data", 2);
 __decorateClass([
-  (0, import_typeorm18.Column)("varchar", { nullable: true })
+  (0, import_typeorm19.Column)("varchar", { nullable: true })
 ], FormSubmission.prototype, "ipAddress", 2);
 __decorateClass([
-  (0, import_typeorm18.Column)("varchar", { nullable: true })
+  (0, import_typeorm19.Column)("varchar", { nullable: true })
 ], FormSubmission.prototype, "userAgent", 2);
 __decorateClass([
-  (0, import_typeorm18.Column)({ type: "timestamp", default: () => "CURRENT_TIMESTAMP" })
+  (0, import_typeorm19.Column)({ type: "timestamp", default: () => "CURRENT_TIMESTAMP" })
 ], FormSubmission.prototype, "createdAt", 2);
 __decorateClass([
-  (0, import_typeorm18.Column)({ type: "timestamp", default: () => "CURRENT_TIMESTAMP" })
+  (0, import_typeorm19.Column)({ type: "timestamp", default: () => "CURRENT_TIMESTAMP" })
 ], FormSubmission.prototype, "updatedAt", 2);
 __decorateClass([
-  (0, import_typeorm18.ManyToOne)(() => Form, (f) => f.submissions, { onDelete: "CASCADE" }),
-  (0, import_typeorm18.JoinColumn)({ name: "formId" })
+  (0, import_typeorm19.ManyToOne)(() => Form, (f) => f.submissions, { onDelete: "CASCADE" }),
+  (0, import_typeorm19.JoinColumn)({ name: "formId" })
 ], FormSubmission.prototype, "form", 2);
 __decorateClass([
-  (0, import_typeorm18.ManyToOne)(() => Contact, (c) => c.form_submissions, { onDelete: "SET NULL" }),
-  (0, import_typeorm18.JoinColumn)({ name: "contactId" })
+  (0, import_typeorm19.ManyToOne)(() => Contact, (c) => c.form_submissions, { onDelete: "SET NULL" }),
+  (0, import_typeorm19.JoinColumn)({ name: "contactId" })
 ], FormSubmission.prototype, "contact", 2);
 FormSubmission = __decorateClass([
-  (0, import_typeorm18.Entity)("form_submissions")
+  (0, import_typeorm19.Entity)("form_submissions")
 ], FormSubmission);
 
 // src/entities/address.entity.ts
-var import_typeorm19 = require("typeorm");
+var import_typeorm20 = require("typeorm");
 var Address = class {
   id;
   contactId;
@@ -5887,48 +6463,48 @@ var Address = class {
   contact;
 };
 __decorateClass([
-  (0, import_typeorm19.PrimaryGeneratedColumn)()
+  (0, import_typeorm20.PrimaryGeneratedColumn)()
 ], Address.prototype, "id", 2);
 __decorateClass([
-  (0, import_typeorm19.Column)("int")
+  (0, import_typeorm20.Column)("int")
 ], Address.prototype, "contactId", 2);
 __decorateClass([
-  (0, import_typeorm19.Column)("varchar", { nullable: true })
+  (0, import_typeorm20.Column)("varchar", { nullable: true })
 ], Address.prototype, "tag", 2);
 __decorateClass([
-  (0, import_typeorm19.Column)("varchar", { nullable: true })
+  (0, import_typeorm20.Column)("varchar", { nullable: true })
 ], Address.prototype, "line1", 2);
 __decorateClass([
-  (0, import_typeorm19.Column)("varchar", { nullable: true })
+  (0, import_typeorm20.Column)("varchar", { nullable: true })
 ], Address.prototype, "line2", 2);
 __decorateClass([
-  (0, import_typeorm19.Column)("varchar", { nullable: true })
+  (0, import_typeorm20.Column)("varchar", { nullable: true })
 ], Address.prototype, "city", 2);
 __decorateClass([
-  (0, import_typeorm19.Column)("varchar", { nullable: true })
+  (0, import_typeorm20.Column)("varchar", { nullable: true })
 ], Address.prototype, "state", 2);
 __decorateClass([
-  (0, import_typeorm19.Column)("varchar", { nullable: true })
+  (0, import_typeorm20.Column)("varchar", { nullable: true })
 ], Address.prototype, "postalCode", 2);
 __decorateClass([
-  (0, import_typeorm19.Column)("varchar", { nullable: true })
+  (0, import_typeorm20.Column)("varchar", { nullable: true })
 ], Address.prototype, "country", 2);
 __decorateClass([
-  (0, import_typeorm19.Column)({ type: "timestamp", default: () => "CURRENT_TIMESTAMP" })
+  (0, import_typeorm20.Column)({ type: "timestamp", default: () => "CURRENT_TIMESTAMP" })
 ], Address.prototype, "createdAt", 2);
 __decorateClass([
-  (0, import_typeorm19.Column)({ type: "timestamp", default: () => "CURRENT_TIMESTAMP" })
+  (0, import_typeorm20.Column)({ type: "timestamp", default: () => "CURRENT_TIMESTAMP" })
 ], Address.prototype, "updatedAt", 2);
 __decorateClass([
-  (0, import_typeorm19.ManyToOne)(() => Contact, (c) => c.addresses, { onDelete: "CASCADE" }),
-  (0, import_typeorm19.JoinColumn)({ name: "contactId" })
+  (0, import_typeorm20.ManyToOne)(() => Contact, (c) => c.addresses, { onDelete: "CASCADE" }),
+  (0, import_typeorm20.JoinColumn)({ name: "contactId" })
 ], Address.prototype, "contact", 2);
 Address = __decorateClass([
-  (0, import_typeorm19.Entity)("addresses")
+  (0, import_typeorm20.Entity)("addresses")
 ], Address);
 
 // src/entities/order.entity.ts
-var import_typeorm20 = require("typeorm");
+var import_typeorm21 = require("typeorm");
 var Order = class {
   id;
   orderNumber;
@@ -5960,99 +6536,99 @@ var Order = class {
   payments;
 };
 __decorateClass([
-  (0, import_typeorm20.PrimaryGeneratedColumn)()
+  (0, import_typeorm21.PrimaryGeneratedColumn)()
 ], Order.prototype, "id", 2);
 __decorateClass([
-  (0, import_typeorm20.Column)("varchar", { unique: true })
+  (0, import_typeorm21.Column)("varchar", { unique: true })
 ], Order.prototype, "orderNumber", 2);
 __decorateClass([
-  (0, import_typeorm20.Column)("varchar", { default: "sale" })
+  (0, import_typeorm21.Column)("varchar", { default: "sale" })
 ], Order.prototype, "orderKind", 2);
 __decorateClass([
-  (0, import_typeorm20.Column)("int", { nullable: true })
+  (0, import_typeorm21.Column)("int", { nullable: true })
 ], Order.prototype, "parentOrderId", 2);
 __decorateClass([
-  (0, import_typeorm20.Column)("int")
+  (0, import_typeorm21.Column)("int")
 ], Order.prototype, "contactId", 2);
 __decorateClass([
-  (0, import_typeorm20.Column)("int", { nullable: true })
+  (0, import_typeorm21.Column)("int", { nullable: true })
 ], Order.prototype, "billingAddressId", 2);
 __decorateClass([
-  (0, import_typeorm20.Column)("int", { nullable: true })
+  (0, import_typeorm21.Column)("int", { nullable: true })
 ], Order.prototype, "shippingAddressId", 2);
 __decorateClass([
-  (0, import_typeorm20.Column)("varchar", { default: "pending" })
+  (0, import_typeorm21.Column)("varchar", { default: "pending" })
 ], Order.prototype, "status", 2);
 __decorateClass([
-  (0, import_typeorm20.Column)("decimal", { precision: 12, scale: 2, default: 0 })
+  (0, import_typeorm21.Column)("decimal", { precision: 12, scale: 2, default: 0 })
 ], Order.prototype, "subtotal", 2);
 __decorateClass([
-  (0, import_typeorm20.Column)("decimal", { precision: 12, scale: 2, default: 0 })
+  (0, import_typeorm21.Column)("decimal", { precision: 12, scale: 2, default: 0 })
 ], Order.prototype, "tax", 2);
 __decorateClass([
-  (0, import_typeorm20.Column)("decimal", { precision: 12, scale: 2, default: 0 })
+  (0, import_typeorm21.Column)("decimal", { precision: 12, scale: 2, default: 0 })
 ], Order.prototype, "discount", 2);
 __decorateClass([
-  (0, import_typeorm20.Column)("decimal", { precision: 12, scale: 2, default: 0 })
+  (0, import_typeorm21.Column)("decimal", { precision: 12, scale: 2, default: 0 })
 ], Order.prototype, "total", 2);
 __decorateClass([
-  (0, import_typeorm20.Column)("varchar", { default: "INR" })
+  (0, import_typeorm21.Column)("varchar", { default: "INR" })
 ], Order.prototype, "currency", 2);
 __decorateClass([
-  (0, import_typeorm20.Column)("jsonb", { nullable: true })
+  (0, import_typeorm21.Column)("jsonb", { nullable: true })
 ], Order.prototype, "metadata", 2);
 __decorateClass([
-  (0, import_typeorm20.Column)({ type: "timestamp", default: () => "CURRENT_TIMESTAMP" })
+  (0, import_typeorm21.Column)({ type: "timestamp", default: () => "CURRENT_TIMESTAMP" })
 ], Order.prototype, "createdAt", 2);
 __decorateClass([
-  (0, import_typeorm20.Column)({ type: "timestamp", default: () => "CURRENT_TIMESTAMP" })
+  (0, import_typeorm21.Column)({ type: "timestamp", default: () => "CURRENT_TIMESTAMP" })
 ], Order.prototype, "updatedAt", 2);
 __decorateClass([
-  (0, import_typeorm20.Column)({ type: "timestamp", nullable: true })
+  (0, import_typeorm21.Column)({ type: "timestamp", nullable: true })
 ], Order.prototype, "deletedAt", 2);
 __decorateClass([
-  (0, import_typeorm20.Column)("boolean", { default: false })
+  (0, import_typeorm21.Column)("boolean", { default: false })
 ], Order.prototype, "deleted", 2);
 __decorateClass([
-  (0, import_typeorm20.Column)("int", { nullable: true })
+  (0, import_typeorm21.Column)("int", { nullable: true })
 ], Order.prototype, "createdBy", 2);
 __decorateClass([
-  (0, import_typeorm20.Column)("int", { nullable: true })
+  (0, import_typeorm21.Column)("int", { nullable: true })
 ], Order.prototype, "updatedBy", 2);
 __decorateClass([
-  (0, import_typeorm20.Column)("int", { nullable: true })
+  (0, import_typeorm21.Column)("int", { nullable: true })
 ], Order.prototype, "deletedBy", 2);
 __decorateClass([
-  (0, import_typeorm20.ManyToOne)(() => Order, (o) => o.children, { nullable: true, onDelete: "SET NULL" }),
-  (0, import_typeorm20.JoinColumn)({ name: "parentOrderId" })
+  (0, import_typeorm21.ManyToOne)(() => Order, (o) => o.children, { nullable: true, onDelete: "SET NULL" }),
+  (0, import_typeorm21.JoinColumn)({ name: "parentOrderId" })
 ], Order.prototype, "parentOrder", 2);
 __decorateClass([
-  (0, import_typeorm20.OneToMany)(() => Order, (o) => o.parentOrder)
+  (0, import_typeorm21.OneToMany)(() => Order, (o) => o.parentOrder)
 ], Order.prototype, "children", 2);
 __decorateClass([
-  (0, import_typeorm20.ManyToOne)(() => Contact, { onDelete: "CASCADE" }),
-  (0, import_typeorm20.JoinColumn)({ name: "contactId" })
+  (0, import_typeorm21.ManyToOne)(() => Contact, { onDelete: "CASCADE" }),
+  (0, import_typeorm21.JoinColumn)({ name: "contactId" })
 ], Order.prototype, "contact", 2);
 __decorateClass([
-  (0, import_typeorm20.ManyToOne)(() => Address, { onDelete: "SET NULL" }),
-  (0, import_typeorm20.JoinColumn)({ name: "billingAddressId" })
+  (0, import_typeorm21.ManyToOne)(() => Address, { onDelete: "SET NULL" }),
+  (0, import_typeorm21.JoinColumn)({ name: "billingAddressId" })
 ], Order.prototype, "billingAddress", 2);
 __decorateClass([
-  (0, import_typeorm20.ManyToOne)(() => Address, { onDelete: "SET NULL" }),
-  (0, import_typeorm20.JoinColumn)({ name: "shippingAddressId" })
+  (0, import_typeorm21.ManyToOne)(() => Address, { onDelete: "SET NULL" }),
+  (0, import_typeorm21.JoinColumn)({ name: "shippingAddressId" })
 ], Order.prototype, "shippingAddress", 2);
 __decorateClass([
-  (0, import_typeorm20.OneToMany)("OrderItem", "order")
+  (0, import_typeorm21.OneToMany)("OrderItem", "order")
 ], Order.prototype, "items", 2);
 __decorateClass([
-  (0, import_typeorm20.OneToMany)("Payment", "order")
+  (0, import_typeorm21.OneToMany)("Payment", "order")
 ], Order.prototype, "payments", 2);
 Order = __decorateClass([
-  (0, import_typeorm20.Entity)("orders")
+  (0, import_typeorm21.Entity)("orders")
 ], Order);
 
 // src/entities/payment.entity.ts
-var import_typeorm21 = require("typeorm");
+var import_typeorm22 = require("typeorm");
 var Payment = class {
   id;
   orderId;
@@ -6075,73 +6651,73 @@ var Payment = class {
   contact;
 };
 __decorateClass([
-  (0, import_typeorm21.PrimaryGeneratedColumn)()
+  (0, import_typeorm22.PrimaryGeneratedColumn)()
 ], Payment.prototype, "id", 2);
 __decorateClass([
-  (0, import_typeorm21.Column)("int")
+  (0, import_typeorm22.Column)("int")
 ], Payment.prototype, "orderId", 2);
 __decorateClass([
-  (0, import_typeorm21.Column)("int", { nullable: true })
+  (0, import_typeorm22.Column)("int", { nullable: true })
 ], Payment.prototype, "contactId", 2);
 __decorateClass([
-  (0, import_typeorm21.Column)("decimal", { precision: 12, scale: 2 })
+  (0, import_typeorm22.Column)("decimal", { precision: 12, scale: 2 })
 ], Payment.prototype, "amount", 2);
 __decorateClass([
-  (0, import_typeorm21.Column)("varchar", { default: "INR" })
+  (0, import_typeorm22.Column)("varchar", { default: "INR" })
 ], Payment.prototype, "currency", 2);
 __decorateClass([
-  (0, import_typeorm21.Column)("varchar", { default: "pending" })
+  (0, import_typeorm22.Column)("varchar", { default: "pending" })
 ], Payment.prototype, "status", 2);
 __decorateClass([
-  (0, import_typeorm21.Column)("varchar", { nullable: true })
+  (0, import_typeorm22.Column)("varchar", { nullable: true })
 ], Payment.prototype, "method", 2);
 __decorateClass([
-  (0, import_typeorm21.Column)("varchar", { nullable: true })
+  (0, import_typeorm22.Column)("varchar", { nullable: true })
 ], Payment.prototype, "externalReference", 2);
 __decorateClass([
-  (0, import_typeorm21.Column)("jsonb", { nullable: true })
+  (0, import_typeorm22.Column)("jsonb", { nullable: true })
 ], Payment.prototype, "metadata", 2);
 __decorateClass([
-  (0, import_typeorm21.Column)({ type: "timestamp", nullable: true })
+  (0, import_typeorm22.Column)({ type: "timestamp", nullable: true })
 ], Payment.prototype, "paidAt", 2);
 __decorateClass([
-  (0, import_typeorm21.Column)({ type: "timestamp", default: () => "CURRENT_TIMESTAMP" })
+  (0, import_typeorm22.Column)({ type: "timestamp", default: () => "CURRENT_TIMESTAMP" })
 ], Payment.prototype, "createdAt", 2);
 __decorateClass([
-  (0, import_typeorm21.Column)({ type: "timestamp", default: () => "CURRENT_TIMESTAMP" })
+  (0, import_typeorm22.Column)({ type: "timestamp", default: () => "CURRENT_TIMESTAMP" })
 ], Payment.prototype, "updatedAt", 2);
 __decorateClass([
-  (0, import_typeorm21.Column)({ type: "timestamp", nullable: true })
+  (0, import_typeorm22.Column)({ type: "timestamp", nullable: true })
 ], Payment.prototype, "deletedAt", 2);
 __decorateClass([
-  (0, import_typeorm21.Column)("boolean", { default: false })
+  (0, import_typeorm22.Column)("boolean", { default: false })
 ], Payment.prototype, "deleted", 2);
 __decorateClass([
-  (0, import_typeorm21.Column)("int", { nullable: true })
+  (0, import_typeorm22.Column)("int", { nullable: true })
 ], Payment.prototype, "createdBy", 2);
 __decorateClass([
-  (0, import_typeorm21.Column)("int", { nullable: true })
+  (0, import_typeorm22.Column)("int", { nullable: true })
 ], Payment.prototype, "updatedBy", 2);
 __decorateClass([
-  (0, import_typeorm21.Column)("int", { nullable: true })
+  (0, import_typeorm22.Column)("int", { nullable: true })
 ], Payment.prototype, "deletedBy", 2);
 __decorateClass([
-  (0, import_typeorm21.ManyToOne)(() => Order, (o) => o.payments, { onDelete: "CASCADE" }),
-  (0, import_typeorm21.JoinColumn)({ name: "orderId" })
+  (0, import_typeorm22.ManyToOne)(() => Order, (o) => o.payments, { onDelete: "CASCADE" }),
+  (0, import_typeorm22.JoinColumn)({ name: "orderId" })
 ], Payment.prototype, "order", 2);
 __decorateClass([
-  (0, import_typeorm21.ManyToOne)(() => Contact, { onDelete: "SET NULL" }),
-  (0, import_typeorm21.JoinColumn)({ name: "contactId" })
+  (0, import_typeorm22.ManyToOne)(() => Contact, { onDelete: "SET NULL" }),
+  (0, import_typeorm22.JoinColumn)({ name: "contactId" })
 ], Payment.prototype, "contact", 2);
 Payment = __decorateClass([
-  (0, import_typeorm21.Entity)("payments")
+  (0, import_typeorm22.Entity)("payments")
 ], Payment);
 
 // src/entities/chat-conversation.entity.ts
-var import_typeorm23 = require("typeorm");
+var import_typeorm24 = require("typeorm");
 
 // src/entities/chat-message.entity.ts
-var import_typeorm22 = require("typeorm");
+var import_typeorm23 = require("typeorm");
 var ChatMessage = class {
   id;
   conversationId;
@@ -6151,26 +6727,26 @@ var ChatMessage = class {
   conversation;
 };
 __decorateClass([
-  (0, import_typeorm22.PrimaryGeneratedColumn)()
+  (0, import_typeorm23.PrimaryGeneratedColumn)()
 ], ChatMessage.prototype, "id", 2);
 __decorateClass([
-  (0, import_typeorm22.Column)("int")
+  (0, import_typeorm23.Column)("int")
 ], ChatMessage.prototype, "conversationId", 2);
 __decorateClass([
-  (0, import_typeorm22.Column)("varchar")
+  (0, import_typeorm23.Column)("varchar")
 ], ChatMessage.prototype, "role", 2);
 __decorateClass([
-  (0, import_typeorm22.Column)("text")
+  (0, import_typeorm23.Column)("text")
 ], ChatMessage.prototype, "content", 2);
 __decorateClass([
-  (0, import_typeorm22.Column)({ type: "timestamp", default: () => "CURRENT_TIMESTAMP" })
+  (0, import_typeorm23.Column)({ type: "timestamp", default: () => "CURRENT_TIMESTAMP" })
 ], ChatMessage.prototype, "createdAt", 2);
 __decorateClass([
-  (0, import_typeorm22.ManyToOne)(() => ChatConversation, (c) => c.messages, { onDelete: "CASCADE" }),
-  (0, import_typeorm22.JoinColumn)({ name: "conversationId" })
+  (0, import_typeorm23.ManyToOne)(() => ChatConversation, (c) => c.messages, { onDelete: "CASCADE" }),
+  (0, import_typeorm23.JoinColumn)({ name: "conversationId" })
 ], ChatMessage.prototype, "conversation", 2);
 ChatMessage = __decorateClass([
-  (0, import_typeorm22.Entity)("chat_messages")
+  (0, import_typeorm23.Entity)("chat_messages")
 ], ChatMessage);
 
 // src/entities/chat-conversation.entity.ts
@@ -6183,26 +6759,26 @@ var ChatConversation = class {
   messages;
 };
 __decorateClass([
-  (0, import_typeorm23.PrimaryGeneratedColumn)()
+  (0, import_typeorm24.PrimaryGeneratedColumn)()
 ], ChatConversation.prototype, "id", 2);
 __decorateClass([
-  (0, import_typeorm23.Column)("int")
+  (0, import_typeorm24.Column)("int")
 ], ChatConversation.prototype, "contactId", 2);
 __decorateClass([
-  (0, import_typeorm23.Column)({ type: "timestamp", default: () => "CURRENT_TIMESTAMP" })
+  (0, import_typeorm24.Column)({ type: "timestamp", default: () => "CURRENT_TIMESTAMP" })
 ], ChatConversation.prototype, "createdAt", 2);
 __decorateClass([
-  (0, import_typeorm23.Column)({ type: "timestamp", default: () => "CURRENT_TIMESTAMP" })
+  (0, import_typeorm24.Column)({ type: "timestamp", default: () => "CURRENT_TIMESTAMP" })
 ], ChatConversation.prototype, "updatedAt", 2);
 __decorateClass([
-  (0, import_typeorm23.ManyToOne)(() => Contact, (c) => c.chatConversations, { onDelete: "CASCADE" }),
-  (0, import_typeorm23.JoinColumn)({ name: "contactId" })
+  (0, import_typeorm24.ManyToOne)(() => Contact, (c) => c.chatConversations, { onDelete: "CASCADE" }),
+  (0, import_typeorm24.JoinColumn)({ name: "contactId" })
 ], ChatConversation.prototype, "contact", 2);
 __decorateClass([
-  (0, import_typeorm23.OneToMany)(() => ChatMessage, (m) => m.conversation)
+  (0, import_typeorm24.OneToMany)(() => ChatMessage, (m) => m.conversation)
 ], ChatConversation.prototype, "messages", 2);
 ChatConversation = __decorateClass([
-  (0, import_typeorm23.Entity)("chat_conversations")
+  (0, import_typeorm24.Entity)("chat_conversations")
 ], ChatConversation);
 
 // src/entities/contact.entity.ts
@@ -6231,78 +6807,78 @@ var Contact = class {
   chatConversations;
 };
 __decorateClass([
-  (0, import_typeorm24.PrimaryGeneratedColumn)()
+  (0, import_typeorm25.PrimaryGeneratedColumn)()
 ], Contact.prototype, "id", 2);
 __decorateClass([
-  (0, import_typeorm24.Column)("varchar")
+  (0, import_typeorm25.Column)("varchar")
 ], Contact.prototype, "name", 2);
 __decorateClass([
-  (0, import_typeorm24.Column)("varchar", { unique: true })
+  (0, import_typeorm25.Column)("varchar", { unique: true })
 ], Contact.prototype, "email", 2);
 __decorateClass([
-  (0, import_typeorm24.Column)("varchar", { nullable: true })
+  (0, import_typeorm25.Column)("varchar", { nullable: true })
 ], Contact.prototype, "phone", 2);
 __decorateClass([
-  (0, import_typeorm24.Column)("varchar", { nullable: true })
+  (0, import_typeorm25.Column)("varchar", { nullable: true })
 ], Contact.prototype, "type", 2);
 __decorateClass([
-  (0, import_typeorm24.Column)("varchar", { nullable: true })
+  (0, import_typeorm25.Column)("varchar", { nullable: true })
 ], Contact.prototype, "company", 2);
 __decorateClass([
-  (0, import_typeorm24.Column)("varchar", { nullable: true })
+  (0, import_typeorm25.Column)("varchar", { nullable: true })
 ], Contact.prototype, "taxId", 2);
 __decorateClass([
-  (0, import_typeorm24.Column)("text", { nullable: true })
+  (0, import_typeorm25.Column)("text", { nullable: true })
 ], Contact.prototype, "notes", 2);
 __decorateClass([
-  (0, import_typeorm24.Column)({ type: "timestamp", default: () => "CURRENT_TIMESTAMP" })
+  (0, import_typeorm25.Column)({ type: "timestamp", default: () => "CURRENT_TIMESTAMP" })
 ], Contact.prototype, "createdAt", 2);
 __decorateClass([
-  (0, import_typeorm24.Column)({ type: "timestamp", default: () => "CURRENT_TIMESTAMP" })
+  (0, import_typeorm25.Column)({ type: "timestamp", default: () => "CURRENT_TIMESTAMP" })
 ], Contact.prototype, "updatedAt", 2);
 __decorateClass([
-  (0, import_typeorm24.Column)({ type: "timestamp", nullable: true })
+  (0, import_typeorm25.Column)({ type: "timestamp", nullable: true })
 ], Contact.prototype, "deletedAt", 2);
 __decorateClass([
-  (0, import_typeorm24.Column)("boolean", { default: false })
+  (0, import_typeorm25.Column)("boolean", { default: false })
 ], Contact.prototype, "deleted", 2);
 __decorateClass([
-  (0, import_typeorm24.Column)("int", { nullable: true })
+  (0, import_typeorm25.Column)("int", { nullable: true })
 ], Contact.prototype, "createdBy", 2);
 __decorateClass([
-  (0, import_typeorm24.Column)("int", { nullable: true })
+  (0, import_typeorm25.Column)("int", { nullable: true })
 ], Contact.prototype, "updatedBy", 2);
 __decorateClass([
-  (0, import_typeorm24.Column)("int", { nullable: true })
+  (0, import_typeorm25.Column)("int", { nullable: true })
 ], Contact.prototype, "deletedBy", 2);
 __decorateClass([
-  (0, import_typeorm24.Column)("int", { nullable: true })
+  (0, import_typeorm25.Column)("int", { nullable: true })
 ], Contact.prototype, "userId", 2);
 __decorateClass([
-  (0, import_typeorm24.ManyToOne)(() => User, { onDelete: "SET NULL" }),
-  (0, import_typeorm24.JoinColumn)({ name: "userId" })
+  (0, import_typeorm25.ManyToOne)(() => User, { onDelete: "SET NULL" }),
+  (0, import_typeorm25.JoinColumn)({ name: "userId" })
 ], Contact.prototype, "user", 2);
 __decorateClass([
-  (0, import_typeorm24.OneToMany)(() => FormSubmission, (fs) => fs.contact)
+  (0, import_typeorm25.OneToMany)(() => FormSubmission, (fs) => fs.contact)
 ], Contact.prototype, "form_submissions", 2);
 __decorateClass([
-  (0, import_typeorm24.OneToMany)(() => Address, (a) => a.contact)
+  (0, import_typeorm25.OneToMany)(() => Address, (a) => a.contact)
 ], Contact.prototype, "addresses", 2);
 __decorateClass([
-  (0, import_typeorm24.OneToMany)(() => Order, (o) => o.contact)
+  (0, import_typeorm25.OneToMany)(() => Order, (o) => o.contact)
 ], Contact.prototype, "orders", 2);
 __decorateClass([
-  (0, import_typeorm24.OneToMany)(() => Payment, (p) => p.contact)
+  (0, import_typeorm25.OneToMany)(() => Payment, (p) => p.contact)
 ], Contact.prototype, "payments", 2);
 __decorateClass([
-  (0, import_typeorm24.OneToMany)(() => ChatConversation, (c) => c.contact)
+  (0, import_typeorm25.OneToMany)(() => ChatConversation, (c) => c.contact)
 ], Contact.prototype, "chatConversations", 2);
 Contact = __decorateClass([
-  (0, import_typeorm24.Entity)("contacts")
+  (0, import_typeorm25.Entity)("contacts")
 ], Contact);
 
 // src/entities/config.entity.ts
-var import_typeorm25 = require("typeorm");
+var import_typeorm26 = require("typeorm");
 var Config = class {
   id;
   settings;
@@ -6319,51 +6895,51 @@ var Config = class {
   deletedBy;
 };
 __decorateClass([
-  (0, import_typeorm25.PrimaryGeneratedColumn)()
+  (0, import_typeorm26.PrimaryGeneratedColumn)()
 ], Config.prototype, "id", 2);
 __decorateClass([
-  (0, import_typeorm25.Column)("varchar")
+  (0, import_typeorm26.Column)("varchar")
 ], Config.prototype, "settings", 2);
 __decorateClass([
-  (0, import_typeorm25.Column)("varchar")
+  (0, import_typeorm26.Column)("varchar")
 ], Config.prototype, "key", 2);
 __decorateClass([
-  (0, import_typeorm25.Column)("varchar")
+  (0, import_typeorm26.Column)("varchar")
 ], Config.prototype, "value", 2);
 __decorateClass([
-  (0, import_typeorm25.Column)("varchar", { default: "private" })
+  (0, import_typeorm26.Column)("varchar", { default: "private" })
 ], Config.prototype, "type", 2);
 __decorateClass([
-  (0, import_typeorm25.Column)("boolean", { default: false })
+  (0, import_typeorm26.Column)("boolean", { default: false })
 ], Config.prototype, "encrypted", 2);
 __decorateClass([
-  (0, import_typeorm25.Column)({ type: "timestamp", default: () => "CURRENT_TIMESTAMP" })
+  (0, import_typeorm26.Column)({ type: "timestamp", default: () => "CURRENT_TIMESTAMP" })
 ], Config.prototype, "createdAt", 2);
 __decorateClass([
-  (0, import_typeorm25.Column)({ type: "timestamp", default: () => "CURRENT_TIMESTAMP" })
+  (0, import_typeorm26.Column)({ type: "timestamp", default: () => "CURRENT_TIMESTAMP" })
 ], Config.prototype, "updatedAt", 2);
 __decorateClass([
-  (0, import_typeorm25.Column)({ type: "timestamp", nullable: true })
+  (0, import_typeorm26.Column)({ type: "timestamp", nullable: true })
 ], Config.prototype, "deletedAt", 2);
 __decorateClass([
-  (0, import_typeorm25.Column)("boolean", { default: false })
+  (0, import_typeorm26.Column)("boolean", { default: false })
 ], Config.prototype, "deleted", 2);
 __decorateClass([
-  (0, import_typeorm25.Column)("int", { nullable: true })
+  (0, import_typeorm26.Column)("int", { nullable: true })
 ], Config.prototype, "createdBy", 2);
 __decorateClass([
-  (0, import_typeorm25.Column)("int", { nullable: true })
+  (0, import_typeorm26.Column)("int", { nullable: true })
 ], Config.prototype, "updatedBy", 2);
 __decorateClass([
-  (0, import_typeorm25.Column)("int", { nullable: true })
+  (0, import_typeorm26.Column)("int", { nullable: true })
 ], Config.prototype, "deletedBy", 2);
 Config = __decorateClass([
-  (0, import_typeorm25.Entity)("configs"),
-  (0, import_typeorm25.Unique)(["settings", "key"])
+  (0, import_typeorm26.Entity)("configs"),
+  (0, import_typeorm26.Unique)(["settings", "key"])
 ], Config);
 
 // src/entities/message-template.entity.ts
-var import_typeorm26 = require("typeorm");
+var import_typeorm27 = require("typeorm");
 var MessageTemplate = class {
   id;
   channel;
@@ -6383,59 +6959,59 @@ var MessageTemplate = class {
   deletedBy;
 };
 __decorateClass([
-  (0, import_typeorm26.PrimaryGeneratedColumn)()
+  (0, import_typeorm27.PrimaryGeneratedColumn)()
 ], MessageTemplate.prototype, "id", 2);
 __decorateClass([
-  (0, import_typeorm26.Column)("varchar")
+  (0, import_typeorm27.Column)("varchar")
 ], MessageTemplate.prototype, "channel", 2);
 __decorateClass([
-  (0, import_typeorm26.Column)("varchar", { name: "template_key" })
+  (0, import_typeorm27.Column)("varchar", { name: "template_key" })
 ], MessageTemplate.prototype, "templateKey", 2);
 __decorateClass([
-  (0, import_typeorm26.Column)("varchar", { nullable: true })
+  (0, import_typeorm27.Column)("varchar", { nullable: true })
 ], MessageTemplate.prototype, "name", 2);
 __decorateClass([
-  (0, import_typeorm26.Column)("varchar", { nullable: true })
+  (0, import_typeorm27.Column)("varchar", { nullable: true })
 ], MessageTemplate.prototype, "subject", 2);
 __decorateClass([
-  (0, import_typeorm26.Column)("text", { default: "" })
+  (0, import_typeorm27.Column)("text", { default: "" })
 ], MessageTemplate.prototype, "body", 2);
 __decorateClass([
-  (0, import_typeorm26.Column)("varchar", { name: "external_template_ref", nullable: true })
+  (0, import_typeorm27.Column)("varchar", { name: "external_template_ref", nullable: true })
 ], MessageTemplate.prototype, "externalTemplateRef", 2);
 __decorateClass([
-  (0, import_typeorm26.Column)({ type: "jsonb", nullable: true })
+  (0, import_typeorm27.Column)({ type: "jsonb", nullable: true })
 ], MessageTemplate.prototype, "providerMeta", 2);
 __decorateClass([
-  (0, import_typeorm26.Column)("boolean", { default: true })
+  (0, import_typeorm27.Column)("boolean", { default: true })
 ], MessageTemplate.prototype, "enabled", 2);
 __decorateClass([
-  (0, import_typeorm26.Column)({ type: "timestamp", default: () => "CURRENT_TIMESTAMP" })
+  (0, import_typeorm27.Column)({ type: "timestamp", default: () => "CURRENT_TIMESTAMP" })
 ], MessageTemplate.prototype, "createdAt", 2);
 __decorateClass([
-  (0, import_typeorm26.Column)({ type: "timestamp", default: () => "CURRENT_TIMESTAMP" })
+  (0, import_typeorm27.Column)({ type: "timestamp", default: () => "CURRENT_TIMESTAMP" })
 ], MessageTemplate.prototype, "updatedAt", 2);
 __decorateClass([
-  (0, import_typeorm26.Column)({ type: "timestamp", nullable: true })
+  (0, import_typeorm27.Column)({ type: "timestamp", nullable: true })
 ], MessageTemplate.prototype, "deletedAt", 2);
 __decorateClass([
-  (0, import_typeorm26.Column)("boolean", { default: false })
+  (0, import_typeorm27.Column)("boolean", { default: false })
 ], MessageTemplate.prototype, "deleted", 2);
 __decorateClass([
-  (0, import_typeorm26.Column)("int", { nullable: true })
+  (0, import_typeorm27.Column)("int", { nullable: true })
 ], MessageTemplate.prototype, "createdBy", 2);
 __decorateClass([
-  (0, import_typeorm26.Column)("int", { nullable: true })
+  (0, import_typeorm27.Column)("int", { nullable: true })
 ], MessageTemplate.prototype, "updatedBy", 2);
 __decorateClass([
-  (0, import_typeorm26.Column)("int", { nullable: true })
+  (0, import_typeorm27.Column)("int", { nullable: true })
 ], MessageTemplate.prototype, "deletedBy", 2);
 MessageTemplate = __decorateClass([
-  (0, import_typeorm26.Entity)("message_templates")
+  (0, import_typeorm27.Entity)("message_templates")
 ], MessageTemplate);
 
 // src/entities/media.entity.ts
-var import_typeorm27 = require("typeorm");
+var import_typeorm28 = require("typeorm");
 var Media = class {
   id;
   kind;
@@ -6454,57 +7030,57 @@ var Media = class {
   deleted;
 };
 __decorateClass([
-  (0, import_typeorm27.PrimaryGeneratedColumn)()
+  (0, import_typeorm28.PrimaryGeneratedColumn)()
 ], Media.prototype, "id", 2);
 __decorateClass([
-  (0, import_typeorm27.Column)({ type: "varchar", length: 16, default: "file" })
+  (0, import_typeorm28.Column)({ type: "varchar", length: 16, default: "file" })
 ], Media.prototype, "kind", 2);
 __decorateClass([
-  (0, import_typeorm27.Column)({ type: "int", nullable: true })
+  (0, import_typeorm28.Column)({ type: "int", nullable: true })
 ], Media.prototype, "parentId", 2);
 __decorateClass([
-  (0, import_typeorm27.ManyToOne)(() => Media, (m) => m.children, { onDelete: "CASCADE" }),
-  (0, import_typeorm27.JoinColumn)({ name: "parentId" })
+  (0, import_typeorm28.ManyToOne)(() => Media, (m) => m.children, { onDelete: "CASCADE" }),
+  (0, import_typeorm28.JoinColumn)({ name: "parentId" })
 ], Media.prototype, "parent", 2);
 __decorateClass([
-  (0, import_typeorm27.OneToMany)(() => Media, (m) => m.parent)
+  (0, import_typeorm28.OneToMany)(() => Media, (m) => m.parent)
 ], Media.prototype, "children", 2);
 __decorateClass([
-  (0, import_typeorm27.Column)("varchar")
+  (0, import_typeorm28.Column)("varchar")
 ], Media.prototype, "filename", 2);
 __decorateClass([
-  (0, import_typeorm27.Column)("varchar", { nullable: true })
+  (0, import_typeorm28.Column)("varchar", { nullable: true })
 ], Media.prototype, "url", 2);
 __decorateClass([
-  (0, import_typeorm27.Column)("varchar", { nullable: true })
+  (0, import_typeorm28.Column)("varchar", { nullable: true })
 ], Media.prototype, "mimeType", 2);
 __decorateClass([
-  (0, import_typeorm27.Column)("int", { default: 0 })
+  (0, import_typeorm28.Column)("int", { default: 0 })
 ], Media.prototype, "size", 2);
 __decorateClass([
-  (0, import_typeorm27.Column)("varchar", { nullable: true })
+  (0, import_typeorm28.Column)("varchar", { nullable: true })
 ], Media.prototype, "alt", 2);
 __decorateClass([
-  (0, import_typeorm27.Column)("boolean", { default: false })
+  (0, import_typeorm28.Column)("boolean", { default: false })
 ], Media.prototype, "isPublic", 2);
 __decorateClass([
-  (0, import_typeorm27.Column)({ type: "timestamp", default: () => "CURRENT_TIMESTAMP" })
+  (0, import_typeorm28.Column)({ type: "timestamp", default: () => "CURRENT_TIMESTAMP" })
 ], Media.prototype, "createdAt", 2);
 __decorateClass([
-  (0, import_typeorm27.Column)({ type: "timestamp", default: () => "CURRENT_TIMESTAMP" })
+  (0, import_typeorm28.Column)({ type: "timestamp", default: () => "CURRENT_TIMESTAMP" })
 ], Media.prototype, "updatedAt", 2);
 __decorateClass([
-  (0, import_typeorm27.Column)({ type: "timestamp", nullable: true })
+  (0, import_typeorm28.Column)({ type: "timestamp", nullable: true })
 ], Media.prototype, "deletedAt", 2);
 __decorateClass([
-  (0, import_typeorm27.Column)("boolean", { default: false })
+  (0, import_typeorm28.Column)("boolean", { default: false })
 ], Media.prototype, "deleted", 2);
 Media = __decorateClass([
-  (0, import_typeorm27.Entity)("media")
+  (0, import_typeorm28.Entity)("media")
 ], Media);
 
 // src/entities/page.entity.ts
-var import_typeorm28 = require("typeorm");
+var import_typeorm29 = require("typeorm");
 var Page = class {
   id;
   title;
@@ -6525,64 +7101,64 @@ var Page = class {
   deletedBy;
 };
 __decorateClass([
-  (0, import_typeorm28.PrimaryGeneratedColumn)()
+  (0, import_typeorm29.PrimaryGeneratedColumn)()
 ], Page.prototype, "id", 2);
 __decorateClass([
-  (0, import_typeorm28.Column)("varchar")
+  (0, import_typeorm29.Column)("varchar")
 ], Page.prototype, "title", 2);
 __decorateClass([
-  (0, import_typeorm28.Column)("varchar", { unique: true })
+  (0, import_typeorm29.Column)("varchar", { unique: true })
 ], Page.prototype, "slug", 2);
 __decorateClass([
-  (0, import_typeorm28.Column)({ type: "jsonb", default: {} })
+  (0, import_typeorm29.Column)({ type: "jsonb", default: {} })
 ], Page.prototype, "content", 2);
 __decorateClass([
-  (0, import_typeorm28.Column)("boolean", { default: false })
+  (0, import_typeorm29.Column)("boolean", { default: false })
 ], Page.prototype, "published", 2);
 __decorateClass([
-  (0, import_typeorm28.Column)("varchar", { default: "default" })
+  (0, import_typeorm29.Column)("varchar", { default: "default" })
 ], Page.prototype, "theme", 2);
 __decorateClass([
-  (0, import_typeorm28.Column)("int", { nullable: true })
+  (0, import_typeorm29.Column)("int", { nullable: true })
 ], Page.prototype, "parentId", 2);
 __decorateClass([
-  (0, import_typeorm28.ManyToOne)(() => Page, { onDelete: "SET NULL" }),
-  (0, import_typeorm28.JoinColumn)({ name: "parentId" })
+  (0, import_typeorm29.ManyToOne)(() => Page, { onDelete: "SET NULL" }),
+  (0, import_typeorm29.JoinColumn)({ name: "parentId" })
 ], Page.prototype, "parent", 2);
 __decorateClass([
-  (0, import_typeorm28.Column)("int", { nullable: true })
+  (0, import_typeorm29.Column)("int", { nullable: true })
 ], Page.prototype, "seoId", 2);
 __decorateClass([
-  (0, import_typeorm28.ManyToOne)(() => Seo, { onDelete: "SET NULL" }),
-  (0, import_typeorm28.JoinColumn)({ name: "seoId" })
+  (0, import_typeorm29.ManyToOne)(() => Seo, { onDelete: "SET NULL" }),
+  (0, import_typeorm29.JoinColumn)({ name: "seoId" })
 ], Page.prototype, "seo", 2);
 __decorateClass([
-  (0, import_typeorm28.Column)({ type: "timestamp", default: () => "CURRENT_TIMESTAMP" })
+  (0, import_typeorm29.Column)({ type: "timestamp", default: () => "CURRENT_TIMESTAMP" })
 ], Page.prototype, "createdAt", 2);
 __decorateClass([
-  (0, import_typeorm28.Column)({ type: "timestamp", default: () => "CURRENT_TIMESTAMP" })
+  (0, import_typeorm29.Column)({ type: "timestamp", default: () => "CURRENT_TIMESTAMP" })
 ], Page.prototype, "updatedAt", 2);
 __decorateClass([
-  (0, import_typeorm28.Column)({ type: "timestamp", nullable: true })
+  (0, import_typeorm29.Column)({ type: "timestamp", nullable: true })
 ], Page.prototype, "deletedAt", 2);
 __decorateClass([
-  (0, import_typeorm28.Column)("boolean", { default: false })
+  (0, import_typeorm29.Column)("boolean", { default: false })
 ], Page.prototype, "deleted", 2);
 __decorateClass([
-  (0, import_typeorm28.Column)("int", { nullable: true })
+  (0, import_typeorm29.Column)("int", { nullable: true })
 ], Page.prototype, "createdBy", 2);
 __decorateClass([
-  (0, import_typeorm28.Column)("int", { nullable: true })
+  (0, import_typeorm29.Column)("int", { nullable: true })
 ], Page.prototype, "updatedBy", 2);
 __decorateClass([
-  (0, import_typeorm28.Column)("int", { nullable: true })
+  (0, import_typeorm29.Column)("int", { nullable: true })
 ], Page.prototype, "deletedBy", 2);
 Page = __decorateClass([
-  (0, import_typeorm28.Entity)("pages")
+  (0, import_typeorm29.Entity)("pages")
 ], Page);
 
 // src/entities/product-category.entity.ts
-var import_typeorm29 = require("typeorm");
+var import_typeorm30 = require("typeorm");
 var ProductCategory = class {
   id;
   name;
@@ -6606,75 +7182,75 @@ var ProductCategory = class {
   collections;
 };
 __decorateClass([
-  (0, import_typeorm29.PrimaryGeneratedColumn)()
+  (0, import_typeorm30.PrimaryGeneratedColumn)()
 ], ProductCategory.prototype, "id", 2);
 __decorateClass([
-  (0, import_typeorm29.Column)("varchar")
+  (0, import_typeorm30.Column)("varchar")
 ], ProductCategory.prototype, "name", 2);
 __decorateClass([
-  (0, import_typeorm29.Column)("varchar", { unique: true })
+  (0, import_typeorm30.Column)("varchar", { unique: true })
 ], ProductCategory.prototype, "slug", 2);
 __decorateClass([
-  (0, import_typeorm29.Column)("int", { nullable: true })
+  (0, import_typeorm30.Column)("int", { nullable: true })
 ], ProductCategory.prototype, "parentId", 2);
 __decorateClass([
-  (0, import_typeorm29.Column)("varchar", { nullable: true })
+  (0, import_typeorm30.Column)("varchar", { nullable: true })
 ], ProductCategory.prototype, "image", 2);
 __decorateClass([
-  (0, import_typeorm29.Column)("text", { nullable: true })
+  (0, import_typeorm30.Column)("text", { nullable: true })
 ], ProductCategory.prototype, "description", 2);
 __decorateClass([
-  (0, import_typeorm29.Column)("jsonb", { nullable: true })
+  (0, import_typeorm30.Column)("jsonb", { nullable: true })
 ], ProductCategory.prototype, "metadata", 2);
 __decorateClass([
-  (0, import_typeorm29.Column)("boolean", { default: true })
+  (0, import_typeorm30.Column)("boolean", { default: true })
 ], ProductCategory.prototype, "active", 2);
 __decorateClass([
-  (0, import_typeorm29.Column)("int", { default: 0 })
+  (0, import_typeorm30.Column)("int", { default: 0 })
 ], ProductCategory.prototype, "sortOrder", 2);
 __decorateClass([
-  (0, import_typeorm29.Column)({ type: "timestamp", default: () => "CURRENT_TIMESTAMP" })
+  (0, import_typeorm30.Column)({ type: "timestamp", default: () => "CURRENT_TIMESTAMP" })
 ], ProductCategory.prototype, "createdAt", 2);
 __decorateClass([
-  (0, import_typeorm29.Column)({ type: "timestamp", default: () => "CURRENT_TIMESTAMP" })
+  (0, import_typeorm30.Column)({ type: "timestamp", default: () => "CURRENT_TIMESTAMP" })
 ], ProductCategory.prototype, "updatedAt", 2);
 __decorateClass([
-  (0, import_typeorm29.Column)({ type: "timestamp", nullable: true })
+  (0, import_typeorm30.Column)({ type: "timestamp", nullable: true })
 ], ProductCategory.prototype, "deletedAt", 2);
 __decorateClass([
-  (0, import_typeorm29.Column)("boolean", { default: false })
+  (0, import_typeorm30.Column)("boolean", { default: false })
 ], ProductCategory.prototype, "deleted", 2);
 __decorateClass([
-  (0, import_typeorm29.Column)("int", { nullable: true })
+  (0, import_typeorm30.Column)("int", { nullable: true })
 ], ProductCategory.prototype, "createdBy", 2);
 __decorateClass([
-  (0, import_typeorm29.Column)("int", { nullable: true })
+  (0, import_typeorm30.Column)("int", { nullable: true })
 ], ProductCategory.prototype, "updatedBy", 2);
 __decorateClass([
-  (0, import_typeorm29.Column)("int", { nullable: true })
+  (0, import_typeorm30.Column)("int", { nullable: true })
 ], ProductCategory.prototype, "deletedBy", 2);
 __decorateClass([
-  (0, import_typeorm29.ManyToOne)(() => ProductCategory, (c) => c.children, { onDelete: "SET NULL" }),
-  (0, import_typeorm29.JoinColumn)({ name: "parentId" })
+  (0, import_typeorm30.ManyToOne)(() => ProductCategory, (c) => c.children, { onDelete: "SET NULL" }),
+  (0, import_typeorm30.JoinColumn)({ name: "parentId" })
 ], ProductCategory.prototype, "parent", 2);
 __decorateClass([
-  (0, import_typeorm29.OneToMany)(() => ProductCategory, (c) => c.parent)
+  (0, import_typeorm30.OneToMany)(() => ProductCategory, (c) => c.parent)
 ], ProductCategory.prototype, "children", 2);
 __decorateClass([
-  (0, import_typeorm29.OneToMany)("Product", "category")
+  (0, import_typeorm30.OneToMany)("Product", "category")
 ], ProductCategory.prototype, "products", 2);
 __decorateClass([
-  (0, import_typeorm29.OneToMany)("Collection", "category")
+  (0, import_typeorm30.OneToMany)("Collection", "category")
 ], ProductCategory.prototype, "collections", 2);
 ProductCategory = __decorateClass([
-  (0, import_typeorm29.Entity)("product_categories")
+  (0, import_typeorm30.Entity)("product_categories")
 ], ProductCategory);
 
 // src/entities/collection.entity.ts
-var import_typeorm31 = require("typeorm");
+var import_typeorm32 = require("typeorm");
 
 // src/entities/brand.entity.ts
-var import_typeorm30 = require("typeorm");
+var import_typeorm31 = require("typeorm");
 var Brand = class {
   id;
   name;
@@ -6697,65 +7273,65 @@ var Brand = class {
   collections;
 };
 __decorateClass([
-  (0, import_typeorm30.PrimaryGeneratedColumn)()
+  (0, import_typeorm31.PrimaryGeneratedColumn)()
 ], Brand.prototype, "id", 2);
 __decorateClass([
-  (0, import_typeorm30.Column)("varchar")
+  (0, import_typeorm31.Column)("varchar")
 ], Brand.prototype, "name", 2);
 __decorateClass([
-  (0, import_typeorm30.Column)("varchar", { unique: true })
+  (0, import_typeorm31.Column)("varchar", { unique: true })
 ], Brand.prototype, "slug", 2);
 __decorateClass([
-  (0, import_typeorm30.Column)("varchar", { nullable: true })
+  (0, import_typeorm31.Column)("varchar", { nullable: true })
 ], Brand.prototype, "logo", 2);
 __decorateClass([
-  (0, import_typeorm30.Column)("jsonb", { nullable: true })
+  (0, import_typeorm31.Column)("jsonb", { nullable: true })
 ], Brand.prototype, "metadata", 2);
 __decorateClass([
-  (0, import_typeorm30.Column)("text", { nullable: true })
+  (0, import_typeorm31.Column)("text", { nullable: true })
 ], Brand.prototype, "description", 2);
 __decorateClass([
-  (0, import_typeorm30.Column)("boolean", { default: true })
+  (0, import_typeorm31.Column)("boolean", { default: true })
 ], Brand.prototype, "active", 2);
 __decorateClass([
-  (0, import_typeorm30.Column)("int", { default: 0 })
+  (0, import_typeorm31.Column)("int", { default: 0 })
 ], Brand.prototype, "sortOrder", 2);
 __decorateClass([
-  (0, import_typeorm30.Column)({ type: "timestamp", default: () => "CURRENT_TIMESTAMP" })
+  (0, import_typeorm31.Column)({ type: "timestamp", default: () => "CURRENT_TIMESTAMP" })
 ], Brand.prototype, "createdAt", 2);
 __decorateClass([
-  (0, import_typeorm30.Column)({ type: "timestamp", default: () => "CURRENT_TIMESTAMP" })
+  (0, import_typeorm31.Column)({ type: "timestamp", default: () => "CURRENT_TIMESTAMP" })
 ], Brand.prototype, "updatedAt", 2);
 __decorateClass([
-  (0, import_typeorm30.Column)({ type: "timestamp", nullable: true })
+  (0, import_typeorm31.Column)({ type: "timestamp", nullable: true })
 ], Brand.prototype, "deletedAt", 2);
 __decorateClass([
-  (0, import_typeorm30.Column)("boolean", { default: false })
+  (0, import_typeorm31.Column)("boolean", { default: false })
 ], Brand.prototype, "deleted", 2);
 __decorateClass([
-  (0, import_typeorm30.Column)("int", { nullable: true })
+  (0, import_typeorm31.Column)("int", { nullable: true })
 ], Brand.prototype, "createdBy", 2);
 __decorateClass([
-  (0, import_typeorm30.Column)("int", { nullable: true })
+  (0, import_typeorm31.Column)("int", { nullable: true })
 ], Brand.prototype, "updatedBy", 2);
 __decorateClass([
-  (0, import_typeorm30.Column)("int", { nullable: true })
+  (0, import_typeorm31.Column)("int", { nullable: true })
 ], Brand.prototype, "deletedBy", 2);
 __decorateClass([
-  (0, import_typeorm30.Column)("int", { nullable: true })
+  (0, import_typeorm31.Column)("int", { nullable: true })
 ], Brand.prototype, "seoId", 2);
 __decorateClass([
-  (0, import_typeorm30.ManyToOne)(() => Seo, { onDelete: "SET NULL" }),
-  (0, import_typeorm30.JoinColumn)({ name: "seoId" })
+  (0, import_typeorm31.ManyToOne)(() => Seo, { onDelete: "SET NULL" }),
+  (0, import_typeorm31.JoinColumn)({ name: "seoId" })
 ], Brand.prototype, "seo", 2);
 __decorateClass([
-  (0, import_typeorm30.OneToMany)("Product", "brand")
+  (0, import_typeorm31.OneToMany)("Product", "brand")
 ], Brand.prototype, "products", 2);
 __decorateClass([
-  (0, import_typeorm30.OneToMany)("Collection", "brand")
+  (0, import_typeorm31.OneToMany)("Collection", "brand")
 ], Brand.prototype, "collections", 2);
 Brand = __decorateClass([
-  (0, import_typeorm30.Entity)("brands")
+  (0, import_typeorm31.Entity)("brands")
 ], Brand);
 
 // src/entities/collection.entity.ts
@@ -6769,6 +7345,7 @@ var Collection = class {
   description;
   image;
   metadata;
+  variants;
   active;
   sortOrder;
   createdAt;
@@ -6785,83 +7362,86 @@ var Collection = class {
   products;
 };
 __decorateClass([
-  (0, import_typeorm31.PrimaryGeneratedColumn)()
+  (0, import_typeorm32.PrimaryGeneratedColumn)()
 ], Collection.prototype, "id", 2);
 __decorateClass([
-  (0, import_typeorm31.Column)("int", { nullable: true })
+  (0, import_typeorm32.Column)("int", { nullable: true })
 ], Collection.prototype, "categoryId", 2);
 __decorateClass([
-  (0, import_typeorm31.Column)("int", { nullable: true })
+  (0, import_typeorm32.Column)("int", { nullable: true })
 ], Collection.prototype, "brandId", 2);
 __decorateClass([
-  (0, import_typeorm31.Column)("varchar")
+  (0, import_typeorm32.Column)("varchar")
 ], Collection.prototype, "name", 2);
 __decorateClass([
-  (0, import_typeorm31.Column)("varchar", { unique: true })
+  (0, import_typeorm32.Column)("varchar", { unique: true })
 ], Collection.prototype, "slug", 2);
 __decorateClass([
-  (0, import_typeorm31.Column)("varchar", { nullable: true })
+  (0, import_typeorm32.Column)("varchar", { nullable: true })
 ], Collection.prototype, "hsn", 2);
 __decorateClass([
-  (0, import_typeorm31.Column)("text", { nullable: true })
+  (0, import_typeorm32.Column)("text", { nullable: true })
 ], Collection.prototype, "description", 2);
 __decorateClass([
-  (0, import_typeorm31.Column)("varchar", { nullable: true })
+  (0, import_typeorm32.Column)("varchar", { nullable: true })
 ], Collection.prototype, "image", 2);
 __decorateClass([
-  (0, import_typeorm31.Column)("jsonb", { nullable: true })
+  (0, import_typeorm32.Column)("jsonb", { nullable: true })
 ], Collection.prototype, "metadata", 2);
 __decorateClass([
-  (0, import_typeorm31.Column)("boolean", { default: true })
+  (0, import_typeorm32.Column)("jsonb", { nullable: true })
+], Collection.prototype, "variants", 2);
+__decorateClass([
+  (0, import_typeorm32.Column)("boolean", { default: true })
 ], Collection.prototype, "active", 2);
 __decorateClass([
-  (0, import_typeorm31.Column)("int", { default: 0 })
+  (0, import_typeorm32.Column)("int", { default: 0 })
 ], Collection.prototype, "sortOrder", 2);
 __decorateClass([
-  (0, import_typeorm31.Column)({ type: "timestamp", default: () => "CURRENT_TIMESTAMP" })
+  (0, import_typeorm32.Column)({ type: "timestamp", default: () => "CURRENT_TIMESTAMP" })
 ], Collection.prototype, "createdAt", 2);
 __decorateClass([
-  (0, import_typeorm31.Column)({ type: "timestamp", default: () => "CURRENT_TIMESTAMP" })
+  (0, import_typeorm32.Column)({ type: "timestamp", default: () => "CURRENT_TIMESTAMP" })
 ], Collection.prototype, "updatedAt", 2);
 __decorateClass([
-  (0, import_typeorm31.Column)({ type: "timestamp", nullable: true })
+  (0, import_typeorm32.Column)({ type: "timestamp", nullable: true })
 ], Collection.prototype, "deletedAt", 2);
 __decorateClass([
-  (0, import_typeorm31.Column)("boolean", { default: false })
+  (0, import_typeorm32.Column)("boolean", { default: false })
 ], Collection.prototype, "deleted", 2);
 __decorateClass([
-  (0, import_typeorm31.Column)("int", { nullable: true })
+  (0, import_typeorm32.Column)("int", { nullable: true })
 ], Collection.prototype, "createdBy", 2);
 __decorateClass([
-  (0, import_typeorm31.Column)("int", { nullable: true })
+  (0, import_typeorm32.Column)("int", { nullable: true })
 ], Collection.prototype, "updatedBy", 2);
 __decorateClass([
-  (0, import_typeorm31.Column)("int", { nullable: true })
+  (0, import_typeorm32.Column)("int", { nullable: true })
 ], Collection.prototype, "deletedBy", 2);
 __decorateClass([
-  (0, import_typeorm31.Column)("int", { nullable: true })
+  (0, import_typeorm32.Column)("int", { nullable: true })
 ], Collection.prototype, "seoId", 2);
 __decorateClass([
-  (0, import_typeorm31.ManyToOne)(() => Seo, { onDelete: "SET NULL" }),
-  (0, import_typeorm31.JoinColumn)({ name: "seoId" })
+  (0, import_typeorm32.ManyToOne)(() => Seo, { onDelete: "SET NULL" }),
+  (0, import_typeorm32.JoinColumn)({ name: "seoId" })
 ], Collection.prototype, "seo", 2);
 __decorateClass([
-  (0, import_typeorm31.ManyToOne)(() => ProductCategory, (c) => c.collections, { onDelete: "SET NULL" }),
-  (0, import_typeorm31.JoinColumn)({ name: "categoryId" })
+  (0, import_typeorm32.ManyToOne)(() => ProductCategory, (c) => c.collections, { onDelete: "SET NULL" }),
+  (0, import_typeorm32.JoinColumn)({ name: "categoryId" })
 ], Collection.prototype, "category", 2);
 __decorateClass([
-  (0, import_typeorm31.ManyToOne)(() => Brand, (b) => b.collections, { onDelete: "SET NULL" }),
-  (0, import_typeorm31.JoinColumn)({ name: "brandId" })
+  (0, import_typeorm32.ManyToOne)(() => Brand, (b) => b.collections, { onDelete: "SET NULL" }),
+  (0, import_typeorm32.JoinColumn)({ name: "brandId" })
 ], Collection.prototype, "brand", 2);
 __decorateClass([
-  (0, import_typeorm31.OneToMany)("Product", "collection")
+  (0, import_typeorm32.OneToMany)("Product", "collection")
 ], Collection.prototype, "products", 2);
 Collection = __decorateClass([
-  (0, import_typeorm31.Entity)("collections")
+  (0, import_typeorm32.Entity)("collections")
 ], Collection);
 
 // src/entities/product.entity.ts
-var import_typeorm32 = require("typeorm");
+var import_typeorm33 = require("typeorm");
 var Product = class {
   id;
   collectionId;
@@ -6895,105 +7475,105 @@ var Product = class {
   taxes;
 };
 __decorateClass([
-  (0, import_typeorm32.PrimaryGeneratedColumn)()
+  (0, import_typeorm33.PrimaryGeneratedColumn)()
 ], Product.prototype, "id", 2);
 __decorateClass([
-  (0, import_typeorm32.Column)("int", { nullable: true })
+  (0, import_typeorm33.Column)("int", { nullable: true })
 ], Product.prototype, "collectionId", 2);
 __decorateClass([
-  (0, import_typeorm32.Column)("int", { nullable: true })
+  (0, import_typeorm33.Column)("int", { nullable: true })
 ], Product.prototype, "brandId", 2);
 __decorateClass([
-  (0, import_typeorm32.Column)("int", { nullable: true })
+  (0, import_typeorm33.Column)("int", { nullable: true })
 ], Product.prototype, "categoryId", 2);
 __decorateClass([
-  (0, import_typeorm32.Column)("varchar", { nullable: true })
+  (0, import_typeorm33.Column)("varchar", { nullable: true })
 ], Product.prototype, "sku", 2);
 __decorateClass([
-  (0, import_typeorm32.Column)("varchar", { nullable: true })
+  (0, import_typeorm33.Column)("varchar", { nullable: true })
 ], Product.prototype, "hsn", 2);
 __decorateClass([
-  (0, import_typeorm32.Column)("varchar", { nullable: true })
+  (0, import_typeorm33.Column)("varchar", { nullable: true })
 ], Product.prototype, "uom", 2);
 __decorateClass([
-  (0, import_typeorm32.Column)("varchar", { default: "product" })
+  (0, import_typeorm33.Column)("varchar", { default: "product" })
 ], Product.prototype, "type", 2);
 __decorateClass([
-  (0, import_typeorm32.Column)("varchar", { unique: true, nullable: true })
+  (0, import_typeorm33.Column)("varchar", { unique: true, nullable: true })
 ], Product.prototype, "slug", 2);
 __decorateClass([
-  (0, import_typeorm32.Column)("varchar", { nullable: true })
+  (0, import_typeorm33.Column)("varchar", { nullable: true })
 ], Product.prototype, "name", 2);
 __decorateClass([
-  (0, import_typeorm32.Column)("decimal", { precision: 12, scale: 2 })
+  (0, import_typeorm33.Column)("decimal", { precision: 12, scale: 2 })
 ], Product.prototype, "price", 2);
 __decorateClass([
-  (0, import_typeorm32.Column)("decimal", { precision: 12, scale: 2, nullable: true })
+  (0, import_typeorm33.Column)("decimal", { precision: 12, scale: 2, nullable: true })
 ], Product.prototype, "compareAtPrice", 2);
 __decorateClass([
-  (0, import_typeorm32.Column)("int", { default: 0 })
+  (0, import_typeorm33.Column)("int", { default: 0 })
 ], Product.prototype, "quantity", 2);
 __decorateClass([
-  (0, import_typeorm32.Column)("varchar", { default: "draft" })
+  (0, import_typeorm33.Column)("varchar", { default: "draft" })
 ], Product.prototype, "status", 2);
 __decorateClass([
-  (0, import_typeorm32.Column)("boolean", { default: false })
+  (0, import_typeorm33.Column)("boolean", { default: false })
 ], Product.prototype, "featured", 2);
 __decorateClass([
-  (0, import_typeorm32.Column)("jsonb", { nullable: true })
+  (0, import_typeorm33.Column)("jsonb", { nullable: true })
 ], Product.prototype, "metadata", 2);
 __decorateClass([
-  (0, import_typeorm32.Column)({ type: "timestamp", default: () => "CURRENT_TIMESTAMP" })
+  (0, import_typeorm33.Column)({ type: "timestamp", default: () => "CURRENT_TIMESTAMP" })
 ], Product.prototype, "createdAt", 2);
 __decorateClass([
-  (0, import_typeorm32.Column)({ type: "timestamp", default: () => "CURRENT_TIMESTAMP" })
+  (0, import_typeorm33.Column)({ type: "timestamp", default: () => "CURRENT_TIMESTAMP" })
 ], Product.prototype, "updatedAt", 2);
 __decorateClass([
-  (0, import_typeorm32.Column)({ type: "timestamp", nullable: true })
+  (0, import_typeorm33.Column)({ type: "timestamp", nullable: true })
 ], Product.prototype, "deletedAt", 2);
 __decorateClass([
-  (0, import_typeorm32.Column)("boolean", { default: false })
+  (0, import_typeorm33.Column)("boolean", { default: false })
 ], Product.prototype, "deleted", 2);
 __decorateClass([
-  (0, import_typeorm32.Column)("int", { nullable: true })
+  (0, import_typeorm33.Column)("int", { nullable: true })
 ], Product.prototype, "createdBy", 2);
 __decorateClass([
-  (0, import_typeorm32.Column)("int", { nullable: true })
+  (0, import_typeorm33.Column)("int", { nullable: true })
 ], Product.prototype, "updatedBy", 2);
 __decorateClass([
-  (0, import_typeorm32.Column)("int", { nullable: true })
+  (0, import_typeorm33.Column)("int", { nullable: true })
 ], Product.prototype, "deletedBy", 2);
 __decorateClass([
-  (0, import_typeorm32.Column)("int", { nullable: true })
+  (0, import_typeorm33.Column)("int", { nullable: true })
 ], Product.prototype, "seoId", 2);
 __decorateClass([
-  (0, import_typeorm32.ManyToOne)(() => Seo, { onDelete: "SET NULL" }),
-  (0, import_typeorm32.JoinColumn)({ name: "seoId" })
+  (0, import_typeorm33.ManyToOne)(() => Seo, { onDelete: "SET NULL" }),
+  (0, import_typeorm33.JoinColumn)({ name: "seoId" })
 ], Product.prototype, "seo", 2);
 __decorateClass([
-  (0, import_typeorm32.ManyToOne)(() => Collection, (c) => c.products, { onDelete: "SET NULL" }),
-  (0, import_typeorm32.JoinColumn)({ name: "collectionId" })
+  (0, import_typeorm33.ManyToOne)(() => Collection, (c) => c.products, { onDelete: "SET NULL" }),
+  (0, import_typeorm33.JoinColumn)({ name: "collectionId" })
 ], Product.prototype, "collection", 2);
 __decorateClass([
-  (0, import_typeorm32.ManyToOne)(() => Brand, (b) => b.products, { onDelete: "SET NULL" }),
-  (0, import_typeorm32.JoinColumn)({ name: "brandId" })
+  (0, import_typeorm33.ManyToOne)(() => Brand, (b) => b.products, { onDelete: "SET NULL" }),
+  (0, import_typeorm33.JoinColumn)({ name: "brandId" })
 ], Product.prototype, "brand", 2);
 __decorateClass([
-  (0, import_typeorm32.ManyToOne)(() => ProductCategory, (c) => c.products, { onDelete: "SET NULL" }),
-  (0, import_typeorm32.JoinColumn)({ name: "categoryId" })
+  (0, import_typeorm33.ManyToOne)(() => ProductCategory, (c) => c.products, { onDelete: "SET NULL" }),
+  (0, import_typeorm33.JoinColumn)({ name: "categoryId" })
 ], Product.prototype, "category", 2);
 __decorateClass([
-  (0, import_typeorm32.OneToMany)("ProductAttribute", "product")
+  (0, import_typeorm33.OneToMany)("ProductAttribute", "product")
 ], Product.prototype, "attributes", 2);
 __decorateClass([
-  (0, import_typeorm32.OneToMany)("ProductTax", "product")
+  (0, import_typeorm33.OneToMany)("ProductTax", "product")
 ], Product.prototype, "taxes", 2);
 Product = __decorateClass([
-  (0, import_typeorm32.Entity)("products")
+  (0, import_typeorm33.Entity)("products")
 ], Product);
 
 // src/entities/attribute.entity.ts
-var import_typeorm33 = require("typeorm");
+var import_typeorm34 = require("typeorm");
 var Attribute = class {
   id;
   name;
@@ -7012,56 +7592,56 @@ var Attribute = class {
   deletedBy;
 };
 __decorateClass([
-  (0, import_typeorm33.PrimaryGeneratedColumn)()
+  (0, import_typeorm34.PrimaryGeneratedColumn)()
 ], Attribute.prototype, "id", 2);
 __decorateClass([
-  (0, import_typeorm33.Column)("varchar")
+  (0, import_typeorm34.Column)("varchar")
 ], Attribute.prototype, "name", 2);
 __decorateClass([
-  (0, import_typeorm33.Column)("varchar", { unique: true })
+  (0, import_typeorm34.Column)("varchar", { unique: true })
 ], Attribute.prototype, "slug", 2);
 __decorateClass([
-  (0, import_typeorm33.Column)("varchar", { default: "text" })
+  (0, import_typeorm34.Column)("varchar", { default: "text" })
 ], Attribute.prototype, "type", 2);
 __decorateClass([
-  (0, import_typeorm33.Column)("jsonb", { nullable: true })
+  (0, import_typeorm34.Column)("jsonb", { nullable: true })
 ], Attribute.prototype, "options", 2);
 __decorateClass([
-  (0, import_typeorm33.Column)("jsonb", { nullable: true })
+  (0, import_typeorm34.Column)("jsonb", { nullable: true })
 ], Attribute.prototype, "metadata", 2);
 __decorateClass([
-  (0, import_typeorm33.Column)("boolean", { default: true })
+  (0, import_typeorm34.Column)("boolean", { default: true })
 ], Attribute.prototype, "active", 2);
 __decorateClass([
-  (0, import_typeorm33.Column)("int", { default: 0 })
+  (0, import_typeorm34.Column)("int", { default: 0 })
 ], Attribute.prototype, "sortOrder", 2);
 __decorateClass([
-  (0, import_typeorm33.Column)({ type: "timestamp", default: () => "CURRENT_TIMESTAMP" })
+  (0, import_typeorm34.Column)({ type: "timestamp", default: () => "CURRENT_TIMESTAMP" })
 ], Attribute.prototype, "createdAt", 2);
 __decorateClass([
-  (0, import_typeorm33.Column)({ type: "timestamp", default: () => "CURRENT_TIMESTAMP" })
+  (0, import_typeorm34.Column)({ type: "timestamp", default: () => "CURRENT_TIMESTAMP" })
 ], Attribute.prototype, "updatedAt", 2);
 __decorateClass([
-  (0, import_typeorm33.Column)({ type: "timestamp", nullable: true })
+  (0, import_typeorm34.Column)({ type: "timestamp", nullable: true })
 ], Attribute.prototype, "deletedAt", 2);
 __decorateClass([
-  (0, import_typeorm33.Column)("boolean", { default: false })
+  (0, import_typeorm34.Column)("boolean", { default: false })
 ], Attribute.prototype, "deleted", 2);
 __decorateClass([
-  (0, import_typeorm33.Column)("int", { nullable: true })
+  (0, import_typeorm34.Column)("int", { nullable: true })
 ], Attribute.prototype, "createdBy", 2);
 __decorateClass([
-  (0, import_typeorm33.Column)("int", { nullable: true })
+  (0, import_typeorm34.Column)("int", { nullable: true })
 ], Attribute.prototype, "updatedBy", 2);
 __decorateClass([
-  (0, import_typeorm33.Column)("int", { nullable: true })
+  (0, import_typeorm34.Column)("int", { nullable: true })
 ], Attribute.prototype, "deletedBy", 2);
 Attribute = __decorateClass([
-  (0, import_typeorm33.Entity)("attributes")
+  (0, import_typeorm34.Entity)("attributes")
 ], Attribute);
 
 // src/entities/product-attribute.entity.ts
-var import_typeorm34 = require("typeorm");
+var import_typeorm35 = require("typeorm");
 var ProductAttribute = class {
   id;
   productId;
@@ -7074,40 +7654,40 @@ var ProductAttribute = class {
   attribute;
 };
 __decorateClass([
-  (0, import_typeorm34.PrimaryGeneratedColumn)()
+  (0, import_typeorm35.PrimaryGeneratedColumn)()
 ], ProductAttribute.prototype, "id", 2);
 __decorateClass([
-  (0, import_typeorm34.Column)("int")
+  (0, import_typeorm35.Column)("int")
 ], ProductAttribute.prototype, "productId", 2);
 __decorateClass([
-  (0, import_typeorm34.Column)("int")
+  (0, import_typeorm35.Column)("int")
 ], ProductAttribute.prototype, "attributeId", 2);
 __decorateClass([
-  (0, import_typeorm34.Column)("varchar")
+  (0, import_typeorm35.Column)("varchar")
 ], ProductAttribute.prototype, "value", 2);
 __decorateClass([
-  (0, import_typeorm34.Column)("jsonb", { nullable: true })
+  (0, import_typeorm35.Column)("jsonb", { nullable: true })
 ], ProductAttribute.prototype, "metadata", 2);
 __decorateClass([
-  (0, import_typeorm34.Column)({ type: "timestamp", default: () => "CURRENT_TIMESTAMP" })
+  (0, import_typeorm35.Column)({ type: "timestamp", default: () => "CURRENT_TIMESTAMP" })
 ], ProductAttribute.prototype, "createdAt", 2);
 __decorateClass([
-  (0, import_typeorm34.Column)({ type: "timestamp", default: () => "CURRENT_TIMESTAMP" })
+  (0, import_typeorm35.Column)({ type: "timestamp", default: () => "CURRENT_TIMESTAMP" })
 ], ProductAttribute.prototype, "updatedAt", 2);
 __decorateClass([
-  (0, import_typeorm34.ManyToOne)(() => Product, (p) => p.attributes, { onDelete: "CASCADE" }),
-  (0, import_typeorm34.JoinColumn)({ name: "productId" })
+  (0, import_typeorm35.ManyToOne)(() => Product, (p) => p.attributes, { onDelete: "CASCADE" }),
+  (0, import_typeorm35.JoinColumn)({ name: "productId" })
 ], ProductAttribute.prototype, "product", 2);
 __decorateClass([
-  (0, import_typeorm34.ManyToOne)(() => Attribute, { onDelete: "CASCADE" }),
-  (0, import_typeorm34.JoinColumn)({ name: "attributeId" })
+  (0, import_typeorm35.ManyToOne)(() => Attribute, { onDelete: "CASCADE" }),
+  (0, import_typeorm35.JoinColumn)({ name: "attributeId" })
 ], ProductAttribute.prototype, "attribute", 2);
 ProductAttribute = __decorateClass([
-  (0, import_typeorm34.Entity)("product_attributes")
+  (0, import_typeorm35.Entity)("product_attributes")
 ], ProductAttribute);
 
 // src/entities/tax.entity.ts
-var import_typeorm35 = require("typeorm");
+var import_typeorm36 = require("typeorm");
 var Tax = class {
   id;
   name;
@@ -7126,56 +7706,56 @@ var Tax = class {
   deletedBy;
 };
 __decorateClass([
-  (0, import_typeorm35.PrimaryGeneratedColumn)()
+  (0, import_typeorm36.PrimaryGeneratedColumn)()
 ], Tax.prototype, "id", 2);
 __decorateClass([
-  (0, import_typeorm35.Column)("varchar")
+  (0, import_typeorm36.Column)("varchar")
 ], Tax.prototype, "name", 2);
 __decorateClass([
-  (0, import_typeorm35.Column)("varchar", { unique: true })
+  (0, import_typeorm36.Column)("varchar", { unique: true })
 ], Tax.prototype, "slug", 2);
 __decorateClass([
-  (0, import_typeorm35.Column)("decimal", { precision: 5, scale: 2 })
+  (0, import_typeorm36.Column)("decimal", { precision: 5, scale: 2 })
 ], Tax.prototype, "rate", 2);
 __decorateClass([
-  (0, import_typeorm35.Column)("boolean", { default: false })
+  (0, import_typeorm36.Column)("boolean", { default: false })
 ], Tax.prototype, "isDefault", 2);
 __decorateClass([
-  (0, import_typeorm35.Column)("text", { nullable: true })
+  (0, import_typeorm36.Column)("text", { nullable: true })
 ], Tax.prototype, "description", 2);
 __decorateClass([
-  (0, import_typeorm35.Column)("boolean", { default: true })
+  (0, import_typeorm36.Column)("boolean", { default: true })
 ], Tax.prototype, "active", 2);
 __decorateClass([
-  (0, import_typeorm35.Column)("jsonb", { nullable: true })
+  (0, import_typeorm36.Column)("jsonb", { nullable: true })
 ], Tax.prototype, "metadata", 2);
 __decorateClass([
-  (0, import_typeorm35.Column)({ type: "timestamp", default: () => "CURRENT_TIMESTAMP" })
+  (0, import_typeorm36.Column)({ type: "timestamp", default: () => "CURRENT_TIMESTAMP" })
 ], Tax.prototype, "createdAt", 2);
 __decorateClass([
-  (0, import_typeorm35.Column)({ type: "timestamp", default: () => "CURRENT_TIMESTAMP" })
+  (0, import_typeorm36.Column)({ type: "timestamp", default: () => "CURRENT_TIMESTAMP" })
 ], Tax.prototype, "updatedAt", 2);
 __decorateClass([
-  (0, import_typeorm35.Column)({ type: "timestamp", nullable: true })
+  (0, import_typeorm36.Column)({ type: "timestamp", nullable: true })
 ], Tax.prototype, "deletedAt", 2);
 __decorateClass([
-  (0, import_typeorm35.Column)("boolean", { default: false })
+  (0, import_typeorm36.Column)("boolean", { default: false })
 ], Tax.prototype, "deleted", 2);
 __decorateClass([
-  (0, import_typeorm35.Column)("int", { nullable: true })
+  (0, import_typeorm36.Column)("int", { nullable: true })
 ], Tax.prototype, "createdBy", 2);
 __decorateClass([
-  (0, import_typeorm35.Column)("int", { nullable: true })
+  (0, import_typeorm36.Column)("int", { nullable: true })
 ], Tax.prototype, "updatedBy", 2);
 __decorateClass([
-  (0, import_typeorm35.Column)("int", { nullable: true })
+  (0, import_typeorm36.Column)("int", { nullable: true })
 ], Tax.prototype, "deletedBy", 2);
 Tax = __decorateClass([
-  (0, import_typeorm35.Entity)("taxes")
+  (0, import_typeorm36.Entity)("taxes")
 ], Tax);
 
 // src/entities/product-tax.entity.ts
-var import_typeorm36 = require("typeorm");
+var import_typeorm37 = require("typeorm");
 var ProductTax = class {
   id;
   productId;
@@ -7187,37 +7767,37 @@ var ProductTax = class {
   tax;
 };
 __decorateClass([
-  (0, import_typeorm36.PrimaryGeneratedColumn)()
+  (0, import_typeorm37.PrimaryGeneratedColumn)()
 ], ProductTax.prototype, "id", 2);
 __decorateClass([
-  (0, import_typeorm36.Column)("int")
+  (0, import_typeorm37.Column)("int")
 ], ProductTax.prototype, "productId", 2);
 __decorateClass([
-  (0, import_typeorm36.Column)("int")
+  (0, import_typeorm37.Column)("int")
 ], ProductTax.prototype, "taxId", 2);
 __decorateClass([
-  (0, import_typeorm36.Column)("decimal", { precision: 5, scale: 2, nullable: true })
+  (0, import_typeorm37.Column)("decimal", { precision: 5, scale: 2, nullable: true })
 ], ProductTax.prototype, "rate", 2);
 __decorateClass([
-  (0, import_typeorm36.Column)({ type: "timestamp", default: () => "CURRENT_TIMESTAMP" })
+  (0, import_typeorm37.Column)({ type: "timestamp", default: () => "CURRENT_TIMESTAMP" })
 ], ProductTax.prototype, "createdAt", 2);
 __decorateClass([
-  (0, import_typeorm36.Column)({ type: "timestamp", default: () => "CURRENT_TIMESTAMP" })
+  (0, import_typeorm37.Column)({ type: "timestamp", default: () => "CURRENT_TIMESTAMP" })
 ], ProductTax.prototype, "updatedAt", 2);
 __decorateClass([
-  (0, import_typeorm36.ManyToOne)(() => Product, (p) => p.taxes, { onDelete: "CASCADE" }),
-  (0, import_typeorm36.JoinColumn)({ name: "productId" })
+  (0, import_typeorm37.ManyToOne)(() => Product, (p) => p.taxes, { onDelete: "CASCADE" }),
+  (0, import_typeorm37.JoinColumn)({ name: "productId" })
 ], ProductTax.prototype, "product", 2);
 __decorateClass([
-  (0, import_typeorm36.ManyToOne)(() => Tax, { onDelete: "CASCADE" }),
-  (0, import_typeorm36.JoinColumn)({ name: "taxId" })
+  (0, import_typeorm37.ManyToOne)(() => Tax, { onDelete: "CASCADE" }),
+  (0, import_typeorm37.JoinColumn)({ name: "taxId" })
 ], ProductTax.prototype, "tax", 2);
 ProductTax = __decorateClass([
-  (0, import_typeorm36.Entity)("product_taxes")
+  (0, import_typeorm37.Entity)("product_taxes")
 ], ProductTax);
 
 // src/entities/order-item.entity.ts
-var import_typeorm37 = require("typeorm");
+var import_typeorm38 = require("typeorm");
 var OrderItem = class {
   id;
   orderId;
@@ -7238,67 +7818,67 @@ var OrderItem = class {
   product;
 };
 __decorateClass([
-  (0, import_typeorm37.PrimaryGeneratedColumn)()
+  (0, import_typeorm38.PrimaryGeneratedColumn)()
 ], OrderItem.prototype, "id", 2);
 __decorateClass([
-  (0, import_typeorm37.Column)("int")
+  (0, import_typeorm38.Column)("int")
 ], OrderItem.prototype, "orderId", 2);
 __decorateClass([
-  (0, import_typeorm37.Column)("int")
+  (0, import_typeorm38.Column)("int")
 ], OrderItem.prototype, "productId", 2);
 __decorateClass([
-  (0, import_typeorm37.Column)("int", { default: 1 })
+  (0, import_typeorm38.Column)("int", { default: 1 })
 ], OrderItem.prototype, "quantity", 2);
 __decorateClass([
-  (0, import_typeorm37.Column)("decimal", { precision: 12, scale: 2 })
+  (0, import_typeorm38.Column)("decimal", { precision: 12, scale: 2 })
 ], OrderItem.prototype, "unitPrice", 2);
 __decorateClass([
-  (0, import_typeorm37.Column)("decimal", { precision: 12, scale: 2, default: 0 })
+  (0, import_typeorm38.Column)("decimal", { precision: 12, scale: 2, default: 0 })
 ], OrderItem.prototype, "tax", 2);
 __decorateClass([
-  (0, import_typeorm37.Column)("decimal", { precision: 12, scale: 2 })
+  (0, import_typeorm38.Column)("decimal", { precision: 12, scale: 2 })
 ], OrderItem.prototype, "total", 2);
 __decorateClass([
-  (0, import_typeorm37.Column)("varchar", { nullable: true })
+  (0, import_typeorm38.Column)("varchar", { nullable: true })
 ], OrderItem.prototype, "hsn", 2);
 __decorateClass([
-  (0, import_typeorm37.Column)("varchar", { nullable: true })
+  (0, import_typeorm38.Column)("varchar", { nullable: true })
 ], OrderItem.prototype, "uom", 2);
 __decorateClass([
-  (0, import_typeorm37.Column)("varchar", { nullable: true })
+  (0, import_typeorm38.Column)("varchar", { nullable: true })
 ], OrderItem.prototype, "productType", 2);
 __decorateClass([
-  (0, import_typeorm37.Column)("decimal", { precision: 5, scale: 2, nullable: true })
+  (0, import_typeorm38.Column)("decimal", { precision: 5, scale: 2, nullable: true })
 ], OrderItem.prototype, "taxRate", 2);
 __decorateClass([
-  (0, import_typeorm37.Column)("varchar", { nullable: true })
+  (0, import_typeorm38.Column)("varchar", { nullable: true })
 ], OrderItem.prototype, "taxCode", 2);
 __decorateClass([
-  (0, import_typeorm37.Column)("jsonb", { nullable: true })
+  (0, import_typeorm38.Column)("jsonb", { nullable: true })
 ], OrderItem.prototype, "metadata", 2);
 __decorateClass([
-  (0, import_typeorm37.Column)({ type: "timestamp", default: () => "CURRENT_TIMESTAMP" })
+  (0, import_typeorm38.Column)({ type: "timestamp", default: () => "CURRENT_TIMESTAMP" })
 ], OrderItem.prototype, "createdAt", 2);
 __decorateClass([
-  (0, import_typeorm37.Column)({ type: "timestamp", default: () => "CURRENT_TIMESTAMP" })
+  (0, import_typeorm38.Column)({ type: "timestamp", default: () => "CURRENT_TIMESTAMP" })
 ], OrderItem.prototype, "updatedAt", 2);
 __decorateClass([
-  (0, import_typeorm37.ManyToOne)(() => Order, (o) => o.items, { onDelete: "CASCADE" }),
-  (0, import_typeorm37.JoinColumn)({ name: "orderId" })
+  (0, import_typeorm38.ManyToOne)(() => Order, (o) => o.items, { onDelete: "CASCADE" }),
+  (0, import_typeorm38.JoinColumn)({ name: "orderId" })
 ], OrderItem.prototype, "order", 2);
 __decorateClass([
-  (0, import_typeorm37.ManyToOne)(() => Product, { onDelete: "CASCADE" }),
-  (0, import_typeorm37.JoinColumn)({ name: "productId" })
+  (0, import_typeorm38.ManyToOne)(() => Product, { onDelete: "CASCADE" }),
+  (0, import_typeorm38.JoinColumn)({ name: "productId" })
 ], OrderItem.prototype, "product", 2);
 OrderItem = __decorateClass([
-  (0, import_typeorm37.Entity)("order_items")
+  (0, import_typeorm38.Entity)("order_items")
 ], OrderItem);
 
 // src/entities/knowledge-base-document.entity.ts
-var import_typeorm39 = require("typeorm");
+var import_typeorm40 = require("typeorm");
 
 // src/entities/knowledge-base-chunk.entity.ts
-var import_typeorm38 = require("typeorm");
+var import_typeorm39 = require("typeorm");
 var KnowledgeBaseChunk = class {
   id;
   documentId;
@@ -7308,26 +7888,26 @@ var KnowledgeBaseChunk = class {
   document;
 };
 __decorateClass([
-  (0, import_typeorm38.PrimaryGeneratedColumn)()
+  (0, import_typeorm39.PrimaryGeneratedColumn)()
 ], KnowledgeBaseChunk.prototype, "id", 2);
 __decorateClass([
-  (0, import_typeorm38.Column)("int")
+  (0, import_typeorm39.Column)("int")
 ], KnowledgeBaseChunk.prototype, "documentId", 2);
 __decorateClass([
-  (0, import_typeorm38.Column)("text")
+  (0, import_typeorm39.Column)("text")
 ], KnowledgeBaseChunk.prototype, "content", 2);
 __decorateClass([
-  (0, import_typeorm38.Column)("int", { default: 0 })
+  (0, import_typeorm39.Column)("int", { default: 0 })
 ], KnowledgeBaseChunk.prototype, "chunkIndex", 2);
 __decorateClass([
-  (0, import_typeorm38.Column)({ type: "timestamp", default: () => "CURRENT_TIMESTAMP" })
+  (0, import_typeorm39.Column)({ type: "timestamp", default: () => "CURRENT_TIMESTAMP" })
 ], KnowledgeBaseChunk.prototype, "createdAt", 2);
 __decorateClass([
-  (0, import_typeorm38.ManyToOne)(() => KnowledgeBaseDocument, (d) => d.chunks, { onDelete: "CASCADE" }),
-  (0, import_typeorm38.JoinColumn)({ name: "documentId" })
+  (0, import_typeorm39.ManyToOne)(() => KnowledgeBaseDocument, (d) => d.chunks, { onDelete: "CASCADE" }),
+  (0, import_typeorm39.JoinColumn)({ name: "documentId" })
 ], KnowledgeBaseChunk.prototype, "document", 2);
 KnowledgeBaseChunk = __decorateClass([
-  (0, import_typeorm38.Entity)("knowledge_base_chunks")
+  (0, import_typeorm39.Entity)("knowledge_base_chunks")
 ], KnowledgeBaseChunk);
 
 // src/entities/knowledge-base-document.entity.ts
@@ -7341,32 +7921,32 @@ var KnowledgeBaseDocument = class {
   chunks;
 };
 __decorateClass([
-  (0, import_typeorm39.PrimaryGeneratedColumn)()
+  (0, import_typeorm40.PrimaryGeneratedColumn)()
 ], KnowledgeBaseDocument.prototype, "id", 2);
 __decorateClass([
-  (0, import_typeorm39.Column)("varchar")
+  (0, import_typeorm40.Column)("varchar")
 ], KnowledgeBaseDocument.prototype, "name", 2);
 __decorateClass([
-  (0, import_typeorm39.Column)("varchar", { nullable: true })
+  (0, import_typeorm40.Column)("varchar", { nullable: true })
 ], KnowledgeBaseDocument.prototype, "sourceUrl", 2);
 __decorateClass([
-  (0, import_typeorm39.Column)("text")
+  (0, import_typeorm40.Column)("text")
 ], KnowledgeBaseDocument.prototype, "content", 2);
 __decorateClass([
-  (0, import_typeorm39.Column)({ type: "timestamp", default: () => "CURRENT_TIMESTAMP" })
+  (0, import_typeorm40.Column)({ type: "timestamp", default: () => "CURRENT_TIMESTAMP" })
 ], KnowledgeBaseDocument.prototype, "createdAt", 2);
 __decorateClass([
-  (0, import_typeorm39.Column)({ type: "timestamp", default: () => "CURRENT_TIMESTAMP" })
+  (0, import_typeorm40.Column)({ type: "timestamp", default: () => "CURRENT_TIMESTAMP" })
 ], KnowledgeBaseDocument.prototype, "updatedAt", 2);
 __decorateClass([
-  (0, import_typeorm39.OneToMany)(() => KnowledgeBaseChunk, (c) => c.document)
+  (0, import_typeorm40.OneToMany)(() => KnowledgeBaseChunk, (c) => c.document)
 ], KnowledgeBaseDocument.prototype, "chunks", 2);
 KnowledgeBaseDocument = __decorateClass([
-  (0, import_typeorm39.Entity)("knowledge_base_documents")
+  (0, import_typeorm40.Entity)("knowledge_base_documents")
 ], KnowledgeBaseDocument);
 
 // src/entities/cart.entity.ts
-var import_typeorm40 = require("typeorm");
+var import_typeorm41 = require("typeorm");
 var Cart = class {
   id;
   guestToken;
@@ -7379,39 +7959,39 @@ var Cart = class {
   items;
 };
 __decorateClass([
-  (0, import_typeorm40.PrimaryGeneratedColumn)()
+  (0, import_typeorm41.PrimaryGeneratedColumn)()
 ], Cart.prototype, "id", 2);
 __decorateClass([
-  (0, import_typeorm40.Column)("varchar", { nullable: true })
+  (0, import_typeorm41.Column)("varchar", { nullable: true })
 ], Cart.prototype, "guestToken", 2);
 __decorateClass([
-  (0, import_typeorm40.Column)("int", { nullable: true })
+  (0, import_typeorm41.Column)("int", { nullable: true })
 ], Cart.prototype, "contactId", 2);
 __decorateClass([
-  (0, import_typeorm40.Column)("varchar", { default: "INR" })
+  (0, import_typeorm41.Column)("varchar", { default: "INR" })
 ], Cart.prototype, "currency", 2);
 __decorateClass([
-  (0, import_typeorm40.Column)({ type: "timestamp", nullable: true })
+  (0, import_typeorm41.Column)({ type: "timestamp", nullable: true })
 ], Cart.prototype, "expiresAt", 2);
 __decorateClass([
-  (0, import_typeorm40.Column)({ type: "timestamp", default: () => "CURRENT_TIMESTAMP" })
+  (0, import_typeorm41.Column)({ type: "timestamp", default: () => "CURRENT_TIMESTAMP" })
 ], Cart.prototype, "createdAt", 2);
 __decorateClass([
-  (0, import_typeorm40.Column)({ type: "timestamp", default: () => "CURRENT_TIMESTAMP" })
+  (0, import_typeorm41.Column)({ type: "timestamp", default: () => "CURRENT_TIMESTAMP" })
 ], Cart.prototype, "updatedAt", 2);
 __decorateClass([
-  (0, import_typeorm40.ManyToOne)(() => Contact, { onDelete: "CASCADE" }),
-  (0, import_typeorm40.JoinColumn)({ name: "contactId" })
+  (0, import_typeorm41.ManyToOne)(() => Contact, { onDelete: "CASCADE" }),
+  (0, import_typeorm41.JoinColumn)({ name: "contactId" })
 ], Cart.prototype, "contact", 2);
 __decorateClass([
-  (0, import_typeorm40.OneToMany)("CartItem", "cart")
+  (0, import_typeorm41.OneToMany)("CartItem", "cart")
 ], Cart.prototype, "items", 2);
 Cart = __decorateClass([
-  (0, import_typeorm40.Entity)("carts")
+  (0, import_typeorm41.Entity)("carts")
 ], Cart);
 
 // src/entities/cart-item.entity.ts
-var import_typeorm41 = require("typeorm");
+var import_typeorm42 = require("typeorm");
 var CartItem = class {
   id;
   cartId;
@@ -7424,40 +8004,40 @@ var CartItem = class {
   product;
 };
 __decorateClass([
-  (0, import_typeorm41.PrimaryGeneratedColumn)()
+  (0, import_typeorm42.PrimaryGeneratedColumn)()
 ], CartItem.prototype, "id", 2);
 __decorateClass([
-  (0, import_typeorm41.Column)("int")
+  (0, import_typeorm42.Column)("int")
 ], CartItem.prototype, "cartId", 2);
 __decorateClass([
-  (0, import_typeorm41.Column)("int")
+  (0, import_typeorm42.Column)("int")
 ], CartItem.prototype, "productId", 2);
 __decorateClass([
-  (0, import_typeorm41.Column)("int", { default: 1 })
+  (0, import_typeorm42.Column)("int", { default: 1 })
 ], CartItem.prototype, "quantity", 2);
 __decorateClass([
-  (0, import_typeorm41.Column)("jsonb", { nullable: true })
+  (0, import_typeorm42.Column)("jsonb", { nullable: true })
 ], CartItem.prototype, "metadata", 2);
 __decorateClass([
-  (0, import_typeorm41.Column)({ type: "timestamp", default: () => "CURRENT_TIMESTAMP" })
+  (0, import_typeorm42.Column)({ type: "timestamp", default: () => "CURRENT_TIMESTAMP" })
 ], CartItem.prototype, "createdAt", 2);
 __decorateClass([
-  (0, import_typeorm41.Column)({ type: "timestamp", default: () => "CURRENT_TIMESTAMP" })
+  (0, import_typeorm42.Column)({ type: "timestamp", default: () => "CURRENT_TIMESTAMP" })
 ], CartItem.prototype, "updatedAt", 2);
 __decorateClass([
-  (0, import_typeorm41.ManyToOne)(() => Cart, (c) => c.items, { onDelete: "CASCADE" }),
-  (0, import_typeorm41.JoinColumn)({ name: "cartId" })
+  (0, import_typeorm42.ManyToOne)(() => Cart, (c) => c.items, { onDelete: "CASCADE" }),
+  (0, import_typeorm42.JoinColumn)({ name: "cartId" })
 ], CartItem.prototype, "cart", 2);
 __decorateClass([
-  (0, import_typeorm41.ManyToOne)(() => Product, { onDelete: "CASCADE" }),
-  (0, import_typeorm41.JoinColumn)({ name: "productId" })
+  (0, import_typeorm42.ManyToOne)(() => Product, { onDelete: "CASCADE" }),
+  (0, import_typeorm42.JoinColumn)({ name: "productId" })
 ], CartItem.prototype, "product", 2);
 CartItem = __decorateClass([
-  (0, import_typeorm41.Entity)("cart_items")
+  (0, import_typeorm42.Entity)("cart_items")
 ], CartItem);
 
 // src/entities/wishlist.entity.ts
-var import_typeorm42 = require("typeorm");
+var import_typeorm43 = require("typeorm");
 var Wishlist = class {
   id;
   guestId;
@@ -7469,36 +8049,36 @@ var Wishlist = class {
   items;
 };
 __decorateClass([
-  (0, import_typeorm42.PrimaryGeneratedColumn)()
+  (0, import_typeorm43.PrimaryGeneratedColumn)()
 ], Wishlist.prototype, "id", 2);
 __decorateClass([
-  (0, import_typeorm42.Column)("varchar", { nullable: true })
+  (0, import_typeorm43.Column)("varchar", { nullable: true })
 ], Wishlist.prototype, "guestId", 2);
 __decorateClass([
-  (0, import_typeorm42.Column)("int", { nullable: true })
+  (0, import_typeorm43.Column)("int", { nullable: true })
 ], Wishlist.prototype, "contactId", 2);
 __decorateClass([
-  (0, import_typeorm42.Column)("varchar", { default: "default" })
+  (0, import_typeorm43.Column)("varchar", { default: "default" })
 ], Wishlist.prototype, "name", 2);
 __decorateClass([
-  (0, import_typeorm42.Column)({ type: "timestamp", default: () => "CURRENT_TIMESTAMP" })
+  (0, import_typeorm43.Column)({ type: "timestamp", default: () => "CURRENT_TIMESTAMP" })
 ], Wishlist.prototype, "createdAt", 2);
 __decorateClass([
-  (0, import_typeorm42.Column)({ type: "timestamp", default: () => "CURRENT_TIMESTAMP" })
+  (0, import_typeorm43.Column)({ type: "timestamp", default: () => "CURRENT_TIMESTAMP" })
 ], Wishlist.prototype, "updatedAt", 2);
 __decorateClass([
-  (0, import_typeorm42.ManyToOne)(() => Contact, { onDelete: "CASCADE" }),
-  (0, import_typeorm42.JoinColumn)({ name: "contactId" })
+  (0, import_typeorm43.ManyToOne)(() => Contact, { onDelete: "CASCADE" }),
+  (0, import_typeorm43.JoinColumn)({ name: "contactId" })
 ], Wishlist.prototype, "contact", 2);
 __decorateClass([
-  (0, import_typeorm42.OneToMany)("WishlistItem", "wishlist")
+  (0, import_typeorm43.OneToMany)("WishlistItem", "wishlist")
 ], Wishlist.prototype, "items", 2);
 Wishlist = __decorateClass([
-  (0, import_typeorm42.Entity)("wishlists")
+  (0, import_typeorm43.Entity)("wishlists")
 ], Wishlist);
 
 // src/entities/wishlist-item.entity.ts
-var import_typeorm43 = require("typeorm");
+var import_typeorm44 = require("typeorm");
 var WishlistItem = class {
   id;
   wishlistId;
@@ -7510,35 +8090,71 @@ var WishlistItem = class {
   product;
 };
 __decorateClass([
-  (0, import_typeorm43.PrimaryGeneratedColumn)()
+  (0, import_typeorm44.PrimaryGeneratedColumn)()
 ], WishlistItem.prototype, "id", 2);
 __decorateClass([
-  (0, import_typeorm43.Column)("int")
+  (0, import_typeorm44.Column)("int")
 ], WishlistItem.prototype, "wishlistId", 2);
 __decorateClass([
-  (0, import_typeorm43.Column)("int")
+  (0, import_typeorm44.Column)("int")
 ], WishlistItem.prototype, "productId", 2);
 __decorateClass([
-  (0, import_typeorm43.Column)("jsonb", { nullable: true })
+  (0, import_typeorm44.Column)("jsonb", { nullable: true })
 ], WishlistItem.prototype, "metadata", 2);
 __decorateClass([
-  (0, import_typeorm43.Column)({ type: "timestamp", default: () => "CURRENT_TIMESTAMP" })
+  (0, import_typeorm44.Column)({ type: "timestamp", default: () => "CURRENT_TIMESTAMP" })
 ], WishlistItem.prototype, "createdAt", 2);
 __decorateClass([
-  (0, import_typeorm43.Column)({ type: "timestamp", default: () => "CURRENT_TIMESTAMP" })
+  (0, import_typeorm44.Column)({ type: "timestamp", default: () => "CURRENT_TIMESTAMP" })
 ], WishlistItem.prototype, "updatedAt", 2);
 __decorateClass([
-  (0, import_typeorm43.ManyToOne)(() => Wishlist, (w) => w.items, { onDelete: "CASCADE" }),
-  (0, import_typeorm43.JoinColumn)({ name: "wishlistId" })
+  (0, import_typeorm44.ManyToOne)(() => Wishlist, (w) => w.items, { onDelete: "CASCADE" }),
+  (0, import_typeorm44.JoinColumn)({ name: "wishlistId" })
 ], WishlistItem.prototype, "wishlist", 2);
 __decorateClass([
-  (0, import_typeorm43.ManyToOne)(() => Product, { onDelete: "CASCADE" }),
-  (0, import_typeorm43.JoinColumn)({ name: "productId" })
+  (0, import_typeorm44.ManyToOne)(() => Product, { onDelete: "CASCADE" }),
+  (0, import_typeorm44.JoinColumn)({ name: "productId" })
 ], WishlistItem.prototype, "product", 2);
 WishlistItem = __decorateClass([
-  (0, import_typeorm43.Entity)("wishlist_items")
+  (0, import_typeorm44.Entity)("wishlist_items")
 ], WishlistItem);
 
+// src/entities/llm-agent-knowledge-document.entity.ts
+var import_typeorm45 = require("typeorm");
+var LlmAgentKnowledgeDocument = class {
+  id;
+  agentId;
+  documentId;
+  createdAt;
+  agent;
+  document;
+};
+__decorateClass([
+  (0, import_typeorm45.PrimaryGeneratedColumn)()
+], LlmAgentKnowledgeDocument.prototype, "id", 2);
+__decorateClass([
+  (0, import_typeorm45.Column)("int")
+], LlmAgentKnowledgeDocument.prototype, "agentId", 2);
+__decorateClass([
+  (0, import_typeorm45.Column)("int")
+], LlmAgentKnowledgeDocument.prototype, "documentId", 2);
+__decorateClass([
+  (0, import_typeorm45.Column)({ type: "timestamp", default: () => "CURRENT_TIMESTAMP" })
+], LlmAgentKnowledgeDocument.prototype, "createdAt", 2);
+__decorateClass([
+  (0, import_typeorm45.ManyToOne)(() => LlmAgent, { onDelete: "CASCADE" }),
+  (0, import_typeorm45.JoinColumn)({ name: "agentId" })
+], LlmAgentKnowledgeDocument.prototype, "agent", 2);
+__decorateClass([
+  (0, import_typeorm45.ManyToOne)(() => KnowledgeBaseDocument, { onDelete: "CASCADE" }),
+  (0, import_typeorm45.JoinColumn)({ name: "documentId" })
+], LlmAgentKnowledgeDocument.prototype, "document", 2);
+LlmAgentKnowledgeDocument = __decorateClass([
+  (0, import_typeorm45.Entity)("llm_agent_knowledge_documents"),
+  (0, import_typeorm45.Unique)("UQ_llm_agent_knowledge_agent_document", ["agentId", "documentId"]),
+  (0, import_typeorm45.Index)("IDX_llm_agent_knowledge_agent", ["agentId"])
+], LlmAgentKnowledgeDocument);
+
 // src/entities/index.ts
 var CMS_ENTITY_MAP = {
   users: User,
@@ -7578,7 +8194,9 @@ var CMS_ENTITY_MAP = {
   carts: Cart,
   cart_items: CartItem,
   wishlists: Wishlist,
-  wishlist_items: WishlistItem
+  wishlist_items: WishlistItem,
+  llm_agents: LlmAgent,
+  llm_agent_knowledge_documents: LlmAgentKnowledgeDocument
 };
 
 // src/auth/permission-entities.ts
@@ -7916,7 +8534,7 @@ function getNextAuthOptions(config) {
 }
 
 // src/api/crud.ts
-var import_typeorm44 = require("typeorm");
+var import_typeorm46 = require("typeorm");
 var DATE_COLUMN_TYPES = /* @__PURE__ */ new Set([
   "date",
   "datetime",
@@ -7961,7 +8579,7 @@ function pickColumnUpdates(repo, body) {
 }
 function buildSearchWhereClause(repo, search) {
   const cols = new Set(repo.metadata.columns.map((c) => c.propertyName));
-  const term = (0, import_typeorm44.ILike)(`%${search}%`);
+  const term = (0, import_typeorm46.ILike)(`%${search}%`);
   const ors = [];
   for (const field of ["name", "title", "slug", "email", "filename"]) {
     if (cols.has(field)) ors.push({ [field]: term });
@@ -8126,10 +8744,10 @@ function createCrudHandler(dataSource, entityMap, options) {
         const inventory = searchParams.get("inventory")?.trim();
         const productWhere = { deleted: false };
         if (statusFilter) productWhere.status = statusFilter;
-        if (inventory === "in_stock") productWhere.quantity = (0, import_typeorm44.MoreThan)(0);
+        if (inventory === "in_stock") productWhere.quantity = (0, import_typeorm46.MoreThan)(0);
         if (inventory === "out_of_stock") productWhere.quantity = 0;
         if (search && typeof search === "string" && search.trim()) {
-          productWhere.name = (0, import_typeorm44.ILike)(`%${search.trim()}%`);
+          productWhere.name = (0, import_typeorm46.ILike)(`%${search.trim()}%`);
         }
         const [data2, total2] = await repo2.findAndCount({
           where: Object.keys(productWhere).length ? productWhere : void 0,
@@ -8197,7 +8815,7 @@ function createCrudHandler(dataSource, entityMap, options) {
         }
         if (typeFilter) {
           qb.andWhere(
-            new import_typeorm44.Brackets((sq) => {
+            new import_typeorm46.Brackets((sq) => {
               sq.where("m.kind = :folderKind", { folderKind: "folder" }).orWhere("m.mimeType LIKE :mtp", {
                 mtp: `${typeFilter}/%`
               });
@@ -8753,6 +9371,314 @@ function createUserAuthApiRouter(config) {
   };
 }
 
+// src/api/llm-agent-knowledge-handlers.ts
+var import_typeorm47 = require("typeorm");
+var INGEST_CHUNK_CHARS = 900;
+var MAX_CHUNKS_PER_UPLOAD = 400;
+var EMBED_CONCURRENCY = 5;
+var MAX_PDF_BYTES = 25 * 1024 * 1024;
+var TEXT_FILE_TYPES = /* @__PURE__ */ new Set(["text/plain", "text/markdown", "application/json"]);
+var KB_LOG = "[llm-agent-knowledge]";
+function llmEmbedDebug() {
+  const v = process.env.LLM_EMBED_DEBUG?.toLowerCase();
+  return v === "1" || v === "true" || v === "yes";
+}
+function isPdfUpload(mime, fileName) {
+  if (mime === "application/pdf") return true;
+  const n = fileName.toLowerCase();
+  return n.endsWith(".pdf");
+}
+async function extractTextFromPdf(buffer) {
+  const pdfParse = await import("pdf-parse");
+  const data = await pdfParse(buffer);
+  return (data?.text ?? "").trim();
+}
+async function writeEmbeddingsConcurrent(dataSource, embed, chunks, concurrency) {
+  let next = 0;
+  let written = 0;
+  let failed = 0;
+  let skippedEmpty = 0;
+  async function worker() {
+    for (; ; ) {
+      const i = next++;
+      if (i >= chunks.length) return;
+      const c = chunks[i];
+      try {
+        const emb = await embed(c.content);
+        if (emb?.length) {
+          const vectorStr = "[" + emb.join(",") + "]";
+          await dataSource.query(
+            `UPDATE knowledge_base_chunks SET embedding = $1::vector WHERE id = $2`,
+            [vectorStr, c.id]
+          );
+          written++;
+        } else {
+          skippedEmpty++;
+          if (llmEmbedDebug()) {
+            console.warn(`${KB_LOG} embed() returned empty vector`, { chunkId: c.id });
+          }
+        }
+      } catch (err) {
+        failed++;
+        console.error(`${KB_LOG} embedding DB update failed`, {
+          chunkId: c.id,
+          err: err instanceof Error ? err.message : String(err)
+        });
+      }
+    }
+  }
+  const n = Math.max(1, Math.min(concurrency, chunks.length));
+  await Promise.all(Array.from({ length: n }, () => worker()));
+  const summary = {
+    chunkCount: chunks.length,
+    written,
+    failed,
+    skippedEmpty
+  };
+  if (skippedEmpty > 0 && written === 0) {
+    summary.hint = "embed() returned empty vectors \u2014 see [LLM embed] logs (often HTTP 404 on /v1/embeddings, or wrong response shape).";
+  }
+  console.error(`${KB_LOG} embedding pass finished`, summary);
+  return { written, failed };
+}
+function splitIntoChunks(text, maxLen) {
+  const t = text.trim();
+  if (!t) return [];
+  const chunks = [];
+  for (let i = 0; i < t.length; i += maxLen) {
+    chunks.push(t.slice(i, i + maxLen));
+  }
+  return chunks;
+}
+async function findAgentBySlug(dataSource, llmAgents, slug) {
+  const repo = dataSource.getRepository(llmAgents);
+  return repo.findOne({
+    where: { slug, deleted: false }
+  });
+}
+function createLlmAgentKnowledgeHandlers(config) {
+  const { dataSource, entityMap, getCms, json, requireAuth, requireEntityPermission } = config;
+  const kbDoc = entityMap.knowledge_base_documents;
+  const kbChunk = entityMap.knowledge_base_chunks;
+  const llmAgents = entityMap.llm_agents;
+  const junction = entityMap.llm_agent_knowledge_documents;
+  if (!kbDoc || !kbChunk || !llmAgents || !junction) {
+    return null;
+  }
+  async function gate(req, action) {
+    const a = await requireAuth(req);
+    if (a) return a;
+    if (requireEntityPermission) {
+      const pe = await requireEntityPermission(req, "llm_agents", action);
+      if (pe) return pe;
+    }
+    return null;
+  }
+  return {
+    async list(req, slug) {
+      const denied = await gate(req, "read");
+      if (denied) return denied;
+      try {
+        const agent = await findAgentBySlug(dataSource, llmAgents, slug);
+        if (!agent) return json({ error: "Agent not found" }, { status: 404 });
+        const linkRepo = dataSource.getRepository(junction);
+        const links = await linkRepo.find({ where: { agentId: agent.id } });
+        const docIds = [...new Set(links.map((l) => l.documentId))];
+        if (docIds.length === 0) return json({ documents: [] });
+        const docRepo = dataSource.getRepository(kbDoc);
+        const docs = await docRepo.find({ where: { id: (0, import_typeorm47.In)(docIds) } });
+        const byId = new Map(docs.map((d) => [d.id, d]));
+        const documents = docIds.map((id) => {
+          const d = byId.get(id);
+          return d ? { id: d.id, name: d.name } : null;
+        }).filter(Boolean);
+        return json({ documents });
+      } catch (err) {
+        const msg = err instanceof Error ? err.message : "Failed to list knowledge";
+        return json({ error: msg }, { status: 500 });
+      }
+    },
+    async post(req, slug) {
+      const denied = await gate(req, "update");
+      if (denied) return denied;
+      try {
+        const agent = await findAgentBySlug(dataSource, llmAgents, slug);
+        if (!agent) return json({ error: "Agent not found" }, { status: 404 });
+        let name = "";
+        let text = "";
+        let sourceUrl = null;
+        let existingDocumentId = null;
+        const ct = req.headers.get("content-type") || "";
+        if (ct.includes("application/json")) {
+          const body = await req.json();
+          existingDocumentId = typeof body?.documentId === "number" && Number.isFinite(body.documentId) ? body.documentId : null;
+          name = (body?.name ?? "").trim();
+          text = (body?.text ?? "").trim();
+          sourceUrl = typeof body?.sourceUrl === "string" && body.sourceUrl.trim() ? body.sourceUrl.trim() : null;
+        } else if (ct.includes("multipart/form-data")) {
+          const form = await req.formData();
+          name = form.get("name")?.trim() ?? "";
+          text = form.get("text")?.trim() ?? "";
+          const file = form.get("file");
+          if (file && typeof file !== "string" && "arrayBuffer" in file) {
+            const f = file;
+            const mime = (f.type || "").split(";")[0].trim().toLowerCase();
+            const buf = Buffer.from(await f.arrayBuffer());
+            if (TEXT_FILE_TYPES.has(mime)) {
+              const decoded = buf.toString("utf8");
+              if (!text) text = decoded;
+            } else if (isPdfUpload(mime, f.name || "")) {
+              if (buf.length > MAX_PDF_BYTES) {
+                return json(
+                  { error: `PDF too large (max ${Math.floor(MAX_PDF_BYTES / (1024 * 1024))}MB)` },
+                  { status: 413 }
+                );
+              }
+              try {
+                const extracted = await extractTextFromPdf(buf);
+                if (!text) text = extracted;
+              } catch {
+                return json(
+                  { error: "Could not read PDF text (file may be encrypted, corrupt, or image-only)" },
+                  { status: 422 }
+                );
+              }
+            } else {
+              return json(
+                {
+                  error: "Unsupported file type; use text/plain, text/markdown, application/json, or application/pdf"
+                },
+                { status: 415 }
+              );
+            }
+            if (!name && f.name) name = f.name.replace(/\.[^/.]+$/, "") || f.name;
+          }
+        } else {
+          return json({ error: "Use application/json or multipart/form-data" }, { status: 400 });
+        }
+        const linkRepo = dataSource.getRepository(junction);
+        if (existingDocumentId != null) {
+          const docRepo2 = dataSource.getRepository(kbDoc);
+          const existing = await docRepo2.findOne({ where: { id: existingDocumentId } });
+          if (!existing) return json({ error: "documentId not found" }, { status: 404 });
+          const dup2 = await linkRepo.findOne({
+            where: { agentId: agent.id, documentId: existingDocumentId }
+          });
+          if (!dup2) {
+            await linkRepo.save(linkRepo.create({ agentId: agent.id, documentId: existingDocumentId }));
+          }
+          return json({ documentId: existingDocumentId, linked: true, created: false });
+        }
+        if (!text) return json({ error: "text or file with text content is required" }, { status: 400 });
+        if (!name) name = "Untitled";
+        const parts = splitIntoChunks(text, INGEST_CHUNK_CHARS);
+        if (parts.length === 0) {
+          return json({ error: "text or file with text content is required" }, { status: 400 });
+        }
+        if (parts.length > MAX_CHUNKS_PER_UPLOAD) {
+          return json(
+            {
+              error: `Document is too large for one upload (${parts.length} chunks; max ${MAX_CHUNKS_PER_UPLOAD}). Split into smaller files.`
+            },
+            { status: 413 }
+          );
+        }
+        const docRepo = dataSource.getRepository(kbDoc);
+        const chunkRepo = dataSource.getRepository(kbChunk);
+        const now = /* @__PURE__ */ new Date();
+        const doc = await docRepo.save(
+          docRepo.create({ name, content: text, sourceUrl, createdAt: now, updatedAt: now })
+        );
+        const docId = doc.id;
+        const chunkRows = parts.map(
+          (content, i) => chunkRepo.create({ documentId: docId, content, chunkIndex: i, createdAt: now })
+        );
+        const savedList = await chunkRepo.save(chunkRows);
+        const savedChunks = savedList.map(
+          (row, i) => ({
+            id: row.id,
+            content: parts[i]
+          })
+        );
+        const dup = await linkRepo.findOne({ where: { agentId: agent.id, documentId: docId } });
+        if (!dup) {
+          await linkRepo.save(linkRepo.create({ agentId: agent.id, documentId: docId }));
+        }
+        let embeddingsWritten = 0;
+        let embeddingsFailed = 0;
+        try {
+          const cms = await getCms();
+          const llm = cms.getPlugin("llm");
+          if (llm?.embed && savedChunks.length > 0) {
+            console.info(`${KB_LOG} starting embedding pass`, { slug, chunkCount: savedChunks.length });
+            const embedBound = (text2) => llm.embed(text2);
+            const { written, failed } = await writeEmbeddingsConcurrent(
+              dataSource,
+              embedBound,
+              savedChunks,
+              EMBED_CONCURRENCY
+            );
+            embeddingsWritten = written;
+            embeddingsFailed = failed;
+          } else {
+            console.error(`${KB_LOG} embeddings skipped`, {
+              slug,
+              hasLlmPlugin: !!llm,
+              hasEmbed: typeof llm?.embed === "function",
+              chunkCount: savedChunks.length,
+              hint: !llm || typeof llm.embed !== "function" ? "LLM plugin missing or no embed(); check LLM_GATEWAY_URL + LLM_API_KEY so llm plugin initializes." : void 0
+            });
+          }
+        } catch (embErr) {
+          const detail = embErr instanceof Error ? embErr.message : String(embErr);
+          console.error(`${KB_LOG} embedding step threw before/during batch`, { slug, detail, embErr });
+          return json(
+            {
+              documentId: docId,
+              chunkCount: savedChunks.length,
+              created: true,
+              linked: true,
+              embeddingsWritten: 0,
+              embeddingsFailed: savedChunks.length,
+              warning: "Document saved and linked; embedding step failed.",
+              detail
+            },
+            { status: 201 }
+          );
+        }
+        return json({
+          documentId: docId,
+          chunkCount: savedChunks.length,
+          created: true,
+          linked: true,
+          embeddingsWritten,
+          embeddingsFailed
+        });
+      } catch (err) {
+        const msg = err instanceof Error ? err.message : "Failed to ingest knowledge";
+        const name = err instanceof Error ? err.name : "";
+        return json({ error: msg, errorName: name || void 0 }, { status: 500 });
+      }
+    },
+    async unlink(req, slug, documentIdStr) {
+      const denied = await gate(req, "update");
+      if (denied) return denied;
+      const documentId = parseInt(documentIdStr, 10);
+      if (!Number.isFinite(documentId)) return json({ error: "Invalid document id" }, { status: 400 });
+      try {
+        const agent = await findAgentBySlug(dataSource, llmAgents, slug);
+        if (!agent) return json({ error: "Agent not found" }, { status: 404 });
+        const linkRepo = dataSource.getRepository(junction);
+        await linkRepo.delete({ agentId: agent.id, documentId });
+        return json({ ok: true });
+      } catch (err) {
+        const msg = err instanceof Error ? err.message : "Failed to unlink";
+        return json({ error: msg }, { status: 500 });
+      }
+    }
+  };
+}
+
 // src/api/message-template-admin-handlers.ts
 init_sms_defaults();
 function createSmsMessageTemplateHandlers(config) {
@@ -9002,6 +9928,26 @@ function createAdminRolesHandlers(config) {
 }
 
 // src/api/cms-api-handler.ts
+var KNOWLEDGE_SUFFIX = "knowledge";
+function matchLlmAgentKnowledgeRoute(path) {
+  const p = path[0] === "api" ? path.slice(1) : path;
+  if (p[0] !== "llm_agents" || p.length < 2) return null;
+  const seg1 = p[1];
+  if (!seg1) return null;
+  if (p[2] === KNOWLEDGE_SUFFIX) {
+    return {
+      slug: seg1,
+      documentId: p.length >= 4 ? p[3] : void 0
+    };
+  }
+  if (seg1.endsWith(KNOWLEDGE_SUFFIX) && seg1.length > KNOWLEDGE_SUFFIX.length) {
+    const slug = seg1.slice(0, -KNOWLEDGE_SUFFIX.length);
+    if (!slug) return null;
+    if (p.length === 2) return { slug, documentId: void 0 };
+    if (p.length === 3) return { slug, documentId: p[2] };
+  }
+  return null;
+}
 var DEFAULT_EXCLUDE = /* @__PURE__ */ new Set([
   "users",
   "password_reset_tokens",
@@ -9014,7 +9960,8 @@ var DEFAULT_EXCLUDE = /* @__PURE__ */ new Set([
   "cart_items",
   "wishlists",
   "wishlist_items",
-  "message_templates"
+  "message_templates",
+  "llm_agent_knowledge_documents"
 ]);
 function createCmsApiHandler(config) {
   const {
@@ -9038,6 +9985,7 @@ function createCmsApiHandler(config) {
     userProfile,
     settings: settingsConfig,
     chat: chatConfig,
+    llmAgentKnowledge: llmAgentKnowledgeConfig,
     requireEntityPermission: userRequireEntityPermission,
     getSessionUser
   } = config;
@@ -9145,6 +10093,17 @@ function createCmsApiHandler(config) {
     requireEntityPermission: requireEntityPermissionEffective
   });
   const chatHandlers = chatConfig ? createChatHandlers(chatConfig) : null;
+  const llmAgentKnowledgeMerged = llmAgentKnowledgeConfig ?? (chatConfig ? {
+    dataSource: chatConfig.dataSource,
+    entityMap: chatConfig.entityMap,
+    getCms: chatConfig.getCms,
+    json: chatConfig.json,
+    requireAuth: chatConfig.requireAuth
+  } : void 0);
+  const llmAgentKnowledgeHandlers = llmAgentKnowledgeMerged ? createLlmAgentKnowledgeHandlers({
+    ...llmAgentKnowledgeMerged,
+    requireEntityPermission: requireEntityPermissionEffective
+  }) : null;
   function resolveResource(segment) {
     const model = pathToModel(segment);
     return crudResources.includes(model) ? model : segment;
@@ -9256,7 +10215,32 @@ function createCmsApiHandler(config) {
         if (method === "GET") return smsMessageTemplateHandlers.GET(req);
         if (method === "PUT") return smsMessageTemplateHandlers.PUT(req);
       }
+      {
+        const kbMatch = matchLlmAgentKnowledgeRoute(path);
+        if (kbMatch) {
+          if (!llmAgentKnowledgeHandlers) {
+            return config.json(
+              {
+                error: "LLM agent knowledge is not available",
+                hint: "With chat enabled, routes usually work automatically. Otherwise pass llmAgentKnowledge. If this persists, ensure entityMap includes knowledge_base_documents, knowledge_base_chunks, llm_agent_knowledge_documents, and run migrations."
+              },
+              { status: 503 }
+            );
+          }
+          const { slug, documentId } = kbMatch;
+          if (method === "DELETE" && documentId != null && documentId !== "") {
+            return llmAgentKnowledgeHandlers.unlink(req, slug, documentId);
+          }
+          if (method === "GET" && (documentId == null || documentId === "")) {
+            return llmAgentKnowledgeHandlers.list(req, slug);
+          }
+          if (method === "POST" && (documentId == null || documentId === "")) {
+            return llmAgentKnowledgeHandlers.post(req, slug);
+          }
+        }
+      }
       if (path[0] === "chat" && chatHandlers) {
+        if (path.length === 2 && path[1] === "config" && method === "GET") return chatHandlers.publicConfig(req);
         if (path.length === 2 && path[1] === "identify" && method === "POST") return chatHandlers.identify(req);
         if (path.length === 4 && path[1] === "conversations" && path[3] === "messages" && method === "GET") return chatHandlers.getMessages(req, path[2]);
         if (path.length === 2 && path[1] === "messages" && method === "POST") return chatHandlers.postMessage(req);
@@ -9325,7 +10309,7 @@ function createCmsApiHandler(config) {
 }
 
 // src/api/storefront-handlers.ts
-var import_typeorm45 = require("typeorm");
+var import_typeorm48 = require("typeorm");
 
 // src/lib/is-valid-signup-email.ts
 var MAX_EMAIL = 254;
@@ -9556,7 +10540,7 @@ function createStorefrontApiHandler(config) {
     const u = await userRepo().findOne({ where: { id: userId } });
     if (!u) return null;
     const unclaimed = await contactRepo().findOne({
-      where: { email: u.email, userId: (0, import_typeorm45.IsNull)(), deleted: false }
+      where: { email: u.email, userId: (0, import_typeorm48.IsNull)(), deleted: false }
     });
     if (unclaimed) {
       await contactRepo().update(unclaimed.id, { userId });
@@ -10597,7 +11581,7 @@ function createStorefrontApiHandler(config) {
           const previewByOrder = {};
           if (orderIds.length) {
             const oItems = await orderItemRepo().find({
-              where: { orderId: (0, import_typeorm45.In)(orderIds) },
+              where: { orderId: (0, import_typeorm48.In)(orderIds) },
               relations: ["product"],
               order: { id: "ASC" }
             });
@@ -10762,6 +11746,7 @@ console.log("\u{1F525} USING LOCAL CMS CORE (index.ts loaded) \u{1F525}");
   FormSubmission,
   KnowledgeBaseChunk,
   KnowledgeBaseDocument,
+  LlmAgent,
   LlmService,
   Media,
   MessageTemplate,
@@ -10811,6 +11796,7 @@ console.log("\u{1F525} USING LOCAL CMS CORE (index.ts loaded) \u{1F525}");
   createForgotPasswordHandler,
   createFormBySlugHandler,
   createInviteAcceptHandler,
+  createLlmAgentKnowledgeHandlers,
   createMediaZipExtractHandler,
   createOtpChallenge,
   createSetPasswordHandler,
@@ -10844,13 +11830,17 @@ console.log("\u{1F525} USING LOCAL CMS CORE (index.ts loaded) \u{1F525}");
   isZipMedia,
   joinRecipientsForSend,
   linkUnclaimedContactToUser,
+  llmAgentToChatAgentOptions,
   llmPlugin,
   loadPublicThemeSettings,
   localStoragePlugin,
   mergeEmailLayoutCompanyDetails,
+  mergeGuardrailsIntoSystemPrompt,
   mergeSeoBySlug,
   normalizePhoneE164,
   parseEmailRecipientsFromConfig,
+  parseHfInferenceEmbeddingBody,
+  parseLlmAgentValidationRules,
   paymentPlugin,
   permissionRowsToRecord,
   queueEmail,
@@ -10882,6 +11872,8 @@ console.log("\u{1F525} USING LOCAL CMS CORE (index.ts loaded) \u{1F525}");
   smsPlugin,
   truncateText,
   validateSlug,
+  validateUserMessageAgainstAgentRules,
+  validateUserMessageAgainstStructuredRules,
   verifyAndConsumeOtpChallenge,
   verifyOtpCodeHash
 });