prompts.chat 0.0.1 → 0.0.3

package/dist/builder/index.js

@@ -0,0 +1,2471 @@
+"use strict";
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+
+// src/builder/index.ts
+var builder_exports = {};
+__export(builder_exports, {
+  AudioPromptBuilder: () => AudioPromptBuilder,
+  ChatPromptBuilder: () => ChatPromptBuilder,
+  ImagePromptBuilder: () => ImagePromptBuilder,
+  PromptBuilder: () => PromptBuilder,
+  VideoPromptBuilder: () => VideoPromptBuilder,
+  audio: () => audio,
+  builder: () => builder,
+  chat: () => chat,
+  chatPresets: () => chatPresets,
+  fromPrompt: () => fromPrompt,
+  image: () => image,
+  templates: () => templates,
+  video: () => video
+});
+module.exports = __toCommonJS(builder_exports);
+
+// 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"
+    ]);
+  }
+};
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  AudioPromptBuilder,
+  ChatPromptBuilder,
+  ImagePromptBuilder,
+  PromptBuilder,
+  VideoPromptBuilder,
+  audio,
+  builder,
+  chat,
+  chatPresets,
+  fromPrompt,
+  image,
+  templates,
+  video
+});
+//# sourceMappingURL=index.js.map