adyou 0.6.16 → 0.6.18

package/dist/core/creatives/linebreak.d.ts

@@ -0,0 +1,28 @@
+type FontRec = {
+    name: string;
+    data: ArrayBuffer;
+    weight: number;
+};
+/** 글꼴 등록 — render.loadFonts 가 satori 에 넘기는 목록을 그대로 넣는다(파싱은 첫 측정 때 굵기별로 게으르게) */
+export declare function registerFonts(list: FontRec[]): void;
+/** 어림 폭(글꼴이 없을 때만 · Pretendard 실측): 한글·전각 0.86em · 숫자·라틴 0.55em · 공백 0.3em */
+export declare const estimateW: (t: string, fs: number) => number;
+/** 실제 글꼴 폭 — 굵기가 같은 글꼴을 등록 순서(Pretendard → JP → CJK → Thai)로 훑어 글리프가 있는 첫 글꼴의 advance 를 더한다(satori 폴백과 같은 순서). letterSpacing 은 satori 처럼 (글자 수−1)배 */
+export declare function measureText(t: string, fs: number, o?: {
+    weight?: number;
+    letterSpacing?: number;
+}): number;
+export declare function hasMeasureFonts(): boolean;
+/** 어절 토큰화 + 한 글자 한글 어절 결속 — 「한 번」「안 팔아요」「수 있어요」「이 동네」는 한 덩어리 */
+export declare function tokenize(text: string): string[];
+/** 어절 i 뒤에서 끊는 비용(음수=좋은 자리) — i 는 앞 줄의 마지막 어절, next 는 다음 줄의 첫 어절 */
+export declare function breakCost(prev: string, next: string): number;
+export type BreakOpts = {
+    maxLines?: number;
+    weight?: number;
+    letterSpacing?: number; /** 폭 안전 여백(기본 2% · 글꼴 셰이핑 오차) */
+    margin?: number;
+};
+/** 줄나눔 — 한 줄에 들어가면 그대로 · 아니면 줄 수를 2부터 늘려가며 모든 어절 경계 조합 중 비용 최소(결속 규칙 + 줄 균형 + 고아 벌점)를 고른다. 어떤 조합도 폭 안에 못 들어가면(한 어절이 줄보다 김) 뒤에서부터 채운 줄을 돌려주고 linesEl 이 글자를 줄인다. */
+export declare function breakLines(text: string, fs: number, maxW: number, o?: BreakOpts | number): string[];
+export {};

package/dist/core/creatives/linebreak.js

