zugzbot 1.0.21 → 1.0.23

package/.opencode/oh-my-design/web/src/lib/fonts/match-intent.ts

@@ -1,288 +0,0 @@
-/**
- * Deterministic text → MatchIntent parser.
- *
- * No AI. Hand-curated rules map query substrings to tag hints + hard
- * filters (script, family). Good enough for 80% of typical queries like
- * "warm korean sans" or "retro display english". Nuanced queries
- * ("찐득찐득한 여름밤") need a Phase 2 LLM layer.
- */
-
-import type { FontEntry, FontFamily, FontScript } from "./types";
-import { FONT_CATALOG } from "./catalog";
-import { similarity } from "./similarity";
-
-export interface MatchIntent {
-  raw: string;
-  tags: {
-    mood: string[];
-    era: string[];
-    use: string[];
-    personality: string[];
-  };
-  /** Hard filter — if present, non-matching fonts are excluded. */
-  scripts?: FontScript[];
-  family?: FontFamily;
-  /** Reference font id if user mentioned one by name. */
-  referenceFontId?: string;
-}
-
-interface Rule {
-  /** Lowercased substrings/keywords that activate this rule. */
-  kw: string[];
-  tags?: Partial<MatchIntent["tags"]>;
-  scripts?: FontScript[];
-  family?: FontFamily;
-}
-
-/* Keyword dictionary — Korean + English. Rules are OR'd: any matching
- * keyword activates the rule's tag contributions. Hard filters (scripts,
- * family) are last-wins. */
-const RULES: Rule[] = [
-  // ─── Scripts ───
-  { kw: ["한글", "한국", "한국어", "korean", "hangul"], scripts: ["hangul"] },
-  { kw: ["영문", "영어", "latin", "english"], scripts: ["latin"] },
-
-  // ─── Families ───
-  { kw: ["세리프", "serif"], family: "serif" },
-  { kw: ["산세리프", "sans-serif", "sans serif", "고딕"], family: "sans" },
-  { kw: ["모노", "mono", "monospace", "코드", "code"], family: "mono" },
-  { kw: ["필기", "손글씨", "캘리그라피", "calligraphy", "handwritten", "script"], family: "handwritten" },
-  { kw: ["디스플레이", "display", "포스터", "poster", "타이틀", "headline"], family: "display" },
-
-  // ─── Moods ───
-  { kw: ["따뜻한", "따뜻", "warm", "cozy", "코지"], tags: { mood: ["warm"] } },
-  { kw: ["차가운", "차분한", "cool", "sharp", "각진"], tags: { mood: ["sharp"] } },
-  { kw: ["미니멀", "심플", "깔끔", "minimal", "clean", "simple"], tags: { mood: ["clean", "neutral"] } },
-  { kw: ["우아", "우아한", "elegant", "luxurious", "고급"], tags: { mood: ["elegant", "editorial"] } },
-  { kw: ["재미있는", "장난", "playful", "fun", "귀여운", "cute", "아기자기", "깜찍", "앙증", "상큼"], tags: { mood: ["playful", "warm"], personality: ["friendly", "cute"] } },
-  { kw: ["레트로", "빈티지", "복고", "retro", "vintage"], tags: { mood: ["retro", "bold"] } },
-  { kw: ["기술적", "technical", "engineering", "개발자", "엔지니어"], tags: { mood: ["technical"] } },
-  { kw: ["부드러운", "soft", "rounded", "둥근", "둥글", "동글동글", "동글", "몽글몽글", "몽글", "말랑말랑", "말랑", "뭉글", "폭신", "poki"], tags: { mood: ["soft", "friendly", "warm"], personality: ["gentle", "approachable"] } },
-  { kw: ["강렬한", "볼드", "굵은", "bold", "heavy", "impact", "임팩트"], tags: { mood: ["bold", "impactful"] } },
-  { kw: ["친근한", "편안한", "approachable", "friendly", "casual"], tags: { mood: ["friendly", "warm"] } },
-  { kw: ["표현력", "expressive", "creative", "독특"], tags: { mood: ["expressive", "characterful"] } },
-  { kw: ["편집", "editorial", "잡지", "매거진", "magazine"], tags: { mood: ["editorial"] } },
-  { kw: ["읽기", "가독성", "readable", "reading", "본문"], tags: { mood: ["readable"] } },
-
-  // ─── Eras ───
-  { kw: ["1970s", "70년대", "70s", "seventies", "retro-70"], tags: { era: ["1970s", "retro"] } },
-  { kw: ["1980s", "80년대", "80s", "eighties"], tags: { era: ["1980s", "retro"] } },
-  { kw: ["2020", "2020s", "요즘", "최신", "modern"], tags: { era: ["2020s", "contemporary"] } },
-  { kw: ["2010s", "2010년대"], tags: { era: ["2010s"] } },
-  { kw: ["timeless", "시대를 초월", "클래식", "classical"], tags: { era: ["timeless"] } },
-  { kw: ["signage", "간판", "포스터"], tags: { era: ["signage"] } },
-
-  // ─── Use cases ───
-  { kw: ["ui", "인터페이스", "interface", "앱", "app"], tags: { use: ["ui"] } },
-  { kw: ["본문", "body", "paragraph", "긴 글", "reading"], tags: { use: ["body"] } },
-  { kw: ["제목", "heading", "headline", "타이틀", "title"], tags: { use: ["heading", "display"] } },
-  { kw: ["로고", "logo", "브랜드", "brand"], tags: { use: ["logo", "display"] } },
-  { kw: ["accent", "강조", "하이라이트"], tags: { use: ["accent"] } },
-  { kw: ["주석", "annotation", "note"], tags: { use: ["accent", "annotation"] } },
-  { kw: ["code", "코드", "programming", "개발"], tags: { use: ["code"] } },
-
-  // ─── Personality ───
-  { kw: ["전문적", "프로페셔널", "professional"], tags: { personality: ["professional"] } },
-  { kw: ["humanist", "휴머니스트", "사람"], tags: { personality: ["humanist"] } },
-  { kw: ["confident", "자신감"], tags: { personality: ["confident"] } },
-  { kw: ["quirky", "개성", "독특"], tags: { personality: ["quirky", "characterful"] } },
-  { kw: ["approachable", "다가가기"], tags: { personality: ["approachable"] } },
-  { kw: ["luxurious", "럭셔리"], tags: { personality: ["luxurious", "sophisticated"] } },
-  { kw: ["thoughtful", "사려깊은", "deliberate"], tags: { personality: ["thoughtful", "deliberate"] } },
-  { kw: ["personal", "친밀", "개인적"], tags: { personality: ["personal", "authentic"] } },
-
-  // ─── Specific vibes ───
-  { kw: ["카페", "café", "cafe", "브런치", "brunch"], tags: { mood: ["warm", "friendly"], personality: ["approachable"] } },
-  { kw: ["판교", "스타트업", "startup", "tech startup"], tags: { mood: ["clean", "modern"], use: ["ui"] } },
-  { kw: ["책", "book", "literary", "문학"], tags: { mood: ["readable", "editorial"], use: ["body"] } },
-  { kw: ["신문", "newspaper", "뉴스"], tags: { mood: ["readable", "editorial"], use: ["body"] } },
-  { kw: ["브루탈", "brutalist", "거친"], tags: { mood: ["bold", "impactful"] } },
-  { kw: ["y2k", "2000년대 초반", "millennium"], tags: { mood: ["retro", "playful", "geometric"] } },
-  { kw: ["일기", "diary", "저널", "journal"], tags: { mood: ["handwritten", "personal"] } },
-];
-
-/** Detect if the query names a font in the catalog (e.g., "like pretendard"). */
-function findReference(query: string, catalog: FontEntry[]): FontEntry | undefined {
-  const q = query.toLowerCase();
-  for (const f of catalog) {
-    const nameL = f.name.toLowerCase();
-    if (q.includes(nameL) || q.includes(f.id)) return f;
-  }
-  return undefined;
-}
-
-/** Parse a free-text query into a MatchIntent. Case-insensitive. */
-export function parseIntent(query: string, catalog: FontEntry[] = FONT_CATALOG): MatchIntent {
-  const q = query.toLowerCase();
-  const intent: MatchIntent = {
-    raw: query,
-    tags: { mood: [], era: [], use: [], personality: [] },
-  };
-
-  for (const rule of RULES) {
-    if (rule.kw.some((k) => q.includes(k))) {
-      if (rule.tags?.mood) intent.tags.mood.push(...rule.tags.mood);
-      if (rule.tags?.era) intent.tags.era.push(...rule.tags.era);
-      if (rule.tags?.use) intent.tags.use.push(...rule.tags.use);
-      if (rule.tags?.personality) intent.tags.personality.push(...rule.tags.personality);
-      if (rule.scripts) intent.scripts = [...new Set([...(intent.scripts ?? []), ...rule.scripts])];
-      if (rule.family) intent.family = rule.family;
-    }
-  }
-
-  // Dedupe tag lists
-  intent.tags.mood = [...new Set(intent.tags.mood)];
-  intent.tags.era = [...new Set(intent.tags.era)];
-  intent.tags.use = [...new Set(intent.tags.use)];
-  intent.tags.personality = [...new Set(intent.tags.personality)];
-
-  // Catalog name reference (e.g. "like pretendard")
-  const ref = findReference(query, catalog);
-  if (ref) intent.referenceFontId = ref.id;
-
-  return intent;
-}
-
-export interface MatchResult {
-  font: FontEntry;
-  /** 0.0-1.0 normalized. */
-  confidence: number;
-  /** Human-readable reasons ("shared mood: warm, clean · same script"). */
-  reasons: string[];
-}
-
-/** Score a single font against the intent. Returns raw (unnormalized) score. */
-function scoreFont(font: FontEntry, intent: MatchIntent, refScore?: number): number {
-  // Hard filters
-  if (intent.scripts && !intent.scripts.some((s) => font.scripts.includes(s))) return 0;
-  if (intent.family && font.family !== intent.family) return 0;
-
-  let score = 0;
-  // Tag overlaps — each matching tag is worth 1.0; mood weighted higher.
-  score += font.tags.mood.filter((t) => intent.tags.mood.includes(t)).length * 1.2;
-  score += font.tags.era.filter((t) => intent.tags.era.includes(t)).length * 0.8;
-  score += font.tags.use.filter((t) => intent.tags.use.includes(t)).length * 1.0;
-  score += font.tags.personality.filter((t) => intent.tags.personality.includes(t)).length * 0.8;
-
-  // Reference bonus — if user mentioned a font by name, boost similar ones
-  if (refScore) score += refScore * 0.6;
-
-  return score;
-}
-
-function reasonsForMatch(font: FontEntry, intent: MatchIntent, isReference: boolean): string[] {
-  const reasons: string[] = [];
-  if (isReference) reasons.push("you asked for this font by name");
-
-  const moodHit = font.tags.mood.filter((t) => intent.tags.mood.includes(t));
-  if (moodHit.length > 0) reasons.push(`mood: ${moodHit.slice(0, 2).join(", ")}`);
-
-  const useHit = font.tags.use.filter((t) => intent.tags.use.includes(t));
-  if (useHit.length > 0 && reasons.length < 3) reasons.push(`for ${useHit[0]}`);
-
-  if (intent.scripts && intent.scripts.some((s) => font.scripts.includes(s)) && reasons.length < 3) {
-    reasons.push(`supports ${intent.scripts.join(" + ")}`);
-  }
-
-  if (intent.family && font.family === intent.family && reasons.length < 3) {
-    reasons.push(`${font.family}`);
-  }
-
-  return reasons.slice(0, 3);
-}
-
-/** Safe defaults for queries that produce zero rule hits. Three different
- *  personalities each — used as a "we couldn't parse you but here are
- *  generally useful picks" fallback. Three variants so post-filter by
- *  script never leaves an empty list. */
-const SAFE_DEFAULTS_BOTH = ["pretendard", "gowun-dodum", "gothic-a1"];
-const SAFE_DEFAULTS_HANGUL_ONLY = ["pretendard", "gowun-dodum", "noto-sans-kr"];
-const SAFE_DEFAULTS_LATIN_ONLY = ["inter", "manrope", "dm-sans"];
-
-function safeDefaultResults(
-  catalog: FontEntry[],
-  requiredScripts: FontScript[] = [],
-): MatchResult[] {
-  const want = new Set(requiredScripts);
-  const ids =
-    want.size === 0 || (want.has("hangul") && want.has("latin"))
-      ? SAFE_DEFAULTS_BOTH
-      : want.has("hangul")
-        ? SAFE_DEFAULTS_HANGUL_ONLY
-        : SAFE_DEFAULTS_LATIN_ONLY;
-  const picks = ids
-    .map((id) => catalog.find((f) => f.id === id))
-    .filter((f): f is FontEntry => Boolean(f))
-    .slice(0, 3);
-  return picks.map((font) => ({
-    font,
-    confidence: 0.15,
-    reasons: ["general-purpose pick", `${font.family}`],
-  }));
-}
-
-/** Run intent → ranked MatchResults. Top N with normalized confidence.
- *  Guarantees at least 3 picks — falls through to `SAFE_DEFAULT_IDS`
- *  when no rule hits, so callers never see an empty list mid-flow. */
-export function runMatch(
-  intent: MatchIntent,
-  catalog: FontEntry[] = FONT_CATALOG,
-  limit = 5,
-): MatchResult[] {
-  // If user named a reference, precompute similarity once
-  const reference = intent.referenceFontId
-    ? catalog.find((f) => f.id === intent.referenceFontId)
-    : undefined;
-
-  const raw = catalog
-    .map((f) => {
-      const refScore = reference ? similarity(reference, f) : 0;
-      const score = scoreFont(f, intent, refScore);
-      return {
-        font: f,
-        score,
-        isReference: reference?.id === f.id,
-      };
-    })
-    .filter((r) => r.score > 0 || r.isReference)
-    .sort((a, b) => b.score - a.score);
-
-  if (raw.length === 0) {
-    return safeDefaultResults(catalog, intent.scripts ?? []).slice(0, limit);
-  }
-
-  const maxScore = raw[0].score || 1;
-  return raw.slice(0, limit).map((r) => ({
-    font: r.font,
-    confidence: Math.min(1, r.score / Math.max(maxScore, 4)),
-    reasons: reasonsForMatch(r.font, intent, r.isReference),
-  }));
-}
-
-/** Convenience: one-shot query → results. `requiredScripts` acts as a
- *  hard filter on top of the parsed intent — if the UI selected "hangul",
- *  every returned font must include "hangul" in its scripts. */
-export function matchQuery(
-  query: string,
-  catalog: FontEntry[] = FONT_CATALOG,
-  limit = 5,
-  requiredScripts: FontScript[] = [],
-): MatchResult[] {
-  if (!query.trim()) return [];
-  const intent = parseIntent(query, catalog);
-  if (requiredScripts.length > 0) {
-    // Merge UI-selected scripts with any the intent parser already picked
-    // up (e.g., "한글" word in query). Union is conservative — we want
-    // every listed script satisfied.
-    const merged = new Set<FontScript>([
-      ...(intent.scripts ?? []),
-      ...requiredScripts,
-    ]);
-    intent.scripts = [...merged];
-  }
-  const results = runMatch(intent, catalog, limit);
-  if (requiredScripts.length === 0) return results;
-  return results.filter((r) =>
-    requiredScripts.every((s) => r.font.scripts.includes(s)),
-  );
-}

