@algorisys/yappydraw 0.8.253

package/chunks/ai-providers-CycU8sO1.js

@@ -0,0 +1,229 @@
+const d = {
+  openai: [
+    { id: "gpt-image-1", label: "GPT Image 1 (best; needs verified org)" },
+    { id: "dall-e-3", label: "DALL·E 3" }
+  ],
+  gemini: [],
+  anthropic: []
+}, l = "yappy:ai:config";
+function g(e) {
+  try {
+    return atob(e);
+  } catch {
+    return e;
+  }
+}
+function m() {
+  return {
+    activeProvider: "openai",
+    providers: {
+      openai: { apiKey: "", model: "gpt-4o", imageModel: "gpt-image-1", enabled: !0 },
+      gemini: { apiKey: "", model: "gemini-2.0-flash", enabled: !0 },
+      anthropic: { apiKey: "", model: "claude-sonnet-4-5-20250929", enabled: !0 }
+    }
+  };
+}
+function i() {
+  try {
+    const e = localStorage.getItem(l);
+    if (e) {
+      const n = JSON.parse(e), o = m();
+      return {
+        activeProvider: n.activeProvider || o.activeProvider,
+        providers: {
+          openai: { ...o.providers.openai, ...n.providers?.openai },
+          gemini: { ...o.providers.gemini, ...n.providers?.gemini },
+          anthropic: { ...o.providers.anthropic, ...n.providers?.anthropic }
+        }
+      };
+    }
+  } catch {
+  }
+  return m();
+}
+function y(e) {
+  const o = i().providers[e]?.apiKey || "";
+  return o ? g(o) : "";
+}
+function v() {
+  const e = i();
+  return Object.values(e.providers).some((n) => n.apiKey !== "");
+}
+function T(e) {
+  return i().providers[e]?.imageModel || d[e][0]?.id;
+}
+function b() {
+  const e = i(), n = e.activeProvider;
+  return {
+    provider: n,
+    model: e.providers[n].model,
+    apiKey: y(n)
+  };
+}
+async function P(e) {
+  switch (e.provider) {
+    case "openai":
+      return f(e);
+    case "gemini":
+      return h(e);
+    case "anthropic":
+      return k(e);
+    default:
+      return { success: !1, content: "", error: `Unknown provider: ${e.provider}` };
+  }
+}
+async function f(e) {
+  const n = "https://api.openai.com/v1/chat/completions", o = e.images?.length ? [
+    ...e.images.map((t) => ({
+      type: "image_url",
+      image_url: { url: `data:${t.mediaType};base64,${t.base64}`, detail: "high" }
+    })),
+    { type: "text", text: e.userPrompt }
+  ] : e.userPrompt, a = {
+    model: e.model,
+    messages: [
+      { role: "system", content: e.systemPrompt },
+      { role: "user", content: o }
+    ],
+    temperature: e.temperature ?? 0.3,
+    max_tokens: e.maxTokens ?? 4096
+  };
+  try {
+    const t = await fetch(n, {
+      method: "POST",
+      headers: {
+        "Content-Type": "application/json",
+        Authorization: `Bearer ${e.apiKey}`
+      },
+      body: JSON.stringify(a)
+    });
+    if (!t.ok) {
+      const r = await t.text().catch(() => "");
+      return { success: !1, content: "", error: c("OpenAI", t.status, r) };
+    }
+    const s = await t.json();
+    return {
+      success: !0,
+      content: s.choices?.[0]?.message?.content || "",
+      usage: s.usage ? {
+        promptTokens: s.usage.prompt_tokens,
+        completionTokens: s.usage.completion_tokens
+      } : void 0
+    };
+  } catch (t) {
+    return { success: !1, content: "", error: p("OpenAI", t) };
+  }
+}
+async function h(e) {
+  const n = `https://generativelanguage.googleapis.com/v1beta/models/${e.model}:generateContent?key=${e.apiKey}`, o = [];
+  if (e.images?.length)
+    for (const t of e.images)
+      o.push({ inlineData: { mimeType: t.mediaType, data: t.base64 } });
+  o.push({ text: e.userPrompt });
+  const a = {
+    systemInstruction: { parts: [{ text: e.systemPrompt }] },
+    contents: [{ parts: o }],
+    generationConfig: {
+      temperature: e.temperature ?? 0.3,
+      maxOutputTokens: e.maxTokens ?? 4096
+    }
+  };
+  try {
+    const t = await fetch(n, {
+      method: "POST",
+      headers: { "Content-Type": "application/json" },
+      body: JSON.stringify(a)
+    });
+    if (!t.ok) {
+      const r = await t.text().catch(() => "");
+      return { success: !1, content: "", error: c("Gemini", t.status, r) };
+    }
+    const s = await t.json();
+    return {
+      success: !0,
+      content: s.candidates?.[0]?.content?.parts?.[0]?.text || "",
+      usage: s.usageMetadata ? {
+        promptTokens: s.usageMetadata.promptTokenCount || 0,
+        completionTokens: s.usageMetadata.candidatesTokenCount || 0
+      } : void 0
+    };
+  } catch (t) {
+    return { success: !1, content: "", error: p("Gemini", t) };
+  }
+}
+async function k(e) {
+  const n = "https://api.anthropic.com/v1/messages", o = e.images?.length ? [
+    ...e.images.map((t) => ({
+      type: "image",
+      source: { type: "base64", media_type: t.mediaType, data: t.base64 }
+    })),
+    { type: "text", text: e.userPrompt }
+  ] : e.userPrompt, a = {
+    model: e.model,
+    system: e.systemPrompt,
+    messages: [{ role: "user", content: o }],
+    max_tokens: e.maxTokens ?? 4096,
+    temperature: e.temperature ?? 0.3
+  };
+  try {
+    const t = await fetch(n, {
+      method: "POST",
+      headers: {
+        "Content-Type": "application/json",
+        "x-api-key": e.apiKey,
+        "anthropic-version": "2023-06-01",
+        "anthropic-dangerous-direct-browser-access": "true"
+      },
+      body: JSON.stringify(a)
+    });
+    if (!t.ok) {
+      const r = await t.text().catch(() => "");
+      return { success: !1, content: "", error: c("Anthropic", t.status, r) };
+    }
+    const s = await t.json();
+    return {
+      success: !0,
+      content: s.content?.[0]?.text || "",
+      usage: s.usage ? {
+        promptTokens: s.usage.input_tokens,
+        completionTokens: s.usage.output_tokens
+      } : void 0
+    };
+  } catch (t) {
+    return { success: !1, content: "", error: p("Anthropic", t) };
+  }
+}
+function c(e, n, o) {
+  let a = "";
+  try {
+    const t = JSON.parse(o);
+    a = t.error?.message || t.error?.status || t.message || "";
+  } catch {
+    a = o.slice(0, 200);
+  }
+  switch (n) {
+    case 401:
+      return `Invalid API key for ${e}. Check your key in AI Settings.`;
+    case 403:
+      return `Access denied by ${e}. ${a || "Check API key permissions."}`;
+    case 429:
+      return `Rate limited by ${e}. Please wait a moment and try again.`;
+    case 500:
+    case 502:
+    case 503:
+      return `${e} server error (${n}). Please try again later.`;
+    default:
+      return `${e} error ${n}: ${a || "Unknown error"}`;
+  }
+}
+function p(e, n) {
+  return n.name === "TypeError" && n.message?.includes("fetch") ? `Network error: unable to reach ${e} API. Check your internet connection.` : n.message?.includes("CORS") || n.message?.includes("cors") ? `CORS error calling ${e}. This provider may not support direct browser calls.` : `Network error calling ${e}: ${n.message || "Unknown error"}`;
+}
+export {
+  T as a,
+  b,
+  P as c,
+  y as g,
+  v as h,
+  i as l
+};