@@ -0,0 +1,315 @@
+// 헤드라인·훅·자막 줄나눔 — 「오늘의 입술, / 틴트 한 번」·「나에게 맞는 / 컬러 찾기」처럼 읽기 자연스러운 어절 경계에서만 줄을 바꾼다(2026-09-18 사장님 · 티르티르 영상 엔드카드 「틴트 / 한 번」·「컬러 / 찾기」).
+// 왜 규칙인가: LLM 은 비용·지연·재현성이 나쁘고, 한국어 헤드라인(≤30자·어절 ≤12개)은 전 조합을 다 재봐도 수백 가지라 규칙+비용 최소 탐색으로 충분하다.
+// 두 층으로 지킨다 — ① 폭은 실제 글꼴 글리프 폭(opentype · satori 와 같은 계산)으로 잰다(어림 폭이 틀려 satori 가 임의 자리에서 접던 구멍을 막음) ② 고른 줄은 nowrap 행으로 그려 렌더러가 다시 접을 수 없게 한다(render.ts linesEl).
+import { parse as parseFont } from '@shuding/opentype.js';
+import { wlen } from './specs.js';
+const registered = [];
+const parsed = new Map();
+/** 글꼴 등록 — render.loadFonts 가 satori 에 넘기는 목록을 그대로 넣는다(파싱은 첫 측정 때 굵기별로 게으르게) */
+export function registerFonts(list) { for (const f of list)
+    if (!registered.some((r) => r.name === f.name && r.weight === f.weight))
+        registered.push(f); }
+function fontOf(rec) {
+    if (parsed.has(rec))
+        return parsed.get(rec);
+    let f = null;
+    try {
+        f = parseFont(rec.data);
+    }
+    catch {
+        f = null;
+    }
+    parsed.set(rec, f);
+    return f;
+}
+/** 어림 폭(글꼴이 없을 때만 · Pretendard 실측): 한글·전각 0.86em · 숫자·라틴 0.55em · 공백 0.3em */
+export const estimateW = (t, fs) => [...t].reduce((n, ch) => n + (ch === ' ' ? 0.3 : (ch.codePointAt(0) || 0) > 0x2e7f ? 0.86 : 0.55), 0) * fs;
+/** 실제 글꼴 폭 — 굵기가 같은 글꼴을 등록 순서(Pretendard → JP → CJK → Thai)로 훑어 글리프가 있는 첫 글꼴의 advance 를 더한다(satori 폴백과 같은 순서). letterSpacing 은 satori 처럼 (글자 수−1)배 */
+export function measureText(t, fs, o = {}) {
+    const weight = o.weight ?? 800;
+    const ls = o.letterSpacing ?? 0;
+    const chars = [...t];
+    if (!chars.length)
+        return 0;
+    const pool = registered.filter((r) => r.weight === weight);
+    const fonts = (pool.length ? pool : registered.filter((r) => r.weight === nearestWeight(weight))).map(fontOf).filter((f) => !!f);
+    if (!fonts.length)
+        return estimateW(t, fs) + ls * (chars.length - 1);
+    let w = 0;
+    for (const ch of chars) {
+        let done = false;
+        for (const f of fonts) {
+            const gi = f.charToGlyphIndex(ch);
+            if (gi > 0) {
+                w += ((f.glyphs.get(gi).advanceWidth ?? f.unitsPerEm * 0.5) / f.unitsPerEm) * fs;
+                done = true;
+                break;
+            }
+        }
+        if (!done)
+            w += (ch === ' ' ? 0.3 : 0.86) * fs;
+    }
+    return w + ls * (chars.length - 1);
+}
+function nearestWeight(w) { const ws = [...new Set(registered.map((r) => r.weight))]; return ws.sort((a, b) => Math.abs(a - w) - Math.abs(b - w))[0] ?? w; }
+export function hasMeasureFonts() { return registered.length > 0; }
+// ── 한국어 결속 규칙 ────────────────────────────────────────────────────────────
+/** 앞 어절에 붙어야 하는 어절(의존명사·후치사류) — 「색조 / 때문에」 금지 */
+const KO_GLUE_PREV = new Set(['때문에', '때문이죠', '때문이에요', '때문입니다', '덕분에', '대신', '만큼', '정도', '이상', '이하', '미만', '이내', '동안', '사이', '이후', '이전', '전에', '후에', '위해', '위한', '통해', '대해', '대한', '관해', '관한', '따라', '처럼', '같이', '같은', '만에', '밖에', '뿐', '채', '척', '듯', '중', '등', '및', '또는', '혹은']);
+/** 뒤 어절에 붙어야 하는 어절(관형사·부정/정도 부사) — 「이런 / 컬러」·「안 / 팔아요」 금지 */
+const KO_GLUE_NEXT_STRONG = new Set(['이런', '그런', '저런', '어떤', '무슨', '모든', '여러', '다른', '각', '매', '약', '총', '무려', '단', '오직', '바로', '이', '그', '저', '새', '첫', '헌', '옛', '온', '안', '못', '한', '두', '세', '네', '몇', '여섯', '일곱', '여덟', '아홉', '열', '스무']);
+const KO_GLUE_NEXT_WEAK = new Set(['더', '덜', '잘', '꼭', '딱', '아주', '매우', '정말', '진짜', '너무', '가장', '제일', '다시', '아직', '이미', '늘', '항상', '함께', '같이', '직접', '먼저', '왜', '어떻게', '뭐부터', '뭘']);
+/** 절이 끝나는 연결어미 — 뒤에서 끊기 좋음(「컬러 못 골라서 / 3분째 고민」) */
+// 🔴 「고·서·면·자」 한 글자 어미는 광고·순서·라면·사용자 같은 명사와 겹쳐 쓰지 않는다
+const KO_CLAUSE_END = /(지만|는데|인데|니까|라서|려고|도록|다가|든지|거나|라면|다면|더니|어서|아서|해서|면서|으면|이면|하고|이고|하며|이며|하면|더라도)$/;
+/** 부사격·보조사로 끝나는 어절 — 뒤에서 끊기 좋음(「항공부터 / 렌터카까지 / 한 곳에서」) */
+const KO_ADVERBIAL_END = /(부터|까지|에서|에게|께|으로|로|처럼|보다|마다|조차|마저|밖에|에는|엔|에도|로도|으로도|에서도|께서|한테|더러|에서는)$/;
+/** 주제·주격·목적격·관형형 등 — 약한 우선 */
+const KO_MARKER_END = /(은|는|이|가|을|를|도|만|던)$/;
+/** 소유격 「의」 뒤 끊기 억제(「오늘의 / 입술」) — 강의·회의·문의처럼 「의」로 끝나는 명사는 제외 */
+const KO_GENITIVE_END = /[가-힣]의$/;
+const KO_UI_NOUNS = new Set(['강의', '회의', '문의', '정의', '주의', '의의', '편의', '호의', '심의', '논의', '합의', '동의', '상의', '토의', '협의', '예의', '유의', '용의', '결의', '건의', '의']);
+const EN_NO_END = new Set(['the', 'a', 'an', 'of', 'to', 'in', 'on', 'for', 'with', 'and', 'or', 'but', 'your', 'our', 'my', 'its', 'their', 'not', 'just', 'at', 'by', 'from', 'into', 'is', 'are', 'be', 'that', 'this', 'very', 'so', 'you\'re', 'we\'re']);
+const EN_NO_START = new Set(['too', 'either', 'yet']);
+const isHangul = (s) => /[가-힣]/.test(s);
+/** 부사격 조사로 끝나는 어절(장소·시간·수단·출발점) — 뒤의 짧은 관형형 용언을 꾸민다(「아침에 딴」·「마트에서 산」·「손으로 빚은」) · 「에」 하나짜리도 포함(일반 끊기 보너스엔 안 씀) */
+const KO_ADVERB_FOR_MODIFIER = /[가-힣](에|에서|로|으로|부터|께|에게|한테|와|과|서|처럼|같이|보다)$/;
+/** 자주 쓰는 2음절 관형형 용언(광고 문구) — 명사와 겹치지 않는 것만 */
+const KO_MODIFIER_2 = new Set(['구운', '만든', '고른', '담은', '키운', '빚은', '캐낸', '뽑은', '볶은', '우린', '지은', '튀긴', '삶은', '말린', '재운', '절인', '쪄낸', '끓인', '내린', '갈아낸', '짜낸', '따낸', '건진', '골라낸', '추린', '모은', '익힌', '갓난', '길러낸', '빻은', '깎은', '썰은', '다진', '무친', '데친', '졸인', '지진', '부친', '섞은', '띄운', '숙성한', '엄선한', '수확한', '재배한', '직접', '갓']);
+/** 짧은 관형형 용언인가 — 1음절은 받침 ㄴ·ㄹ(딴·산·쓴·든·본·준·큰·낼·쓸 …)이고 관형사·수사·부사 결속 표에 없는 것 · 2음절은 표에 있는 것 */
+function isShortModifier(w) {
+    const chars = [...w.replace(/[^가-힣]/g, '')];
+    if (!chars.length || chars.length !== [...w].length)
+        return false;
+    if (chars.length === 1) {
+        if (KO_GLUE_NEXT_STRONG.has(w) || KO_GLUE_NEXT_WEAK.has(w))
+            return false;
+        const fin = (w.codePointAt(0) - 0xac00) % 28;
+        return fin === 4 || fin === 8;
+    }
+    if (chars.length === 2)
+        return KO_MODIFIER_2.has(w);
+    return false;
+}
+const isCJKNoSpace = (s) => /[぀-ヿ㐀-鿿]/.test(s) && !/[가-힣]/.test(s);
+const PUNCT_END = /[,，、.!?！？:：·—–\-…」』’”)）]$/;
+const HARD_PUNCT_END = /[,，、.!?！？:：·…]$/;
+/** 어절 토큰화 + 한 글자 한글 어절 결속 — 「한 번」「안 팔아요」「수 있어요」「이 동네」는 한 덩어리 */
+export function tokenize(text) {
+    const raw = String(text || '').replace(/([,，、!?！？.])(?=[^\s\d,.!?])/g, '$1 ').trim().split(/\s+/).filter(Boolean);
+    const words = [];
+    for (let i = 0; i < raw.length; i++) {
+        const w = raw[i];
+        if ([...w].length === 1 && isHangul(w)) {
+            // 🔴 「아침에 딴 토마토」 — 한 글자 관형형 용언(딴·산·쓴)은 앞의 부사어(아침에·마트에서)가 꾸미는 말이라 앞에 붙인다(「아침에 / 딴 토마토」 금지 · 2026-09-18 사장님). 「하루에 한 번」의 「한」(수 관형사)은 예전처럼 뒤에 붙는다
+            if (words.length && i + 1 < raw.length && isShortModifier(w) && isHangul(raw[i - 1]) && KO_ADVERB_FOR_MODIFIER.test(raw[i - 1]) && !PUNCT_END.test(raw[i - 1])) {
+                words[words.length - 1] += ' ' + w;
+                continue;
+            }
+            if (i + 1 < raw.length) {
+                words.push(w + ' ' + raw[i + 1]);
+                i++;
+                continue;
+            }
+            if (words.length) {
+                words[words.length - 1] += ' ' + w;
+                continue;
+            }
+        }
+        words.push(w);
+    }
+    return words;
+}
+const lastWord = (tok) => tok.split(' ').pop() || tok;
+const firstWord = (tok) => tok.split(' ')[0] || tok;
+/** 어절 i 뒤에서 끊는 비용(음수=좋은 자리) — i 는 앞 줄의 마지막 어절, next 는 다음 줄의 첫 어절 */
+export function breakCost(prev, next) {
+    const a = lastWord(prev), b = firstWord(next);
+    const al = a.toLowerCase().replace(/[^a-z']/g, ''), bl = b.toLowerCase().replace(/[^a-z']/g, '');
+    let c = 0;
+    // 부연(꾸밈) 관계는 한 어절처럼 — 「아침에 | 딴」(부사어 → 관형형) +0.8 · 「구운 | 빵」(관형형 → 명사) +0.5 · 공간이 허락하면 붙고, 없으면 다른 자리보다 먼저 지킨다
+    const bIsMod = isShortModifier(b) && isHangul(next.split(' ')[1] || b) && !PUNCT_END.test(b);
+    if (isHangul(a) && isHangul(b) && bIsMod && KO_ADVERB_FOR_MODIFIER.test(a) && !PUNCT_END.test(a))
+        return 0.8;
+    if (isShortModifier(a) && isHangul(b) && !PUNCT_END.test(a))
+        return 0.5;
+    if (HARD_PUNCT_END.test(a))
+        c -= 0.6;
+    else if (PUNCT_END.test(a))
+        c -= 0.3;
+    else if (isHangul(a)) {
+        if (KO_GENITIVE_END.test(a) && !KO_UI_NOUNS.has(a))
+            c += 0.3;
+        else if (KO_CLAUSE_END.test(a))
+            c -= 0.3;
+        else if (KO_ADVERBIAL_END.test(a))
+            c -= 0.25;
+        else if (KO_MARKER_END.test(a))
+            c -= 0.12;
+    }
+    else if (al && EN_NO_END.has(al))
+        c += 0.45;
+    if (isHangul(b) || isHangul(a)) {
+        if (KO_GLUE_PREV.has(b))
+            c += 0.8;
+        if (KO_GLUE_NEXT_STRONG.has(a))
+            c += 0.8;
+        else if (KO_GLUE_NEXT_WEAK.has(a))
+            c += 0.3;
+    }
+    if (bl && EN_NO_START.has(bl))
+        c += 0.3;
+    // 숫자·단위가 갈라지는 자리(「82,700 / 원」·「3 / 분」) 는 tokenize 가 붙이지 않으므로 여기서 막는다
+    if (/\d$/.test(a) && /^[%원명개분초시년월일건회번배]/.test(b))
+        c += 0.9;
+    return c;
+}
+/** 줄나눔 — 한 줄에 들어가면 그대로 · 아니면 줄 수를 2부터 늘려가며 모든 어절 경계 조합 중 비용 최소(결속 규칙 + 줄 균형 + 고아 벌점)를 고른다. 어떤 조합도 폭 안에 못 들어가면(한 어절이 줄보다 김) 뒤에서부터 채운 줄을 돌려주고 linesEl 이 글자를 줄인다. */
+export function breakLines(text, fs, maxW, o = {}) {
+    const opt = typeof o === 'number' ? { maxLines: o } : o;
+    const maxLines = opt.maxLines ?? 3;
+    const limit = maxW * (1 - (opt.margin ?? 0.02));
+    const W = (s) => measureText(s, fs, { weight: opt.weight, letterSpacing: opt.letterSpacing });
+    const src = String(text || '').trim();
+    if (!src)
+        return [];
+    if (isCJKNoSpace(src) && !src.includes(' '))
+        return breakCJK(src, W, limit, maxLines);
+    const words = tokenize(src);
+    if (!words.length)
+        return [];
+    if (words.length === 1 || W(words.join(' ')) <= limit)
+        return [words.join(' ')];
+    const widths = new Map();
+    const lineW = (from, to) => { const k = `${from}:${to}`; let v = widths.get(k); if (v === undefined) {
+        v = W(words.slice(from, to).join(' '));
+        widths.set(k, v);
+    } return v; };
+    // 고아 — 한글은 짧은 한 어절(≤2자)만 · 라틴은 한 단어 줄 전부(「… Main / Character」)
+    const orphan = (from, to) => to - from === 1 && (isHangul(words[from]) ? wlen(words[from].replace(/ /g, '')) <= 4 : true);
+    const n = words.length;
+    // 줄 수 k 를 2부터 늘려가며 조합 비용 최소를 찾는다 · 줄이 하나 늘 때마다 +EXTRA_LINE(결속 위반(+0.8)을 무릅쓴 두 줄보다 깨끗한 세 줄을 고르되, 균형만 조금 나은 두 줄은 그대로) · maxLines 안에서 답이 없으면 그 밖에서도 찾고 linesEl 이 글자를 줄인다
+    const EXTRA_LINE = 0.7;
+    let global = null;
+    for (let k = 2; k <= Math.min(n, maxLines + 2); k++) {
+        if (global && k > maxLines)
+            break;
+        let best = null;
+        const rec = (start, cutsSoFar, cost) => {
+            const linesLeft = k - cutsSoFar.length;
+            if (linesLeft === 1) {
+                const w = lineW(start, n);
+                if (w > limit)
+                    return;
+                const cuts = [...cutsSoFar, n];
+                const ws = cuts.map((c, i) => lineW(i ? cuts[i - 1] : 0, c));
+                const mean = ws.reduce((a, b) => a + b, 0) / ws.length;
+                // 줄 균형(폭 편차 합 / 한도) — 세 줄 이상(본문)은 결속 보너스가 균형을 이기지 않게 1.5배(「가벼운 발림으로 / 하루 종일 … / …」 첫 줄만 짧은 모양 방지)
+                let total = cost + (ws.reduce((a, b) => a + Math.abs(b - mean), 0) / limit) * (k >= 3 ? 1.5 : 1);
+                // 고아: 마지막(또는 첫) 줄 → 강한 벌점 · 가운데 줄은 중간 벌점
+                cuts.forEach((c, i) => { const from = i ? cuts[i - 1] : 0; if (orphan(from, c))
+                    total += i === 0 || i === cuts.length - 1 ? 1 : 0.6; });
+                // 뒤 줄이 앞 줄보다 눈에 띄게 길면(역삼각형) 살짝 벌점 — 「오늘의 입술, / 틴트 한 번」 처럼 위가 길거나 비슷한 모양 선호
+                for (let i = 1; i < ws.length; i++)
+                    if (ws[i] - ws[i - 1] > limit * 0.15)
+                        total += 0.08;
+                if (!best || total < best.cost)
+                    best = { cuts, cost: total };
+                return;
+            }
+            for (let cut = start + 1; cut <= n - (linesLeft - 1); cut++) {
+                if (lineW(start, cut) > limit)
+                    break;
+                rec(cut, [...cutsSoFar, cut], cost + breakCost(words[cut - 1], words[cut]));
+            }
+        };
+        rec(0, [], 0);
+        if (best) {
+            const b = best;
+            const total = b.cost + EXTRA_LINE * (k - 2);
+            if (!global || total < global.cost)
+                global = { cuts: b.cuts, cost: total, k };
+        }
+    }
+    if (global) {
+        const g = global;
+        return g.cuts.map((c, i) => words.slice(i ? g.cuts[i - 1] : 0, c).join(' '));
+    }
+    // 못 맞추는 경우(한 어절이 줄보다 김) — 뒤에서부터 채워 마지막 줄 고아를 피하고, 넘치는 줄은 linesEl 이 글자를 줄인다 · 🔴 어절을 버리지 않는다(예전엔 maxLines 로 잘라 뒷말이 사라졌다)
+    const lines = [];
+    let cur = [];
+    for (let i = n - 1; i >= 0; i--) {
+        const next = [words[i], ...cur];
+        if (cur.length && W(next.join(' ')) > limit) {
+            lines.unshift(cur);
+            cur = [words[i]];
+        }
+        else
+            cur = next;
+    }
+    if (cur.length)
+        lines.unshift(cur);
+    return lines.map((l) => l.join(' '));
+}
+/** 일본어·중국어(띄어쓰기 없음) — 글자 사이 어디서든 끊되 금칙(줄 머리에 。、」ー っ 작은 가나 · 줄 끝에 「（) 을 지키고 구두점·조사 뒤를 우선, 줄 균형으로 고른다 */
+function breakCJK(src, W, limit, maxLines) {
+    const chars = [...src];
+    if (W(src) <= limit)
+        return [src];
+    // 금칙 + 조사(は・が・を・に・で・と・へ・も・の) 는 줄 머리에 두지 않고 그 뒤에서 끊는다 · 가타카나 낱말(ティント) 안은 끊지 않고 문자 종류가 바뀌는 자리를 우선
+    const noStart = /[。、，．・ー〜っゃゅょぁぃぅぇぉ」』）】!?！？はがをにでとへもの]/;
+    const noEnd = /[「『（【]/;
+    const goodAfter = /[。、，！？!?]/;
+    const particle = /[はがをにでとへもの]/;
+    const kata = /[\u30a0-\u30ff]/;
+    const cost = (i) => { const a = chars[i - 1], b = chars[i]; if (noStart.test(b) || noEnd.test(a))
+        return Infinity; if (goodAfter.test(a))
+        return -0.6; if (particle.test(a))
+        return /[\u3040-\u309f]/.test(b) ? 0.1 : -0.25 /* 조사 뒤가 히라가나면(ひ「と」つ) 낱말 속일 수 있어 보너스 없음 */; if (kata.test(a) && kata.test(b))
+        return 0.6; if (kata.test(a) !== kata.test(b))
+        return -0.2; return 0.35; /* 낱말 가운데일 가능성 — 조사·구두점·문자 종류 경계가 아닌 자리는 되도록 피한다 */ };
+    const n = chars.length;
+    for (let k = 2; k <= maxLines; k++) {
+        let best = null;
+        const rec = (start, cuts, c) => {
+            const left = k - cuts.length;
+            if (left === 1) {
+                const all = [...cuts, n];
+                const ws = all.map((x, i) => W(chars.slice(i ? all[i - 1] : 0, x).join('')));
+                if (ws.some((w) => w > limit))
+                    return;
+                const mean = ws.reduce((a, b) => a + b, 0) / ws.length;
+                const total = c + ws.reduce((a, b) => a + Math.abs(b - mean), 0) / limit;
+                if (!best || total < best.cost)
+                    best = { cuts: all, cost: total };
+                return;
+            }
+            for (let cut = start + 1; cut <= n - (left - 1); cut++) {
+                if (W(chars.slice(start, cut).join('')) > limit)
+                    break;
+                const bc = cost(cut);
+                if (bc === Infinity)
+                    continue;
+                rec(cut, [...cuts, cut], c + bc);
+            }
+        };
+        rec(0, [], 0);
+        if (best) {
+            const b = best;
+            return b.cuts.map((x, i) => chars.slice(i ? b.cuts[i - 1] : 0, x).join(''));
+        }
+    }
+    const out = [];
+    let cur = '';
+    for (const ch of chars) {
+        if (cur && W(cur + ch) > limit) {
+            out.push(cur);
+            cur = ch;
+        }
+        else
+            cur += ch;
+    }
+    if (cur)
+        out.push(cur);
+    return out;
+}

