zugzbot 1.0.21 → 1.0.22

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

@@ -1,52 +0,0 @@
-/**
- * URL-state codec for Font Playground.
- *
- * State → JSON → LZ-string compressed → `?f=<compact>`. Mirrors the
- * Playground codec but with a minimal shape: fontId + selection +
- * previewSize + sampleText. Shared links land in Stage 3 (customize)
- * with the selection preloaded.
- */
-
-import { compressToEncodedURIComponent, decompressFromEncodedURIComponent } from "lz-string";
-import type { LiveSelection } from "./tweaks";
-
-export interface SharedFontState {
-  v: 1;
-  fontId: string;
-  selection: LiveSelection;
-  previewSize: number;
-  sampleText: string;
-}
-
-export function encodeSharedFont(state: Omit<SharedFontState, "v">): string {
-  const full: SharedFontState = { v: 1, ...state };
-  return compressToEncodedURIComponent(JSON.stringify(full));
-}
-
-export function decodeSharedFont(compact: string): SharedFontState | null {
-  try {
-    const json = decompressFromEncodedURIComponent(compact);
-    if (!json) return null;
-    const parsed = JSON.parse(json) as Partial<SharedFontState>;
-    if (
-      parsed.v !== 1 ||
-      typeof parsed.fontId !== "string" ||
-      !parsed.selection ||
-      typeof parsed.selection !== "object" ||
-      typeof parsed.previewSize !== "number" ||
-      typeof parsed.sampleText !== "string"
-    ) {
-      return null;
-    }
-    return parsed as SharedFontState;
-  } catch {
-    return null;
-  }
-}
-
-export function buildFontShareUrl(
-  origin: string,
-  state: Omit<SharedFontState, "v">,
-): string {
-  return `${origin}/font-playground?f=${encodeSharedFont(state)}`;
-}

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

@@ -1,106 +0,0 @@
-/**
- * Tag-based font similarity. Deterministic, no AI.
- *
- * Given a reference font, finds the catalog entries closest in register.
- * Scoring combines:
- *   - Jaccard similarity on the pooled tag set (mood + era + use + personality)
- *   - Script overlap bonus (shared script = more substitutable)
- *   - Family match bonus (sans → sans > sans → serif)
- *   - Variable-capability match (user tweaking workflow only transfers across
- *     variable↔variable pairs, so same variability is rewarded)
- *
- * Hand-curated tag quality drives ranking quality. If tags are sloppy,
- * similarity results are sloppy — we intentionally keep AI out of this
- * step so that the catalog curator can predict and debug output.
- */
-
-import type { FontEntry } from "./types";
-import { FONT_CATALOG } from "./catalog";
-
-/** Flatten a font's tag bag to a Set for overlap calculations. */
-function tagSet(f: FontEntry): Set<string> {
-  const s = new Set<string>();
-  for (const t of f.tags.mood) s.add(`mood:${t}`);
-  for (const t of f.tags.era) s.add(`era:${t}`);
-  for (const t of f.tags.use) s.add(`use:${t}`);
-  for (const t of f.tags.personality) s.add(`p:${t}`);
-  return s;
-}
-
-function jaccard(a: Set<string>, b: Set<string>): number {
-  if (a.size === 0 && b.size === 0) return 0;
-  let intersection = 0;
-  for (const v of a) if (b.has(v)) intersection++;
-  const union = a.size + b.size - intersection;
-  return union === 0 ? 0 : intersection / union;
-}
-
-/** Component-wise similarity score. Higher = more similar. Range ~0-3. */
-export function similarity(a: FontEntry, b: FontEntry): number {
-  if (a.id === b.id) return 0;
-
-  // Tag similarity is the main signal — most discriminative
-  const jac = jaccard(tagSet(a), tagSet(b));
-  let score = jac * 2.0;
-
-  // Script overlap — shared scripts mean the fonts are substitutable in
-  // the same layouts. Two-way hangul+latin fonts get full bonus; a
-  // hangul-only vs latin-only pairing gets 0 here.
-  const sharedScripts = a.scripts.filter((s) => b.scripts.includes(s)).length;
-  score += sharedScripts * 0.35;
-
-  // Family match — sans/serif/mono/display/handwritten taxonomy.
-  // Cross-family matches still possible via tag overlap, just weighted down.
-  if (a.family === b.family) score += 0.6;
-
-  // Variable capability — user customization intent transfers better when
-  // both fonts share variable support.
-  if (a.variable === b.variable) score += 0.2;
-
-  return score;
-}
-
-export interface SimilarityResult {
-  font: FontEntry;
-  score: number;
-  /** Human-readable reason string shown in the UI ("shared mood: clean, modern"). */
-  reasons: string[];
-}
-
-/** Find the top-N catalog fonts most similar to `reference`. */
-export function findSimilar(
-  reference: FontEntry,
-  catalog: FontEntry[] = FONT_CATALOG,
-  limit = 5,
-): SimilarityResult[] {
-  return catalog
-    .filter((f) => f.id !== reference.id)
-    .map((f) => ({
-      font: f,
-      score: similarity(reference, f),
-      reasons: reasonsFor(reference, f),
-    }))
-    .filter((x) => x.score > 0.3) // threshold to avoid noisy matches
-    .sort((a, b) => b.score - a.score)
-    .slice(0, limit);
-}
-
-function reasonsFor(a: FontEntry, b: FontEntry): string[] {
-  const reasons: string[] = [];
-  const sharedMood = a.tags.mood.filter((t) => b.tags.mood.includes(t));
-  if (sharedMood.length > 0) {
-    reasons.push(`shared mood: ${sharedMood.slice(0, 2).join(", ")}`);
-  }
-  const sharedUse = a.tags.use.filter((t) => b.tags.use.includes(t));
-  if (sharedUse.length > 0 && reasons.length < 2) {
-    reasons.push(`same use: ${sharedUse[0]}`);
-  }
-  if (a.family === b.family && reasons.length < 2) {
-    reasons.push(`also ${b.family}`);
-  }
-  const sharedScripts = a.scripts.filter((s) => b.scripts.includes(s));
-  if (sharedScripts.length > 0 && reasons.length < 2 && reasons.length === 0) {
-    reasons.push(`covers ${sharedScripts.join(" + ")}`);
-  }
-  return reasons.slice(0, 2);
-}

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

