@hewnui/themes 0.0.0-stage → 0.1.1

package/src/authoring/export-dtcg.ts

@@ -0,0 +1,116 @@
+import {
+  colorEntries,
+  modeOrder,
+  primaryMode,
+  structuralEntries,
+} from "./token-entries";
+import type { ResolvedMode, ResolvedPack } from "./types";
+
+type DtcgLeaf = {
+  $type: string;
+  $value: string | number | string[];
+  $description?: string;
+};
+
+type DtcgNode = { [key: string]: DtcgNode | DtcgLeaf };
+
+function leaf(
+  type: string,
+  value: string | number | string[],
+  description?: string,
+): DtcgLeaf {
+  return description
+    ? { $type: type, $value: value, $description: description }
+    : { $type: type, $value: value };
+}
+
+function modeColors(mode: ResolvedMode): DtcgNode {
+  const color: DtcgNode = {};
+  for (const entry of colorEntries(mode)) {
+    color[entry.name] = leaf("color", entry.value);
+  }
+  return color;
+}
+
+function structuralGroup(mode: ResolvedMode): DtcgNode {
+  const radius: DtcgNode = {};
+  const motion: DtcgNode = {};
+  let density: DtcgLeaf | undefined;
+
+  for (const entry of structuralEntries(mode)) {
+    if (entry.name.startsWith("radius-")) {
+      radius[entry.name.replace(/^radius-/, "")] = leaf(
+        "dimension",
+        entry.value,
+      );
+      continue;
+    }
+    if (entry.name.startsWith("motion-")) {
+      const key = entry.name.replace(/^motion-/, "");
+      motion[key] = leaf(
+        entry.kind === "number" ? "number" : "duration",
+        entry.kind === "number" ? Number(entry.value) : entry.value,
+      );
+      continue;
+    }
+    if (entry.name === "density") {
+      density = leaf("number", Number(entry.value));
+    }
+  }
+
+  return {
+    radius,
+    motion,
+    ...(density ? { density } : {}),
+  };
+}
+
+/**
+ * Free — W3C Design Tokens Community Group JSON (`$value` / `$type`).
+ * Modes live under `modes.light` / `modes.dark` when supported.
+ */
+export function exportDtcg(pack: ResolvedPack): string {
+  const modes: DtcgNode = {};
+  for (const modeName of modeOrder(pack)) {
+    const mode = pack.modes[modeName];
+    if (!mode) continue;
+    modes[modeName] = {
+      color: modeColors(mode),
+      ...structuralGroup(mode),
+    };
+  }
+
+  const primary = primaryMode(pack);
+  const doc = {
+    $description: `Hewn ${pack.id} theme — DTCG design tokens (${modeOrder(pack).join(" / ")}).`,
+    meta: {
+      packId: leaf("string", pack.id),
+      basePackId: leaf("string", pack.basePackId),
+      supportedModes: leaf("string", modeOrder(pack).join(",")),
+      colorScheme: leaf("string", primary.colorScheme),
+    },
+    typography: {
+      fontFamily: {
+        sans: leaf("fontFamily", [
+          "IBM Plex Sans",
+          "ui-sans-serif",
+          "system-ui",
+          "sans-serif",
+        ]),
+        mono: leaf("fontFamily", [
+          "IBM Plex Mono",
+          "ui-monospace",
+          "monospace",
+        ]),
+        display: leaf("fontFamily", [
+          "Space Grotesk",
+          "IBM Plex Sans",
+          "sans-serif",
+        ]),
+      },
+    },
+    modes,
+  };
+
+  return `${JSON.stringify(doc, null, 2)}\n`;
+}

package/src/authoring/export-figma.ts

