@kevin5251984/guild 0.2.18 → 0.2.20

package/src/opencode-free.ts

@@ -0,0 +1,248 @@
+import type { ModelEntry, ProviderEntry } from "@guild/protocol";
+import { guildUserAgent } from "./version.ts";
+
+/** Built-in alias `free` → this provider, matching Hermes Agent (2026-08). */
+export const OPENCODE_FREE_PROVIDER_ID = "opencode-free";
+export const OPENCODE_FREE_BASE_URL = "https://opencode.ai/zen/v1";
+
+const ALIASES = new Set(["opencode-free", "free", "opencode_free"]);
+
+/**
+ * Offline floor — Hermes Agent's curated catalog.
+ * Live GET /zen/v1/models is the source of truth when reachable.
+ * Known-delisted slugs must not stay here (they 401 keyless).
+ */
+export const OPENCODE_FREE_FLOOR = [
+  "laguna-s-2.1-free",
+  "mimo-v2.5-free",
+  "nemotron-3.5-lightning-free",
+  "nemotron-3-ultra-free",
+  "muse-spark-1.2-contributor-free",
+  "ling-3.0-flash-fin-free",
+  "deepseek-v4-flash-free",
+] as const;
+
+/** Default pick — user-facing Guild default, routed to `/v1/responses`. */
+export const OPENCODE_FREE_DEFAULT_MODEL = "muse-spark-1.2-contributor-free";
+
+/**
+ * Hermes `opencode_model_api_mode`: Muse Spark on Zen/Go is Responses-only.
+ * `/v1/chat/completions` 500s; `/v1/responses` completes.
+ */
+export function usesZenResponses(model: string): boolean {
+  return String(model || "")
+    .trim()
+    .toLowerCase()
+    .startsWith("muse-spark");
+}
+
+/** Free slugs that do not end in `-free` (OpenCode's rotating stealth slot). */
+const EXTRA_SLUGS = new Set(["big-pickle"]);
+
+/** `-free` suffix but KEYED (Go subscription), not anonymous. */
+const KEYED_FREE_SUFFIX = new Set(["ox-alpha-free"]);
+
+export function isKeylessProvider(id: string): boolean {
+  return ALIASES.has(String(id || "").trim().toLowerCase());
+}
+
+export function prettyOpenCodeFreeName(id: string): string {
+  const bare = String(id || "").trim().split("/").pop() || String(id || "");
+  const slug = bare.replace(/-/g, " ").replace(/\s+/g, " ").trim();
+  if (!slug) return id;
+  return slug.replace(/\b([a-z])/g, (ch) => ch.toUpperCase());
+}
+
+export function openCodeFreeModels(ids: readonly string[] = OPENCODE_FREE_FLOOR): ModelEntry[] {
+  return ids.map((id) => ({ id, name: prettyOpenCodeFreeName(id) }));
+}
+
+export function openCodeFreeProvider(): ProviderEntry {
+  return {
+    name: "OpenCode Free",
+    baseUrl: OPENCODE_FREE_BASE_URL,
+    api: "openai-completions",
+    apiKey: "",
+    models: openCodeFreeModels(),
+  };
+}
+
+export function filterOpenCodeFreeIds(ids: string[]): string[] {
+  const out: string[] = [];
+  const seen = new Set<string>();
+  for (const raw of ids) {
+    const id = String(raw || "").trim();
+    if (!id) continue;
+    const bare = (id.split("/").pop() || id).toLowerCase();
+    const ok =
+      (bare.endsWith("-free") && !KEYED_FREE_SUFFIX.has(bare)) ||
+      EXTRA_SLUGS.has(bare);
+    if (!ok || seen.has(bare)) continue;
+    seen.add(bare);
+    out.push(id.includes("/") ? bare : id);
+  }
+  return out;
+}
+
+export function llmRequestHeaders(target: {
+  providerId: string;
+  apiKey: string;
+  headers?: Record<string, string>;
+}): Record<string, string> {
+  const extra = { ...(target.headers ?? {}) };
+  if (isKeylessProvider(target.providerId)) {
+    const headers: Record<string, string> = {
+      "content-type": "application/json",
+      "http-referer": "https://github.com/Jakevin/guild",
+      "x-title": "Guild",
+      "user-agent": guildUserAgent(),
+      ...extra,
+    };
+    delete headers.authorization;
+    delete headers.Authorization;
+    return headers;
+  }
+  const headers: Record<string, string> = {
+    "content-type": "application/json",
+    ...extra,
+  };
+  if (!headers.authorization && !headers.Authorization) {
+    headers.authorization = `Bearer ${target.apiKey}`;
+  }
+  return headers;
+}
+
+let liveMemo: { at: number; ids: string[] | null } | null = null;
+const LIVE_TTL_MS = 300_000;
+
+export async function fetchOpenCodeFreeModels(
+  timeoutMs = 4_000,
+  force = false,
+): Promise<string[] | null> {
+  const now = Date.now();
+  if (!force && liveMemo && now - liveMemo.at < LIVE_TTL_MS) {
+    return liveMemo.ids ? [...liveMemo.ids] : null;
+  }
+  try {
+    const res = await fetch(`${OPENCODE_FREE_BASE_URL}/models`, {
+      headers: {
+        accept: "application/json",
+        "user-agent": guildUserAgent(),
+        "http-referer": "https://github.com/Jakevin/guild",
+        "x-title": "Guild",
+      },
+      signal: AbortSignal.timeout(timeoutMs),
+    });
+    if (!res.ok) {
+      liveMemo = { at: now, ids: null };
+      return null;
+    }
+    const body = (await res.json()) as { data?: { id?: string }[] } | { id?: string }[];
+    const rows = Array.isArray(body) ? body : body.data;
+    const ids = filterOpenCodeFreeIds(
+      (rows ?? [])
+        .map((row) => (row && typeof row.id === "string" ? row.id : ""))
+        .filter(Boolean),
+    );
+    const result = ids.length ? ids : null;
+    liveMemo = { at: now, ids: result };
+    return result ? [...result] : null;
+  } catch {
+    liveMemo = { at: now, ids: null };
+    return null;
+  }
+}
+
+/** Tests only. */
+export function resetOpenCodeFreeMemo(): void {
+  liveMemo = null;
+}
+
+export type OpenCodeFreeProbe = {
+  id: string;
+  ok: boolean;
+  status: number;
+  reason?: string;
+};
+
+/** Health ping — not a turn timer. Muse /responses often needs ~7s. */
+export const OPENCODE_FREE_PROBE_TIMEOUT_MS = 12_000;
+const PROBE_CONCURRENCY = 4;
+
+type FetchLike = typeof fetch;
+
+export function selectOpenCodeFreeIds(
+  live: string[],
+  probe: OpenCodeFreeProbe[],
+  keepId?: string,
+): string[] {
+  const ok = new Set(probe.filter((row) => row.ok).map((row) => row.id));
+  const picked = live.filter((id) => ok.has(id));
+  if (keepId && live.includes(keepId) && !picked.includes(keepId) && picked.length) {
+    picked.push(keepId);
+  }
+  return picked;
+}
+
+export async function probeOpenCodeFreeModel(
+  id: string,
+  fetcher: FetchLike = fetch,
+): Promise<OpenCodeFreeProbe> {
+  const model = String(id || "").trim();
+  if (!model) return { id: model, ok: false, status: 0, reason: "empty" };
+  const responses = usesZenResponses(model);
+  const url = `${OPENCODE_FREE_BASE_URL}${responses ? "/responses" : "/chat/completions"}`;
+  const body = responses
+    ? { model, input: [{ role: "user", content: "ping" }] }
+    : {
+        model,
+        messages: [{ role: "user", content: "ping" }],
+        max_tokens: 16,
+      };
+  try {
+    const res = await fetcher(url, {
+      method: "POST",
+      headers: llmRequestHeaders({
+        providerId: OPENCODE_FREE_PROVIDER_ID,
+        apiKey: "",
+      }),
+      body: JSON.stringify(body),
+      signal: AbortSignal.timeout(OPENCODE_FREE_PROBE_TIMEOUT_MS),
+    });
+    if (res.status === 429) {
+      return { id: model, ok: true, status: 429, reason: "rate-limited" };
+    }
+    if (!res.ok) {
+      return { id: model, ok: false, status: res.status, reason: `HTTP ${res.status}` };
+    }
+    return { id: model, ok: true, status: res.status };
+  } catch (err) {
+    const message = err instanceof Error ? err.message : String(err);
+    const timeout = /timeout|aborted/i.test(message);
+    return {
+      id: model,
+      ok: false,
+      status: 0,
+      reason: timeout ? "timeout" : message || "error",
+    };
+  }
+}
+
+export async function probeOpenCodeFreeModels(
+  ids: string[],
+  fetcher: FetchLike = fetch,
+): Promise<OpenCodeFreeProbe[]> {
+  const list = ids.filter(Boolean);
+  const results: OpenCodeFreeProbe[] = new Array(list.length);
+  let next = 0;
+  const worker = async () => {
+    while (true) {
+      const i = next++;
+      if (i >= list.length) return;
+      results[i] = await probeOpenCodeFreeModel(list[i], fetcher);
+    }
+  };
+  const n = Math.min(PROBE_CONCURRENCY, Math.max(list.length, 0));
+  await Promise.all(Array.from({ length: n }, () => worker()));
+  return results;
+}