@@ -1,213 +0,0 @@
-/**
- * Pure-logic tests for the tweak engine. Covers:
- *   - initialSelection seeds from axis defaults
- *   - applyTweak clamps to axis bounds (never escapes min/max)
- *   - static-font weight walks the weights[] array, not wght axis
- *   - applyTweak is pure (no mutation of inputs)
- *   - distanceFromDefault is 0 at default, grows monotonically with edits
- *   - tweakAvailable gates correctly based on axis / weights[]
- */
-
-import { describe, expect, it } from "vitest";
-import type { FontEntry } from "./types";
-import {
-  applyTweak,
-  distanceFromDefault,
-  initialSelection,
-  tweakAvailable,
-} from "./tweaks";
-
-function variableFont(): FontEntry {
-  return {
-    id: "test-var",
-    name: "Test Variable",
-    family: "sans",
-    scripts: ["latin"],
-    cssFamily: `"Test Variable"`,
-    variable: true,
-    axes: [
-      { tag: "wght", name: "Weight", min: 100, max: 900, default: 400 },
-      { tag: "CASL", name: "Casual", min: 0, max: 1, default: 0.5 },
-    ],
-    license: "OFL-1.1",
-    source: "https://example.com",
-    description: "",
-    loader: { kind: "google", family: "Test" },
-    tags: { mood: [], era: [], use: [], personality: [] },
-    sampleText: { latin: "Aa" },
-  };
-}
-
-function staticFont(): FontEntry {
-  return {
-    id: "test-static",
-    name: "Test Static",
-    family: "sans",
-    scripts: ["latin"],
-    cssFamily: `"Test Static"`,
-    variable: false,
-    axes: [],
-    weights: [300, 400, 700, 900],
-    license: "OFL-1.1",
-    source: "https://example.com",
-    description: "",
-    loader: { kind: "google", family: "Test" },
-    tags: { mood: [], era: [], use: [], personality: [] },
-    sampleText: { latin: "Aa" },
-  };
-}
-
-function singleWeight(): FontEntry {
-  return {
-    ...staticFont(),
-    id: "test-single",
-    name: "Test Single",
-    weights: [400],
-  };
-}
-
-describe("initialSelection", () => {
-  it("seeds variable-font axes to each axis's default", () => {
-    const sel = initialSelection(variableFont());
-    expect(sel.axisValues.wght).toBe(400);
-    expect(sel.axisValues.CASL).toBe(0.5);
-  });
-
-  it("picks the middle static weight for non-variable fonts", () => {
-    const sel = initialSelection(staticFont());
-    expect([400, 700]).toContain(sel.staticWeight);
-  });
-
-  it("seeds letter-spacing to 0 and line-height to 1.2", () => {
-    const sel = initialSelection(variableFont());
-    expect(sel.letterSpacing).toBe(0);
-    expect(sel.lineHeight).toBe(1.2);
-  });
-});
-
-describe("applyTweak — clamping", () => {
-  it("thicker stays within wght max", () => {
-    const font = variableFont();
-    let sel = initialSelection(font);
-    // Start near the top, then repeatedly thicken — should never exceed 900
-    sel = { ...sel, axisValues: { ...sel.axisValues, wght: 850 } };
-    for (let i = 0; i < 10; i++) sel = applyTweak(font, sel, "thicker");
-    expect(sel.axisValues.wght).toBe(900);
-  });
-
-  it("thinner stays within wght min", () => {
-    const font = variableFont();
-    let sel = initialSelection(font);
-    sel = { ...sel, axisValues: { ...sel.axisValues, wght: 200 } };
-    for (let i = 0; i < 10; i++) sel = applyTweak(font, sel, "thinner");
-    expect(sel.axisValues.wght).toBe(100);
-  });
-
-  it("tighter clamps letter-spacing at -0.1 em", () => {
-    const font = variableFont();
-    let sel = initialSelection(font);
-    for (let i = 0; i < 20; i++) sel = applyTweak(font, sel, "tighter");
-    expect(sel.letterSpacing).toBeGreaterThanOrEqual(-0.1);
-  });
-
-  it("looser clamps letter-spacing at 0.2 em", () => {
-    const font = variableFont();
-    let sel = initialSelection(font);
-    for (let i = 0; i < 20; i++) sel = applyTweak(font, sel, "looser");
-    expect(sel.letterSpacing).toBeLessThanOrEqual(0.2);
-  });
-});
-
-describe("applyTweak — static-font weight walking", () => {
-  it("thicker picks the next entry in weights[]", () => {
-    const font = staticFont();
-    let sel = initialSelection(font);
-    sel = { ...sel, staticWeight: 400 };
-    sel = applyTweak(font, sel, "thicker");
-    expect(sel.staticWeight).toBe(700);
-    sel = applyTweak(font, sel, "thicker");
-    expect(sel.staticWeight).toBe(900);
-    sel = applyTweak(font, sel, "thicker");
-    expect(sel.staticWeight).toBe(900); // clamps at last
-  });
-
-  it("thinner picks the previous entry", () => {
-    const font = staticFont();
-    let sel = initialSelection(font);
-    sel = { ...sel, staticWeight: 700 };
-    sel = applyTweak(font, sel, "thinner");
-    expect(sel.staticWeight).toBe(400);
-    sel = applyTweak(font, sel, "thinner");
-    expect(sel.staticWeight).toBe(300);
-    sel = applyTweak(font, sel, "thinner");
-    expect(sel.staticWeight).toBe(300); // clamps at first
-  });
-});
-
-describe("applyTweak — purity", () => {
-  it("does not mutate the input selection", () => {
-    const font = variableFont();
-    const sel = initialSelection(font);
-    const snapshot = JSON.parse(JSON.stringify(sel));
-    applyTweak(font, sel, "thicker");
-    applyTweak(font, sel, "tighter");
-    applyTweak(font, sel, "looser");
-    expect(sel).toEqual(snapshot);
-  });
-
-  it("preserves lineHeight across tweaks (regression for the back-compat shim)", () => {
-    const font = variableFont();
-    let sel = initialSelection(font);
-    sel = { ...sel, lineHeight: 1.8 };
-    const after = applyTweak(font, sel, "thicker");
-    expect(after.lineHeight).toBe(1.8);
-  });
-});
-
-describe("distanceFromDefault", () => {
-  it("is 0 for a fresh initial selection", () => {
-    const font = variableFont();
-    const sel = initialSelection(font);
-    expect(distanceFromDefault(font, sel)).toBeCloseTo(0, 5);
-  });
-
-  it("grows monotonically as axes move away", () => {
-    const font = variableFont();
-    let sel = initialSelection(font);
-    const d0 = distanceFromDefault(font, sel);
-    sel = applyTweak(font, sel, "thicker");
-    const d1 = distanceFromDefault(font, sel);
-    sel = applyTweak(font, sel, "thicker");
-    const d2 = distanceFromDefault(font, sel);
-    expect(d1).toBeGreaterThan(d0);
-    expect(d2).toBeGreaterThan(d1);
-  });
-
-  it("picks up letter-spacing and line-height drift too", () => {
-    const font = variableFont();
-    const base = initialSelection(font);
-    const withTracking = { ...base, letterSpacing: 0.05 };
-    const withLeading = { ...base, lineHeight: 1.6 };
-    expect(distanceFromDefault(font, withTracking)).toBeGreaterThan(0);
-    expect(distanceFromDefault(font, withLeading)).toBeGreaterThan(0);
-  });
-});
-
-describe("tweakAvailable", () => {
-  it("single-weight static fonts disable thicker/thinner", () => {
-    const font = singleWeight();
-    expect(tweakAvailable(font, "thicker")).toBe(false);
-    expect(tweakAvailable(font, "thinner")).toBe(false);
-  });
-
-  it("tighter/looser is always available (letter-spacing is universal)", () => {
-    expect(tweakAvailable(singleWeight(), "tighter")).toBe(true);
-    expect(tweakAvailable(singleWeight(), "looser")).toBe(true);
-  });
-
-  it("rounder/sharper requires a CASL, SOFT, or wght axis", () => {
-    const bareFont: FontEntry = { ...singleWeight(), axes: [] };
-    expect(tweakAvailable(bareFont, "rounder")).toBe(false);
-    expect(tweakAvailable(variableFont(), "rounder")).toBe(true);
-  });
-});

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