package/.opencode/oh-my-design/web/src/lib/fonts/preview-contexts.ts

@@ -1,124 +0,0 @@
-/**
- * Preview context templates — "how does this font look applied in a real
- * UI context." Not the font tile with a single string; full mini-layouts
- * (hero section, product card, article body, button row) rendered with
- * the user's selection.
- *
- * Data-only — the components that render these live in
- * `components/font-playground/preview-templates.tsx`. Keeping content
- * here lets localization / authoring happen without touching React.
- */
-
-export type PreviewContextId = "hero" | "card" | "article" | "ui";
-
-export interface HeroTemplate {
-  kicker: string;
-  title: string;
-  body: string;
-  cta: string;
-}
-
-export interface CardTemplate {
-  title: string;
-  body: string;
-  actionLabel: string;
-  metaLabel: string;
-  metaValue: string;
-}
-
-export interface ArticleTemplate {
-  kicker: string;
-  title: string;
-  dateline: string;
-  paragraphs: string[];
-  subheading: string;
-  tailParagraph: string;
-}
-
-export interface UiTemplate {
-  primaryLabel: string;
-  secondaryLabel: string;
-  ghostLabel: string;
-  badges: string[];
-  menuItems: string[];
-  price: { label: string; value: string };
-}
-
-export const PREVIEW_LATIN = {
-  hero: {
-    kicker: "Launching Spring 2026",
-    title: "Build the thing you wanted",
-    body: "A lightweight tool for designers and vibe-coders who need a typeface that matches the vibe, not a decision tree to find one.",
-    cta: "Try it free",
-  } satisfies HeroTemplate,
-  card: {
-    title: "Playful interface kit",
-    body: "Twelve components, radius-tunable, built for weekend projects. Ships with sensible defaults.",
-    actionLabel: "See the kit →",
-    metaLabel: "Category",
-    metaValue: "Starter",
-  } satisfies CardTemplate,
-  article: {
-    kicker: "Essay",
-    title: "Type is the interface",
-    dateline: "Apr 20 · 6 min read",
-    paragraphs: [
-      "A product's font is the first sentence it says out loud. Before the layout, before the copy, before the color — the letters sit on the canvas and tell the reader who's talking.",
-      "The best product teams treat that sentence as intentional. They don't default to Inter because everyone else did. They pick a face that matches the voice of the product, and then they let every other decision — weight, spacing, size — cohere behind it.",
-    ],
-    subheading: "What changes when you choose on purpose",
-    tailParagraph:
-      "Nothing obvious. The marketing copy reads the same. The buttons still work. But the product feels considered, and considered products are trusted — which is, in the end, the only thing a typeface can earn for you.",
-  } satisfies ArticleTemplate,
-  ui: {
-    primaryLabel: "Save changes",
-    secondaryLabel: "Cancel",
-    ghostLabel: "More options",
-    badges: ["New", "Beta", "Free tier"],
-    menuItems: ["Home", "Docs", "Pricing", "Changelog"],
-    price: { label: "Pro plan", value: "$12 / month" },
-  } satisfies UiTemplate,
-} as const;
-
-export const PREVIEW_HANGUL = {
-  hero: {
-    kicker: "2026년 봄 출시",
-    title: "만들고 싶었던 걸 만들어요",
-    body: "디자이너와 바이브 코더를 위한 타입 도구. 검색하지 말고 묘사하세요. 나머지는 알아서 찾아드립니다.",
-    cta: "무료로 시작하기",
-  } satisfies HeroTemplate,
-  card: {
-    title: "놀기 좋은 인터페이스 키트",
-    body: "12개 컴포넌트, radius 조절 가능, 주말 프로젝트용. 합리적인 기본값과 함께 제공돼요.",
-    actionLabel: "키트 보러 가기 →",
-    metaLabel: "카테고리",
-    metaValue: "스타터",
-  } satisfies CardTemplate,
-  article: {
-    kicker: "에세이",
-    title: "타이포그래피는 인터페이스다",
-    dateline: "2026년 4월 20일 · 읽기 6분",
-    paragraphs: [
-      "제품이 처음 건네는 말은 글자다. 레이아웃보다, 카피보다, 색보다 먼저 — 캔버스 위에 놓인 글자가 말하는 사람의 인격을 전한다.",
-      "좋은 제품 팀은 그 인격을 의도적으로 고른다. 남들이 Inter를 쓰니까 Inter를 쓰는 게 아니라, 제품의 목소리에 맞는 얼굴을 고르고 두께, 자간, 크기 모든 결정을 그 뒤에 일관되게 둔다.",
-    ],
-    subheading: "의도적으로 고르면 무엇이 달라지는가",
-    tailParagraph:
-      "눈에 띄게 달라지는 건 없다. 카피는 같고 버튼은 작동한다. 다만 제품이 사려 깊어 보이고, 사려 깊은 제품은 신뢰받는다 — 그게 결국 폰트가 해줄 수 있는 유일한 일이다.",
-  } satisfies ArticleTemplate,
-  ui: {
-    primaryLabel: "저장하기",
-    secondaryLabel: "취소",
-    ghostLabel: "더 보기",
-    badges: ["새로움", "베타", "무료"],
-    menuItems: ["홈", "문서", "가격", "업데이트"],
-    price: { label: "프로 플랜", value: "월 $12" },
-  } satisfies UiTemplate,
-} as const;
-
-export type PreviewLocale = "latin" | "hangul";
-
-/** Return the full template bundle for a locale. */
-export function getPreviewBundle(locale: PreviewLocale) {
-  return locale === "hangul" ? PREVIEW_HANGUL : PREVIEW_LATIN;
-}