package/chunks/canva-ai-BREIRXSl.js

@@ -0,0 +1,285 @@
+import { g as w, a as P, b as E, c as T } from "./ai-providers-CycU8sO1.js";
+import { s as u, b as r, p as y, u as b, Z as B, f as v, g as j } from "./index-Bm3Inzn8.js";
+const z = {
+  rewrite: "Rewrite this text to be clearer and more engaging while keeping its meaning and rough length.",
+  shorten: "Shorten this text to roughly half its length while keeping the key message.",
+  expand: "Expand this text with one or two extra sentences of relevant detail.",
+  fix: "Fix any spelling and grammar mistakes. Change nothing else."
+};
+async function C(p, s = "rewrite", i) {
+  const { provider: e, model: t, apiKey: a } = E();
+  if (!a)
+    return r("Add an API key in AI Settings first", "error"), 0;
+  const n = p.map((g) => u.elements.find((d) => d.id === g)).filter((g) => !!g && g.type === "text" && !!(g.text || "").trim());
+  if (n.length === 0)
+    return r("Select a text element first", "info"), 0;
+  const o = s === "custom" ? i || "Improve this text." : z[s];
+  r("Magic Write…", "loading");
+  let l = 0, c = !1;
+  for (const g of n) {
+    const d = await T({
+      provider: e,
+      model: t,
+      apiKey: a,
+      systemPrompt: "You are a copywriter working inside a graphic design tool. Reply with ONLY the final text — no quotes, no markdown, no explanations. Preserve intentional line breaks.",
+      userPrompt: `${o}
+
+Text:
+${g.text}`,
+      temperature: 0.7,
+      maxTokens: 1024
+    });
+    if (d.success && d.content.trim())
+      l === 0 && y(), b(g.id, { text: d.content.trim() }), l++;
+    else if (!d.success) {
+      r(d.error || "Magic Write failed", "error"), c = !0;
+      break;
+    }
+  }
+  return l > 0 ? r(`Magic Write updated ${l} text element${l === 1 ? "" : "s"}`, "success") : c || B(), l;
+}
+async function S(p, s, i) {
+  const e = w("openai");
+  if (!e) return { dataURL: null, error: "Add an OpenAI API key in AI Settings first" };
+  try {
+    const t = { model: i, prompt: p, n: 1, size: s };
+    i.startsWith("dall-e") && (t.response_format = "b64_json");
+    const a = await fetch("https://api.openai.com/v1/images/generations", {
+      method: "POST",
+      headers: { "Content-Type": "application/json", Authorization: `Bearer ${e}` },
+      body: JSON.stringify(t)
+    });
+    if (!a.ok) {
+      const c = await a.text().catch(() => "");
+      let g = "";
+      try {
+        g = JSON.parse(c).error?.message || "";
+      } catch {
+        g = c.slice(0, 200);
+      }
+      return { dataURL: null, error: `OpenAI image error ${a.status}: ${g}` };
+    }
+    const n = await a.json(), o = n.data?.[0]?.b64_json;
+    if (o) return { dataURL: `data:image/png;base64,${o}` };
+    const l = n.data?.[0]?.url;
+    if (l) {
+      const g = await (await fetch(l)).blob();
+      return { dataURL: await new Promise((m, I) => {
+        const h = new FileReader();
+        h.onload = () => m(String(h.result)), h.onerror = I, h.readAsDataURL(g);
+      }) };
+    }
+    return { dataURL: null, error: "OpenAI returned no image data" };
+  } catch (t) {
+    return { dataURL: null, error: `Network error calling OpenAI Images: ${t?.message || t}` };
+  }
+}
+function D(p, s, i, e) {
+  const t = u.slides[u.activeSlideIndex], a = t ? t.dimensions.width * 0.6 : 512, n = Math.min(1, a / s), o = Math.round(s * n), l = Math.round(i * n), c = t ? t.spatialPosition.x + (t.dimensions.width - o) / 2 : 120, g = t ? t.spatialPosition.y + (t.dimensions.height - l) / 2 : 120, d = {
+    id: `image-${Date.now()}-${Math.floor(Math.random() * 1e6)}`,
+    type: "image",
+    x: c,
+    y: g,
+    width: o,
+    height: l,
+    dataURL: p,
+    status: "loaded",
+    backgroundColor: "transparent",
+    fillStyle: "solid",
+    strokeColor: "transparent",
+    strokeWidth: 0,
+    strokeStyle: "solid",
+    opacity: 100,
+    angle: 0,
+    roughness: 0,
+    renderStyle: "architectural",
+    locked: !1,
+    link: null,
+    layerId: u.activeLayerId || "default-layer",
+    seed: Math.floor(Math.random() * 2 ** 31),
+    roundness: null
+  };
+  return y(), v("elements", (m) => [...m, d]), v("selection", [d.id]), j(), r(`${e} added`, "success"), d.id;
+}
+async function K(p, s = {}) {
+  const i = s.size || "1024x1024", e = P("openai"), t = i === "1536x1024" ? "1792x1024" : i === "1024x1536" ? "1024x1792" : "1024x1024";
+  r("Generating image…", "loading");
+  let a = await S(p, e.startsWith("dall-e") ? t : i, e);
+  if (!a.dataURL && e !== "dall-e-3") {
+    const l = await S(p, t, "dall-e-3");
+    l.dataURL && (a = l);
+  }
+  if (!a.dataURL)
+    return r(a.error || "Image generation failed", "error"), null;
+  const [n, o] = i.split("x").map(Number);
+  return D(a.dataURL, n || 1024, o || 1024, "AI image");
+}
+const k = (p) => new Promise((s, i) => {
+  const e = new Image();
+  e.onload = () => s(e), e.onerror = i, e.src = p;
+});
+async function F(p, s) {
+  try {
+    const [i, e] = await Promise.all([k(p), k(s)]), t = document.createElement("canvas");
+    t.width = i.naturalWidth, t.height = i.naturalHeight;
+    const a = t.getContext("2d");
+    if (!a) return null;
+    a.drawImage(i, 0, 0), a.globalCompositeOperation = "destination-in", a.drawImage(e, 0, 0, t.width, t.height);
+    const n = a.getImageData(0, 0, t.width, t.height).data, o = n.length / 4, l = 4 * Math.max(1, Math.floor(o / 1e3));
+    let c = 0, g = 0;
+    for (let d = 3; d < n.length; d += l)
+      n[d] < 16 ? c++ : g++;
+    return c === 0 || g === 0 ? null : t.toDataURL("image/png");
+  } catch {
+    return null;
+  }
+}
+async function x(p, s) {
+  try {
+    const i = await fetch("https://api.openai.com/v1/images/edits", {
+      method: "POST",
+      headers: { Authorization: `Bearer ${s}` },
+      body: p
+    });
+    if (!i.ok) {
+      const a = await i.text().catch(() => "");
+      let n = "";
+      try {
+        n = JSON.parse(a).error?.message || "";
+      } catch {
+        n = a.slice(0, 200);
+      }
+      return { b64: null, error: `OpenAI image edit error ${i.status}: ${n}` };
+    }
+    const t = (await i.json()).data?.[0]?.b64_json;
+    return t ? { b64: t } : { b64: null, error: "OpenAI returned no image data" };
+  } catch (i) {
+    return { b64: null, error: `Network error calling OpenAI Images: ${i?.message || i}` };
+  }
+}
+async function W(p, s) {
+  const i = p || u.selection[0], e = u.elements.find((c) => c.id === i);
+  if (!e || e.type !== "image" || !e.dataURL)
+    return r("Select an image element first", "info"), !1;
+  if (!s?.trim())
+    return r("Describe the change first", "info"), !1;
+  const t = w("openai");
+  if (!t)
+    return r("Add an OpenAI API key in AI Settings first", "error"), !1;
+  r("Magic Edit…", "loading");
+  const a = await (await fetch(e.dataURL)).blob(), n = new FormData();
+  n.append("model", "gpt-image-1"), n.append("image", new File([a], "image.png", { type: a.type || "image/png" })), n.append(
+    "prompt",
+    `${s.trim()}. Apply ONLY this change — keep everything else in the image pixel-identical to the input: same composition, colors, style, and framing.`
+  ), n.append("size", "auto");
+  const { b64: o, error: l } = await x(n, t);
+  return o ? (y(), b(e.id, { dataURL: `data:image/png;base64,${o}` }), r("Magic Edit applied", "success"), !0) : (r(l || "Magic Edit failed", "error"), !1);
+}
+async function J(p, s) {
+  const i = p || u.selection[0], e = u.elements.find((c) => c.id === i);
+  if (!e || e.type !== "image" || !e.dataURL)
+    return r("Select an image element first", "info"), !1;
+  if (!s?.trim())
+    return r("Describe the new background first", "info"), !1;
+  const t = w("openai");
+  if (!t)
+    return r("Add an OpenAI API key in AI Settings first", "error"), !1;
+  r("Replacing background…", "loading");
+  const a = await (await fetch(e.dataURL)).blob(), n = new FormData();
+  n.append("model", "gpt-image-1"), n.append("image", new File([a], "image.png", { type: a.type || "image/png" })), n.append(
+    "prompt",
+    `Replace the background behind the main foreground subject with: ${s.trim()}. Keep the foreground subject pixel-identical to the input — do not restyle, repaint, recolor, move, crop, or resize it. Change ONLY the background, blending the new background naturally with realistic lighting and edges around the subject.`
+  ), n.append("size", "auto"), n.append("input_fidelity", "high");
+  let { b64: o, error: l } = await x(n, t);
+  return !o && l?.includes("input_fidelity") && (n.delete("input_fidelity"), { b64: o, error: l } = await x(n, t)), o ? (y(), b(e.id, { dataURL: `data:image/png;base64,${o}` }), r("Background replaced", "success"), !0) : (r(l || "Replace Background failed", "error"), !1);
+}
+async function Y(p, s = {}) {
+  const i = p || u.selection[0], e = u.elements.find((c) => c.id === i);
+  if (!e || e.type !== "image" || !e.dataURL)
+    return r("Select an image element first", "info"), !1;
+  const t = w("openai");
+  if (!t)
+    return r("Add an OpenAI API key in AI Settings first", "error"), !1;
+  const a = Math.max(0, s.left ?? 0.25), n = Math.max(0, s.right ?? 0.25), o = Math.max(0, s.top ?? 0.25), l = Math.max(0, s.bottom ?? 0.25);
+  if (a + n + o + l === 0) return !1;
+  r("Magic Expand…", "loading");
+  try {
+    const c = await k(e.dataURL), g = c.naturalWidth, d = c.naturalHeight, m = Math.round(g * (1 + a + n)), I = Math.round(d * (1 + o + l)), h = document.createElement("canvas");
+    h.width = m, h.height = I;
+    const A = h.getContext("2d");
+    if (!A)
+      return r("Magic Expand failed: no canvas context", "error"), !1;
+    A.drawImage(c, Math.round(g * a), Math.round(d * o));
+    const R = await new Promise((U, O) => h.toBlob((M) => M ? U(M) : O(new Error("canvas.toBlob failed")), "image/png")), f = new FormData();
+    f.append("model", "gpt-image-1"), f.append("image", new File([R], "image.png", { type: "image/png" })), f.append("mask", new File([R], "mask.png", { type: "image/png" })), f.append(
+      "prompt",
+      (s.prompt?.trim() ? `${s.prompt.trim()}. ` : "") + "Extend the existing image seamlessly into the transparent areas, continuing its scene, lighting, style, and perspective. Keep the original (non-transparent) pixels unchanged."
+    ), f.append("size", "auto");
+    const { b64: L, error: $ } = await x(f, t);
+    return L ? (y(), b(e.id, {
+      dataURL: `data:image/png;base64,${L}`,
+      x: e.x - e.width * a,
+      y: e.y - e.height * o,
+      width: e.width * (1 + a + n),
+      height: e.height * (1 + o + l)
+    }), r("Magic Expand applied", "success"), !0) : (r($ || "Magic Expand failed", "error"), !1);
+  } catch (c) {
+    return r(`Magic Expand failed: ${c?.message || c}`, "error"), !1;
+  }
+}
+async function H(p, s = {}) {
+  const i = p || u.selection[0], e = u.elements.find((a) => a.id === i);
+  if (!e || e.type !== "image" || !e.dataURL)
+    return r("Select an image element first", "info"), !1;
+  const t = w("openai");
+  if (!t)
+    return r("Add an OpenAI API key in AI Settings first", "error"), !1;
+  r("Removing background…", "loading");
+  try {
+    const a = await (await fetch(e.dataURL)).blob(), n = (d) => {
+      const m = new FormData();
+      return m.append("model", "gpt-image-1"), m.append("image", new File([a], "image.png", { type: a.type || "image/png" })), m.append(
+        "prompt",
+        "Remove the background completely so it is fully transparent. Keep the foreground subject pixel-identical to the input — do not restyle, repaint, recolor, sharpen, or add any effects, glow, outlines, or shadows. Do not move, crop, or resize the subject."
+      ), m.append("background", "transparent"), m.append("size", "auto"), d && m.append("input_fidelity", "high"), m;
+    };
+    let o = await fetch("https://api.openai.com/v1/images/edits", {
+      method: "POST",
+      headers: { Authorization: `Bearer ${t}` },
+      body: n(!0)
+    });
+    if (o.status === 400 && (await o.clone().text().catch(() => "")).includes("input_fidelity") && (o = await fetch("https://api.openai.com/v1/images/edits", {
+      method: "POST",
+      headers: { Authorization: `Bearer ${t}` },
+      body: n(!1)
+    })), !o.ok) {
+      const d = await o.text().catch(() => "");
+      let m = "";
+      try {
+        m = JSON.parse(d).error?.message || "";
+      } catch {
+        m = d.slice(0, 200);
+      }
+      return r(`Background removal failed (${o.status}): ${m}`, "error"), !1;
+    }
+    const c = (await o.json()).data?.[0]?.b64_json;
+    if (!c)
+      return r("Background removal returned no image", "error"), !1;
+    let g = `data:image/png;base64,${c}`;
+    if (s.preserveOriginal !== !1) {
+      const d = await F(e.dataURL, g);
+      d && (g = d);
+    }
+    return y(), b(e.id, { dataURL: g }), r("Background removed", "success"), !0;
+  } catch (a) {
+    return r(`Background removal failed: ${a?.message || a}`, "error"), !1;
+  }
+}
+export {
+  Y as expandImage,
+  K as generateImage,
+  W as magicEditImage,
+  C as magicWrite,
+  H as removeBackground,
+  J as replaceBackground
+};