@@ -1,186 +0,0 @@
-/**
- * Deterministic 3-button tweaks. Novice users don't want to learn axis
- * vocabulary — they want "rounder", "thicker", "tighter". Each tweak maps
- * to a concrete delta on axis values / letter-spacing / static-weight index.
- *
- * Non-variable fonts still support Thicker/Thinner (walks the weights[]
- * array) and Tighter/Looser (letter-spacing). Rounder/Sharper only applies
- * when the font has a CASL / SOFT / wght axis.
- */
-
-import type { FontEntry } from "./types";
-
-export type TweakKey =
-  | "rounder"
-  | "sharper"
-  | "thicker"
-  | "thinner"
-  | "tighter"
-  | "looser";
-
-export interface LiveSelection {
-  axisValues: Record<string, number>;
-  /** Chosen weight for static fonts. For variable fonts this is ignored. */
-  staticWeight: number;
-  /** Letter-spacing in `em` (scales with font-size). */
-  letterSpacing: number;
-  /** Unitless CSS line-height. 1.2 is a sensible generic default; body
-   *  text usually wants 1.5+, display/headline wants 1.05–1.2. */
-  lineHeight: number;
-}
-
-const clamp = (v: number, min: number, max: number) =>
-  Math.min(max, Math.max(min, v));
-
-/** Initial live selection seeded from the font's declared defaults.
- *  Line-height defaults to 1.2 (tight, headline-weighted) because the
- *  big specimen is what users look at first — body copy users can
- *  bump it to 1.5 themselves. */
-export function initialSelection(font: FontEntry): LiveSelection {
-  const axisValues: Record<string, number> = Object.fromEntries(
-    font.axes.map((a) => [a.tag, a.default]),
-  );
-  const staticWeight = font.variable
-    ? (axisValues.wght ?? 400)
-    : (font.weights?.[Math.floor((font.weights?.length ?? 1) / 2)] ?? 400);
-  return { axisValues, staticWeight, letterSpacing: 0, lineHeight: 1.2 };
-}
-
-/** Whether a tweak can actually do anything given this font's axes. */
-export function tweakAvailable(font: FontEntry, tweak: TweakKey): boolean {
-  const hasWght = font.axes.some((a) => a.tag === "wght");
-  const hasCASL = font.axes.some((a) => a.tag === "CASL");
-  const hasSOFT = font.axes.some((a) => a.tag === "SOFT");
-  const hasStaticWeights = (font.weights?.length ?? 0) > 1;
-  switch (tweak) {
-    case "rounder":
-    case "sharper":
-      return hasCASL || hasSOFT || hasWght;
-    case "thicker":
-    case "thinner":
-      return hasWght || hasStaticWeights;
-    case "tighter":
-    case "looser":
-      return true;
-  }
-}
-
-function axisRange(font: FontEntry, tag: string): { min: number; max: number } | null {
-  const a = font.axes.find((x) => x.tag === tag);
-  return a ? { min: a.min, max: a.max } : null;
-}
-
-/** Apply one tweak. Returns a new selection object. */
-export function applyTweak(
-  font: FontEntry,
-  current: LiveSelection,
-  tweak: TweakKey,
-): LiveSelection {
-  const next: LiveSelection = {
-    axisValues: { ...current.axisValues },
-    staticWeight: current.staticWeight,
-    letterSpacing: current.letterSpacing,
-    lineHeight: current.lineHeight,
-  };
-
-  const wghtRange = axisRange(font, "wght");
-  const caslRange = axisRange(font, "CASL");
-  const softRange = axisRange(font, "SOFT");
-
-  switch (tweak) {
-    case "rounder":
-      if (caslRange) {
-        next.axisValues.CASL = clamp(
-          (current.axisValues.CASL ?? 0) + 0.3,
-          caslRange.min,
-          caslRange.max,
-        );
-      } else if (softRange) {
-        next.axisValues.SOFT = clamp(
-          (current.axisValues.SOFT ?? 30) + 20,
-          softRange.min,
-          softRange.max,
-        );
-      } else if (wghtRange) {
-        // Soft fallback — heavier weight slightly opens counters in most faces
-        next.axisValues.wght = clamp(
-          (current.axisValues.wght ?? 400) + 50,
-          wghtRange.min,
-          wghtRange.max,
-        );
-      }
-      break;
-    case "sharper":
-      if (caslRange) {
-        next.axisValues.CASL = clamp(
-          (current.axisValues.CASL ?? 0) - 0.3,
-          caslRange.min,
-          caslRange.max,
-        );
-      } else if (softRange) {
-        next.axisValues.SOFT = clamp(
-          (current.axisValues.SOFT ?? 30) - 20,
-          softRange.min,
-          softRange.max,
-        );
-      } else if (wghtRange) {
-        next.axisValues.wght = clamp(
-          (current.axisValues.wght ?? 400) - 50,
-          wghtRange.min,
-          wghtRange.max,
-        );
-      }
-      break;
-    case "thicker":
-      if (wghtRange) {
-        next.axisValues.wght = clamp(
-          (current.axisValues.wght ?? 400) + 150,
-          wghtRange.min,
-          wghtRange.max,
-        );
-      } else if (font.weights && font.weights.length > 1) {
-        const i = font.weights.indexOf(current.staticWeight);
-        const nextI = Math.min(font.weights.length - 1, (i === -1 ? 0 : i) + 1);
-        next.staticWeight = font.weights[nextI];
-      }
-      break;
-    case "thinner":
-      if (wghtRange) {
-        next.axisValues.wght = clamp(
-          (current.axisValues.wght ?? 400) - 150,
-          wghtRange.min,
-          wghtRange.max,
-        );
-      } else if (font.weights && font.weights.length > 1) {
-        const i = font.weights.indexOf(current.staticWeight);
-        const prevI = Math.max(0, (i === -1 ? 1 : i) - 1);
-        next.staticWeight = font.weights[prevI];
-      }
-      break;
-    case "tighter":
-      next.letterSpacing = clamp(current.letterSpacing - 0.02, -0.1, 0.2);
-      break;
-    case "looser":
-      next.letterSpacing = clamp(current.letterSpacing + 0.02, -0.1, 0.2);
-      break;
-  }
-
-  return next;
-}
-
-/** Distance from the current selection to the font's default, used by the
- *  "Reset" button affordance. 0 = at default. */
-export function distanceFromDefault(
-  font: FontEntry,
-  current: LiveSelection,
-): number {
-  let d = 0;
-  for (const a of font.axes) {
-    const delta = Math.abs((current.axisValues[a.tag] ?? a.default) - a.default);
-    const range = a.max - a.min;
-    if (range > 0) d += delta / range;
-  }
-  if (current.letterSpacing !== 0) d += Math.abs(current.letterSpacing) * 10;
-  if (current.lineHeight !== 1.2) d += Math.abs(current.lineHeight - 1.2) * 2;
-  return d;
-}

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