package/.opencode/oh-my-design/web/src/lib/fonts/rate-limit.ts

@@ -1,43 +0,0 @@
-/**
- * In-memory sliding-window rate limiter for the Haiku match route.
- *
- * Keyed by client IP. Dev-gated route so a process-local Map is fine —
- * no Redis needed. Production exposure would need an external store to
- * survive serverless cold starts, but this route is dev-only.
- */
-
-interface Bucket {
-  hits: number[];
-}
-
-const WINDOW_MS = 60_000;
-const MAX_HITS_PER_WINDOW = 10;
-
-const buckets = new Map<string, Bucket>();
-
-export interface RateLimitResult {
-  ok: boolean;
-  remaining: number;
-  retryAfterSec: number;
-}
-
-export function checkRateLimit(key: string): RateLimitResult {
-  const now = Date.now();
-  const bucket = buckets.get(key) ?? { hits: [] };
-  bucket.hits = bucket.hits.filter((t) => now - t < WINDOW_MS);
-
-  if (bucket.hits.length >= MAX_HITS_PER_WINDOW) {
-    const oldest = bucket.hits[0];
-    const retryAfterSec = Math.ceil((WINDOW_MS - (now - oldest)) / 1000);
-    buckets.set(key, bucket);
-    return { ok: false, remaining: 0, retryAfterSec };
-  }
-
-  bucket.hits.push(now);
-  buckets.set(key, bucket);
-  return {
-    ok: true,
-    remaining: MAX_HITS_PER_WINDOW - bucket.hits.length,
-    retryAfterSec: 0,
-  };
-}