@@ -0,0 +1,109 @@
+import {
+  colorEntries,
+  modeOrder,
+  primaryMode,
+  structuralEntries,
+} from "./token-entries";
+import type { ResolvedPack } from "./types";
+
+type TsToken = {
+  value: string | number;
+  type: string;
+  description?: string;
+};
+
+type TsSet = { [key: string]: TsToken | TsSet };
+
+type TsTheme = {
+  id: string;
+  name: string;
+  selectedTokenSets: Record<string, "enabled" | "source">;
+};
+
+function nest(set: TsSet, path: string[], token: TsToken) {
+  let cursor: TsSet = set;
+  for (let i = 0; i < path.length - 1; i += 1) {
+    const key = path[i]!;
+    const existing = cursor[key];
+    if (!existing || typeof existing !== "object" || "value" in existing) {
+      cursor[key] = {};
+    }
+    cursor = cursor[key] as TsSet;
+  }
+  cursor[path[path.length - 1]!] = token;
+}
+
+/** Build Tokens Studio token sets + themes for one or more packs. */
+export function buildFigmaDocument(packs: readonly ResolvedPack[]): {
+  tokenSets: Record<string, TsSet>;
+  themes: TsTheme[];
+} {
+  const tokenSets: Record<string, TsSet> = {};
+  const themes: TsTheme[] = [];
+
+  for (const pack of packs) {
+    const structural: TsSet = {};
+    const primary = primaryMode(pack);
+    for (const entry of structuralEntries(primary)) {
+      nest(structural, [entry.name], {
+        value: entry.kind === "number" ? Number(entry.value) : entry.value,
+        type: entry.kind === "number" ? "number" : "sizing",
+      });
+    }
+    tokenSets[`${pack.id}/structural`] = structural;
+
+    for (const modeName of modeOrder(pack)) {
+      const mode = pack.modes[modeName];
+      if (!mode) continue;
+      const setName = `${pack.id}/${modeName}`;
+      const set: TsSet = {};
+      for (const entry of colorEntries(mode)) {
+        nest(set, ["color", entry.name], {
+          value: entry.value,
+          type: "color",
+        });
+      }
+      tokenSets[setName] = set;
+      themes.push({
+        id: `${pack.id}-${modeName}`,
+        name: `${pack.id} / ${modeName}`,
+        selectedTokenSets: {
+          [`${pack.id}/structural`]: "source",
+          [setName]: "enabled",
+        },
+      });
+    }
+  }
+
+  return { tokenSets, themes };
+}
+
+function stringifyFigmaDoc(
+  tokenSets: Record<string, TsSet>,
+  themes: TsTheme[],
+): string {
+  const doc = {
+    $metadata: {
+      tokenSetOrder: Object.keys(tokenSets),
+      activeThemeEditor: themes[0]?.id ?? null,
+    },
+    $themes: themes,
+    ...tokenSets,
+  };
+  return `${JSON.stringify(doc, null, 2)}\n`;
+}
+
+/**
+ * Pro — Tokens Studio–compatible multi-set export for one authored pack.
+ * Import via Tokens Studio → Figma variables.
+ */
+export function exportFigmaVariables(pack: ResolvedPack): string {
+  const { tokenSets, themes } = buildFigmaDocument([pack]);
+  return stringifyFigmaDoc(tokenSets, themes);
+}
+
+/** Curated kit — all packs in one Tokens Studio document. */
+export function exportFigmaKit(packs: readonly ResolvedPack[]): string {
+  const { tokenSets, themes } = buildFigmaDocument(packs);
+  return stringifyFigmaDoc(tokenSets, themes);
+}

package/src/authoring/export-formats.ts