@@ -1,96 +0,0 @@
-/**
- * Font Playground — catalog types.
- *
- * Each FontEntry is a curated OFL / libre-licensed font family. The catalog
- * is hand-maintained (not auto-scraped) so tag quality stays high for
- * reference-based discovery.
- */
-
-export type FontScript = "latin" | "hangul" | "japanese" | "chinese";
-export type FontFamily =
-  | "sans"
-  | "serif"
-  | "mono"
-  | "display"
-  | "handwritten";
-/** Free-form license tag. Displayed verbatim in the UI. Common values:
- *  "OFL-1.1", "Apache-2.0", "UFL-1.0", or foundry-specific free licenses
- *  (e.g., "BM — free for commercial use", "YG — 상업적 사용 허용"). The
- *  playground curates and points at source; no redistribution, so permissive
- *  free-use licenses are all acceptable. */
-export type FontLicense = string;
-
-/** Registered or custom axis of a variable font. */
-export interface FontAxis {
-  /** OpenType tag, e.g. "wght", "wdth", "CASL". */
-  tag: string;
-  /** Display name, e.g. "Weight". */
-  name: string;
-  min: number;
-  max: number;
-  /** Value used as the tile-preview default. */
-  default: number;
-}
-
-/** How the font is loaded into the page. */
-export type FontLoader =
-  | {
-      kind: "google";
-      /** Full Google Fonts css2 `family=` segment (URL-encoded, keeps axis specs).
-       *  Example: `Inter:wght@100..900` or `Fraunces:ital,opsz,wght@0..1,9..144,100..900`. */
-      family: string;
-    }
-  | {
-      kind: "jsdelivr";
-      /** Raw @font-face CSS to inject. Used for fonts not on Google Fonts
-       *  (Gmarket Sans, Galmuri, etc.) — pulled from jsdelivr / unpkg. */
-      fontFaceCss: string;
-    };
-
-export interface FontEntry {
-  id: string;
-  name: string;
-  family: FontFamily;
-  scripts: FontScript[];
-  /** CSS `font-family` value (quoted string). */
-  cssFamily: string;
-  /** True if the font has variable axes. */
-  variable: boolean;
-  /** Defined axes for variable fonts. Empty when variable=false. */
-  axes: FontAxis[];
-  /** Static weights available when variable=false. */
-  weights?: number[];
-  license: FontLicense;
-  /** Upstream repo / canonical page. */
-  source: string;
-  /** One-sentence editorial description. */
-  description: string;
-  /** How to load the font at runtime. */
-  loader: FontLoader;
-  /** Tags drive filtering + Phase 3 reference matching. */
-  tags: {
-    /** Register — playful/warm/sharp/luxurious/editorial/technical/etc. */
-    mood: string[];
-    /** Era — 2020s, 1970s, timeless, retro. Phase 3 uses this heavily. */
-    era: string[];
-    /** Intended use — ui, body, display, heading, logo, code, caption. */
-    use: string[];
-    /** Personality — professional, approachable, quirky, serious, friendly. */
-    personality: string[];
-  };
-  /** Sample copy shown on the tile per script. */
-  sampleText: Partial<Record<FontScript, string>>;
-  /** Designer / foundry attribution shown in detail view. */
-  designer?: string;
-}
-
-/** Runtime selection state for a single font (axis values, etc.). */
-export interface FontSelection {
-  fontId: string;
-  /** Axis tag → value. Empty for static fonts. */
-  axisValues: Record<string, number>;
-  /** Static-font weight choice (only used when variable=false). */
-  staticWeight?: number;
-  /** Sample text the user typed. */
-  sampleText: string;
-}