package/.opencode/oh-my-design/web/src/lib/fonts/saved-store.ts

@@ -1,113 +0,0 @@
-/**
- * localStorage-backed persistence for Font Playground saves.
- *
- * Each SavedFont captures the user's catalog pick + customization state
- * (axis values, letter-spacing, static weight, render size, sample text).
- * No server — simpler privacy story, zero auth. Users can also share
- * individual saves via URL-state encoding (see share-link.ts).
- */
-
-import type { LiveSelection } from "./tweaks";
-
-const STORAGE_KEY = "omd.fontPlayground.saved.v1";
-
-export interface SavedFont {
-  id: string;
-  /** User-chosen display name ("My warm brand font"). */
-  name: string;
-  fontId: string;
-  /** UNIX ms. */
-  createdAt: number;
-  selection: LiveSelection;
-  /** Preview size (px) the user settled on. */
-  previewSize: number;
-  /** Sample text the user was typing when they saved. */
-  sampleText: string;
-}
-
-function safeParse(text: string | null): SavedFont[] {
-  if (!text) return [];
-  try {
-    const parsed = JSON.parse(text);
-    if (!Array.isArray(parsed)) return [];
-    return parsed.filter(
-      (x): x is SavedFont =>
-        x &&
-        typeof x === "object" &&
-        typeof x.id === "string" &&
-        typeof x.fontId === "string" &&
-        typeof x.name === "string" &&
-        x.selection &&
-        typeof x.selection === "object",
-    );
-  } catch {
-    return [];
-  }
-}
-
-function read(): SavedFont[] {
-  if (typeof window === "undefined") return [];
-  return safeParse(localStorage.getItem(STORAGE_KEY));
-}
-
-function write(list: SavedFont[]): void {
-  if (typeof window === "undefined") return;
-  localStorage.setItem(STORAGE_KEY, JSON.stringify(list));
-}
-
-export function listSaved(): SavedFont[] {
-  return read().sort((a, b) => b.createdAt - a.createdAt);
-}
-
-export function getSaved(id: string): SavedFont | null {
-  return read().find((s) => s.id === id) ?? null;
-}
-
-export interface SaveInput {
-  name: string;
-  fontId: string;
-  selection: LiveSelection;
-  previewSize: number;
-  sampleText: string;
-}
-
-export function saveFont(input: SaveInput): SavedFont {
-  const list = read();
-  const entry: SavedFont = {
-    id: `sf_${Date.now().toString(36)}_${Math.random().toString(36).slice(2, 7)}`,
-    name: input.name.trim() || "Untitled font",
-    fontId: input.fontId,
-    createdAt: Date.now(),
-    selection: input.selection,
-    previewSize: input.previewSize,
-    sampleText: input.sampleText,
-  };
-  list.push(entry);
-  write(list);
-  return entry;
-}
-
-export function updateSaved(id: string, patch: Partial<SaveInput>): SavedFont | null {
-  const list = read();
-  const idx = list.findIndex((s) => s.id === id);
-  if (idx === -1) return null;
-  list[idx] = {
-    ...list[idx],
-    ...(patch.name !== undefined ? { name: patch.name.trim() || list[idx].name } : {}),
-    ...(patch.fontId !== undefined ? { fontId: patch.fontId } : {}),
-    ...(patch.selection !== undefined ? { selection: patch.selection } : {}),
-    ...(patch.previewSize !== undefined ? { previewSize: patch.previewSize } : {}),
-    ...(patch.sampleText !== undefined ? { sampleText: patch.sampleText } : {}),
-  };
-  write(list);
-  return list[idx];
-}
-
-export function deleteSaved(id: string): void {
-  const list = read().filter((s) => s.id !== id);
-  write(list);
-}
-
-export function countSaved(): number {
-  return read().length;
-}

