prompts.chat 0.0.1 → 0.0.2

package/dist/index.mjs

@@ -0,0 +1,3276 @@
+var __defProp = Object.defineProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+
+// src/variables/index.ts
+var variables_exports = {};
+__export(variables_exports, {
+  compile: () => compile,
+  convertAllVariables: () => convertAllVariables,
+  convertToSupportedFormat: () => convertToSupportedFormat,
+  detect: () => detect,
+  detectVariables: () => detectVariables,
+  extractVariables: () => extractVariables,
+  getPatternDescription: () => getPatternDescription,
+  normalize: () => normalize
+});
+var PATTERNS = [
+  // Double bracket: [[name]] or [[ name ]] or [[name: default]]
+  {
+    pattern: "double_bracket",
+    regex: /\[\[\s*([a-zA-Z_][a-zA-Z0-9_\s]*?)(?:\s*:\s*([^\]]*?))?\s*\]\]/g,
+    extractName: (m) => m[1].trim(),
+    extractDefault: (m) => m[2]?.trim()
+  },
+  // Double curly: {{name}} or {{ name }} or {{name: default}}
+  {
+    pattern: "double_curly",
+    regex: /\{\{\s*([a-zA-Z_][a-zA-Z0-9_\s]*?)(?:\s*:\s*([^}]*?))?\s*\}\}/g,
+    extractName: (m) => m[1].trim(),
+    extractDefault: (m) => m[2]?.trim()
+  },
+  // Our supported format (to exclude from warnings)
+  {
+    pattern: "dollar_curly",
+    regex: /\$\{([a-zA-Z_][a-zA-Z0-9_\s]*?)(?::([^}]*))?\}/g,
+    extractName: (m) => m[1].trim()
+  },
+  // Single bracket with uppercase or placeholder-like: [NAME] or [Your Name]
+  {
+    pattern: "single_bracket",
+    regex: /\[([A-Z][A-Z0-9_\s]*|[A-Za-z][a-zA-Z0-9_]*(?:\s+[A-Za-z][a-zA-Z0-9_]*)*)\]/g,
+    extractName: (m) => m[1].trim()
+  },
+  // Single curly with uppercase: {NAME} or {Your Name}
+  {
+    pattern: "single_curly",
+    regex: /\{([A-Z][A-Z0-9_\s]*|[A-Za-z][a-zA-Z0-9_]*(?:\s+[A-Za-z][a-zA-Z0-9_]*)*)\}/g,
+    extractName: (m) => m[1].trim()
+  },
+  // Angle brackets: <NAME> or <name>
+  {
+    pattern: "angle_bracket",
+    regex: /<([A-Z][A-Z0-9_\s]*|[a-zA-Z_][a-zA-Z0-9_\s]*)>/g,
+    extractName: (m) => m[1].trim()
+  },
+  // Percent signs: %NAME% or %name%
+  {
+    pattern: "percent",
+    regex: /%([a-zA-Z_][a-zA-Z0-9_]*)%/g,
+    extractName: (m) => m[1].trim()
+  }
+];
+var FALSE_POSITIVES = /* @__PURE__ */ new Set([
+  // HTML/XML common tags
+  "div",
+  "span",
+  "p",
+  "a",
+  "br",
+  "hr",
+  "img",
+  "input",
+  "button",
+  "h1",
+  "h2",
+  "h3",
+  "h4",
+  "h5",
+  "h6",
+  "ul",
+  "ol",
+  "li",
+  "table",
+  "tr",
+  "td",
+  "th",
+  "thead",
+  "tbody",
+  "form",
+  "label",
+  "select",
+  "option",
+  "textarea",
+  "script",
+  "style",
+  "link",
+  "meta",
+  "head",
+  "body",
+  "html",
+  "section",
+  "article",
+  "nav",
+  "header",
+  "footer",
+  "main",
+  "aside",
+  "figure",
+  "figcaption",
+  "strong",
+  "em",
+  "code",
+  "pre",
+  "blockquote",
+  "cite",
+  "abbr",
+  "address",
+  "b",
+  "i",
+  "u",
+  // Common programming constructs
+  "if",
+  "else",
+  "for",
+  "while",
+  "switch",
+  "case",
+  "break",
+  "return",
+  "function",
+  "class",
+  "const",
+  "let",
+  "var",
+  "import",
+  "export",
+  "default",
+  "try",
+  "catch",
+  "finally",
+  "throw",
+  "new",
+  "this",
+  "null",
+  "undefined",
+  "true",
+  "false",
+  "typeof",
+  "instanceof",
+  // JSON structure keywords (when in context)
+  "type",
+  "id",
+  "key",
+  "value",
+  "data",
+  "items",
+  "properties"
+]);
+function isInsideJsonString(text, index) {
+  let inString = false;
+  for (let i = 0; i < index; i++) {
+    if (text[i] === '"' && (i === 0 || text[i - 1] !== "\\")) {
+      inString = !inString;
+    }
+  }
+  return inString;
+}
+function detectVariables(text) {
+  const detected = [];
+  const seenRanges = [];
+  const supportedVars = /* @__PURE__ */ new Set();
+  const dollarCurlyPattern = /\$\{([a-zA-Z_][a-zA-Z0-9_\s]*?)(?::([^}]*))?\}/g;
+  let match;
+  while ((match = dollarCurlyPattern.exec(text)) !== null) {
+    seenRanges.push([match.index, match.index + match[0].length]);
+    supportedVars.add(match[0]);
+  }
+  for (const config of PATTERNS) {
+    if (config.pattern === "dollar_curly") continue;
+    const regex = new RegExp(config.regex.source, config.regex.flags);
+    while ((match = regex.exec(text)) !== null) {
+      const startIndex = match.index;
+      const endIndex = startIndex + match[0].length;
+      const overlaps = seenRanges.some(
+        ([start, end]) => startIndex >= start && startIndex < end || endIndex > start && endIndex <= end
+      );
+      if (overlaps) continue;
+      const name = config.extractName(match);
+      if (FALSE_POSITIVES.has(name.toLowerCase())) continue;
+      if (name.length < 2) continue;
+      if (config.pattern === "angle_bracket") {
+        if (!/^[A-Z]/.test(name) && !name.includes(" ")) continue;
+      }
+      if ((config.pattern === "single_curly" || config.pattern === "single_bracket") && isInsideJsonString(text, startIndex)) {
+        if (!/^[A-Z]/.test(name) && !name.includes(" ")) continue;
+      }
+      const defaultValue = config.extractDefault?.(match);
+      detected.push({
+        original: match[0],
+        name,
+        defaultValue,
+        pattern: config.pattern,
+        startIndex,
+        endIndex
+      });
+      seenRanges.push([startIndex, endIndex]);
+    }
+  }
+  return detected.sort((a, b) => a.startIndex - b.startIndex).filter(
+    (v, i, arr) => i === 0 || v.original !== arr[i - 1].original || v.startIndex !== arr[i - 1].startIndex
+  );
+}
+function convertToSupportedFormat(variable) {
+  const normalizedName = variable.name.toLowerCase().replace(/\s+/g, "_").replace(/[^a-z0-9_]/g, "");
+  if (variable.defaultValue) {
+    return `\${${normalizedName}:${variable.defaultValue}}`;
+  }
+  return `\${${normalizedName}}`;
+}
+function convertAllVariables(text) {
+  const detected = detectVariables(text);
+  if (detected.length === 0) return text;
+  const sorted = [...detected].sort((a, b) => b.startIndex - a.startIndex);
+  let result = text;
+  for (const variable of sorted) {
+    const converted = convertToSupportedFormat(variable);
+    result = result.slice(0, variable.startIndex) + converted + result.slice(variable.endIndex);
+  }
+  return result;
+}
+var normalize = convertAllVariables;
+var detect = detectVariables;
+function getPatternDescription(pattern) {
+  switch (pattern) {
+    case "double_bracket":
+      return "[[...]]";
+    case "double_curly":
+      return "{{...}}";
+    case "single_bracket":
+      return "[...]";
+    case "single_curly":
+      return "{...}";
+    case "angle_bracket":
+      return "<...>";
+    case "percent":
+      return "%...%";
+    case "dollar_curly":
+      return "${...}";
+  }
+}
+function extractVariables(text) {
+  const regex = /\$\{([a-zA-Z_][a-zA-Z0-9_\s]*?)(?::([^}]*))?\}/g;
+  const variables = [];
+  let match;
+  while ((match = regex.exec(text)) !== null) {
+    variables.push({
+      name: match[1].trim(),
+      defaultValue: match[2]?.trim()
+    });
+  }
+  return variables;
+}
+function compile(template, values, options = {}) {
+  const { useDefaults = true } = options;
+  return template.replace(
+    /\$\{([a-zA-Z_][a-zA-Z0-9_\s]*?)(?::([^}]*))?\}/g,
+    (match, name, defaultValue) => {
+      const trimmedName = name.trim();
+      if (trimmedName in values) {
+        return values[trimmedName];
+      }
+      if (useDefaults && defaultValue !== void 0) {
+        return defaultValue.trim();
+      }
+      return match;
+    }
+  );
+}
+
+// src/similarity/index.ts
+var similarity_exports = {};
+__export(similarity_exports, {
+  calculate: () => calculate,
+  calculateSimilarity: () => calculateSimilarity,
+  deduplicate: () => deduplicate,
+  findDuplicates: () => findDuplicates,
+  getContentFingerprint: () => getContentFingerprint,
+  isDuplicate: () => isDuplicate,
+  isSimilarContent: () => isSimilarContent,
+  normalizeContent: () => normalizeContent
+});
+function normalizeContent(content) {
+  return content.replace(/\$\{[^}]+\}/g, "").replace(/\[[^\]]+\]/g, "").replace(/<[^>]+>/g, "").toLowerCase().replace(/[^\w\s]/g, "").replace(/\s+/g, " ").trim();
+}
+function jaccardSimilarity(str1, str2) {
+  const set1 = new Set(str1.split(" ").filter(Boolean));
+  const set2 = new Set(str2.split(" ").filter(Boolean));
+  if (set1.size === 0 && set2.size === 0) return 1;
+  if (set1.size === 0 || set2.size === 0) return 0;
+  const intersection = new Set([...set1].filter((x) => set2.has(x)));
+  const union = /* @__PURE__ */ new Set([...set1, ...set2]);
+  return intersection.size / union.size;
+}
+function ngramSimilarity(str1, str2, n = 3) {
+  const getNgrams = (str) => {
+    const ngrams = /* @__PURE__ */ new Set();
+    const padded = " ".repeat(n - 1) + str + " ".repeat(n - 1);
+    for (let i = 0; i <= padded.length - n; i++) {
+      ngrams.add(padded.slice(i, i + n));
+    }
+    return ngrams;
+  };
+  const ngrams1 = getNgrams(str1);
+  const ngrams2 = getNgrams(str2);
+  if (ngrams1.size === 0 && ngrams2.size === 0) return 1;
+  if (ngrams1.size === 0 || ngrams2.size === 0) return 0;
+  const intersection = new Set([...ngrams1].filter((x) => ngrams2.has(x)));
+  const union = /* @__PURE__ */ new Set([...ngrams1, ...ngrams2]);
+  return intersection.size / union.size;
+}
+function calculateSimilarity(content1, content2) {
+  const normalized1 = normalizeContent(content1);
+  const normalized2 = normalizeContent(content2);
+  if (normalized1 === normalized2) return 1;
+  if (!normalized1 || !normalized2) return 0;
+  const jaccard = jaccardSimilarity(normalized1, normalized2);
+  const ngram = ngramSimilarity(normalized1, normalized2);
+  return jaccard * 0.6 + ngram * 0.4;
+}
+var calculate = calculateSimilarity;
+function isSimilarContent(content1, content2, threshold = 0.85) {
+  return calculateSimilarity(content1, content2) >= threshold;
+}
+var isDuplicate = isSimilarContent;
+function getContentFingerprint(content) {
+  const normalized = normalizeContent(content);
+  return normalized.slice(0, 500);
+}
+function findDuplicates(prompts, threshold = 0.85) {
+  const groups = [];
+  const used = /* @__PURE__ */ new Set();
+  for (let i = 0; i < prompts.length; i++) {
+    if (used.has(i)) continue;
+    const group = [prompts[i]];
+    used.add(i);
+    for (let j = i + 1; j < prompts.length; j++) {
+      if (used.has(j)) continue;
+      if (isSimilarContent(prompts[i].content, prompts[j].content, threshold)) {
+        group.push(prompts[j]);
+        used.add(j);
+      }
+    }
+    if (group.length > 1) {
+      groups.push(group);
+    }
+  }
+  return groups;
+}
+function deduplicate(prompts, threshold = 0.85) {
+  const result = [];
+  for (const prompt of prompts) {
+    const isDupe = result.some(
+      (existing) => isSimilarContent(existing.content, prompt.content, threshold)
+    );
+    if (!isDupe) {
+      result.push(prompt);
+    }
+  }
+  return result;
+}
+
+// src/quality/index.ts
+var quality_exports = {};
+__export(quality_exports, {
+  check: () => check,
+  getSuggestions: () => getSuggestions,
+  isValid: () => isValid,
+  validate: () => validate
+});
+var MIN_CHAR_COUNT = 20;
+var MIN_WORD_COUNT = 5;
+var OPTIMAL_MIN_WORDS = 20;
+var OPTIMAL_MAX_WORDS = 2e3;
+function isGibberish(text) {
+  if (/(.)\1{4,}/.test(text)) return true;
+  const keyboardPatterns = ["qwerty", "asdfgh", "zxcvbn", "qwertz", "azerty"];
+  const lower = text.toLowerCase();
+  if (keyboardPatterns.some((p) => lower.includes(p))) return true;
+  const vowels = (text.match(/[aeiouAEIOU]/g) || []).length;
+  const consonants = (text.match(/[bcdfghjklmnpqrstvwxyzBCDFGHJKLMNPQRSTVWXYZ]/g) || []).length;
+  if (consonants > 0 && vowels / consonants < 0.1) return true;
+  return false;
+}
+function detectPatterns(text) {
+  const lower = text.toLowerCase();
+  return {
+    hasRole: /\b(act as|you are|imagine you|pretend to be|role:|persona:)\b/i.test(text),
+    hasTask: /\b(your task|you (will|should|must)|please|help me|i need|i want you to)\b/i.test(text),
+    hasConstraints: /\b(do not|don't|never|always|must|should not|avoid|only|limit)\b/i.test(text) || /\b(rule|constraint|requirement|guideline)\b/i.test(lower),
+    hasExamples: /\b(example|for instance|such as|e\.g\.|like this)\b/i.test(lower) || /```[\s\S]*```/.test(text)
+  };
+}
+function countVariables(text) {
+  const patterns = [
+    /\$\{[^}]+\}/g,
+    // ${var}
+    /\{\{[^}]+\}\}/g,
+    // {{var}}
+    /\[\[[^\]]+\]\]/g,
+    // [[var]]
+    /\[[A-Z][A-Z0-9_\s]*\]/g
+    // [VAR]
+  ];
+  let count = 0;
+  for (const pattern of patterns) {
+    const matches = text.match(pattern);
+    if (matches) count += matches.length;
+  }
+  return count;
+}
+function calculateScore(stats, issues) {
+  let score = 1;
+  const errors = issues.filter((i) => i.type === "error").length;
+  const warnings = issues.filter((i) => i.type === "warning").length;
+  score -= errors * 0.2;
+  score -= warnings * 0.05;
+  if (stats.hasRole) score += 0.05;
+  if (stats.hasTask) score += 0.05;
+  if (stats.hasConstraints) score += 0.03;
+  if (stats.hasExamples) score += 0.05;
+  if (stats.wordCount < OPTIMAL_MIN_WORDS) {
+    score -= 0.1 * (1 - stats.wordCount / OPTIMAL_MIN_WORDS);
+  }
+  if (stats.wordCount > OPTIMAL_MAX_WORDS) {
+    score -= 0.05;
+  }
+  if (stats.variableCount > 0) {
+    score += 0.05;
+  }
+  return Math.max(0, Math.min(1, score));
+}
+function check(prompt) {
+  const issues = [];
+  const trimmed = prompt.trim();
+  const characterCount = trimmed.length;
+  const words = trimmed.split(/\s+/).filter((w) => w.length > 0);
+  const wordCount = words.length;
+  const sentenceCount = (trimmed.match(/[.!?]+/g) || []).length || 1;
+  const variableCount = countVariables(trimmed);
+  const patterns = detectPatterns(trimmed);
+  if (characterCount === 0) {
+    issues.push({
+      type: "error",
+      code: "EMPTY",
+      message: "Prompt is empty"
+    });
+  } else if (characterCount < MIN_CHAR_COUNT) {
+    issues.push({
+      type: "error",
+      code: "TOO_SHORT",
+      message: `Prompt is too short (${characterCount} chars, minimum ${MIN_CHAR_COUNT})`
+    });
+  }
+  if (wordCount > 0 && wordCount < MIN_WORD_COUNT) {
+    issues.push({
+      type: "warning",
+      code: "FEW_WORDS",
+      message: `Prompt has very few words (${wordCount} words, recommended ${OPTIMAL_MIN_WORDS}+)`
+    });
+  }
+  if (isGibberish(trimmed)) {
+    issues.push({
+      type: "error",
+      code: "GIBBERISH",
+      message: "Prompt appears to contain gibberish or random characters"
+    });
+  }
+  if (!patterns.hasTask && !patterns.hasRole) {
+    issues.push({
+      type: "suggestion",
+      code: "NO_CLEAR_INSTRUCTION",
+      message: "Consider adding a clear task or role definition"
+    });
+  }
+  const brackets = [
+    { open: "{", close: "}" },
+    { open: "[", close: "]" },
+    { open: "(", close: ")" }
+  ];
+  for (const { open, close } of brackets) {
+    const openCount = (trimmed.match(new RegExp(`\\${open}`, "g")) || []).length;
+    const closeCount = (trimmed.match(new RegExp(`\\${close}`, "g")) || []).length;
+    if (openCount !== closeCount) {
+      issues.push({
+        type: "warning",
+        code: "UNBALANCED_BRACKETS",
+        message: `Unbalanced ${open}${close} brackets (${openCount} open, ${closeCount} close)`
+      });
+    }
+  }
+  const lines = trimmed.split("\n");
+  const longLines = lines.filter((l) => l.length > 500);
+  if (longLines.length > 0) {
+    issues.push({
+      type: "suggestion",
+      code: "LONG_LINES",
+      message: "Some lines are very long. Consider breaking them up for readability."
+    });
+  }
+  const stats = {
+    characterCount,
+    wordCount,
+    sentenceCount,
+    variableCount,
+    ...patterns
+  };
+  const score = calculateScore(stats, issues);
+  const hasErrors = issues.some((i) => i.type === "error");
+  return {
+    valid: !hasErrors,
+    score,
+    issues,
+    stats
+  };
+}
+function validate(prompt) {
+  const result = check(prompt);
+  if (!result.valid) {
+    const errors = result.issues.filter((i) => i.type === "error").map((i) => i.message).join("; ");
+    throw new Error(`Invalid prompt: ${errors}`);
+  }
+}
+function isValid(prompt) {
+  return check(prompt).valid;
+}
+function getSuggestions(prompt) {
+  const result = check(prompt);
+  const suggestions = [];
+  suggestions.push(
+    ...result.issues.filter((i) => i.type === "suggestion" || i.type === "warning").map((i) => i.message)
+  );
+  if (!result.stats.hasRole) {
+    suggestions.push('Add a role definition (e.g., "Act as a...")');
+  }
+  if (!result.stats.hasConstraints && result.stats.wordCount > 50) {
+    suggestions.push("Consider adding constraints or rules for better control");
+  }
+  if (!result.stats.hasExamples && result.stats.wordCount > 100) {
+    suggestions.push("Adding examples can improve output quality");
+  }
+  if (result.stats.variableCount === 0 && result.stats.wordCount > 30) {
+    suggestions.push("Consider adding variables (${var}) to make the prompt reusable");
+  }
+  return suggestions;
+}
+
+// src/parser/index.ts
+var parser_exports = {};
+__export(parser_exports, {
+  getSystemPrompt: () => getSystemPrompt,
+  interpolate: () => interpolate,
+  parse: () => parse,
+  toJson: () => toJson,
+  toYaml: () => toYaml
+});
+function parseSimpleYaml(content) {
+  const result = {};
+  const lines = content.split("\n");
+  let currentKey = null;
+  let currentValue = null;
+  let inArray = false;
+  let inMultiline = false;
+  let multilineContent = "";
+  let arrayItems = [];
+  let indent = 0;
+  for (let i = 0; i < lines.length; i++) {
+    const line = lines[i];
+    const trimmed = line.trim();
+    if (!trimmed || trimmed.startsWith("#")) {
+      if (inMultiline) {
+        multilineContent += "\n";
+      }
+      continue;
+    }
+    if (inMultiline) {
+      const lineIndent = line.search(/\S/);
+      if (lineIndent > indent) {
+        multilineContent += (multilineContent ? "\n" : "") + line.slice(indent + 2);
+        continue;
+      } else {
+        if (inArray && currentKey) {
+          const lastItem = arrayItems[arrayItems.length - 1];
+          if (lastItem && typeof lastItem === "object") {
+            const keys = Object.keys(lastItem);
+            const lastKey = keys[keys.length - 1];
+            lastItem[lastKey] = multilineContent.trim();
+          }
+        } else if (currentKey) {
+          result[currentKey] = multilineContent.trim();
+        }
+        inMultiline = false;
+        multilineContent = "";
+      }
+    }
+    if (trimmed.startsWith("- ")) {
+      if (!inArray && currentKey) {
+        inArray = true;
+        arrayItems = [];
+      }
+      const itemContent = trimmed.slice(2);
+      const kvMatch = itemContent.match(/^(\w+):\s*(.*)$/);
+      if (kvMatch) {
+        const obj = {};
+        obj[kvMatch[1]] = kvMatch[2] === "|" ? "" : kvMatch[2] || "";
+        if (kvMatch[2] === "|") {
+          inMultiline = true;
+          indent = line.search(/\S/);
+          multilineContent = "";
+        }
+        arrayItems.push(obj);
+      } else {
+        arrayItems.push(itemContent);
+      }
+      continue;
+    }
+    if (inArray && line.startsWith("    ")) {
+      const propMatch = trimmed.match(/^(\w+):\s*(.*)$/);
+      if (propMatch && arrayItems.length > 0) {
+        const lastItem = arrayItems[arrayItems.length - 1];
+        if (typeof lastItem === "object" && lastItem !== null) {
+          lastItem[propMatch[1]] = propMatch[2] === "|" ? "" : propMatch[2] || "";
+          if (propMatch[2] === "|") {
+            inMultiline = true;
+            indent = line.search(/\S/);
+            multilineContent = "";
+          }
+        }
+      }
+      continue;
+    }
+    if (inArray && !line.startsWith(" ") && !line.startsWith("	")) {
+      if (currentKey) {
+        result[currentKey] = arrayItems;
+      }
+      inArray = false;
+      arrayItems = [];
+    }
+    const match = trimmed.match(/^(\w+):\s*(.*)$/);
+    if (match) {
+      currentKey = match[1];
+      const value = match[2];
+      if (value === "" || value === "|" || value === ">") {
+        if (value === "|" || value === ">") {
+          inMultiline = true;
+          indent = line.search(/\S/);
+          multilineContent = "";
+        }
+      } else if (value.startsWith('"') && value.endsWith('"')) {
+        result[currentKey] = value.slice(1, -1);
+      } else if (value.startsWith("'") && value.endsWith("'")) {
+        result[currentKey] = value.slice(1, -1);
+      } else if (value === "true") {
+        result[currentKey] = true;
+      } else if (value === "false") {
+        result[currentKey] = false;
+      } else if (!isNaN(Number(value))) {
+        result[currentKey] = Number(value);
+      } else {
+        result[currentKey] = value;
+      }
+    }
+  }
+  if (inArray && currentKey) {
+    result[currentKey] = arrayItems;
+  }
+  if (inMultiline && currentKey) {
+    result[currentKey] = multilineContent.trim();
+  }
+  return result;
+}
+function parseJson(content) {
+  return JSON.parse(content);
+}
+function parseMarkdown(content) {
+  const frontmatterMatch = content.match(/^---\n([\s\S]*?)\n---\n([\s\S]*)$/);
+  if (frontmatterMatch) {
+    const frontmatter = parseSimpleYaml(frontmatterMatch[1]);
+    const body = frontmatterMatch[2].trim();
+    return {
+      ...frontmatter,
+      messages: [{ role: "system", content: body }]
+    };
+  }
+  return {
+    messages: [{ role: "system", content: content.trim() }]
+  };
+}
+function normalize2(data) {
+  const messages = [];
+  if (Array.isArray(data.messages)) {
+    for (const msg of data.messages) {
+      if (typeof msg === "object" && msg !== null) {
+        const m = msg;
+        messages.push({
+          role: m.role || "user",
+          content: String(m.content || "")
+        });
+      }
+    }
+  }
+  if (messages.length === 0 && typeof data.content === "string") {
+    messages.push({ role: "system", content: data.content });
+  }
+  if (messages.length === 0 && typeof data.prompt === "string") {
+    messages.push({ role: "system", content: data.prompt });
+  }
+  return {
+    name: data.name,
+    description: data.description,
+    model: data.model,
+    modelParameters: data.modelParameters,
+    messages,
+    variables: data.variables,
+    metadata: data.metadata
+  };
+}
+function parse(content, format) {
+  const trimmed = content.trim();
+  if (!format) {
+    if (trimmed.startsWith("{")) {
+      format = "json";
+    } else if (trimmed.startsWith("---")) {
+      format = "markdown";
+    } else if (trimmed.includes(":") && (trimmed.includes("\n  ") || trimmed.includes("\n-"))) {
+      format = "yaml";
+    } else {
+      format = "text";
+    }
+  }
+  let data;
+  switch (format) {
+    case "json":
+      data = parseJson(trimmed);
+      break;
+    case "yaml":
+      data = parseSimpleYaml(trimmed);
+      break;
+    case "markdown":
+      data = parseMarkdown(trimmed);
+      break;
+    case "text":
+    default:
+      data = { messages: [{ role: "system", content: trimmed }] };
+      break;
+  }
+  return normalize2(data);
+}
+function toYaml(prompt) {
+  const lines = [];
+  if (prompt.name) {
+    lines.push(`name: ${prompt.name}`);
+  }
+  if (prompt.description) {
+    lines.push(`description: ${prompt.description}`);
+  }
+  if (prompt.model) {
+    lines.push(`model: ${prompt.model}`);
+  }
+  if (prompt.modelParameters) {
+    lines.push("modelParameters:");
+    for (const [key, value] of Object.entries(prompt.modelParameters)) {
+      if (value !== void 0) {
+        lines.push(`  ${key}: ${value}`);
+      }
+    }
+  }
+  if (prompt.messages.length > 0) {
+    lines.push("messages:");
+    for (const msg of prompt.messages) {
+      lines.push(`  - role: ${msg.role}`);
+      if (msg.content.includes("\n")) {
+        lines.push("    content: |");
+        for (const line of msg.content.split("\n")) {
+          lines.push(`      ${line}`);
+        }
+      } else {
+        lines.push(`    content: "${msg.content.replace(/"/g, '\\"')}"`);
+      }
+    }
+  }
+  return lines.join("\n");
+}
+function toJson(prompt, pretty = true) {
+  return JSON.stringify(prompt, null, pretty ? 2 : 0);
+}
+function getSystemPrompt(prompt) {
+  const systemMessage = prompt.messages.find((m) => m.role === "system");
+  return systemMessage?.content || "";
+}
+function interpolate(prompt, values) {
+  const interpolateString = (str) => {
+    return str.replace(/\{\{(\w+)\}\}/g, (match, key) => {
+      if (key in values) return values[key];
+      if (prompt.variables?.[key]?.default) return prompt.variables[key].default;
+      return match;
+    });
+  };
+  return {
+    ...prompt,
+    messages: prompt.messages.map((msg) => ({
+      ...msg,
+      content: interpolateString(msg.content)
+    }))
+  };
+}
+
+// src/builder/media.ts
+var ImagePromptBuilder = class {
+  constructor() {
+    this._negative = [];
+    this._custom = [];
+  }
+  // --- Subject Methods ---
+  subject(main) {
+    if (typeof main === "string") {
+      this._subject = { ...this._subject || {}, main };
+    } else {
+      this._subject = { ...this._subject || {}, ...main };
+    }
+    return this;
+  }
+  subjectDetails(details) {
+    this._subject = { ...this._subject || { main: "" }, details };
+    return this;
+  }
+  expression(expression) {
+    this._subject = { ...this._subject || { main: "" }, expression };
+    return this;
+  }
+  pose(pose) {
+    this._subject = { ...this._subject || { main: "" }, pose };
+    return this;
+  }
+  action(action) {
+    this._subject = { ...this._subject || { main: "" }, action };
+    return this;
+  }
+  clothing(clothing) {
+    this._subject = { ...this._subject || { main: "" }, clothing };
+    return this;
+  }
+  accessories(accessories) {
+    this._subject = { ...this._subject || { main: "" }, accessories };
+    return this;
+  }
+  subjectCount(count) {
+    this._subject = { ...this._subject || { main: "" }, count };
+    return this;
+  }
+  // --- Camera Methods ---
+  camera(settings) {
+    this._camera = { ...this._camera || {}, ...settings };
+    return this;
+  }
+  angle(angle) {
+    this._camera = { ...this._camera || {}, angle };
+    return this;
+  }
+  shot(shot) {
+    this._camera = { ...this._camera || {}, shot };
+    return this;
+  }
+  lens(lens) {
+    this._camera = { ...this._camera || {}, lens };
+    return this;
+  }
+  focus(focus) {
+    this._camera = { ...this._camera || {}, focus };
+    return this;
+  }
+  aperture(aperture) {
+    this._camera = { ...this._camera || {}, aperture };
+    return this;
+  }
+  filmStock(filmStock) {
+    this._camera = { ...this._camera || {}, filmStock };
+    return this;
+  }
+  filmFormat(format) {
+    this._camera = { ...this._camera || {}, filmFormat: format };
+    return this;
+  }
+  cameraBrand(brand) {
+    this._camera = { ...this._camera || {}, brand };
+    return this;
+  }
+  cameraModel(model) {
+    this._camera = { ...this._camera || {}, model };
+    return this;
+  }
+  sensor(sensor) {
+    this._camera = { ...this._camera || {}, sensor };
+    return this;
+  }
+  lensModel(model) {
+    this._camera = { ...this._camera || {}, lensModel: model };
+    return this;
+  }
+  lensBrand(brand) {
+    this._camera = { ...this._camera || {}, lensBrand: brand };
+    return this;
+  }
+  focalLength(length) {
+    this._camera = { ...this._camera || {}, focalLength: length };
+    return this;
+  }
+  bokeh(style) {
+    this._camera = { ...this._camera || {}, bokeh: style };
+    return this;
+  }
+  filter(filter) {
+    this._camera = { ...this._camera || {}, filter };
+    return this;
+  }
+  iso(iso) {
+    this._camera = { ...this._camera || {}, iso };
+    return this;
+  }
+  shutterSpeed(speed) {
+    this._camera = { ...this._camera || {}, shutterSpeed: speed };
+    return this;
+  }
+  whiteBalance(wb) {
+    this._camera = { ...this._camera || {}, whiteBalance: wb };
+    return this;
+  }
+  colorProfile(profile) {
+    this._camera = { ...this._camera || {}, colorProfile: profile };
+    return this;
+  }
+  // --- Lighting Methods ---
+  lighting(settings) {
+    this._lighting = { ...this._lighting || {}, ...settings };
+    return this;
+  }
+  lightingType(type) {
+    this._lighting = { ...this._lighting || {}, type };
+    return this;
+  }
+  timeOfDay(time) {
+    this._lighting = { ...this._lighting || {}, time };
+    return this;
+  }
+  weather(weather) {
+    this._lighting = { ...this._lighting || {}, weather };
+    return this;
+  }
+  lightDirection(direction) {
+    this._lighting = { ...this._lighting || {}, direction };
+    return this;
+  }
+  lightIntensity(intensity) {
+    this._lighting = { ...this._lighting || {}, intensity };
+    return this;
+  }
+  // --- Composition Methods ---
+  composition(settings) {
+    this._composition = { ...this._composition || {}, ...settings };
+    return this;
+  }
+  ruleOfThirds() {
+    this._composition = { ...this._composition || {}, ruleOfThirds: true };
+    return this;
+  }
+  goldenRatio() {
+    this._composition = { ...this._composition || {}, goldenRatio: true };
+    return this;
+  }
+  symmetry(type) {
+    this._composition = { ...this._composition || {}, symmetry: type };
+    return this;
+  }
+  foreground(fg) {
+    this._composition = { ...this._composition || {}, foreground: fg };
+    return this;
+  }
+  midground(mg) {
+    this._composition = { ...this._composition || {}, midground: mg };
+    return this;
+  }
+  background(bg) {
+    this._composition = { ...this._composition || {}, background: bg };
+    return this;
+  }
+  // --- Environment Methods ---
+  environment(setting) {
+    if (typeof setting === "string") {
+      this._environment = { ...this._environment || { setting: "" }, setting };
+    } else {
+      this._environment = { ...this._environment || { setting: "" }, ...setting };
+    }
+    return this;
+  }
+  location(location) {
+    this._environment = { ...this._environment || { setting: "" }, location };
+    return this;
+  }
+  props(props) {
+    this._environment = { ...this._environment || { setting: "" }, props };
+    return this;
+  }
+  atmosphere(atmosphere) {
+    this._environment = { ...this._environment || { setting: "" }, atmosphere };
+    return this;
+  }
+  season(season) {
+    this._environment = { ...this._environment || { setting: "" }, season };
+    return this;
+  }
+  // --- Style Methods ---
+  style(settings) {
+    this._style = { ...this._style || {}, ...settings };
+    return this;
+  }
+  medium(medium) {
+    this._style = { ...this._style || {}, medium };
+    return this;
+  }
+  artist(artist) {
+    this._style = { ...this._style || {}, artist };
+    return this;
+  }
+  influence(influences) {
+    this._style = { ...this._style || {}, influence: influences };
+    return this;
+  }
+  // --- Color Methods ---
+  color(settings) {
+    this._color = { ...this._color || {}, ...settings };
+    return this;
+  }
+  palette(palette) {
+    this._color = { ...this._color || {}, palette };
+    return this;
+  }
+  primaryColors(colors) {
+    this._color = { ...this._color || {}, primary: colors };
+    return this;
+  }
+  accentColors(colors) {
+    this._color = { ...this._color || {}, accent: colors };
+    return this;
+  }
+  colorGrade(grade) {
+    this._color = { ...this._color || {}, grade };
+    return this;
+  }
+  // --- Technical Methods ---
+  technical(settings) {
+    this._technical = { ...this._technical || {}, ...settings };
+    return this;
+  }
+  aspectRatio(ratio) {
+    this._technical = { ...this._technical || {}, aspectRatio: ratio };
+    return this;
+  }
+  resolution(resolution) {
+    this._technical = { ...this._technical || {}, resolution };
+    return this;
+  }
+  quality(quality) {
+    this._technical = { ...this._technical || {}, quality };
+    return this;
+  }
+  // --- Mood & Misc ---
+  mood(mood) {
+    this._mood = mood;
+    return this;
+  }
+  negative(items) {
+    this._negative = [...this._negative, ...items];
+    return this;
+  }
+  custom(text) {
+    this._custom.push(text);
+    return this;
+  }
+  // --- Build Methods ---
+  buildPromptText() {
+    const parts = [];
+    if (this._subject) {
+      let subjectText = this._subject.main;
+      if (this._subject.count && this._subject.count !== "single") {
+        subjectText = `${this._subject.count} ${subjectText}`;
+      }
+      if (this._subject.expression) subjectText += `, ${this._subject.expression} expression`;
+      if (this._subject.pose) subjectText += `, ${this._subject.pose}`;
+      if (this._subject.action) subjectText += `, ${this._subject.action}`;
+      if (this._subject.clothing) subjectText += `, wearing ${this._subject.clothing}`;
+      if (this._subject.accessories?.length) subjectText += `, with ${this._subject.accessories.join(", ")}`;
+      if (this._subject.details?.length) subjectText += `, ${this._subject.details.join(", ")}`;
+      parts.push(subjectText);
+    }
+    if (this._environment) {
+      let envText = this._environment.setting;
+      if (this._environment.location) envText += ` in ${this._environment.location}`;
+      if (this._environment.atmosphere) envText += `, ${this._environment.atmosphere} atmosphere`;
+      if (this._environment.season) envText += `, ${this._environment.season}`;
+      if (this._environment.props?.length) envText += `, with ${this._environment.props.join(", ")}`;
+      parts.push(envText);
+    }
+    if (this._composition) {
+      const compParts = [];
+      if (this._composition.foreground) compParts.push(`foreground: ${this._composition.foreground}`);
+      if (this._composition.midground) compParts.push(`midground: ${this._composition.midground}`);
+      if (this._composition.background) compParts.push(`background: ${this._composition.background}`);
+      if (this._composition.ruleOfThirds) compParts.push("rule of thirds composition");
+      if (this._composition.goldenRatio) compParts.push("golden ratio composition");
+      if (this._composition.symmetry && this._composition.symmetry !== "none") {
+        compParts.push(`${this._composition.symmetry} symmetry`);
+      }
+      if (compParts.length) parts.push(compParts.join(", "));
+    }
+    if (this._camera) {
+      const camParts = [];
+      if (this._camera.shot) camParts.push(`${this._camera.shot} shot`);
+      if (this._camera.angle) camParts.push(`${this._camera.angle}`);
+      if (this._camera.lens) camParts.push(`${this._camera.lens} lens`);
+      if (this._camera.focus) camParts.push(`${this._camera.focus} depth of field`);
+      if (this._camera.aperture) camParts.push(`f/${this._camera.aperture}`);
+      if (this._camera.filmStock) camParts.push(`shot on ${this._camera.filmStock}`);
+      if (this._camera.brand) camParts.push(`${this._camera.brand}`);
+      if (camParts.length) parts.push(camParts.join(", "));
+    }
+    if (this._lighting) {
+      const lightParts = [];
+      if (this._lighting.type) {
+        const types = Array.isArray(this._lighting.type) ? this._lighting.type : [this._lighting.type];
+        lightParts.push(`${types.join(" and ")} lighting`);
+      }
+      if (this._lighting.time) lightParts.push(this._lighting.time);
+      if (this._lighting.weather) lightParts.push(`${this._lighting.weather} weather`);
+      if (this._lighting.direction) lightParts.push(`light from ${this._lighting.direction}`);
+      if (this._lighting.intensity) lightParts.push(`${this._lighting.intensity} light`);
+      if (lightParts.length) parts.push(lightParts.join(", "));
+    }
+    if (this._style) {
+      const styleParts = [];
+      if (this._style.medium) {
+        const mediums = Array.isArray(this._style.medium) ? this._style.medium : [this._style.medium];
+        styleParts.push(mediums.join(", "));
+      }
+      if (this._style.artist) {
+        const artists = Array.isArray(this._style.artist) ? this._style.artist : [this._style.artist];
+        styleParts.push(`in the style of ${artists.join(" and ")}`);
+      }
+      if (this._style.era) styleParts.push(this._style.era);
+      if (this._style.influence?.length) styleParts.push(`influenced by ${this._style.influence.join(", ")}`);
+      if (this._style.quality?.length) styleParts.push(this._style.quality.join(", "));
+      if (styleParts.length) parts.push(styleParts.join(", "));
+    }
+    if (this._color) {
+      const colorParts = [];
+      if (this._color.palette) {
+        const palettes = Array.isArray(this._color.palette) ? this._color.palette : [this._color.palette];
+        colorParts.push(`${palettes.join(" and ")} color palette`);
+      }
+      if (this._color.primary?.length) colorParts.push(`primary colors: ${this._color.primary.join(", ")}`);
+      if (this._color.accent?.length) colorParts.push(`accent colors: ${this._color.accent.join(", ")}`);
+      if (this._color.grade) colorParts.push(`${this._color.grade} color grade`);
+      if (this._color.temperature) colorParts.push(`${this._color.temperature} tones`);
+      if (colorParts.length) parts.push(colorParts.join(", "));
+    }
+    if (this._mood) {
+      const moods = Array.isArray(this._mood) ? this._mood : [this._mood];
+      parts.push(`${moods.join(", ")} mood`);
+    }
+    if (this._technical) {
+      const techParts = [];
+      if (this._technical.quality) techParts.push(`${this._technical.quality} quality`);
+      if (this._technical.detail) techParts.push(`${this._technical.detail} detail`);
+      if (this._technical.resolution) techParts.push(this._technical.resolution);
+      if (techParts.length) parts.push(techParts.join(", "));
+    }
+    if (this._custom.length) {
+      parts.push(this._custom.join(", "));
+    }
+    let prompt = parts.join(", ");
+    if (this._negative.length) {
+      prompt += ` --no ${this._negative.join(", ")}`;
+    }
+    if (this._technical?.aspectRatio) {
+      prompt += ` --ar ${this._technical.aspectRatio}`;
+    }
+    return prompt;
+  }
+  build() {
+    return {
+      prompt: this.buildPromptText(),
+      structure: {
+        subject: this._subject,
+        camera: this._camera,
+        lighting: this._lighting,
+        composition: this._composition,
+        style: this._style,
+        color: this._color,
+        environment: this._environment,
+        technical: this._technical,
+        mood: this._mood,
+        negative: this._negative.length ? this._negative : void 0
+      }
+    };
+  }
+  toString() {
+    return this.build().prompt;
+  }
+  toJSON() {
+    return JSON.stringify(this.build().structure, null, 2);
+  }
+  toYAML() {
+    return objectToYaml(this.build().structure);
+  }
+  toMarkdown() {
+    const built = this.build();
+    const sections = ["# Image Prompt\n"];
+    sections.push("## Prompt\n```\n" + built.prompt + "\n```\n");
+    if (built.structure.subject) {
+      sections.push("## Subject\n" + objectToMarkdownList(built.structure.subject));
+    }
+    if (built.structure.environment) {
+      sections.push("## Environment\n" + objectToMarkdownList(built.structure.environment));
+    }
+    if (built.structure.camera) {
+      sections.push("## Camera\n" + objectToMarkdownList(built.structure.camera));
+    }
+    if (built.structure.lighting) {
+      sections.push("## Lighting\n" + objectToMarkdownList(built.structure.lighting));
+    }
+    if (built.structure.composition) {
+      sections.push("## Composition\n" + objectToMarkdownList(built.structure.composition));
+    }
+    if (built.structure.style) {
+      sections.push("## Style\n" + objectToMarkdownList(built.structure.style));
+    }
+    if (built.structure.color) {
+      sections.push("## Color\n" + objectToMarkdownList(built.structure.color));
+    }
+    if (built.structure.technical) {
+      sections.push("## Technical\n" + objectToMarkdownList(built.structure.technical));
+    }
+    return sections.join("\n");
+  }
+  format(fmt) {
+    switch (fmt) {
+      case "json":
+        return this.toJSON();
+      case "yaml":
+        return this.toYAML();
+      case "markdown":
+        return this.toMarkdown();
+      default:
+        return this.toString();
+    }
+  }
+};
+function objectToYaml(obj, indent = 0) {
+  const spaces = "  ".repeat(indent);
+  const lines = [];
+  for (const [key, value] of Object.entries(obj)) {
+    if (value === void 0 || value === null) continue;
+    if (Array.isArray(value)) {
+      if (value.length === 0) continue;
+      lines.push(`${spaces}${key}:`);
+      for (const item of value) {
+        if (typeof item === "object") {
+          lines.push(`${spaces}  -`);
+          lines.push(objectToYaml(item, indent + 2).replace(/^/gm, "  "));
+        } else {
+          lines.push(`${spaces}  - ${item}`);
+        }
+      }
+    } else if (typeof value === "object") {
+      lines.push(`${spaces}${key}:`);
+      lines.push(objectToYaml(value, indent + 1));
+    } else {
+      lines.push(`${spaces}${key}: ${value}`);
+    }
+  }
+  return lines.join("\n");
+}
+function objectToMarkdownList(obj, indent = 0) {
+  const spaces = "  ".repeat(indent);
+  const lines = [];
+  for (const [key, value] of Object.entries(obj)) {
+    if (value === void 0 || value === null) continue;
+    if (Array.isArray(value)) {
+      lines.push(`${spaces}- **${key}:** ${value.join(", ")}`);
+    } else if (typeof value === "object") {
+      lines.push(`${spaces}- **${key}:**`);
+      lines.push(objectToMarkdownList(value, indent + 1));
+    } else {
+      lines.push(`${spaces}- **${key}:** ${value}`);
+    }
+  }
+  return lines.join("\n");
+}
+function image() {
+  return new ImagePromptBuilder();
+}
+
+// src/builder/video.ts
+var VideoPromptBuilder = class {
+  constructor() {
+    this._actions = [];
+    this._shots = [];
+    this._transitions = [];
+    this._custom = [];
+  }
+  // --- Scene Methods ---
+  scene(description) {
+    if (typeof description === "string") {
+      this._scene = { ...this._scene || { description: "" }, description };
+    } else {
+      this._scene = { ...this._scene || { description: "" }, ...description };
+    }
+    return this;
+  }
+  setting(setting) {
+    this._scene = { ...this._scene || { description: "" }, setting };
+    return this;
+  }
+  // --- Subject Methods ---
+  subject(main) {
+    if (typeof main === "string") {
+      this._subject = { ...this._subject || { main: "" }, main };
+    } else {
+      this._subject = { ...this._subject || { main: "" }, ...main };
+    }
+    return this;
+  }
+  appearance(appearance) {
+    this._subject = { ...this._subject || { main: "" }, appearance };
+    return this;
+  }
+  clothing(clothing) {
+    this._subject = { ...this._subject || { main: "" }, clothing };
+    return this;
+  }
+  // --- Camera Methods ---
+  camera(settings) {
+    this._camera = { ...this._camera || {}, ...settings };
+    return this;
+  }
+  shot(shot) {
+    this._camera = { ...this._camera || {}, shot };
+    return this;
+  }
+  angle(angle) {
+    this._camera = { ...this._camera || {}, angle };
+    return this;
+  }
+  movement(movement) {
+    this._camera = { ...this._camera || {}, movement };
+    return this;
+  }
+  lens(lens) {
+    this._camera = { ...this._camera || {}, lens };
+    return this;
+  }
+  platform(platform) {
+    this._camera = { ...this._camera || {}, platform };
+    return this;
+  }
+  cameraSpeed(speed) {
+    this._camera = { ...this._camera || {}, movementSpeed: speed };
+    return this;
+  }
+  movementDirection(direction) {
+    this._camera = { ...this._camera || {}, movementDirection: direction };
+    return this;
+  }
+  rig(rig) {
+    this._camera = { ...this._camera || {}, rig };
+    return this;
+  }
+  gimbal(gimbal) {
+    this._camera = { ...this._camera || {}, gimbal };
+    return this;
+  }
+  cameraBrand(brand) {
+    this._camera = { ...this._camera || {}, brand };
+    return this;
+  }
+  cameraModel(model) {
+    this._camera = { ...this._camera || {}, model };
+    return this;
+  }
+  sensor(sensor) {
+    this._camera = { ...this._camera || {}, sensor };
+    return this;
+  }
+  lensModel(model) {
+    this._camera = { ...this._camera || {}, lensModel: model };
+    return this;
+  }
+  lensBrand(brand) {
+    this._camera = { ...this._camera || {}, lensBrand: brand };
+    return this;
+  }
+  focalLength(length) {
+    this._camera = { ...this._camera || {}, focalLength: length };
+    return this;
+  }
+  anamorphic(ratio) {
+    this._camera = { ...this._camera || {}, anamorphic: true, anamorphicRatio: ratio };
+    return this;
+  }
+  aperture(aperture) {
+    this._camera = { ...this._camera || {}, aperture };
+    return this;
+  }
+  frameRate(fps) {
+    this._camera = { ...this._camera || {}, frameRate: fps };
+    return this;
+  }
+  slowMotion(enabled = true) {
+    this._camera = { ...this._camera || {}, slowMotion: enabled };
+    return this;
+  }
+  shutterAngle(angle) {
+    this._camera = { ...this._camera || {}, shutterAngle: angle };
+    return this;
+  }
+  filter(filter) {
+    this._camera = { ...this._camera || {}, filter };
+    return this;
+  }
+  filmStock(stock) {
+    this._camera = { ...this._camera || {}, filmStock: stock };
+    return this;
+  }
+  filmGrain(grain) {
+    this._camera = { ...this._camera || {}, filmGrain: grain };
+    return this;
+  }
+  halation(enabled = true) {
+    this._camera = { ...this._camera || {}, halation: enabled };
+    return this;
+  }
+  // --- Lighting Methods ---
+  lighting(settings) {
+    this._lighting = { ...this._lighting || {}, ...settings };
+    return this;
+  }
+  lightingType(type) {
+    this._lighting = { ...this._lighting || {}, type };
+    return this;
+  }
+  timeOfDay(time) {
+    this._lighting = { ...this._lighting || {}, time };
+    this._scene = { ...this._scene || { description: "" }, timeOfDay: time };
+    return this;
+  }
+  weather(weather) {
+    this._lighting = { ...this._lighting || {}, weather };
+    this._scene = { ...this._scene || { description: "" }, weather };
+    return this;
+  }
+  // --- Action & Motion Methods ---
+  action(action, options = {}) {
+    this._actions.push({
+      beat: this._actions.length + 1,
+      action,
+      ...options
+    });
+    return this;
+  }
+  actions(actions) {
+    actions.forEach((a, i) => this._actions.push({ beat: i + 1, action: a }));
+    return this;
+  }
+  motion(settings) {
+    this._motion = { ...this._motion || {}, ...settings };
+    return this;
+  }
+  motionBeats(beats) {
+    this._motion = { ...this._motion || {}, beats };
+    return this;
+  }
+  // --- Style Methods ---
+  style(settings) {
+    this._style = { ...this._style || {}, ...settings };
+    return this;
+  }
+  format(format) {
+    this._style = { ...this._style || {}, format };
+    return this;
+  }
+  era(era) {
+    this._style = { ...this._style || {}, era };
+    return this;
+  }
+  styleFilmStock(stock) {
+    this._style = { ...this._style || {}, filmStock: stock };
+    return this;
+  }
+  look(look) {
+    this._style = { ...this._style || {}, look };
+    return this;
+  }
+  reference(references) {
+    this._style = { ...this._style || {}, reference: references };
+    return this;
+  }
+  // --- Color Methods ---
+  color(settings) {
+    this._color = { ...this._color || {}, ...settings };
+    return this;
+  }
+  palette(palette) {
+    this._color = { ...this._color || {}, palette };
+    return this;
+  }
+  colorAnchors(anchors) {
+    this._color = { ...this._color || {}, anchors };
+    return this;
+  }
+  colorGrade(grade) {
+    this._color = { ...this._color || {}, grade };
+    return this;
+  }
+  // --- Audio Methods ---
+  audio(settings) {
+    this._audio = { ...this._audio || {}, ...settings };
+    return this;
+  }
+  dialogue(dialogue) {
+    this._audio = { ...this._audio || {}, dialogue };
+    return this;
+  }
+  ambient(ambient) {
+    this._audio = { ...this._audio || {}, ambient };
+    return this;
+  }
+  diegetic(sounds) {
+    this._audio = { ...this._audio || {}, diegetic: sounds };
+    return this;
+  }
+  soundEffects(effects) {
+    this._audio = { ...this._audio || {}, soundEffects: effects };
+    return this;
+  }
+  music(music) {
+    this._audio = { ...this._audio || {}, music };
+    return this;
+  }
+  // --- Technical Methods ---
+  technical(settings) {
+    this._technical = { ...this._technical || {}, ...settings };
+    return this;
+  }
+  duration(seconds) {
+    this._technical = { ...this._technical || {}, duration: seconds };
+    return this;
+  }
+  resolution(res) {
+    this._technical = { ...this._technical || {}, resolution: res };
+    return this;
+  }
+  fps(fps) {
+    this._technical = { ...this._technical || {}, fps };
+    return this;
+  }
+  aspectRatio(ratio) {
+    this._technical = { ...this._technical || {}, aspectRatio: ratio };
+    return this;
+  }
+  // --- Shot List Methods ---
+  addShot(shot) {
+    this._shots.push(shot);
+    return this;
+  }
+  shotList(shots) {
+    this._shots = [...this._shots, ...shots];
+    return this;
+  }
+  // --- Mood & Pacing ---
+  mood(mood) {
+    this._mood = mood;
+    return this;
+  }
+  pacing(pacing) {
+    this._pacing = pacing;
+    return this;
+  }
+  transition(transition) {
+    this._transitions.push(transition);
+    return this;
+  }
+  transitions(transitions) {
+    this._transitions = [...this._transitions, ...transitions];
+    return this;
+  }
+  custom(text) {
+    this._custom.push(text);
+    return this;
+  }
+  // --- Build Methods ---
+  buildPromptText() {
+    const sections = [];
+    if (this._scene) {
+      let sceneText = this._scene.description;
+      if (this._scene.setting) sceneText = `${this._scene.setting}. ${sceneText}`;
+      if (this._scene.atmosphere) sceneText += `, ${this._scene.atmosphere} atmosphere`;
+      sections.push(sceneText);
+    }
+    if (this._subject) {
+      let subjectText = this._subject.main;
+      if (this._subject.appearance) subjectText += `, ${this._subject.appearance}`;
+      if (this._subject.clothing) subjectText += `, wearing ${this._subject.clothing}`;
+      sections.push(subjectText);
+    }
+    const cinematography = [];
+    if (this._camera) {
+      if (this._camera.shot) cinematography.push(`${this._camera.shot} shot`);
+      if (this._camera.angle) cinematography.push(this._camera.angle);
+      if (this._camera.movement) cinematography.push(`${this._camera.movement} camera`);
+      if (this._camera.lens) cinematography.push(`${this._camera.lens} lens`);
+      if (this._camera.platform) cinematography.push(this._camera.platform);
+      if (this._camera.focus) cinematography.push(`${this._camera.focus} focus`);
+    }
+    if (cinematography.length) {
+      sections.push(`Cinematography: ${cinematography.join(", ")}`);
+    }
+    if (this._lighting) {
+      const lightParts = [];
+      if (this._lighting.type) {
+        const types = Array.isArray(this._lighting.type) ? this._lighting.type : [this._lighting.type];
+        lightParts.push(`${types.join(" and ")} lighting`);
+      }
+      if (this._lighting.time) lightParts.push(this._lighting.time);
+      if (this._lighting.weather) lightParts.push(`${this._lighting.weather} weather`);
+      if (this._lighting.intensity) lightParts.push(`${this._lighting.intensity} light`);
+      if (this._lighting.sources?.length) lightParts.push(`light sources: ${this._lighting.sources.join(", ")}`);
+      if (lightParts.length) sections.push(`Lighting: ${lightParts.join(", ")}`);
+    }
+    if (this._actions.length) {
+      const actionText = this._actions.map((a) => `- ${a.action}`).join("\n");
+      sections.push(`Actions:
+${actionText}`);
+    }
+    if (this._motion?.beats?.length) {
+      sections.push(`Motion beats: ${this._motion.beats.join(", ")}`);
+    }
+    if (this._style) {
+      const styleParts = [];
+      if (this._style.format) styleParts.push(this._style.format);
+      if (this._style.era) styleParts.push(this._style.era);
+      if (this._style.filmStock) styleParts.push(`shot on ${this._style.filmStock}`);
+      if (this._style.look) {
+        const looks = Array.isArray(this._style.look) ? this._style.look : [this._style.look];
+        styleParts.push(looks.join(", "));
+      }
+      if (styleParts.length) sections.push(`Style: ${styleParts.join(", ")}`);
+    }
+    if (this._color) {
+      const colorParts = [];
+      if (this._color.palette) {
+        const palettes = Array.isArray(this._color.palette) ? this._color.palette : [this._color.palette];
+        colorParts.push(`${palettes.join(" and ")} palette`);
+      }
+      if (this._color.anchors?.length) colorParts.push(`color anchors: ${this._color.anchors.join(", ")}`);
+      if (this._color.grade) colorParts.push(this._color.grade);
+      if (colorParts.length) sections.push(`Color: ${colorParts.join(", ")}`);
+    }
+    if (this._audio) {
+      const audioParts = [];
+      if (this._audio.dialogue) audioParts.push(`Dialogue: "${this._audio.dialogue}"`);
+      if (this._audio.ambient) audioParts.push(`Ambient: ${this._audio.ambient}`);
+      if (this._audio.diegetic?.length) audioParts.push(`Diegetic sounds: ${this._audio.diegetic.join(", ")}`);
+      if (this._audio.music) audioParts.push(`Music: ${this._audio.music}`);
+      if (audioParts.length) sections.push(`Audio:
+${audioParts.join("\n")}`);
+    }
+    if (this._mood) {
+      const moods = Array.isArray(this._mood) ? this._mood : [this._mood];
+      sections.push(`Mood: ${moods.join(", ")}`);
+    }
+    if (this._pacing) {
+      sections.push(`Pacing: ${this._pacing}`);
+    }
+    if (this._custom.length) {
+      sections.push(this._custom.join("\n"));
+    }
+    return sections.join("\n\n");
+  }
+  build() {
+    return {
+      prompt: this.buildPromptText(),
+      structure: {
+        scene: this._scene,
+        subject: this._subject,
+        camera: this._camera,
+        lighting: this._lighting,
+        actions: this._actions.length ? this._actions : void 0,
+        motion: this._motion,
+        style: this._style,
+        color: this._color,
+        audio: this._audio,
+        technical: this._technical,
+        shots: this._shots.length ? this._shots : void 0,
+        mood: this._mood,
+        pacing: this._pacing,
+        transitions: this._transitions.length ? this._transitions : void 0
+      }
+    };
+  }
+  toString() {
+    return this.build().prompt;
+  }
+  toJSON() {
+    return JSON.stringify(this.build().structure, null, 2);
+  }
+  toYAML() {
+    return objectToYaml2(this.build().structure);
+  }
+  toMarkdown() {
+    const built = this.build();
+    const sections = ["# Video Prompt\n"];
+    sections.push("## Prompt\n```\n" + built.prompt + "\n```\n");
+    if (built.structure.scene) {
+      sections.push("## Scene\n" + objectToMarkdownList2(built.structure.scene));
+    }
+    if (built.structure.subject) {
+      sections.push("## Subject\n" + objectToMarkdownList2(built.structure.subject));
+    }
+    if (built.structure.camera) {
+      sections.push("## Camera\n" + objectToMarkdownList2(built.structure.camera));
+    }
+    if (built.structure.lighting) {
+      sections.push("## Lighting\n" + objectToMarkdownList2(built.structure.lighting));
+    }
+    if (built.structure.actions) {
+      sections.push("## Actions\n" + built.structure.actions.map((a) => `- **Beat ${a.beat}:** ${a.action}`).join("\n"));
+    }
+    if (built.structure.style) {
+      sections.push("## Style\n" + objectToMarkdownList2(built.structure.style));
+    }
+    if (built.structure.audio) {
+      sections.push("## Audio\n" + objectToMarkdownList2(built.structure.audio));
+    }
+    if (built.structure.technical) {
+      sections.push("## Technical\n" + objectToMarkdownList2(built.structure.technical));
+    }
+    return sections.join("\n");
+  }
+  outputFormat(fmt) {
+    switch (fmt) {
+      case "json":
+        return this.toJSON();
+      case "yaml":
+        return this.toYAML();
+      case "markdown":
+        return this.toMarkdown();
+      default:
+        return this.toString();
+    }
+  }
+};
+function objectToYaml2(obj, indent = 0) {
+  const spaces = "  ".repeat(indent);
+  const lines = [];
+  for (const [key, value] of Object.entries(obj)) {
+    if (value === void 0 || value === null) continue;
+    if (Array.isArray(value)) {
+      if (value.length === 0) continue;
+      lines.push(`${spaces}${key}:`);
+      for (const item of value) {
+        if (typeof item === "object") {
+          lines.push(`${spaces}  -`);
+          lines.push(objectToYaml2(item, indent + 2).replace(/^/gm, "  "));
+        } else {
+          lines.push(`${spaces}  - ${item}`);
+        }
+      }
+    } else if (typeof value === "object") {
+      lines.push(`${spaces}${key}:`);
+      lines.push(objectToYaml2(value, indent + 1));
+    } else {
+      lines.push(`${spaces}${key}: ${value}`);
+    }
+  }
+  return lines.join("\n");
+}
+function objectToMarkdownList2(obj, indent = 0) {
+  const spaces = "  ".repeat(indent);
+  const lines = [];
+  for (const [key, value] of Object.entries(obj)) {
+    if (value === void 0 || value === null) continue;
+    if (Array.isArray(value)) {
+      lines.push(`${spaces}- **${key}:** ${value.join(", ")}`);
+    } else if (typeof value === "object") {
+      lines.push(`${spaces}- **${key}:**`);
+      lines.push(objectToMarkdownList2(value, indent + 1));
+    } else {
+      lines.push(`${spaces}- **${key}:** ${value}`);
+    }
+  }
+  return lines.join("\n");
+}
+function video() {
+  return new VideoPromptBuilder();
+}
+
+// src/builder/audio.ts
+var AudioPromptBuilder = class {
+  constructor() {
+    this._tags = [];
+    this._custom = [];
+  }
+  // --- Genre Methods ---
+  genre(primary) {
+    if (typeof primary === "string") {
+      this._genre = { ...this._genre || { primary: "pop" }, primary };
+    } else {
+      this._genre = { ...this._genre || { primary: "pop" }, ...primary };
+    }
+    return this;
+  }
+  subgenre(subgenre) {
+    this._genre = { ...this._genre || { primary: "pop" }, subgenre };
+    return this;
+  }
+  fusion(genres) {
+    this._genre = {
+      ...this._genre || { primary: "pop" },
+      secondary: genres,
+      fusion: genres
+    };
+    return this;
+  }
+  // --- Mood Methods ---
+  mood(primary, ...secondary) {
+    this._mood = {
+      primary,
+      secondary: secondary.length ? secondary : void 0
+    };
+    return this;
+  }
+  energy(level) {
+    this._mood = { ...this._mood || { primary: "energetic" }, energy: level };
+    return this;
+  }
+  emotion(emotion) {
+    this._mood = { ...this._mood || { primary: "emotional" }, emotion };
+    return this;
+  }
+  // --- Tempo Methods ---
+  tempo(bpmOrSettings) {
+    if (typeof bpmOrSettings === "number") {
+      this._tempo = { ...this._tempo || {}, bpm: bpmOrSettings };
+    } else {
+      this._tempo = { ...this._tempo || {}, ...bpmOrSettings };
+    }
+    return this;
+  }
+  bpm(bpm) {
+    this._tempo = { ...this._tempo || {}, bpm };
+    return this;
+  }
+  tempoMarking(marking) {
+    this._tempo = { ...this._tempo || {}, marking };
+    return this;
+  }
+  tempoFeel(feel) {
+    this._tempo = { ...this._tempo || {}, feel };
+    return this;
+  }
+  // --- Vocal Methods ---
+  vocals(settings) {
+    this._vocals = { ...this._vocals || {}, ...settings };
+    return this;
+  }
+  vocalStyle(style) {
+    this._vocals = { ...this._vocals || {}, style };
+    return this;
+  }
+  language(language) {
+    this._vocals = { ...this._vocals || {}, language };
+    return this;
+  }
+  lyrics(lyrics) {
+    this._vocals = { ...this._vocals || {}, lyrics };
+    return this;
+  }
+  lyricsTheme(theme) {
+    this._vocals = { ...this._vocals || {}, theme };
+    return this;
+  }
+  delivery(delivery) {
+    this._vocals = { ...this._vocals || {}, delivery };
+    return this;
+  }
+  instrumental() {
+    this._vocals = { ...this._vocals || {}, language: "instrumental" };
+    return this;
+  }
+  // --- Instrumentation Methods ---
+  instruments(instruments) {
+    this._instrumentation = {
+      ...this._instrumentation || {},
+      lead: instruments
+    };
+    return this;
+  }
+  instrumentation(settings) {
+    this._instrumentation = { ...this._instrumentation || {}, ...settings };
+    return this;
+  }
+  leadInstrument(instrument) {
+    this._instrumentation = { ...this._instrumentation || {}, lead: instrument };
+    return this;
+  }
+  rhythmSection(instruments) {
+    this._instrumentation = { ...this._instrumentation || {}, rhythm: instruments };
+    return this;
+  }
+  bassInstrument(instrument) {
+    this._instrumentation = { ...this._instrumentation || {}, bass: instrument };
+    return this;
+  }
+  percussion(instruments) {
+    this._instrumentation = { ...this._instrumentation || {}, percussion: instruments };
+    return this;
+  }
+  pads(instruments) {
+    this._instrumentation = { ...this._instrumentation || {}, pads: instruments };
+    return this;
+  }
+  featuredInstrument(instrument) {
+    this._instrumentation = { ...this._instrumentation || {}, featured: instrument };
+    return this;
+  }
+  // --- Structure Methods ---
+  structure(settings) {
+    if ("sections" in settings || "form" in settings || "duration" in settings) {
+      this._structure = { ...this._structure || {}, ...settings };
+    } else {
+      const sections = [];
+      for (const [type, bars] of Object.entries(settings)) {
+        if (typeof bars === "number") {
+          sections.push({ type, bars });
+        }
+      }
+      this._structure = { ...this._structure || {}, sections };
+    }
+    return this;
+  }
+  section(type, bars, description) {
+    const sections = this._structure?.sections || [];
+    sections.push({ type, bars, description });
+    this._structure = { ...this._structure || {}, sections };
+    return this;
+  }
+  form(form) {
+    this._structure = { ...this._structure || {}, form };
+    return this;
+  }
+  duration(seconds) {
+    this._structure = { ...this._structure || {}, duration: seconds };
+    return this;
+  }
+  // --- Production Methods ---
+  production(settings) {
+    this._production = { ...this._production || {}, ...settings };
+    return this;
+  }
+  productionStyle(style) {
+    this._production = { ...this._production || {}, style };
+    return this;
+  }
+  era(era) {
+    this._production = { ...this._production || {}, era };
+    return this;
+  }
+  reference(artists) {
+    this._production = { ...this._production || {}, reference: artists };
+    return this;
+  }
+  texture(texture) {
+    this._production = { ...this._production || {}, texture };
+    return this;
+  }
+  effects(effects) {
+    this._production = { ...this._production || {}, effects };
+    return this;
+  }
+  // --- Technical Methods ---
+  technical(settings) {
+    this._technical = { ...this._technical || {}, ...settings };
+    return this;
+  }
+  key(key) {
+    this._technical = { ...this._technical || {}, key };
+    return this;
+  }
+  timeSignature(sig) {
+    this._technical = { ...this._technical || {}, timeSignature: sig };
+    return this;
+  }
+  formatType(format) {
+    this._technical = { ...this._technical || {}, format };
+    return this;
+  }
+  // --- Tags & Custom ---
+  tag(tag) {
+    this._tags.push(tag);
+    return this;
+  }
+  tags(tags) {
+    this._tags = [...this._tags, ...tags];
+    return this;
+  }
+  custom(text) {
+    this._custom.push(text);
+    return this;
+  }
+  // --- Build Methods ---
+  buildStylePrompt() {
+    const parts = [];
+    if (this._genre) {
+      let genreText = this._genre.primary;
+      if (this._genre.subgenre) genreText = `${this._genre.subgenre} ${genreText}`;
+      if (this._genre.secondary?.length) {
+        genreText += ` with ${this._genre.secondary.join(" and ")} influences`;
+      }
+      parts.push(genreText);
+    }
+    if (this._mood) {
+      let moodText = String(this._mood.primary);
+      if (this._mood.secondary?.length) {
+        moodText += `, ${this._mood.secondary.join(", ")}`;
+      }
+      if (this._mood.energy) moodText += `, ${this._mood.energy} energy`;
+      parts.push(moodText);
+    }
+    if (this._tempo) {
+      const tempoParts = [];
+      if (this._tempo.bpm) tempoParts.push(`${this._tempo.bpm} BPM`);
+      if (this._tempo.marking) tempoParts.push(this._tempo.marking);
+      if (this._tempo.feel) tempoParts.push(`${this._tempo.feel} feel`);
+      if (tempoParts.length) parts.push(tempoParts.join(", "));
+    }
+    if (this._instrumentation) {
+      const instrParts = [];
+      if (this._instrumentation.lead) {
+        const leads = Array.isArray(this._instrumentation.lead) ? this._instrumentation.lead : [this._instrumentation.lead];
+        instrParts.push(leads.join(", "));
+      }
+      if (this._instrumentation.featured) {
+        instrParts.push(`featuring ${this._instrumentation.featured}`);
+      }
+      if (instrParts.length) parts.push(instrParts.join(", "));
+    }
+    if (this._vocals) {
+      const vocalParts = [];
+      if (this._vocals.language === "instrumental") {
+        vocalParts.push("instrumental");
+      } else {
+        if (this._vocals.style) {
+          const styles = Array.isArray(this._vocals.style) ? this._vocals.style : [this._vocals.style];
+          vocalParts.push(`${styles.join(" and ")} vocals`);
+        }
+        if (this._vocals.language && this._vocals.language !== "english") {
+          vocalParts.push(`in ${this._vocals.language}`);
+        }
+      }
+      if (vocalParts.length) parts.push(vocalParts.join(" "));
+    }
+    if (this._production) {
+      const prodParts = [];
+      if (this._production.style) {
+        const styles = Array.isArray(this._production.style) ? this._production.style : [this._production.style];
+        prodParts.push(`${styles.join(", ")} production`);
+      }
+      if (this._production.era) prodParts.push(`${this._production.era} sound`);
+      if (this._production.texture) prodParts.push(this._production.texture);
+      if (prodParts.length) parts.push(prodParts.join(", "));
+    }
+    if (this._technical) {
+      const techParts = [];
+      if (this._technical.key) techParts.push(`in the key of ${this._technical.key}`);
+      if (this._technical.timeSignature && this._technical.timeSignature !== "4/4") {
+        techParts.push(`${this._technical.timeSignature} time`);
+      }
+      if (techParts.length) parts.push(techParts.join(", "));
+    }
+    if (this._tags.length) {
+      parts.push(this._tags.join(", "));
+    }
+    if (this._custom.length) {
+      parts.push(this._custom.join(", "));
+    }
+    return parts.join(", ");
+  }
+  buildLyricsPrompt() {
+    if (!this._vocals?.lyrics && !this._vocals?.theme) return void 0;
+    const parts = [];
+    if (this._vocals.theme) {
+      parts.push(`Theme: ${this._vocals.theme}`);
+    }
+    if (this._vocals.lyrics) {
+      parts.push(this._vocals.lyrics);
+    }
+    return parts.join("\n\n");
+  }
+  buildFullPrompt() {
+    const sections = [];
+    sections.push(`Style: ${this.buildStylePrompt()}`);
+    if (this._structure?.sections?.length) {
+      const structureText = this._structure.sections.map((s) => `[${s.type.toUpperCase()}]${s.description ? ` ${s.description}` : ""}`).join("\n");
+      sections.push(`Structure:
+${structureText}`);
+    }
+    const lyrics = this.buildLyricsPrompt();
+    if (lyrics) {
+      sections.push(`Lyrics:
+${lyrics}`);
+    }
+    return sections.join("\n\n");
+  }
+  build() {
+    return {
+      prompt: this.buildFullPrompt(),
+      stylePrompt: this.buildStylePrompt(),
+      lyricsPrompt: this.buildLyricsPrompt(),
+      structure: {
+        genre: this._genre,
+        mood: this._mood,
+        tempo: this._tempo,
+        vocals: this._vocals,
+        instrumentation: this._instrumentation,
+        structure: this._structure,
+        production: this._production,
+        technical: this._technical,
+        tags: this._tags.length ? this._tags : void 0
+      }
+    };
+  }
+  toString() {
+    return this.build().prompt;
+  }
+  toStyleString() {
+    return this.build().stylePrompt;
+  }
+  toJSON() {
+    return JSON.stringify(this.build().structure, null, 2);
+  }
+  toYAML() {
+    return objectToYaml3(this.build().structure);
+  }
+  toMarkdown() {
+    const built = this.build();
+    const sections = ["# Audio Prompt\n"];
+    sections.push("## Style Prompt\n```\n" + built.stylePrompt + "\n```\n");
+    if (built.lyricsPrompt) {
+      sections.push("## Lyrics\n```\n" + built.lyricsPrompt + "\n```\n");
+    }
+    if (built.structure.genre) {
+      sections.push("## Genre\n" + objectToMarkdownList3(built.structure.genre));
+    }
+    if (built.structure.mood) {
+      sections.push("## Mood\n" + objectToMarkdownList3(built.structure.mood));
+    }
+    if (built.structure.tempo) {
+      sections.push("## Tempo\n" + objectToMarkdownList3(built.structure.tempo));
+    }
+    if (built.structure.vocals) {
+      sections.push("## Vocals\n" + objectToMarkdownList3(built.structure.vocals));
+    }
+    if (built.structure.instrumentation) {
+      sections.push("## Instrumentation\n" + objectToMarkdownList3(built.structure.instrumentation));
+    }
+    if (built.structure.production) {
+      sections.push("## Production\n" + objectToMarkdownList3(built.structure.production));
+    }
+    return sections.join("\n");
+  }
+  outputFormat(fmt) {
+    switch (fmt) {
+      case "json":
+        return this.toJSON();
+      case "yaml":
+        return this.toYAML();
+      case "markdown":
+        return this.toMarkdown();
+      default:
+        return this.toString();
+    }
+  }
+};
+function objectToYaml3(obj, indent = 0) {
+  const spaces = "  ".repeat(indent);
+  const lines = [];
+  for (const [key, value] of Object.entries(obj)) {
+    if (value === void 0 || value === null) continue;
+    if (Array.isArray(value)) {
+      if (value.length === 0) continue;
+      lines.push(`${spaces}${key}:`);
+      for (const item of value) {
+        if (typeof item === "object") {
+          lines.push(`${spaces}  -`);
+          lines.push(objectToYaml3(item, indent + 2).replace(/^/gm, "  "));
+        } else {
+          lines.push(`${spaces}  - ${item}`);
+        }
+      }
+    } else if (typeof value === "object") {
+      lines.push(`${spaces}${key}:`);
+      lines.push(objectToYaml3(value, indent + 1));
+    } else {
+      lines.push(`${spaces}${key}: ${value}`);
+    }
+  }
+  return lines.join("\n");
+}
+function objectToMarkdownList3(obj, indent = 0) {
+  const spaces = "  ".repeat(indent);
+  const lines = [];
+  for (const [key, value] of Object.entries(obj)) {
+    if (value === void 0 || value === null) continue;
+    if (Array.isArray(value)) {
+      lines.push(`${spaces}- **${key}:** ${value.join(", ")}`);
+    } else if (typeof value === "object") {
+      lines.push(`${spaces}- **${key}:**`);
+      lines.push(objectToMarkdownList3(value, indent + 1));
+    } else {
+      lines.push(`${spaces}- **${key}:** ${value}`);
+    }
+  }
+  return lines.join("\n");
+}
+function audio() {
+  return new AudioPromptBuilder();
+}
+
+// src/builder/chat.ts
+var ChatPromptBuilder = class {
+  constructor() {
+    this._messages = [];
+    this._examples = [];
+    this._customSystemParts = [];
+  }
+  // --- Message Methods ---
+  system(content) {
+    this._messages = this._messages.filter((m) => m.role !== "system");
+    this._messages.unshift({ role: "system", content });
+    return this;
+  }
+  user(content, name) {
+    this._messages.push({ role: "user", content, name });
+    return this;
+  }
+  assistant(content) {
+    this._messages.push({ role: "assistant", content });
+    return this;
+  }
+  message(role, content, name) {
+    this._messages.push({ role, content, name });
+    return this;
+  }
+  messages(messages) {
+    this._messages = [...this._messages, ...messages];
+    return this;
+  }
+  conversation(turns) {
+    for (const turn of turns) {
+      this.user(turn.user);
+      if (turn.assistant) {
+        this.assistant(turn.assistant);
+      }
+    }
+    return this;
+  }
+  // --- Persona Methods ---
+  persona(settings) {
+    if (typeof settings === "string") {
+      this._persona = { ...this._persona || {}, role: settings };
+    } else {
+      this._persona = { ...this._persona || {}, ...settings };
+    }
+    return this;
+  }
+  role(role) {
+    this._persona = { ...this._persona || {}, role };
+    return this;
+  }
+  tone(tone) {
+    this._persona = { ...this._persona || {}, tone };
+    return this;
+  }
+  expertise(expertise) {
+    this._persona = { ...this._persona || {}, expertise };
+    return this;
+  }
+  personality(traits) {
+    this._persona = { ...this._persona || {}, personality: traits };
+    return this;
+  }
+  background(background) {
+    this._persona = { ...this._persona || {}, background };
+    return this;
+  }
+  speakAs(name) {
+    this._persona = { ...this._persona || {}, name };
+    return this;
+  }
+  responseLanguage(language) {
+    this._persona = { ...this._persona || {}, language };
+    return this;
+  }
+  // --- Context Methods ---
+  context(settings) {
+    if (typeof settings === "string") {
+      this._context = { ...this._context || {}, background: settings };
+    } else {
+      this._context = { ...this._context || {}, ...settings };
+    }
+    return this;
+  }
+  domain(domain) {
+    this._context = { ...this._context || {}, domain };
+    return this;
+  }
+  audience(audience) {
+    this._context = { ...this._context || {}, audience };
+    return this;
+  }
+  purpose(purpose) {
+    this._context = { ...this._context || {}, purpose };
+    return this;
+  }
+  constraints(constraints) {
+    const existing = this._context?.constraints || [];
+    this._context = { ...this._context || {}, constraints: [...existing, ...constraints] };
+    return this;
+  }
+  constraint(constraint) {
+    return this.constraints([constraint]);
+  }
+  assumptions(assumptions) {
+    this._context = { ...this._context || {}, assumptions };
+    return this;
+  }
+  knowledge(facts) {
+    this._context = { ...this._context || {}, knowledge: facts };
+    return this;
+  }
+  // --- Task Methods ---
+  task(instruction) {
+    if (typeof instruction === "string") {
+      this._task = { ...this._task || { instruction: "" }, instruction };
+    } else {
+      this._task = { ...this._task || { instruction: "" }, ...instruction };
+    }
+    return this;
+  }
+  instruction(instruction) {
+    this._task = { ...this._task || { instruction: "" }, instruction };
+    return this;
+  }
+  steps(steps) {
+    this._task = { ...this._task || { instruction: "" }, steps };
+    return this;
+  }
+  deliverables(deliverables) {
+    this._task = { ...this._task || { instruction: "" }, deliverables };
+    return this;
+  }
+  criteria(criteria) {
+    this._task = { ...this._task || { instruction: "" }, criteria };
+    return this;
+  }
+  avoid(antiPatterns) {
+    this._task = { ...this._task || { instruction: "" }, antiPatterns };
+    return this;
+  }
+  priority(priority) {
+    this._task = { ...this._task || { instruction: "" }, priority };
+    return this;
+  }
+  // --- Example Methods ---
+  example(input, output, explanation) {
+    this._examples.push({ input, output, explanation });
+    return this;
+  }
+  examples(examples) {
+    this._examples = [...this._examples, ...examples];
+    return this;
+  }
+  fewShot(examples) {
+    for (const ex of examples) {
+      this._examples.push(ex);
+    }
+    return this;
+  }
+  // --- Output Methods ---
+  output(settings) {
+    this._output = { ...this._output || {}, ...settings };
+    return this;
+  }
+  outputFormat(format) {
+    this._output = {
+      ...this._output || {},
+      format: { type: format }
+    };
+    return this;
+  }
+  json(schema) {
+    if (schema) {
+      this._output = {
+        ...this._output || {},
+        format: { type: "json", jsonSchema: schema }
+      };
+    } else {
+      this._output = {
+        ...this._output || {},
+        format: { type: "json" }
+      };
+    }
+    return this;
+  }
+  jsonSchema(name, schema, description) {
+    this._output = {
+      ...this._output || {},
+      format: {
+        type: "json",
+        jsonSchema: { name, schema, description }
+      }
+    };
+    return this;
+  }
+  markdown() {
+    this._output = { ...this._output || {}, format: { type: "markdown" } };
+    return this;
+  }
+  code(language) {
+    this._output = { ...this._output || {}, format: { type: "code", language } };
+    return this;
+  }
+  table() {
+    this._output = { ...this._output || {}, format: { type: "table" } };
+    return this;
+  }
+  length(length) {
+    this._output = { ...this._output || {}, length };
+    return this;
+  }
+  style(style) {
+    this._output = { ...this._output || {}, style };
+    return this;
+  }
+  brief() {
+    return this.length("brief");
+  }
+  moderate() {
+    return this.length("moderate");
+  }
+  detailed() {
+    return this.length("detailed");
+  }
+  comprehensive() {
+    return this.length("comprehensive");
+  }
+  exhaustive() {
+    return this.length("exhaustive");
+  }
+  withExamples() {
+    this._output = { ...this._output || {}, includeExamples: true };
+    return this;
+  }
+  withExplanation() {
+    this._output = { ...this._output || {}, includeExplanation: true };
+    return this;
+  }
+  withSources() {
+    this._output = { ...this._output || {}, includeSources: true };
+    return this;
+  }
+  withConfidence() {
+    this._output = { ...this._output || {}, includeConfidence: true };
+    return this;
+  }
+  // --- Reasoning Methods ---
+  reasoning(settings) {
+    this._reasoning = { ...this._reasoning || {}, ...settings };
+    return this;
+  }
+  reasoningStyle(style) {
+    this._reasoning = { ...this._reasoning || {}, style };
+    return this;
+  }
+  stepByStep() {
+    this._reasoning = { ...this._reasoning || {}, style: "step-by-step", showWork: true };
+    return this;
+  }
+  chainOfThought() {
+    this._reasoning = { ...this._reasoning || {}, style: "chain-of-thought", showWork: true };
+    return this;
+  }
+  treeOfThought() {
+    this._reasoning = { ...this._reasoning || {}, style: "tree-of-thought", showWork: true };
+    return this;
+  }
+  firstPrinciples() {
+    this._reasoning = { ...this._reasoning || {}, style: "first-principles", showWork: true };
+    return this;
+  }
+  devilsAdvocate() {
+    this._reasoning = { ...this._reasoning || {}, style: "devil-advocate", considerAlternatives: true };
+    return this;
+  }
+  showWork(show = true) {
+    this._reasoning = { ...this._reasoning || {}, showWork: show };
+    return this;
+  }
+  verifyAnswer(verify = true) {
+    this._reasoning = { ...this._reasoning || {}, verifyAnswer: verify };
+    return this;
+  }
+  considerAlternatives(consider = true) {
+    this._reasoning = { ...this._reasoning || {}, considerAlternatives: consider };
+    return this;
+  }
+  explainAssumptions(explain = true) {
+    this._reasoning = { ...this._reasoning || {}, explainAssumptions: explain };
+    return this;
+  }
+  // --- Memory Methods ---
+  memory(memory) {
+    this._memory = { ...this._memory || {}, ...memory };
+    return this;
+  }
+  remember(facts) {
+    const existing = this._memory?.facts || [];
+    this._memory = { ...this._memory || {}, facts: [...existing, ...facts] };
+    return this;
+  }
+  preferences(prefs) {
+    this._memory = { ...this._memory || {}, preferences: prefs };
+    return this;
+  }
+  history(messages) {
+    this._memory = { ...this._memory || {}, history: messages };
+    return this;
+  }
+  summarizeHistory(summary) {
+    this._memory = { ...this._memory || {}, summary };
+    return this;
+  }
+  // --- Custom System Prompt Parts ---
+  addSystemPart(part) {
+    this._customSystemParts.push(part);
+    return this;
+  }
+  raw(content) {
+    this._customSystemParts = [content];
+    return this;
+  }
+  // --- Build Methods ---
+  buildSystemPrompt() {
+    const parts = [];
+    if (this._persona) {
+      let personaText = "";
+      if (this._persona.name) {
+        personaText += `You are ${this._persona.name}`;
+        if (this._persona.role) personaText += `, ${this._persona.role}`;
+        personaText += ".";
+      } else if (this._persona.role) {
+        personaText += `You are ${this._persona.role}.`;
+      }
+      if (this._persona.tone) {
+        const tones = Array.isArray(this._persona.tone) ? this._persona.tone : [this._persona.tone];
+        personaText += ` Your tone is ${tones.join(" and ")}.`;
+      }
+      if (this._persona.expertise) {
+        const areas = Array.isArray(this._persona.expertise) ? this._persona.expertise : [this._persona.expertise];
+        personaText += ` You have expertise in ${areas.join(", ")}.`;
+      }
+      if (this._persona.personality?.length) {
+        personaText += ` You are ${this._persona.personality.join(", ")}.`;
+      }
+      if (this._persona.background) {
+        personaText += ` ${this._persona.background}`;
+      }
+      if (this._persona.verbosity) {
+        personaText += ` Keep responses ${this._persona.verbosity}.`;
+      }
+      if (this._persona.language) {
+        personaText += ` Respond in ${this._persona.language}.`;
+      }
+      if (personaText) parts.push(personaText.trim());
+    }
+    if (this._context) {
+      const contextParts = [];
+      if (this._context.background) {
+        contextParts.push(this._context.background);
+      }
+      if (this._context.domain) {
+        contextParts.push(`Domain: ${this._context.domain}`);
+      }
+      if (this._context.audience) {
+        contextParts.push(`Target audience: ${this._context.audience}`);
+      }
+      if (this._context.purpose) {
+        contextParts.push(`Purpose: ${this._context.purpose}`);
+      }
+      if (this._context.knowledge?.length) {
+        contextParts.push(`Known facts:
+${this._context.knowledge.map((k) => `- ${k}`).join("\n")}`);
+      }
+      if (this._context.assumptions?.length) {
+        contextParts.push(`Assumptions:
+${this._context.assumptions.map((a) => `- ${a}`).join("\n")}`);
+      }
+      if (contextParts.length) {
+        parts.push(`## Context
+${contextParts.join("\n")}`);
+      }
+    }
+    if (this._task) {
+      const taskParts = [];
+      if (this._task.instruction) {
+        taskParts.push(this._task.instruction);
+      }
+      if (this._task.priority) {
+        taskParts.push(`Priority: ${this._task.priority}`);
+      }
+      if (this._task.steps?.length) {
+        taskParts.push(`
+Steps:
+${this._task.steps.map((s, i) => `${i + 1}. ${s}`).join("\n")}`);
+      }
+      if (this._task.deliverables?.length) {
+        taskParts.push(`
+Deliverables:
+${this._task.deliverables.map((d) => `- ${d}`).join("\n")}`);
+      }
+      if (this._task.criteria?.length) {
+        taskParts.push(`
+Success criteria:
+${this._task.criteria.map((c) => `- ${c}`).join("\n")}`);
+      }
+      if (this._task.antiPatterns?.length) {
+        taskParts.push(`
+Avoid:
+${this._task.antiPatterns.map((a) => `- ${a}`).join("\n")}`);
+      }
+      if (taskParts.length) {
+        parts.push(`## Task
+${taskParts.join("\n")}`);
+      }
+    }
+    if (this._context?.constraints?.length) {
+      parts.push(`## Constraints
+${this._context.constraints.map((c, i) => `${i + 1}. ${c}`).join("\n")}`);
+    }
+    if (this._examples.length) {
+      const examplesText = this._examples.map((ex, i) => {
+        let text = `### Example ${i + 1}
+**Input:** ${ex.input}
+**Output:** ${ex.output}`;
+        if (ex.explanation) text += `
+**Explanation:** ${ex.explanation}`;
+        return text;
+      }).join("\n\n");
+      parts.push(`## Examples
+${examplesText}`);
+    }
+    if (this._output) {
+      const outputParts = [];
+      if (this._output.format) {
+        switch (this._output.format.type) {
+          case "json":
+            if (this._output.format.jsonSchema) {
+              outputParts.push(`Respond in valid JSON matching this schema:
+\`\`\`json
+${JSON.stringify(this._output.format.jsonSchema.schema, null, 2)}
+\`\`\``);
+            } else {
+              outputParts.push("Respond in valid JSON format.");
+            }
+            break;
+          case "markdown":
+            outputParts.push("Format your response using Markdown.");
+            break;
+          case "code":
+            outputParts.push(`Respond with code${this._output.format.language ? ` in ${this._output.format.language}` : ""}.`);
+            break;
+          case "table":
+            outputParts.push("Format your response as a table.");
+            break;
+        }
+      }
+      if (this._output.length) {
+        outputParts.push(`Keep your response ${this._output.length}.`);
+      }
+      if (this._output.style) {
+        const styleMap = {
+          "prose": "flowing prose",
+          "bullet-points": "bullet points",
+          "numbered-list": "a numbered list",
+          "table": "a table",
+          "code": "code",
+          "mixed": "a mix of prose and lists",
+          "qa": "Q&A format",
+          "dialogue": "dialogue format"
+        };
+        outputParts.push(`Structure as ${styleMap[this._output.style]}.`);
+      }
+      if (this._output.language) {
+        outputParts.push(`Respond in ${this._output.language}.`);
+      }
+      if (this._output.includeExamples) {
+        outputParts.push("Include relevant examples.");
+      }
+      if (this._output.includeExplanation) {
+        outputParts.push("Include clear explanations.");
+      }
+      if (this._output.includeSources) {
+        outputParts.push("Cite your sources.");
+      }
+      if (this._output.includeConfidence) {
+        outputParts.push("Include your confidence level in the answer.");
+      }
+      if (outputParts.length) {
+        parts.push(`## Output Format
+${outputParts.join("\n")}`);
+      }
+    }
+    if (this._reasoning) {
+      const reasoningParts = [];
+      if (this._reasoning.style) {
+        const styleInstructions = {
+          "step-by-step": "Think through this step by step.",
+          "chain-of-thought": "Use chain-of-thought reasoning to work through the problem.",
+          "tree-of-thought": "Consider multiple approaches and evaluate each before deciding.",
+          "direct": "Provide a direct answer.",
+          "analytical": "Analyze the problem systematically.",
+          "comparative": "Compare different options or approaches.",
+          "deductive": "Use deductive reasoning from general principles.",
+          "inductive": "Use inductive reasoning from specific examples.",
+          "first-principles": "Reason from first principles, breaking down to fundamental truths.",
+          "analogical": "Use analogies to explain and reason about the problem.",
+          "devil-advocate": "Consider and argue against your own conclusions."
+        };
+        reasoningParts.push(styleInstructions[this._reasoning.style]);
+      }
+      if (this._reasoning.showWork) {
+        reasoningParts.push("Show your reasoning process.");
+      }
+      if (this._reasoning.verifyAnswer) {
+        reasoningParts.push("Verify your answer before presenting it.");
+      }
+      if (this._reasoning.considerAlternatives) {
+        reasoningParts.push("Consider alternative perspectives and solutions.");
+      }
+      if (this._reasoning.explainAssumptions) {
+        reasoningParts.push("Explicitly state any assumptions you make.");
+      }
+      if (reasoningParts.length) {
+        parts.push(`## Reasoning
+${reasoningParts.join("\n")}`);
+      }
+    }
+    if (this._memory) {
+      const memoryParts = [];
+      if (this._memory.summary) {
+        memoryParts.push(`Previous conversation summary: ${this._memory.summary}`);
+      }
+      if (this._memory.facts?.length) {
+        memoryParts.push(`Known facts:
+${this._memory.facts.map((f) => `- ${f}`).join("\n")}`);
+      }
+      if (this._memory.preferences?.length) {
+        memoryParts.push(`User preferences:
+${this._memory.preferences.map((p) => `- ${p}`).join("\n")}`);
+      }
+      if (memoryParts.length) {
+        parts.push(`## Memory
+${memoryParts.join("\n")}`);
+      }
+    }
+    if (this._customSystemParts.length) {
+      parts.push(...this._customSystemParts);
+    }
+    return parts.join("\n\n");
+  }
+  build() {
+    const systemPrompt = this.buildSystemPrompt();
+    let messages = [...this._messages];
+    const hasSystemMessage = messages.some((m) => m.role === "system");
+    if (systemPrompt && !hasSystemMessage) {
+      messages = [{ role: "system", content: systemPrompt }, ...messages];
+    } else if (systemPrompt && hasSystemMessage) {
+      messages = messages.map(
+        (m) => m.role === "system" ? { ...m, content: `${systemPrompt}
+
+${m.content}` } : m
+      );
+    }
+    if (this._memory?.history) {
+      const systemIdx = messages.findIndex((m) => m.role === "system");
+      const insertIdx = systemIdx >= 0 ? systemIdx + 1 : 0;
+      messages.splice(insertIdx, 0, ...this._memory.history);
+    }
+    const userMessages = messages.filter((m) => m.role === "user");
+    const userPrompt = userMessages.length ? userMessages[userMessages.length - 1].content : void 0;
+    return {
+      messages,
+      systemPrompt,
+      userPrompt,
+      metadata: {
+        persona: this._persona,
+        context: this._context,
+        task: this._task,
+        output: this._output,
+        reasoning: this._reasoning,
+        examples: this._examples.length ? this._examples : void 0
+      }
+    };
+  }
+  // --- Output Methods ---
+  toString() {
+    return this.buildSystemPrompt();
+  }
+  toSystemPrompt() {
+    return this.buildSystemPrompt();
+  }
+  toMessages() {
+    return this.build().messages;
+  }
+  toJSON() {
+    return JSON.stringify(this.build(), null, 2);
+  }
+  toYAML() {
+    return objectToYaml4(this.build());
+  }
+  toMarkdown() {
+    const built = this.build();
+    const sections = ["# Chat Prompt\n"];
+    sections.push("## System Prompt\n```\n" + built.systemPrompt + "\n```\n");
+    if (built.messages.length > 1) {
+      sections.push("## Messages\n");
+      for (const msg of built.messages) {
+        if (msg.role === "system") continue;
+        sections.push(`**${msg.role.toUpperCase()}${msg.name ? ` (${msg.name})` : ""}:**
+${msg.content}
+`);
+      }
+    }
+    return sections.join("\n");
+  }
+};
+function objectToYaml4(obj, indent = 0) {
+  const spaces = "  ".repeat(indent);
+  const lines = [];
+  for (const [key, value] of Object.entries(obj)) {
+    if (value === void 0 || value === null) continue;
+    if (Array.isArray(value)) {
+      if (value.length === 0) continue;
+      lines.push(`${spaces}${key}:`);
+      for (const item of value) {
+        if (typeof item === "object") {
+          lines.push(`${spaces}  -`);
+          lines.push(objectToYaml4(item, indent + 2).replace(/^/gm, "  "));
+        } else {
+          lines.push(`${spaces}  - ${item}`);
+        }
+      }
+    } else if (typeof value === "object") {
+      lines.push(`${spaces}${key}:`);
+      lines.push(objectToYaml4(value, indent + 1));
+    } else if (typeof value === "string" && value.includes("\n")) {
+      lines.push(`${spaces}${key}: |`);
+      for (const line of value.split("\n")) {
+        lines.push(`${spaces}  ${line}`);
+      }
+    } else {
+      lines.push(`${spaces}${key}: ${value}`);
+    }
+  }
+  return lines.join("\n");
+}
+function chat() {
+  return new ChatPromptBuilder();
+}
+var chatPresets = {
+  /**
+   * Code assistant preset
+   */
+  coder: (language) => {
+    const c = chat().role("expert software developer").expertise("coding").tone("technical");
+    if (language) {
+      c.context(`Programming language: ${language}`);
+    }
+    return c;
+  },
+  /**
+   * Writing assistant preset
+   */
+  writer: (style) => {
+    const c = chat().role("skilled writer and editor").expertise("writing");
+    if (style) {
+      c.tone(style === "creative" ? "creative" : style === "academic" ? "academic" : "professional");
+    }
+    return c;
+  },
+  /**
+   * Teacher/tutor preset
+   */
+  tutor: (subject) => {
+    const c = chat().role("patient and knowledgeable tutor").expertise("teaching").tone(["friendly", "empathetic"]).stepByStep().withExamples();
+    if (subject) {
+      c.domain(subject);
+    }
+    return c;
+  },
+  /**
+   * Analyst preset
+   */
+  analyst: () => {
+    return chat().role("data analyst and researcher").expertise("analysis").tone("analytical").chainOfThought().detailed().withSources();
+  },
+  /**
+   * Socratic dialogue preset
+   */
+  socratic: () => {
+    return chat().role("Socratic philosopher and teacher").tone("socratic").reasoning({ style: "deductive", showWork: true }).avoid(["Give direct answers", "Lecture", "Be condescending"]);
+  },
+  /**
+   * Critic preset
+   */
+  critic: () => {
+    return chat().role("constructive critic").tone(["analytical", "professional"]).devilsAdvocate().detailed().avoid(["Be harsh", "Dismiss ideas without explanation"]);
+  },
+  /**
+   * Brainstormer preset
+   */
+  brainstormer: () => {
+    return chat().role("creative brainstorming partner").tone(["creative", "encouraging"]).expertise("creative").considerAlternatives().avoid(["Dismiss ideas", "Be negative", "Limit creativity"]);
+  },
+  /**
+   * JSON response preset
+   */
+  jsonResponder: (schemaName, schema) => {
+    return chat().role("data processing assistant").tone("concise").jsonSchema(schemaName, schema).avoid(["Include markdown", "Add explanations outside JSON", "Include code fences"]);
+  },
+  /**
+   * Summarizer preset
+   */
+  summarizer: (length = "brief") => {
+    return chat().role("expert summarizer").expertise("analysis").tone("concise").length(length).task("Summarize the provided content, preserving key information");
+  },
+  /**
+   * Translator preset
+   */
+  translator: (targetLanguage) => {
+    return chat().role("professional translator").expertise("languages").responseLanguage(targetLanguage).avoid(["Add commentary", "Change meaning", "Omit content"]);
+  }
+};
+
+// src/builder/index.ts
+var PromptBuilder = class {
+  constructor() {
+    this._constraints = [];
+    this._examples = [];
+    this._variables = [];
+    this._customSections = [];
+  }
+  /**
+   * Set the role/persona for the AI
+   */
+  role(role) {
+    this._role = role;
+    return this;
+  }
+  /**
+   * Alias for role()
+   */
+  persona(persona) {
+    return this.role(persona);
+  }
+  /**
+   * Set the context/background information
+   */
+  context(context) {
+    this._context = context;
+    return this;
+  }
+  /**
+   * Alias for context()
+   */
+  background(background) {
+    return this.context(background);
+  }
+  /**
+   * Set the main task/instruction
+   */
+  task(task) {
+    this._task = task;
+    return this;
+  }
+  /**
+   * Alias for task()
+   */
+  instruction(instruction) {
+    return this.task(instruction);
+  }
+  /**
+   * Add constraints/rules the AI should follow
+   */
+  constraints(constraints) {
+    this._constraints = [...this._constraints, ...constraints];
+    return this;
+  }
+  /**
+   * Add a single constraint
+   */
+  constraint(constraint) {
+    this._constraints.push(constraint);
+    return this;
+  }
+  /**
+   * Alias for constraints()
+   */
+  rules(rules) {
+    return this.constraints(rules);
+  }
+  /**
+   * Set the expected output format
+   */
+  output(format) {
+    this._outputFormat = format;
+    return this;
+  }
+  /**
+   * Alias for output()
+   */
+  format(format) {
+    return this.output(format);
+  }
+  /**
+   * Add an example input/output pair
+   */
+  example(input, output) {
+    this._examples.push({ input, output });
+    return this;
+  }
+  /**
+   * Add multiple examples
+   */
+  examples(examples) {
+    this._examples = [...this._examples, ...examples];
+    return this;
+  }
+  /**
+   * Define a variable placeholder
+   */
+  variable(name, options = {}) {
+    this._variables.push({
+      name,
+      description: options.description,
+      required: options.required ?? true,
+      defaultValue: options.defaultValue
+    });
+    return this;
+  }
+  /**
+   * Add a custom section
+   */
+  section(title, content) {
+    this._customSections.push({ title, content });
+    return this;
+  }
+  /**
+   * Set raw content (bypasses structured building)
+   */
+  raw(content) {
+    this._rawContent = content;
+    return this;
+  }
+  /**
+   * Build the final prompt
+   */
+  build() {
+    if (this._rawContent) {
+      return {
+        content: this._rawContent,
+        variables: this._variables,
+        metadata: {}
+      };
+    }
+    const sections = [];
+    if (this._role) {
+      sections.push(`You are ${this._role}.`);
+    }
+    if (this._context) {
+      sections.push(`
+## Context
+${this._context}`);
+    }
+    if (this._task) {
+      sections.push(`
+## Task
+${this._task}`);
+    }
+    if (this._constraints.length > 0) {
+      const constraintsList = this._constraints.map((c, i) => `${i + 1}. ${c}`).join("\n");
+      sections.push(`
+## Constraints
+${constraintsList}`);
+    }
+    if (this._outputFormat) {
+      sections.push(`
+## Output Format
+${this._outputFormat}`);
+    }
+    if (this._examples.length > 0) {
+      const examplesText = this._examples.map((e, i) => `### Example ${i + 1}
+**Input:** ${e.input}
+**Output:** ${e.output}`).join("\n\n");
+      sections.push(`
+## Examples
+${examplesText}`);
+    }
+    for (const section of this._customSections) {
+      sections.push(`
+## ${section.title}
+${section.content}`);
+    }
+    if (this._variables.length > 0) {
+      const varsText = this._variables.map((v) => {
+        const placeholder = v.defaultValue ? `\${${v.name}:${v.defaultValue}}` : `\${${v.name}}`;
+        const desc = v.description ? ` - ${v.description}` : "";
+        const req = v.required ? " (required)" : " (optional)";
+        return `- ${placeholder}${desc}${req}`;
+      }).join("\n");
+      sections.push(`
+## Variables
+${varsText}`);
+    }
+    return {
+      content: sections.join("\n").trim(),
+      variables: this._variables,
+      metadata: {
+        role: this._role,
+        context: this._context,
+        task: this._task,
+        constraints: this._constraints.length > 0 ? this._constraints : void 0,
+        outputFormat: this._outputFormat,
+        examples: this._examples.length > 0 ? this._examples : void 0
+      }
+    };
+  }
+  /**
+   * Build and return only the content string
+   */
+  toString() {
+    return this.build().content;
+  }
+};
+function builder() {
+  return new PromptBuilder();
+}
+function fromPrompt(content) {
+  return new PromptBuilder().raw(content);
+}
+var templates = {
+  /**
+   * Create a code review prompt
+   */
+  codeReview: (options = {}) => {
+    const b = builder().role("expert code reviewer").task("Review the provided code and identify issues, improvements, and best practices.").variable("code", { required: true, description: "The code to review" });
+    if (options.language) {
+      b.context(`You are reviewing ${options.language} code.`);
+    }
+    if (options.focus && options.focus.length > 0) {
+      b.constraints(options.focus.map((f) => `Focus on ${f}`));
+    }
+    return b.output("Provide a structured review with: issues found, suggestions, and overall assessment.");
+  },
+  /**
+   * Create a translation prompt
+   */
+  translation: (from, to) => {
+    return builder().role(`professional translator fluent in ${from} and ${to}`).task(`Translate the following text from ${from} to ${to}.`).constraints([
+      "Maintain the original meaning and tone",
+      "Use natural, idiomatic expressions in the target language",
+      "Preserve formatting and structure"
+    ]).variable("text", { required: true, description: "Text to translate" });
+  },
+  /**
+   * Create a summarization prompt
+   */
+  summarize: (options = {}) => {
+    const b = builder().role("expert summarizer").task("Summarize the following content concisely while preserving key information.").variable("content", { required: true, description: "Content to summarize" });
+    if (options.maxLength) {
+      b.constraint(`Keep the summary under ${options.maxLength} words`);
+    }
+    if (options.style === "bullet") {
+      b.output("Provide the summary as bullet points");
+    }
+    return b;
+  },
+  /**
+   * Create a Q&A prompt
+   */
+  qa: (context) => {
+    const b = builder().role("helpful assistant").task("Answer the question based on the provided context.").variable("question", { required: true, description: "The question to answer" });
+    if (context) {
+      b.context(context);
+    } else {
+      b.variable("context", { required: false, description: "Additional context" });
+    }
+    return b.constraints([
+      "Be accurate and concise",
+      "If you don't know the answer, say so",
+      "Cite relevant parts of the context if applicable"
+    ]);
+  }
+};
+export {
+  AudioPromptBuilder,
+  ChatPromptBuilder,
+  ImagePromptBuilder,
+  PromptBuilder,
+  VideoPromptBuilder,
+  audio,
+  builder,
+  calculateSimilarity,
+  chat,
+  chatPresets,
+  check as checkQuality,
+  compile,
+  convertAllVariables,
+  convertToSupportedFormat,
+  deduplicate,
+  detectVariables,
+  detect as detectVars,
+  extractVariables,
+  findDuplicates,
+  fromPrompt,
+  getContentFingerprint,
+  getSuggestions,
+  getSystemPrompt,
+  image,
+  interpolate,
+  isSimilarContent,
+  isValid as isValidPrompt,
+  normalizeContent,
+  normalize as normalizeVariables,
+  parse as parsePrompt,
+  parser_exports as parser,
+  quality_exports as quality,
+  similarity_exports as similarity,
+  templates,
+  toJson,
+  toYaml,
+  validate as validatePrompt,
+  variables_exports as variables,
+  video
+};
+//# sourceMappingURL=index.mjs.map