package/src/public/buddy.js

@@ -0,0 +1,432 @@
+/* 18×32 tavern buddy. Handle-seeded hair/skin/cloth + outline. Not a cast. */
+(function (root) {
+  "use strict";
+  const W = 18;
+  const H = 32;
+  const OUT = [27, 21, 16];
+  const SHOE = [
+    [44, 36, 32],
+    [62, 44, 34],
+  ];
+  const PANTS = [
+    [42, 48, 62],
+    [58, 48, 40],
+    [46, 58, 48],
+    [72, 64, 58],
+  ];
+  const HAIR_RGB = [
+    [42, 28, 18],
+    [22, 18, 16],
+    [196, 163, 90],
+    [122, 52, 44],
+    [58, 72, 108],
+    [88, 56, 140],
+    [154, 86, 46],
+    [72, 44, 58],
+  ];
+  const SKIN = [
+    { hi: [255, 221, 189], base: [247, 201, 170], sh: [212, 158, 126], line: [168, 112, 82] },
+    { hi: [232, 182, 136], base: [214, 162, 116], sh: [176, 126, 86], line: [138, 92, 60] },
+    { hi: [196, 148, 108], base: [176, 128, 90], sh: [140, 98, 68], line: [104, 70, 48] },
+    { hi: [168, 118, 86], base: [146, 100, 70], sh: [112, 76, 52], line: [80, 54, 36] },
+    { hi: [130, 90, 64], base: [108, 74, 52], sh: [82, 56, 38], line: [56, 38, 26] },
+  ];
+  const L = 4;
+  const R = 13;
+
+  function clamp(v) {
+    return v < 0 ? 0 : v > 255 ? 255 : Math.round(v);
+  }
+  function shades(rgb, hi = 1.22, lo = 0.68) {
+    return [
+      [clamp(rgb[0] * hi), clamp(rgb[1] * hi), clamp(rgb[2] * hi)],
+      rgb,
+      [clamp(rgb[0] * lo), clamp(rgb[1] * lo), clamp(rgb[2] * lo)],
+    ];
+  }
+  function parseHex(hex) {
+    const h = String(hex || "#7c6af7").replace("#", "");
+    const full = h.length === 3 ? h[0] + h[0] + h[1] + h[1] + h[2] + h[2] : h;
+    return [
+      parseInt(full.slice(0, 2), 16) || 120,
+      parseInt(full.slice(2, 4), 16) || 100,
+      parseInt(full.slice(4, 6), 16) || 90,
+    ];
+  }
+  function set(buf, x, y, c, a = 255) {
+    if (x < 0 || x >= W || y < 0 || y >= H) return;
+    const i = (y * W + x) * 4;
+    buf[i] = c[0];
+    buf[i + 1] = c[1];
+    buf[i + 2] = c[2];
+    buf[i + 3] = a;
+  }
+  function alpha(buf, x, y) {
+    if (x < 0 || x >= W || y < 0 || y >= H) return 0;
+    return buf[(y * W + x) * 4 + 3];
+  }
+  function rect(buf, x0, y0, x1, y1, c) {
+    for (let y = y0; y <= y1; y++) for (let x = x0; x <= x1; x++) set(buf, x, y, c);
+  }
+  function dots(buf, pts, c) {
+    for (const [x, y] of pts) set(buf, x, y, c);
+  }
+
+  function drawHead(buf, s) {
+    for (let y = 4; y <= 16; y++) {
+      for (let x = L; x <= R; x++) {
+        if ((x === L || x === R) && (y === 4 || y === 16)) continue;
+        if ((x === L + 1 || x === R - 1) && y === 4) continue;
+        set(buf, x, y, s.base);
+      }
+    }
+    for (let y = 6; y <= 11; y++) set(buf, 5, y, s.hi);
+    set(buf, 6, 5, s.hi);
+    set(buf, 7, 5, s.hi);
+    for (let y = 6; y <= 15; y++) set(buf, 12, y, s.sh);
+    for (const x of [7, 8, 9, 10, 11]) set(buf, x, 16, s.sh);
+    set(buf, 3, 9, s.base);
+    set(buf, 3, 10, s.base);
+    set(buf, 3, 11, s.sh);
+    set(buf, 14, 9, s.base);
+    set(buf, 14, 10, s.base);
+    set(buf, 14, 11, s.sh);
+    rect(buf, 7, 17, 10, 18, s.sh);
+    rect(buf, 7, 17, 9, 17, s.base);
+  }
+
+  function drawFace(buf, s, brow, mouth, blush, lashes) {
+    const white = [250, 248, 244];
+    const pup = [46, 38, 42];
+    const glint = [252, 250, 248];
+    const lash = [54, 40, 48];
+    const lip = [158, 86, 80];
+    set(buf, 5, 9, white);
+    set(buf, 6, 9, pup);
+    set(buf, 10, 9, pup);
+    set(buf, 11, 9, white);
+    set(buf, 5, 9, glint);
+    if (lashes) {
+      for (const x of [5, 6, 10, 11]) set(buf, x, 8, lash);
+      set(buf, 4, 8, lash);
+      set(buf, 12, 8, lash);
+      set(buf, 10, 9, glint);
+    }
+    if (brow === 0) for (const x of [5, 6, 10, 11]) set(buf, x, 7, s.line);
+    else if (brow === 1) {
+      set(buf, 5, 8, s.line);
+      set(buf, 6, 7, s.line);
+      set(buf, 10, 7, s.line);
+      set(buf, 11, 8, s.line);
+    } else if (brow === 2) for (const x of [5, 6, 10, 11]) set(buf, x, 6, s.line);
+    else {
+      set(buf, 5, 7, s.line);
+      set(buf, 11, 7, s.line);
+      set(buf, 6, 7, s.sh);
+      set(buf, 10, 7, s.sh);
+    }
+    set(buf, 8, 11, s.sh);
+    set(buf, 8, 12, s.sh);
+    set(buf, 7, 12, s.sh);
+    const mouths = [
+      [[7, 14], [8, 14], [9, 14], [10, 14]],
+      [[7, 14], [8, 14], [9, 14], [10, 14], [6, 13], [11, 13]],
+      [[7, 15], [8, 15], [9, 15], [10, 15]],
+      [[6, 14], [7, 14], [8, 14], [9, 14], [10, 14], [11, 14], [6, 13], [11, 13]],
+    ];
+    dots(buf, mouths[mouth], lip);
+    if (blush) {
+      set(buf, 5, 12, [228, 140, 128]);
+      set(buf, 12, 12, [228, 140, 128]);
+    }
+  }
+
+  function hairShort(buf, hi, base, sh) {
+    rect(buf, L, 2, R, 4, base);
+    rect(buf, L - 1, 3, R + 1, 5, base);
+    for (let y = 6; y <= 8; y++) {
+      set(buf, L - 1, y, base);
+      set(buf, L, y, base);
+      set(buf, R, y, base);
+      set(buf, R + 1, y, base);
+    }
+    for (let x = L; x <= R; x++) set(buf, x, 5, base);
+    for (let y = 2; y <= 5; y++) set(buf, 8, y, sh);
+    for (let x = L; x <= 7; x++) if (alpha(buf, x, 2)) set(buf, x, 2, hi);
+    for (let x = L; x <= 7; x++) if (alpha(buf, x, 3)) set(buf, x, 3, hi);
+  }
+  function hairFringe(buf, hi, base, sh, skinBase) {
+    hairShort(buf, hi, base, sh);
+    rect(buf, 6, 6, 11, 6, base);
+    set(buf, 8, 6, skinBase);
+    set(buf, 9, 6, skinBase);
+    set(buf, 7, 6, hi);
+    set(buf, 10, 6, base);
+  }
+  function hairLong(buf, hi, base, sh, skinBase) {
+    hairShort(buf, hi, base, sh);
+    rect(buf, 6, 6, 11, 6, base);
+    set(buf, 8, 6, skinBase);
+    set(buf, 9, 6, skinBase);
+    for (let y = 9; y <= 18; y++) {
+      set(buf, L - 1, y, base);
+      set(buf, R + 1, y, sh);
+    }
+    set(buf, L - 1, 19, base);
+    set(buf, R + 1, 19, sh);
+  }
+  function hairBun(buf, hi, base, sh, skinBase) {
+    rect(buf, L, 3, R, 5, base);
+    rect(buf, L - 1, 4, R + 1, 5, base);
+    rect(buf, 7, 1, 10, 2, base);
+    set(buf, 8, 0, hi);
+    set(buf, 9, 0, base);
+    rect(buf, 6, 6, 11, 6, base);
+    set(buf, 8, 6, skinBase);
+    set(buf, 9, 6, skinBase);
+    for (let y = 6; y <= 8; y++) {
+      set(buf, L, y, base);
+      set(buf, R, y, sh);
+    }
+    for (let x = L; x <= R; x++) if (alpha(buf, x, 3)) set(buf, x, 3, hi);
+  }
+  function hairCurly(buf, hi, base, sh, skinBase) {
+    rect(buf, L, 3, R, 5, base);
+    const pts = [
+      [4, 2], [5, 1], [6, 2], [7, 1], [8, 2], [9, 1], [10, 2], [11, 1], [12, 2], [13, 2],
+      [3, 3], [3, 4], [3, 5], [3, 6], [14, 3], [14, 4], [14, 5], [14, 6], [4, 6], [13, 6],
+    ];
+    dots(buf, pts, base);
+    rect(buf, 6, 6, 11, 6, base);
+    set(buf, 8, 6, skinBase);
+    set(buf, 9, 6, skinBase);
+    dots(buf, [[5, 1], [7, 1], [9, 1], [11, 1]], hi);
+    set(buf, R + 1, 5, sh);
+  }
+  function hairSpiky(buf, hi, base, sh, skinBase) {
+    rect(buf, L, 3, R, 5, base);
+    rect(buf, L - 1, 4, R + 1, 5, base);
+    dots(buf, [[5, 2], [6, 1], [7, 2], [8, 1], [9, 2], [10, 1], [11, 2], [12, 1], [13, 2]], base);
+    dots(buf, [[6, 1], [8, 1], [10, 1], [12, 1]], hi);
+    rect(buf, 6, 6, 11, 6, base);
+    set(buf, 8, 6, skinBase);
+    set(buf, 9, 6, skinBase);
+    for (let y = 6; y <= 7; y++) {
+      set(buf, L, y, base);
+      set(buf, R, y, sh);
+    }
+  }
+  function hairBob(buf, hi, base, sh, skinBase) {
+    hairShort(buf, hi, base, sh);
+    rect(buf, 5, 6, 12, 6, base);
+    set(buf, 8, 6, skinBase);
+    set(buf, 9, 6, skinBase);
+    for (let y = 7; y <= 12; y++) {
+      set(buf, L - 1, y, base);
+      set(buf, R + 1, y, sh);
+    }
+    set(buf, L - 1, 13, base);
+    set(buf, R + 1, 13, sh);
+  }
+  function hairPony(buf, hi, base, sh) {
+    hairShort(buf, hi, base, sh);
+    rect(buf, 11, 0, 13, 2, base);
+    set(buf, 12, 0, hi);
+    set(buf, 13, 3, sh);
+    set(buf, 14, 1, base);
+    set(buf, 14, 2, sh);
+  }
+
+  const HAIR_FNS = [hairShort, hairFringe, hairLong, hairBun, hairCurly, hairSpiky, hairBob, hairPony];
+
+  function drawFacial(buf, kind, color) {
+    const [, base, sh] = shades(color);
+    if (kind === 1) {
+      for (const x of [6, 7, 8, 9, 10]) set(buf, x, 13, base);
+      set(buf, 6, 12, base);
+      set(buf, 10, 12, base);
+    } else if (kind === 2) {
+      dots(buf, [[5, 14], [6, 15], [7, 15], [8, 15], [9, 15], [10, 15], [11, 14], [12, 13], [4, 13]], sh);
+    } else if (kind === 3) {
+      rect(buf, 8, 14, 9, 15, base);
+      rect(buf, 7, 13, 10, 13, base);
+    }
+  }
+
+  function drawGlasses(buf) {
+    const frame = [60, 54, 62];
+    const glint = [236, 240, 246];
+    for (const x of [5, 6]) {
+      set(buf, x, 8, frame);
+      set(buf, x, 10, frame);
+    }
+    set(buf, 4, 9, frame);
+    set(buf, 7, 9, frame);
+    for (const x of [10, 11]) {
+      set(buf, x, 8, frame);
+      set(buf, x, 10, frame);
+    }
+    set(buf, 9, 9, frame);
+    set(buf, 12, 9, frame);
+    set(buf, 8, 8, frame);
+    set(buf, 3, 9, frame);
+    set(buf, 13, 9, frame);
+    set(buf, 4, 8, glint);
+    set(buf, 9, 8, glint);
+  }
+
+  function drawBody(buf, cloth, c1, c2, skin) {
+    const [hi, base, sh] = shades(c1);
+    rect(buf, 4, 18, 13, 18, base);
+    rect(buf, 3, 19, 14, 19, base);
+    rect(buf, 4, 20, 13, 24, base);
+    for (let y = 20; y <= 24; y++) {
+      set(buf, 3, y, sh);
+      set(buf, 14, y, sh);
+      set(buf, 13, y, sh);
+    }
+    set(buf, 3, 24, skin.sh);
+    set(buf, 14, 24, skin.sh);
+    if (cloth === 0) {
+      for (const [x, y] of [[6, 18], [7, 18], [10, 18], [11, 18]]) set(buf, x, y, sh);
+      rect(buf, 7, 18, 10, 19, skin.sh);
+    } else if (cloth === 1) {
+      const inner = c2 ? shades(c2)[1] : [235, 233, 226];
+      for (let y = 18; y <= 24; y++) {
+        set(buf, 8, y, inner);
+        set(buf, 9, y, inner);
+      }
+      for (const [x, y] of [[6, 18], [7, 18], [10, 18], [11, 18]]) set(buf, x, y, sh);
+    } else if (cloth === 2) {
+      for (const [x, y] of [[6, 18], [7, 18], [10, 18], [11, 18]]) set(buf, x, y, hi);
+      set(buf, 8, 19, sh);
+      set(buf, 8, 21, sh);
+    } else if (cloth === 3) {
+      for (const x of [6, 7, 8, 9, 10, 11]) set(buf, x, 18, sh);
+    } else if (cloth === 4) {
+      const inner = c2 ? shades(c2)[1] : [238, 236, 228];
+      rect(buf, 7, 18, 10, 19, inner);
+      for (const [x, y] of [[6, 18], [7, 19], [11, 18], [10, 19]]) set(buf, x, y, sh);
+      for (let y = 20; y <= 24; y += 2) set(buf, 8, y, sh);
+    } else {
+      const apron = [236, 224, 196];
+      rect(buf, 7, 20, 10, 24, apron);
+      set(buf, 8, 19, apron);
+      set(buf, 9, 19, apron);
+      for (const [x, y] of [[6, 18], [7, 18], [10, 18], [11, 18]]) set(buf, x, y, hi);
+    }
+  }
+
+  function drawLegs(buf, pants, shoe, short) {
+    const top = short ? 26 : 25;
+    const foot = short ? 30 : 31;
+    const [, base, sh] = shades(pants);
+    rect(buf, 5, top, 7, foot - 1, base);
+    rect(buf, 10, top, 12, foot - 1, base);
+    for (let y = top; y <= foot - 1; y++) {
+      set(buf, 7, y, sh);
+      set(buf, 12, y, sh);
+    }
+    rect(buf, 5, foot, 7, foot, shoe);
+    rect(buf, 10, foot, 12, foot, shoe);
+  }
+
+  function elfEars(buf, s) {
+    dots(buf, [[2, 8], [2, 7], [3, 7], [3, 8]], s.base);
+    set(buf, 2, 7, s.hi);
+    dots(buf, [[15, 8], [15, 7], [14, 7], [14, 8]], s.base);
+    set(buf, 15, 7, s.hi);
+  }
+
+  function demiEars(buf, s) {
+    set(buf, 3, 8, s.base);
+    set(buf, 2, 9, s.sh);
+    set(buf, 14, 8, s.base);
+    set(buf, 15, 9, s.sh);
+  }
+
+  function dwarfStout(buf, clothRgb, skin) {
+    const sh = shades(clothRgb)[2];
+    for (let y = 19; y <= 24; y++) {
+      set(buf, 2, y, sh);
+      set(buf, 15, y, sh);
+    }
+    for (const x of [5, 6, 10, 11]) set(buf, x, 7, skin.line);
+  }
+
+  function outlinePass(buf) {
+    const pts = [];
+    for (let y = 0; y < H; y++) {
+      for (let x = 0; x < W; x++) {
+        if (alpha(buf, x, y) !== 0) continue;
+        if (
+          alpha(buf, x + 1, y) === 255 ||
+          alpha(buf, x - 1, y) === 255 ||
+          alpha(buf, x, y + 1) === 255 ||
+          alpha(buf, x, y - 1) === 255
+        ) {
+          pts.push([x, y]);
+        }
+      }
+    }
+    for (const [x, y] of pts) set(buf, x, y, OUT);
+  }
+
+  function fnv(key) {
+    let n = 2166136261;
+    const s = String(key || "");
+    for (let i = 0; i < s.length; i++) {
+      n ^= s.charCodeAt(i);
+      n = Math.imul(n, 16777619);
+    }
+    return n >>> 0;
+  }
+
+  function buddyPixels(shirt, seed) {
+    const n = typeof seed === "string" ? fnv(seed) : seed >>> 0;
+    const buf = new Uint8ClampedArray(W * H * 4);
+    const race = (n >>> 20) % 4;
+    const skin = SKIN[n % SKIN.length];
+    const hairc = HAIR_RGB[(n * 3) % HAIR_RGB.length];
+    const [hi, base, sh] = shades(hairc);
+    const cloth = n % 6;
+    const pants = PANTS[(n * 5) % PANTS.length];
+    const shoe = SHOE[n % SHOE.length];
+    const shirtRgb = parseHex(shirt);
+    const accent = shades(shirtRgb)[2];
+    const brow = race === 1 ? 0 : (n * 7) % 4;
+    const mouth = [1, 3, 0, 1][n % 4];
+    const lashes = cloth === 1 || cloth === 5 || (n % 5 === 2);
+    const blush = lashes && n % 3 !== 0;
+    const glasses = n % 19 === 0;
+    const facial = 0;
+    drawBody(buf, cloth, shirtRgb, accent, skin);
+    drawLegs(buf, pants, shoe, race === 1);
+    drawHead(buf, skin);
+    drawFace(buf, skin, brow, mouth, blush, lashes);
+    if (facial) drawFacial(buf, facial, hairc);
+    HAIR_FNS[n % HAIR_FNS.length](buf, hi, base, sh, skin.base);
+    if (glasses) drawGlasses(buf);
+    if (race === 1) dwarfStout(buf, shirtRgb, skin);
+    if (race === 2) elfEars(buf, skin);
+    if (race === 3) demiEars(buf, skin);
+    outlinePass(buf);
+    return buf;
+  }
+
+  function drawBuddy(canvas, shirt, seed) {
+    const ctx = canvas.getContext("2d");
+    canvas.width = W;
+    canvas.height = H;
+    ctx.imageSmoothingEnabled = false;
+    const img = ctx.createImageData(W, H);
+    img.data.set(buddyPixels(shirt, seed));
+    ctx.putImageData(img, 0, 0);
+  }
+
+  root.BUDDY_W = W;
+  root.BUDDY_H = H;
+  root.buddyFnv = fnv;
+  root.buddyPixels = buddyPixels;
+  root.drawBuddy = drawBuddy;
+})(typeof globalThis !== "undefined" ? globalThis : this);