package/.opencode/oh-my-design/web/src/lib/fonts/share-link.test.ts

@@ -1,101 +0,0 @@
-/**
- * Share-link codec tests. Share URLs embed the entire selection state in
- * `?f=<compact>`; a silent regression here would break every link
- * previously shared out, so round-trip + rejection-of-garbage both need
- * coverage.
- */
-
-import { describe, expect, it } from "vitest";
-import type { LiveSelection } from "./tweaks";
-import {
-  buildFontShareUrl,
-  decodeSharedFont,
-  encodeSharedFont,
-} from "./share-link";
-
-const sampleSelection: LiveSelection = {
-  axisValues: { wght: 650, CASL: 0.3 },
-  staticWeight: 400,
-  letterSpacing: -0.02,
-  lineHeight: 1.4,
-};
-
-describe("encode/decode round-trip", () => {
-  it("preserves every field of a typical state", () => {
-    const encoded = encodeSharedFont({
-      fontId: "pretendard",
-      selection: sampleSelection,
-      previewSize: 72,
-      sampleText: "Hello 안녕",
-    });
-    const decoded = decodeSharedFont(encoded);
-    expect(decoded).not.toBeNull();
-    expect(decoded!.v).toBe(1);
-    expect(decoded!.fontId).toBe("pretendard");
-    expect(decoded!.previewSize).toBe(72);
-    expect(decoded!.sampleText).toBe("Hello 안녕");
-    expect(decoded!.selection).toEqual(sampleSelection);
-  });
-
-  it("survives a real URL round-trip (encodeURIComponent → decode)", () => {
-    const encoded = encodeSharedFont({
-      fontId: "pretendard",
-      selection: sampleSelection,
-      previewSize: 56,
-      sampleText: "test",
-    });
-    // Simulate ?f=… parsing by running the payload through URLSearchParams
-    const params = new URLSearchParams(`f=${encoded}`);
-    const fromUrl = params.get("f");
-    expect(fromUrl).not.toBeNull();
-    const decoded = decodeSharedFont(fromUrl!);
-    expect(decoded).not.toBeNull();
-    expect(decoded!.fontId).toBe("pretendard");
-  });
-});
-
-describe("decodeSharedFont — rejects garbage", () => {
-  it("returns null for obviously broken input", () => {
-    expect(decodeSharedFont("this is not lz-compressed")).toBeNull();
-    expect(decodeSharedFont("")).toBeNull();
-  });
-
-  it("returns null when the version tag is missing or wrong", () => {
-    // Fake a valid-looking but wrong-shape payload
-    const malformed = encodeSharedFont({
-      fontId: "x",
-      selection: sampleSelection,
-      previewSize: 10,
-      sampleText: "",
-    }).slice(0, -4);
-    expect(decodeSharedFont(malformed)).toBeNull();
-  });
-});
-
-describe("buildFontShareUrl", () => {
-  it("prefixes with origin and /font-playground path", () => {
-    const url = buildFontShareUrl("https://oh-my-design.kr", {
-      fontId: "pretendard",
-      selection: sampleSelection,
-      previewSize: 56,
-      sampleText: "test",
-    });
-    expect(url).toMatch(/^https:\/\/oh-my-design\.kr\/font-playground\?f=/);
-  });
-
-  it("is reversible — the link can be parsed back into the same state", () => {
-    const origin = "https://example.com";
-    const input = {
-      fontId: "pretendard",
-      selection: sampleSelection,
-      previewSize: 96,
-      sampleText: "Hi",
-    };
-    const url = buildFontShareUrl(origin, input);
-    const compact = url.split("?f=")[1];
-    const decoded = decodeSharedFont(compact);
-    expect(decoded!.fontId).toBe(input.fontId);
-    expect(decoded!.previewSize).toBe(input.previewSize);
-    expect(decoded!.sampleText).toBe(input.sampleText);
-  });
-});