@@ -0,0 +1,101 @@
+import { exportDesignMd } from "./export-design-md";
+import { exportDtcg } from "./export-dtcg";
+import { exportTailwindTheme } from "./export-css";
+import { exportSkillMd } from "./export-skill";
+import type { ResolvedPack } from "./types";
+
+/**
+ * Export tier marker — today every curated Theme Lab format is `free`.
+ * Advanced Studio formats (Style Dictionary, Figma) can flip to `pro` later
+ * without changing call sites; consumers must not gate on this yet.
+ */
+export type ExportTier = "free" | "pro";
+
+export type ThemeExportFormatId =
+  | "design-md"
+  | "dtcg"
+  | "tailwind-theme"
+  | "skill-md";
+
+export type ThemeExportFormat = {
+  id: ThemeExportFormatId;
+  /** Short UI label */
+  label: string;
+  /** Accessible description for buttons / docs */
+  description: string;
+  /** Suggested download filename (pack id substituted) */
+  filename: (packId: string) => string;
+  mime: string;
+  tier: ExportTier;
+  render: (pack: ResolvedPack) => string;
+};
+
+/** Free curated Theme Lab / docs site formats. */
+export const THEME_EXPORT_FORMATS: readonly ThemeExportFormat[] = [
+  {
+    id: "design-md",
+    label: "DESIGN.md",
+    description: "Human- and AI-readable design brief with OKLCH roles and rules",
+    filename: (packId) => `${packId}.DESIGN.md`,
+    mime: "text/markdown;charset=utf-8",
+    tier: "free",
+    render: exportDesignMd,
+  },
+  {
+    id: "dtcg",
+    label: "DTCG tokens",
+    description: "W3C Design Tokens JSON ($value / $type) with light and dark modes",
+    filename: (packId) => `${packId}.tokens.dtcg.json`,
+    mime: "application/json",
+    tier: "free",
+    render: exportDtcg,
+  },
+  {
+    id: "tailwind-theme",
+    label: "Tailwind @theme",
+    description: "Tailwind CSS v4 @theme file with mode remaps",
+    filename: (packId) => `${packId}.theme.css`,
+    mime: "text/css;charset=utf-8",
+    tier: "free",
+    render: exportTailwindTheme,
+  },
+  {
+    id: "skill-md",
+    label: "Agent skill",
+    description: "SKILL.md instructions for coding agents using this theme",
+    filename: (packId) => `${packId}.SKILL.md`,
+    mime: "text/markdown;charset=utf-8",
+    tier: "free",
+    render: exportSkillMd,
+  },
+] as const;
+
+export function getThemeExportFormat(
+  id: ThemeExportFormatId,
+): ThemeExportFormat {
+  const format = THEME_EXPORT_FORMATS.find((entry) => entry.id === id);
+  if (!format) throw new Error(`Unknown theme export format: ${id}`);
+  return format;
+}
+
+export function renderThemeExport(
+  id: ThemeExportFormatId,
+  pack: ResolvedPack,
+): string {
+  return getThemeExportFormat(id).render(pack);
+}
+
+export const THEME_EXPORT_BASENAMES: Record<ThemeExportFormatId, string> = {
+  "design-md": "DESIGN.md",
+  dtcg: "tokens.dtcg.json",
+  "tailwind-theme": "theme.css",
+  "skill-md": "SKILL.md",
+};
+
+/** Static public path for a generated curated export. */
+export function themeExportPublicPath(
+  packId: string,
+  id: ThemeExportFormatId,
+): string {
+  return `/themes/${packId}/${THEME_EXPORT_BASENAMES[id]}`;
+}

package/src/authoring/export-skill.ts

@@ -0,0 +1,93 @@
+import {
+  COLOR_ROLES,
+  DESIGN_DO,
+  DESIGN_DONT,
+  PACK_IDENTITY,
+} from "./pack-meta";
+import {
+  colorEntries,
+  modeOrder,
+  primaryMode,
+  structuralEntries,
+} from "./token-entries";
+import type { BasePackId, ResolvedPack } from "./types";
+
+function identity(pack: ResolvedPack) {
+  return (
+    PACK_IDENTITY[pack.basePackId as BasePackId] ?? {
+      label: pack.id,
+      summary: `Custom pack based on ${pack.basePackId}.`,
+    }
+  );
+}
+
+/**
+ * Free — Cursor-style agent skill (SKILL.md) for applying this theme correctly.
+ */
+export function exportSkillMd(pack: ResolvedPack): string {
+  const { label, summary } = identity(pack);
+  const modes = modeOrder(pack);
+  const mode = primaryMode(pack);
+  const skillName = `hewn-${pack.id}-theme`;
+
+  const colorLines = colorEntries(mode)
+    .map((e) => `| \`--kp-${e.name}\` / \`--color-${e.name}\` | ${COLOR_ROLES[e.name] ?? e.name} | \`${e.value}\` |`)
+    .join("\n");
+
+  const structuralLines = structuralEntries(mode)
+    .map((e) => `- \`--kp-${e.name}\`: \`${e.value}\``)
+    .join("\n");
+
+  return `---
+name: ${skillName}
+description: Apply the Hewn ${label} theme tokens, typography, motion, and design rules when building or restyling UI.
+---
+
+# ${label} theme (Hewn)
+
+${summary}
+
+Use this skill whenever generating UI that should match the **${label}** pack
+(\`${pack.id}\`). Supported modes: **${modes.join(", ")}**.
+
+## Quick rules
+
+${DESIGN_DO.map((item) => `- ${item}`).join("\n")}
+
+## Never
+
+${DESIGN_DONT.map((item) => `- ${item}`).join("\n")}
+
+## How to apply
+
+1. Set \`data-theme="${pack.id}"\` and \`data-mode="{${modes.join("|")}}"\` on a root element (or import the generated \`@theme\` CSS).
+2. Prefer semantic utilities / CSS variables (\`bg-background\`, \`text-foreground\`, \`bg-accent\`, \`border-border\`, \`--kp-*\`).
+3. Respect reduced motion — disable springs/shimmers when \`prefers-reduced-motion: reduce\`.
+4. Keep glass as a global material toggle; do not add per-component glass props.
+
+## Color tokens (primary mode: ${mode.mode})
+
+| Token | Role | Value |
+|---|---|---|
+${colorLines}
+
+## Structure
+
+${structuralLines}
+
+## Typography
+
+- **Sans:** IBM Plex Sans — UI and body
+- **Mono:** IBM Plex Mono — labels, code, metrics (\`tabular-nums\`)
+- **Display:** Space Grotesk — hero H1 / brand wordmark ≥18px only
+
+## Export companions
+
+- \`DESIGN.md\` — full design brief
+- \`tokens.dtcg.json\` — DTCG (\`$value\` / \`$type\`) with light/dark modes
+- \`theme.css\` — Tailwind v4 \`@theme\` block
+
+When unsure, re-read \`DESIGN.md\` for this pack and keep accents within the
+curated ramp — do not invent a new hue family.
+`;
+}