package/chunks/design-generator-C89SKTqv.js

@@ -0,0 +1,149 @@
+import { b as x, c as S } from "./ai-providers-CycU8sO1.js";
+import { b as u, _ as A, s as C, f as y, z as M, g as D } from "./index-Bm3Inzn8.js";
+const P = 'You are a senior graphic designer. Reply with ONLY a JSON object, no markdown fences, matching exactly: {"headline": string (max 6 words), "subhead": string (max 12 words), "bullets": string[] (0-4 short items), "cta": string (max 5 words, optional), "palette": {"background": hex, "primary": hex, "accent": hex, "text": hex}}. The palette must be harmonious with strong text/background contrast.';
+function $(r) {
+  try {
+    const e = r.trim().replace(/^```(?:json)?\s*/i, "").replace(/\s*```$/, ""), n = JSON.parse(e);
+    return !n?.headline || !n?.palette?.background ? null : n;
+  } catch {
+    return null;
+  }
+}
+let T = 0;
+const k = (r) => `${r}-${Date.now()}-${++T}`, p = {
+  roughness: 0,
+  angle: 0,
+  renderStyle: "architectural",
+  locked: !1,
+  link: null,
+  layerId: "default-layer",
+  strokeStyle: "solid",
+  opacity: 100,
+  roundness: null,
+  seed: () => Math.floor(Math.random() * 2 ** 31)
+}, f = (r, e, n, t, o, s, i, a = {}) => ({
+  id: k("text"),
+  type: "text",
+  x: e,
+  y: n,
+  width: t,
+  height: o,
+  text: r,
+  fontSize: s,
+  fontFamily: "poppins",
+  textAlign: "center",
+  verticalAlign: "top",
+  textColor: i,
+  strokeColor: "transparent",
+  backgroundColor: "transparent",
+  fillStyle: "solid",
+  strokeWidth: 0,
+  ...p,
+  seed: p.seed(),
+  ...a
+}), m = (r, e, n, t, o = {}) => ({
+  id: k("rect"),
+  type: "rectangle",
+  x: r,
+  y: e,
+  width: n,
+  height: t,
+  strokeColor: "transparent",
+  backgroundColor: "#ffffff",
+  fillStyle: "solid",
+  strokeWidth: 0,
+  ...p,
+  seed: p.seed(),
+  ...o
+});
+function v(r, e, n, t, o) {
+  const s = r.palette, i = Math.min(t, o), a = [];
+  a.push(m(e, n, t, o, {
+    backgroundColor: s.background,
+    fillStyle: "linear",
+    gradientStops: [
+      { color: s.background, offset: 0 },
+      { color: s.primary, offset: 1 }
+    ],
+    gradientDirection: 135
+  }));
+  const g = t * 0.14;
+  a.push(m(e + (t - g) / 2, n + o * 0.14, g, i * 0.012, { backgroundColor: s.accent })), a.push(f(
+    r.headline,
+    e + t * 0.08,
+    n + o * 0.18,
+    t * 0.84,
+    o * 0.2,
+    Math.round(i * 0.085),
+    s.text,
+    { fontWeight: "bold" }
+  ));
+  let c = n + o * 0.4;
+  r.subhead && (a.push(f(
+    r.subhead,
+    e + t * 0.1,
+    c,
+    t * 0.8,
+    o * 0.1,
+    Math.round(i * 0.04),
+    s.text,
+    { opacity: 88 }
+  )), c += o * 0.13);
+  const h = (r.bullets || []).slice(0, 4);
+  if (h.length > 0 && a.push(f(
+    h.map((l) => `•  ${l}`).join(`
+`),
+    e + t * 0.12,
+    c,
+    t * 0.76,
+    o * 0.28,
+    Math.round(i * 0.032),
+    s.text,
+    { textAlign: "left", opacity: 92 }
+  )), r.cta) {
+    const l = t * 0.44, d = i * 0.085, b = n + o * 0.86 - d / 2;
+    a.push(m(e + (t - l) / 2, b, l, d, {
+      backgroundColor: s.accent,
+      borderRadius: d / 2
+    })), a.push(f(
+      r.cta,
+      e + (t - l) / 2,
+      b + d * 0.22,
+      l,
+      d * 0.6,
+      Math.round(i * 0.032),
+      s.background,
+      { fontWeight: "bold", verticalAlign: "middle" }
+    ));
+  }
+  return a;
+}
+async function Y(r, e = { width: 1080, height: 1080 }) {
+  const { provider: n, model: t, apiKey: o } = x();
+  if (!o)
+    return u("Add an API key in AI Settings first", "error"), !1;
+  if (!r.trim()) return !1;
+  u("Generating design…", "info");
+  const s = await S({
+    provider: n,
+    model: t,
+    apiKey: o,
+    systemPrompt: P,
+    userPrompt: `Design brief: ${r.trim()}
+Format: ${e.width}×${e.height}px.`,
+    temperature: 0.8,
+    maxTokens: 800
+  });
+  if (!s.success)
+    return u(s.error || "Design generation failed", "error"), !1;
+  const i = $(s.content);
+  if (!i)
+    return u("The AI returned an unusable design — try again", "error"), !1;
+  A("design", e);
+  const a = C.slides[0], g = a?.spatialPosition.x ?? 0, c = a?.spatialPosition.y ?? 0, h = v(i, g, c, e.width, e.height);
+  return y("elements", h), y("selection", []), M(), D(), u("Design generated — edit away", "success"), !0;
+}
+export {
+  v as buildDesignElements,
+  Y as generateDesign
+};