package/dist/core/creatives/render.d.ts

@@ -1,5 +1,6 @@
 import type { Brief, Concept, CreativeAsset } from '../state.js';
 import { type Size } from './specs.js';
+export { breakLines, measureText } from './linebreak.js';
 export declare const FONT_FAMILY = "Pretendard, PretendardJP, NotoCJKtc, NotoCJKsc, NotoThai";
 export declare function loadFonts(lang?: string): Promise<{
     name: string;
@@ -15,18 +16,15 @@ type El = {
     type: string;
     props: Record<string, unknown>;
 };
-/** 밝은 브랜드색(베이지·노랑·민트) 위엔 어두운 글자 — 상대 명도로 판정 */
+export declare function bgLuminance(bg: string): number | null;
 export declare function onColor(hex: string): string;
 /** 어절 단위 줄바꿈 — satori 는 숫자·라틴과 한글 사이에서 줄을 바꾼다(「300명도」→「300 / 명도」 · 2026-09-17 사장님 지적). 공백으로 나눈 어절을 nowrap 조각으로 감싸고 flex-wrap 으로 흐르게 한다. */
 /** 어절 경계에서 자르기 — 본문이 한도에서 「아이템이에」처럼 낱말 중간에 끊기지 않게(2026-09-17 가로 이미지 검수). 문장부호 끝 정리 */
 export declare function cutWords(text: string, limit: number): string;
-/** 글자 폭 어림(Pretendard 실측 · 에어서울 97px 헤드라인 780px): 한글·전각 0.86em · 숫자·라틴 0.55em · 공백 0.3em */
-export declare const textW: (t: string, fs: number) => number;
-/** 헤드라인 줄나눔 — 「오늘의 입술, 틴트 한 / 번」·「나에게 맞는 컬러 / 찾기」처럼 넘치는 자리에서 끊겨 한 어절이 떨어지는 것을 막는다(2026-09-17 사장님).
- *  규칙: 한 줄에 들어가면 그대로 · 두 줄이면 모든 어절 경계 후보 중 (① 쉼표·물음표·마침표·가운뎃점 뒤 우선 ② 두 줄 길이 균형 ③ 마지막 줄이 한 어절(≤4wlen)이면 강한 벌점 ④ 두 줄 모두 폭 안) 비용 최소 · 세 줄 이상은 뒤에서부터 채워 마지막 줄 고아를 피한다 */
-export declare function breakLines(text: string, fs: number, maxW: number, maxLines?: number): string[];
-/** 줄나눔이 계산된 헤드라인 — 줄마다 nowrap 행 */
-export declare function linesEl(text: string, style: Record<string, unknown>, maxW: number, align?: 'left' | 'center'): El;
+/** 글자 폭 — 실제 글꼴 글리프 폭(linebreak.measureText · 굵기 700 기준 · 글꼴 미등록이면 어림). 가로 포스터 세로 예산·알약 폭 계산에 쓴다 */
+export declare const textW: (t: string, fs: number, weight?: number) => number;
+/** 줄나눔이 계산된 글줄 — 줄마다 nowrap 행으로 그려 satori 가 다른 자리에서 접을 수 없게 한다(한 줄이어도 nowrap). 어절 하나가 줄보다 길어 어떤 조합도 폭 안에 못 들어가면 가장 넓은 줄이 들어가도록 글자를 줄인다(최소 0.7배 · 그 아래는 글자 단위 줄바꿈). */
+export declare function linesEl(text: string, style: Record<string, unknown>, maxW: number, align?: 'left' | 'center', maxLines?: number): El;
 export declare function wordsEl(text: string, style: Record<string, unknown>, align?: 'left' | 'center'): El;
 /** 한 규격의 트리 */
 export declare function tree(size: Size, concept: Concept, brief: Brief, bg: string | null, logo: string | null, ctaText: string): El;

package/dist/core/creatives/render.js

@@ -7,6 +7,8 @@ import satori from 'satori';
 import { Resvg } from '@resvg/resvg-js';
 import { HOME } from '../state.js';
 import { SIZES, wlen, policyIssues } from './specs.js';
+import { breakLines, measureText, registerFonts } from './linebreak.js';
+export { breakLines, measureText } from './linebreak.js';
 const FONT_CDN = 'https://cdn.jsdelivr.net/gh/orioncactus/pretendard@v1.3.9/packages/pretendard/dist/public/static';
 const WEIGHTS = [['Pretendard-ExtraBold', 800], ['Pretendard-Bold', 700], ['Pretendard-Medium', 500]];
 /** 언어별 글꼴 폴백 — Pretendard 는 한글·라틴만. 일본어=Pretendard JP(가나·한자) · 중국어=Noto Sans TC/SC · 태국어=Noto Sans Thai. 같은 family 이름으로 넣어 satori 가 빠진 글리프를 다음 글꼴에서 찾게 한다. */
@@ -36,8 +38,10 @@ async function fetchFont(dir, url, file) {
 }
 export async function loadFonts(lang) {
     const key = lang ? (EXTRA_FONTS[lang] ? lang : EXTRA_FONTS[lang.split('-')[0]] ? lang.split('-')[0] : '') : '';
-    if (fontCache.has(key))
+    if (fontCache.has(key)) {
+        registerFonts(fontCache.get(key));
         return fontCache.get(key);
+    } // 캐시 적중에도 측정용 등록(멱등) — 어림 폭으로 떨어지면 「아침에 / 딴 토마토,」 같은 줄나눔이 나온다
     const dir = path.join(HOME, 'fonts');
     fs.mkdirSync(dir, { recursive: true });
     const out = [];
@@ -60,6 +64,7 @@ export async function loadFonts(lang) {
             out.push({ name: family, data: buf.buffer.slice(buf.byteOffset, buf.byteOffset + buf.byteLength), weight: weight, style: 'normal' });
     }
     fontCache.set(key, out);
+    registerFonts(out);
     return out;
 }
 /** 🔴 확장자가 아니라 바이트로 MIME 판별 — Gemini 이미지 API 는 .png 요청에도 JPEG 를 돌려준다(2026-09-16 실측 · 잘못된 MIME 이면 satori 가 배경을 조용히 버림) */
@@ -96,6 +101,35 @@ async function fetchLogo(url, dir) {
 }
 const h = (type, style, children, extra = {}) => ({ type, props: { style, ...extra, ...(children === undefined ? {} : { children }) } });
 /** 밝은 브랜드색(베이지·노랑·민트) 위엔 어두운 글자 — 상대 명도로 판정 */
+/** 배경 이미지의 평균 밝기(0~1) — data URI 를 resvg 로 8×8 로 축소 렌더해 픽셀 평균(상대 휘도). 글자 영역(위 65%)만 잰다. 실패하면 null */
+const lumCache = new Map();
+export function bgLuminance(bg) {
+    const key = bg.length + ':' + bg.slice(-80);
+    if (lumCache.has(key))
+        return lumCache.get(key);
+    let L = null;
+    try {
+        const n = 8;
+        const svg = `<svg xmlns="http://www.w3.org/2000/svg" xmlns:xlink="http://www.w3.org/1999/xlink" width="${n}" height="${n}"><image xlink:href="${bg}" href="${bg}" width="${n}" height="${n}" preserveAspectRatio="xMidYMid slice"/></svg>`;
+        const img = new Resvg(svg, { fitTo: { mode: 'width', value: n } }).render();
+        const px = img.pixels;
+        let sum = 0, cnt = 0;
+        for (let y = 0; y < Math.ceil(n * 0.65); y++)
+            for (let x = 0; x < n; x++) {
+                const i = (y * n + x) * 4;
+                const a = px[i + 3] / 255;
+                const r = px[i] * a + 255 * (1 - a), g = px[i + 1] * a + 255 * (1 - a), b = px[i + 2] * a + 255 * (1 - a);
+                sum += (0.2126 * r + 0.7152 * g + 0.0722 * b) / 255;
+                cnt++;
+            }
+        L = cnt ? sum / cnt : null;
+    }
+    catch {
+        L = null;
+    }
+    lumCache.set(key, L);
+    return L;
+}
 export function onColor(hex) { const m = hex.replace('#', ''); const n = parseInt(m.length === 3 ? m.split('').map((c) => c + c).join('') : m, 16); const r = (n >> 16) & 255, g = (n >> 8) & 255, b = n & 255; const L = (0.2126 * r + 0.7152 * g + 0.0722 * b) / 255; return L > 0.62 ? '#0b1526' : '#ffffff'; }
 /** 어절 단위 줄바꿈 — satori 는 숫자·라틴과 한글 사이에서 줄을 바꾼다(「300명도」→「300 / 명도」 · 2026-09-17 사장님 지적). 공백으로 나눈 어절을 nowrap 조각으로 감싸고 flex-wrap 으로 흐르게 한다. */
 /** 어절 경계에서 자르기 — 본문이 한도에서 「아이템이에」처럼 낱말 중간에 끊기지 않게(2026-09-17 가로 이미지 검수). 문장부호 끝 정리 */
@@ -107,67 +141,31 @@ export function cutWords(text, limit) {
     const sp = cut.lastIndexOf(' ');
     return (sp > limit * 0.5 ? cut.slice(0, sp) : t.slice(0, limit)).replace(/[\s,·:;\-—]+$/, '');
 }
-/** 글자 폭 어림(Pretendard 실측 · 에어서울 97px 헤드라인 780px): 한글·전각 0.86em · 숫자·라틴 0.55em · 공백 0.3em */
-export const textW = (t, fs) => [...t].reduce((n, ch) => n + (ch === ' ' ? 0.3 : (ch.codePointAt(0) || 0) > 0x2e7f ? 0.86 : 0.55), 0) * fs;
-/** 헤드라인 줄나눔 — 「오늘의 입술, 틴트 한 / 번」·「나에게 맞는 컬러 / 찾기」처럼 넘치는 자리에서 끊겨 한 어절이 떨어지는 것을 막는다(2026-09-17 사장님).
- *  규칙: 한 줄에 들어가면 그대로 · 두 줄이면 모든 어절 경계 후보 중 (① 쉼표·물음표·마침표·가운뎃점 뒤 우선 ② 두 줄 길이 균형 ③ 마지막 줄이 한 어절(≤4wlen)이면 강한 벌점 ④ 두 줄 모두 폭 안) 비용 최소 · 세 줄 이상은 뒤에서부터 채워 마지막 줄 고아를 피한다 */
-export function breakLines(text, fs, maxW, maxLines = 3) {
-    // 쉼표·물음표 뒤에 띄어쓰기가 없으면(「분양정보,몇 개」) 어절이 붙어 엉뚱한 자리에서 나뉜다 → 문장부호 뒤 공백 정규화
-    const raw = String(text || '').replace(/([,，、!?！？.])(?=[^\s\d,.!?])/g, '$1 ').trim().split(/\s+/).filter(Boolean);
-    // 한 글자 어절(「한」「다」「그」)은 다음 어절과 한 덩어리 — 「틴트 한 / 번」 금지
-    const words = [];
-    for (let i = 0; i < raw.length; i++) {
-        if ([...raw[i]].length === 1 && /[가-힣]/.test(raw[i]) && i + 1 < raw.length) {
-            words.push(raw[i] + ' ' + raw[i + 1]);
-            i++;
-        }
-        else
-            words.push(raw[i]);
-    }
-    if (!words.length)
-        return [];
-    const W = (ws) => textW(ws.join(' '), fs);
-    if (words.length === 1 || W(words) <= maxW)
-        return [words.join(' ')];
-    const orphan = (ws) => ws.length === 1 && wlen(ws[0].replace(' ', '')) <= 4;
-    let best = null;
-    for (let i = 1; i < words.length; i++) {
-        const a = words.slice(0, i), b = words.slice(i);
-        const wa = W(a), wb = W(b);
-        if (wa > maxW || wb > maxW)
-            continue;
-        let cost = Math.abs(wa - wb) / maxW;
-        if (/[,，、.!?！？:·—-]$/.test(a[a.length - 1]))
-            cost -= 0.5;
-        if (orphan(b) || orphan(a))
-            cost += 1;
-        if (!best || cost < best.cost)
-            best = { lines: [a.join(' '), b.join(' ')], cost };
+/** 글자 폭 — 실제 글꼴 글리프 폭(linebreak.measureText · 굵기 700 기준 · 글꼴 미등록이면 어림). 가로 포스터 세로 예산·알약 폭 계산에 쓴다 */
+export const textW = (t, fs, weight = 700) => measureText(t, fs, { weight });
+/** 줄나눔이 계산된 글줄 — 줄마다 nowrap 행으로 그려 satori 가 다른 자리에서 접을 수 없게 한다(한 줄이어도 nowrap). 어절 하나가 줄보다 길어 어떤 조합도 폭 안에 못 들어가면 가장 넓은 줄이 들어가도록 글자를 줄인다(최소 0.7배 · 그 아래는 글자 단위 줄바꿈). */
+export function linesEl(text, style, maxW, align = 'left', maxLines = 3) {
+    let fs = Number(style.fontSize || 16);
+    const weight = Number(style.fontWeight || 800);
+    const letterSpacing = Number(style.letterSpacing || 0);
+    let lines = breakLines(text, fs, maxW, { maxLines, weight, letterSpacing });
+    if (!lines.length)
+        return h('div', {}, '');
+    // 줄 수가 한도를 넘으면(긴 헤드라인) 어절을 버리지 않고 글자를 조금씩 줄여 한도 안으로(최소 0.6배)
+    const fs0 = fs;
+    while (lines.length > maxLines && fs > fs0 * 0.6) {
+        fs = Math.floor(fs * 0.92);
+        lines = breakLines(text, fs, maxW, { maxLines, weight, letterSpacing });
     }
-    if (best)
-        return best.lines;
-    // 세 줄 이상 — 뒤에서부터 채워 마지막 줄이 짧게 남지 않게
-    const lines = [];
-    let cur = [];
-    for (let i = words.length - 1; i >= 0; i--) {
-        const next = [words[i], ...cur];
-        if (cur.length && W(next) > maxW) {
-            lines.unshift(cur);
-            cur = [words[i]];
-        }
+    const widest = Math.max(...lines.map((l) => measureText(l, fs, { weight, letterSpacing })));
+    if (widest > maxW) {
+        const shrunk = Math.floor(fs * maxW / widest);
+        if (shrunk >= fs * 0.7)
+            fs = shrunk;
         else
-            cur = next;
+            return wordsEl(text, style, align); // 그래도 안 들어가면(띄어쓰기 없는 긴 어절) 렌더러 줄바꿈에 맡긴다
     }
-    if (cur.length)
-        lines.unshift(cur);
-    return lines.slice(0, maxLines).map((l) => l.join(' '));
-}
-/** 줄나눔이 계산된 헤드라인 — 줄마다 nowrap 행 */
-export function linesEl(text, style, maxW, align = 'left') {
-    const lines = breakLines(text, Number(style.fontSize || 16), maxW);
-    if (lines.length <= 1)
-        return wordsEl(text, style, align);
-    return h('div', { display: 'flex', flexDirection: 'column', alignItems: align === 'center' ? 'center' : 'flex-start', ...style }, lines.map((l) => h('div', { whiteSpace: 'nowrap' }, l)));
+    return h('div', { display: 'flex', flexDirection: 'column', alignItems: align === 'center' ? 'center' : 'flex-start', ...style, fontSize: fs }, lines.map((l) => h('div', { whiteSpace: 'nowrap' }, l)));
 }
 export function wordsEl(text, style, align = 'left') {
     const words = String(text || '').split(/\s+/).filter(Boolean);
@@ -181,7 +179,13 @@ function hexA(hex, a) { const m = hex.replace('#', ''); const n = parseInt(m.len
 /** 한 규격의 트리 */
 export function tree(size, concept, brief, bg, logo, ctaText) {
     const { w, h: hh } = size;
-    const dark = concept.theme === 'dark';
+    // 🔴 글자색은 콘셉트 테마가 아니라 실제 배경 밝기로 — 밝은 테마인데 AI 배경이 중간~어두운 톤이면 검은 글자가 배경에 죽는다(2026-09-18 사장님 「배경도 어두운데 텍스트도 어두우니」) → 밝기 0.5 미만이면 흰 글자+어두운 막, 막의 세기도 배경이 중간 톤일수록 강하게
+    const L = bg ? bgLuminance(bg) : null;
+    const dark = L === null ? concept.theme === 'dark' : L < 0.5;
+    const Leff = L ?? (dark ? 0.2 : 0.9);
+    // 막 세기(위쪽 · 헤드라인 자리): 어두운 처리는 배경이 밝아질수록(0.25→0.5) 0.15→0.45 · 밝은 처리는 배경이 어두워질수록(0.85→0.5) 0.10→0.55
+    const scrimTop = dark ? Math.min(0.5, 0.15 + Math.max(0, Leff - 0.25) * 1.3) : Math.min(0.55, 0.10 + Math.max(0, 0.85 - Leff) * 1.3);
+    const scrimBottom = dark ? Math.max(0.75, scrimTop + 0.3) : Math.max(0.55, scrimTop + 0.25);
     const primary = brief.palette.primary;
     const base = Math.min(w, hh);
     const banner = size.kind === 'banner';
@@ -253,7 +257,7 @@ export function tree(size, concept, brief, bg, logo, ctaText) {
     const children = [];
     if (bg)
         children.push(h('img', { position: 'absolute', top: 0, left: 0, width: w, height: hh, objectFit: 'cover', filter: dark ? 'brightness(.66)' : 'brightness(1.02)' }, undefined, { src: bg, width: w, height: hh }));
-    children.push(h('div', { position: 'absolute', top: 0, left: 0, width: w, height: hh, backgroundImage: dark ? `linear-gradient(180deg, ${hexA('#0b1526', 0.15)} 0%, ${hexA('#0b1526', 0.75)} 100%)` : `linear-gradient(180deg, rgba(255,255,255,.10) 0%, rgba(255,255,255,.55) 100%)` }));
+    children.push(h('div', { position: 'absolute', top: 0, left: 0, width: w, height: hh, backgroundImage: dark ? `linear-gradient(180deg, ${hexA('#0b1526', scrimTop)} 0%, ${hexA('#0b1526', scrimBottom)} 100%)` : `linear-gradient(180deg, rgba(255,255,255,${scrimTop.toFixed(2)}) 0%, rgba(255,255,255,${scrimBottom.toFixed(2)}) 100%)` }));
     const brandRow = h('div', { display: 'flex', alignItems: 'center', gap: Math.round(pad * 0.3) }, [
         logo ? h('img', { height: short ? Math.round(hh * 0.5) : Math.round(headFs * 0.9), borderRadius: 6 }, undefined, { src: logo }) : h('div', { fontSize: Math.round(headFs * 0.42), fontWeight: 800, color: fg, letterSpacing: -0.5 }, brief.company),
     ]);
@@ -271,7 +275,8 @@ export function tree(size, concept, brief, bg, logo, ctaText) {
             h('div', { display: 'flex', justifyContent: 'space-between', alignItems: 'center' }, [brandRow, domain && !banner ? h('div', { fontSize: Math.round(headFs * 0.3), fontWeight: 500, color: sub }, domain) : h('div', {}, '')]),
             h('div', { display: 'flex', flexDirection: 'column', gap: Math.round(pad * (banner ? 0.35 : 0.5)), maxWidth: isWide ? Math.round(w * 0.72) : w - pad * 2 }, [
                 linesEl(head, { fontSize: headFs, fontWeight: 800, color: fg, lineHeight: 1.12, letterSpacing: -1.5 }, isWide ? Math.round(w * 0.72) : w - pad * 2),
-                (banner && bodyFs < 14) || bodyFs === 0 ? h('div', {}, '') : wordsEl(bodyText, { fontSize: bodyFs, fontWeight: 500, color: sub, lineHeight: 1.45 }),
+                // 본문도 같은 규칙으로 균형 있게(「… 분들께 / 추천해요.」 한 어절 고아 방지 · 최대 4줄 · 배너는 폭이 좁아 렌더러 줄바꿈)
+                (banner && bodyFs < 14) || bodyFs === 0 ? h('div', {}, '') : banner ? wordsEl(bodyText, { fontSize: bodyFs, fontWeight: 500, color: sub, lineHeight: 1.45 }) : linesEl(bodyText, { fontSize: bodyFs, fontWeight: 500, color: sub, lineHeight: 1.45 }, isWide ? Math.round(w * 0.72) : w - pad * 2, 'left', 4),
                 ...(chips ? [chips] : []),
                 h('div', { display: 'flex', marginTop: Math.round(pad * 0.3) }, [ctaPill]),
             ]),
@@ -334,7 +339,7 @@ export async function renderOverlay(file, w, hh, text, o) {
     const fs1 = Math.round(base * (o.kind === 'cta' ? 0.055 : 0.068));
     const pill = o.kind === 'cta'
         ? h('div', { display: 'flex', fontSize: fs1, fontWeight: 700, color: onColor(o.primary), backgroundColor: o.primary, borderRadius: 999, padding: `${Math.round(fs1 * 0.55)}px ${Math.round(fs1 * 1.3)}px`, boxShadow: `0 10px 30px ${hexA(o.primary, 0.45)}` }, text)
-        : h('div', { display: 'flex', backgroundColor: 'rgba(11,21,38,.62)', borderRadius: Math.round(fs1 * 0.4), padding: `${Math.round(fs1 * 0.35)}px ${Math.round(fs1 * 0.6)}px`, maxWidth: Math.round(w * 0.86) }, [wordsEl(text, { fontSize: fs1, fontWeight: 800, color: '#fff', lineHeight: 1.25, letterSpacing: -1 }, 'center')]);
+        : h('div', { display: 'flex', backgroundColor: 'rgba(11,21,38,.62)', borderRadius: Math.round(fs1 * 0.4), padding: `${Math.round(fs1 * 0.35)}px ${Math.round(fs1 * 0.6)}px`, maxWidth: Math.round(w * 0.86) }, [linesEl(text, { fontSize: fs1, fontWeight: 800, color: '#fff', lineHeight: 1.25, letterSpacing: -1 }, Math.round(w * 0.86) - Math.round(fs1 * 0.6) * 2, 'center', 2)]);
     // 안전영역: 릴스·쇼츠 UI 가 하단 ~20%·우측 ~10% 를 가린다 → 자막은 상단 1/3(훅) 또는 하단 25~30% 선. 훅은 크고 브랜드색 하이라이트.
     const hook = o.kind === 'hook';
     const hookEl = h('div', { display: 'flex', maxWidth: Math.round(w * 0.86), backgroundColor: hexA(o.primary, 0.92), padding: `${Math.round(base * 0.035)}px ${Math.round(base * 0.05)}px`, borderRadius: Math.round(base * 0.03), transform: 'rotate(-2deg)' }, [linesEl(text, { fontSize: Math.round(base * 0.095), fontWeight: 800, color: onColor(o.primary), lineHeight: 1.12, letterSpacing: -1.5, textShadow: '0 4px 24px rgba(0,0,0,.65), 0 1px 2px rgba(0,0,0,.8)' }, Math.round(w * 0.86) - Math.round(base * 0.05) * 2, 'center')]);

package/dist/core/plan.js

@@ -36,11 +36,11 @@ export function computePlan(i) {
     const explain = [
         `한 달 ${fmtKrw(monthly)} 을 하루 약 ${fmtKrw(daily)} 으로 나눠 씁니다.`,
         ...out.map((m) => `· ${MEDIUM_LABEL[m.medium]} 하루 ${fmtKrw(m.dailyBudgetKrw)}${m.currency !== 'KRW' ? ` (계정 통화 ${m.currency} → ${fmtMinor(m.dailyBudgetMinor, m.currency)})` : ''}${m.note ? ` — ${m.note}` : ''}`),
-        `보여 줄 사람: ${i.markets.map((m) => `${m.country}(${m.language})`).join(' · ')} · 18세 이상 · 매체가 관심사를 자동으로 찾아요(Advantage+ / 자동 타겟).`,
+        `보여 줄 사람: ${i.markets.map((m) => `${m.country}(${m.language})`).join(' · ')} · 18세 이상 · 관심사는 매체가 자동으로 찾아요.`,
         `광고 소재는 ${concepts.length}가지 방향(${concepts.join(', ')})으로 나눠서 어느 쪽이 잘 되는지 비교합니다${i.conceptKeys.length > concepts.length ? ` — 예산이 작아 ${i.conceptKeys.length - concepts.length}개는 뒤로 미뤘어요` : ''}.`,
         `목표: ${goalWord}${i.hasTracking ? ' — 전환이 50건쯤 쌓이면 전환 최적화로 자동 전환' : ' — 추적 태그가 없어 방문 기준으로만 최적화돼요(추적 코드를 사이트에 넣어 주세요)'}.`,
         ...(i.markets.some((m) => m.language.split('-')[0] !== (i.briefLanguage || 'ko').split('-')[0]) ? [`⚠ 카피 언어가 ${i.briefLanguage} 인데 시장에 다른 언어(${[...new Set(i.markets.map((m) => m.language))].join(', ')})가 있어요 — 언어별 소재를 따로 만들어 주세요.`] : []),
-        `만들어지는 광고는 전부 「대기 상태(PAUSED · 노출 안 됨)」이고, 광고 시작 전엔 1원도 나가지 않아요.${i.endDate ? ` 종료일 ${i.endDate}.` : ''}`,
+        `광고는 전부 「대기 상태(아직 안 보임)」로 만들어지고, 광고 시작 전엔 1원도 나가지 않아요.${i.endDate ? ` 종료일 ${i.endDate}.` : ''}`,
     ].join('\n');
     return { monthlyKrw: monthly, dailyKrw: daily, media: out, concepts, markets: i.markets, goal: i.goal, endDate: i.endDate, explain, createdAt: new Date().toISOString() };
 }

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "adyou",
-  "version": "0.6.16",
+  "version": "0.6.18",
   "description": "ADYou — 대행사 없이, 당신이 직접. 사이트 주소 하나로 광고 소재·매체 등록·자동 운영·보고까지: AI 광고 자율주행 CLI + MCP 서버(Meta·Google · 생성은 항상 PAUSED · 승인 뒤 시작)",
   "type": "module",
   "license": "MIT",
@@ -29,7 +29,8 @@
     "@resvg/resvg-js": "^2.6.2",
     "commander": "^15.0.0",
     "satori": "^0.33.4",
-    "zod": "^4.4.3"
+    "zod": "^4.4.3",
+    "@shuding/opentype.js": "1.4.0-beta.0"
   },
   "devDependencies": {
     "@types/node": "^22",