package/src/authoring/export-sticker.ts

@@ -0,0 +1,60 @@
+import { formatOklch } from "./oklch";
+import { primaryMode } from "./token-entries";
+import type { ResolvedPack } from "./types";
+
+const ROW_H = 96;
+const PAD = 24;
+const COL_W = 120;
+const LABEL_W = 88;
+
+/**
+ * Core sticker sheet SVG — surfaces, button, and input per pack.
+ * Use as a Figma community kit reference (paste or import SVG).
+ */
+export function exportStickerSheetSvg(packs: readonly ResolvedPack[]): string {
+  const width = PAD * 2 + LABEL_W + COL_W * 4;
+  const height = PAD * 2 + 40 + packs.length * ROW_H;
+  const rows = packs
+    .map((pack, index) => renderRow(pack, PAD + 40 + index * ROW_H))
+    .join("\n");
+
+  return `<?xml version="1.0" encoding="UTF-8"?>
+<svg xmlns="http://www.w3.org/2000/svg" width="${width}" height="${height}" viewBox="0 0 ${width} ${height}" role="img" aria-label="Hewn sticker sheet">
+  <rect width="100%" height="100%" fill="#f4f4f2"/>
+  <text x="${PAD}" y="${PAD + 16}" font-family="IBM Plex Sans, ui-sans-serif, system-ui, sans-serif" font-size="16" font-weight="600" fill="#1a1a18">Hewn · sticker sheet</text>
+  <text x="${PAD + LABEL_W}" y="${PAD + 34}" font-family="IBM Plex Mono, ui-monospace, monospace" font-size="10" fill="#6b6b66">surface</text>
+  <text x="${PAD + LABEL_W + COL_W}" y="${PAD + 34}" font-family="IBM Plex Mono, ui-monospace, monospace" font-size="10" fill="#6b6b66">raised</text>
+  <text x="${PAD + LABEL_W + COL_W * 2}" y="${PAD + 34}" font-family="IBM Plex Mono, ui-monospace, monospace" font-size="10" fill="#6b6b66">button</text>
+  <text x="${PAD + LABEL_W + COL_W * 3}" y="${PAD + 34}" font-family="IBM Plex Mono, ui-monospace, monospace" font-size="10" fill="#6b6b66">input</text>
+${rows}
+</svg>
+`;
+}
+
+function renderRow(pack: ResolvedPack, y: number): string {
+  const mode = primaryMode(pack);
+  const bg = formatOklch(mode.background);
+  const surface = formatOklch(mode.surface);
+  const raised = formatOklch(mode.surfaceRaised);
+  const accent = formatOklch(mode.accent);
+  const accentFg = formatOklch(mode.accentForeground);
+  const fg = formatOklch(mode.foreground);
+  const border = formatOklch(mode.border);
+  const muted = formatOklch(mode.mutedForeground);
+  const x0 = PAD + LABEL_W;
+
+  return `  <g>
+    <text x="${PAD}" y="${y + 42}" font-family="IBM Plex Sans, ui-sans-serif, system-ui, sans-serif" font-size="13" fill="#1a1a18">${pack.id}</text>
+    <rect x="${x0}" y="${y}" width="100" height="72" rx="10" fill="${bg}" stroke="${border}" stroke-width="1"/>
+    <rect x="${x0 + 12}" y="${y + 14}" width="76" height="44" rx="8" fill="${surface}" stroke="${border}" stroke-width="1"/>
+    <rect x="${x0 + COL_W}" y="${y}" width="100" height="72" rx="10" fill="${bg}" stroke="${border}" stroke-width="1"/>
+    <rect x="${x0 + COL_W + 12}" y="${y + 14}" width="76" height="44" rx="8" fill="${raised}" stroke="${border}" stroke-width="1"/>
+    <rect x="${x0 + COL_W * 2}" y="${y}" width="100" height="72" rx="10" fill="${bg}" stroke="${border}" stroke-width="1"/>
+    <rect x="${x0 + COL_W * 2 + 14}" y="${y + 22}" width="72" height="28" rx="8" fill="${accent}"/>
+    <text x="${x0 + COL_W * 2 + 50}" y="${y + 40}" text-anchor="middle" font-family="IBM Plex Sans, ui-sans-serif, system-ui, sans-serif" font-size="11" fill="${accentFg}">Button</text>
+    <rect x="${x0 + COL_W * 3}" y="${y}" width="100" height="72" rx="10" fill="${bg}" stroke="${border}" stroke-width="1"/>
+    <rect x="${x0 + COL_W * 3 + 10}" y="${y + 22}" width="80" height="28" rx="8" fill="${surface}" stroke="${border}" stroke-width="1"/>
+    <text x="${x0 + COL_W * 3 + 18}" y="${y + 40}" font-family="IBM Plex Sans, ui-sans-serif, system-ui, sans-serif" font-size="11" fill="${muted}">Input</text>
+    <text x="${x0 + COL_W * 3 + 70}" y="${y + 40}" font-family="IBM Plex Sans, ui-sans-serif, system-ui, sans-serif" font-size="9" fill="${fg}" opacity="0.35">|</text>
+  </g>`;
+}

package/src/authoring/export-style-dictionary.ts

@@ -0,0 +1,67 @@
+import {
+  colorEntries,
+  modeOrder,
+  primaryMode,
+  structuralEntries,
+} from "./token-entries";
+import type { ResolvedPack } from "./types";
+
+type SdLeaf = { value: string | number; type: string };
+type SdNode = { [key: string]: SdNode | SdLeaf };
+
+function setPath(root: SdNode, path: string[], leaf: SdLeaf) {
+  let cursor = root;
+  for (let i = 0; i < path.length - 1; i += 1) {
+    const key = path[i]!;
+    const existing = cursor[key];
+    if (!existing || typeof existing !== "object" || "value" in existing) {
+      cursor[key] = {};
+    }
+    cursor = cursor[key] as SdNode;
+  }
+  cursor[path[path.length - 1]!] = leaf;
+}
+
+function parseNumeric(value: string): string | number {
+  const asNum = Number(value);
+  return Number.isFinite(asNum) && value.trim() !== "" ? asNum : value;
+}
+
+/** Pro — Style Dictionary–friendly nested token JSON (all modes). */
+export function exportStyleDictionary(pack: ResolvedPack): string {
+  const tree: SdNode = {};
+  const modes = modeOrder(pack);
+
+  for (const modeName of modes) {
+    const mode = pack.modes[modeName];
+    if (!mode) continue;
+    for (const entry of colorEntries(mode)) {
+      setPath(tree, ["color", entry.name, modeName], {
+        value: entry.value,
+        type: "color",
+      });
+    }
+  }
+
+  const primary = primaryMode(pack);
+  for (const entry of structuralEntries(primary)) {
+    const [group, ...rest] = entry.name.split("-");
+    const path = rest.length > 0 ? [group!, rest.join("-")] : [entry.name];
+    setPath(tree, path, {
+      value: parseNumeric(entry.value),
+      type: entry.kind === "number" ? "number" : "dimension",
+    });
+  }
+
+  setPath(tree, ["meta", "packId"], { value: pack.id, type: "other" });
+  setPath(tree, ["meta", "basePackId"], {
+    value: pack.basePackId,
+    type: "other",
+  });
+  setPath(tree, ["meta", "supportedModes"], {
+    value: modes.join(","),
+    type: "other",
+  });
+
+  return `${JSON.stringify(tree, null, 2)}\n`;
+}

package/src/authoring/figma-kit.ts

@@ -0,0 +1,60 @@
+import { derivePack } from "./derive";
+import { exportFigmaKit } from "./export-figma";
+import {
+  THEME_EXPORT_BASENAMES,
+  THEME_EXPORT_FORMATS,
+  type ThemeExportFormatId,
+} from "./export-formats";
+import { exportStickerSheetSvg } from "./export-sticker";
+import { BASE_PACK_IDS, type BasePackId, type ResolvedPack } from "./types";
+
+/** Derive curated packs with no overrides (canonical kit source). */
+export function curatedResolvedPacks(): ResolvedPack[] {
+  return BASE_PACK_IDS.map((basePackId) => curatedResolvedPack(basePackId));
+}
+
+export function curatedResolvedPack(basePackId: BasePackId): ResolvedPack {
+  const result = derivePack({
+    schemaVersion: 2,
+    basePackId,
+    packId: basePackId,
+  });
+  if (!result.ok) {
+    throw new Error(
+      `failed to derive curated pack ${basePackId}: ${result.errors.join(", ")}`,
+    );
+  }
+  return result.pack;
+}
+
+export function exportCuratedFigmaKit(): string {
+  return exportFigmaKit(curatedResolvedPacks());
+}
+
+export function exportCuratedStickerSheet(): string {
+  return exportStickerSheetSvg(curatedResolvedPacks());
+}
+
+export type CuratedThemeExportFile = {
+  packId: string;
+  formatId: ThemeExportFormatId;
+  /** Stable basename under `/themes/{packId}/` */
+  basename: string;
+  contents: string;
+};
+
+/** All free Theme Lab formats × six curated packs. */
+export function exportCuratedThemeFiles(): CuratedThemeExportFile[] {
+  const files: CuratedThemeExportFile[] = [];
+  for (const pack of curatedResolvedPacks()) {
+    for (const format of THEME_EXPORT_FORMATS) {
+      files.push({
+        packId: pack.id,
+        formatId: format.id,
+        basename: THEME_EXPORT_BASENAMES[format.id],
+        contents: format.render(pack),
+      });
+    }
+  }
+  return files;
+}

package/src/authoring/index.ts

@@ -0,0 +1,61 @@
+export { derivePack } from "./derive";
+export type { DeriveResult } from "./derive";
+export { exportPackCss, exportTailwindTheme } from "./export-css";
+export { exportDesignMd, sampleAccent } from "./export-design-md";
+export { exportDtcg } from "./export-dtcg";
+export {
+  getThemeExportFormat,
+  renderThemeExport,
+  themeExportPublicPath,
+  THEME_EXPORT_BASENAMES,
+  THEME_EXPORT_FORMATS,
+  type ExportTier,
+  type ThemeExportFormat,
+  type ThemeExportFormatId,
+} from "./export-formats";
+export { exportSkillMd } from "./export-skill";
+export { modeToCssVars, modeToPreviewCss } from "./css-vars";
+export { exportFigmaKit, exportFigmaVariables } from "./export-figma";
+export { exportStyleDictionary } from "./export-style-dictionary";
+export { exportStickerSheetSvg } from "./export-sticker";
+export {
+  curatedResolvedPack,
+  curatedResolvedPacks,
+  exportCuratedFigmaKit,
+  exportCuratedStickerSheet,
+  exportCuratedThemeFiles,
+  type CuratedThemeExportFile,
+} from "./figma-kit";
+export { contrastForeground, contrastRatio, formatHex, formatOklch, parseColor } from "./oklch";
+export { normalizeOverrideMap } from "./override-map";
+export type { NormalizeResult } from "./override-map";
+export { PACK_IDENTITY, DESIGN_DO, DESIGN_DONT } from "./pack-meta";
+export { BASE_PACKS, supportedModes } from "./packs";
+export {
+  extractColorsFromCss,
+  parseAiProposal,
+  pickAccentFromColors,
+  proposeFromPalette,
+  proposeFromPrompt,
+  proposalToOverrideMap,
+  suggestBasePack,
+  suggestRadius,
+} from "./propose";
+export type { ThemeProposal } from "./propose";
+export { accentSetFromSeed } from "./ramps";
+export {
+  BASE_PACK_IDS,
+  PRO_AUTHORING_UNLOCKED,
+  SCHEMA_VERSION,
+  type BasePackId,
+  type DensityPreset,
+  type GlassOverrides,
+  type MotionCharacter,
+  type NeutralOverrides,
+  type OverrideMap,
+  type RadiusPreset,
+  type ResolvedPack,
+  type SemanticOverrides,
+  type ShapeOverrides,
+  type ThemeMode,
+} from "./types";