@tomako/tools-runtime 0.1.0

package/src/lib/tools/draft-preview-access.ts

@@ -0,0 +1,3 @@
+export function canAccessToolDraftPreview(nodeEnv = process.env.NODE_ENV): boolean {
+  return nodeEnv !== "production";
+}

package/src/lib/tools/draft-store.ts

@@ -0,0 +1,69 @@
+import { DRAFT_STORE_KEY } from "../../constants/LKS";
+import type { ToolDraft, ToolDraftStore } from "./types";
+const MAX_DRAFTS = 20;
+
+function emptyStore(): ToolDraftStore {
+  return { version: 1, drafts: [] };
+}
+
+function readStore(): ToolDraftStore {
+  if (typeof window === "undefined") {
+    return emptyStore();
+  }
+
+  try {
+    const raw = window.localStorage.getItem(DRAFT_STORE_KEY);
+    if (!raw) return emptyStore();
+    const parsed = JSON.parse(raw) as ToolDraftStore;
+    if (parsed.version !== 1 || !Array.isArray(parsed.drafts)) {
+      return emptyStore();
+    }
+    return parsed;
+  } catch {
+    return emptyStore();
+  }
+}
+
+function writeStore(store: ToolDraftStore) {
+  if (typeof window === "undefined") return;
+  window.localStorage.setItem(DRAFT_STORE_KEY, JSON.stringify(store));
+}
+
+export function listToolDrafts(): ToolDraft[] {
+  return readStore().drafts.sort(
+    (a, b) => new Date(b.updatedAt).getTime() - new Date(a.updatedAt).getTime(),
+  );
+}
+
+export function getToolDraftBySlug(slug: string): ToolDraft | undefined {
+  return listToolDrafts().find((draft) => draft.slug === slug);
+}
+
+export function getToolDraftById(id: string): ToolDraft | undefined {
+  return listToolDrafts().find((draft) => draft.id === id);
+}
+
+export function upsertToolDraft(draft: ToolDraft): ToolDraft {
+  const store = readStore();
+  const index = store.drafts.findIndex((item) => item.id === draft.id);
+  const nextDraft = { ...draft, updatedAt: new Date().toISOString() };
+
+  if (index >= 0) {
+    store.drafts[index] = nextDraft;
+  } else {
+    store.drafts.unshift(nextDraft);
+  }
+
+  store.drafts = store.drafts
+    .sort((a, b) => new Date(b.updatedAt).getTime() - new Date(a.updatedAt).getTime())
+    .slice(0, MAX_DRAFTS);
+
+  writeStore(store);
+  return nextDraft;
+}
+
+export function removeToolDraft(id: string) {
+  const store = readStore();
+  store.drafts = store.drafts.filter((draft) => draft.id !== id);
+  writeStore(store);
+}

package/src/lib/tools/email-template-generator-schema.ts

@@ -0,0 +1,124 @@
+import { z } from "zod";
+
+export const EMAIL_TEMPLATE_RESULT_TYPE = "email_template_package";
+export const EMAIL_TEMPLATE_SCENE = "email_template_generator";
+export const EMAIL_TEMPLATE_PROMPT_VERSION = "email-template-generator.v1";
+
+export const emailTemplateScenarioSchema = z.enum([
+  "newsletter",
+  "productLaunch",
+  "promoCampaign",
+  "lifecycleNurture",
+  "verificationCode",
+  "invoiceReceipt",
+  "subscriptionConfirmation",
+  "accountNotification",
+]);
+
+export const emailTemplateToneSchema = z.enum([
+  "clear",
+  "friendly",
+  "premium",
+  "urgent",
+  "minimal",
+  "technical",
+]);
+
+export const emailTemplateLanguageSchema = z.enum(["zh", "en"]);
+
+export const emailTemplateInputSchema = z.object({
+  productName: z.string().trim().min(1).max(100),
+  audience: z.string().trim().min(2).max(160),
+  brief: z.string().trim().min(24).max(1600),
+  scenario: emailTemplateScenarioSchema.default("newsletter"),
+  tone: emailTemplateToneSchema.default("clear"),
+  language: emailTemplateLanguageSchema.default("zh"),
+  primaryCta: z.string().trim().max(120).optional().default(""),
+  brandNotes: z.string().trim().max(900).optional().default(""),
+  mustInclude: z.string().trim().max(900).optional().default(""),
+});
+
+export const emailTemplateVariableSchema = z.object({
+  key: z.string().trim().min(1).max(80),
+  example: z.string().trim().max(160).optional(),
+  description: z.string().trim().max(260).optional(),
+});
+
+export const emailTemplateSectionSchema = z.object({
+  id: z.string().trim().min(1).max(80),
+  label: z.string().trim().min(1).max(120),
+  purpose: z.string().trim().max(260).optional(),
+  content: z.string().trim().min(1).max(1800),
+});
+
+export const emailTemplateResultSchema = z.object({
+  summary: z.string().trim().min(1).max(1000),
+  subject: z.string().trim().min(1).max(180),
+  preheader: z.string().trim().min(1).max(220),
+  mjml: z.string().trim().min(80),
+  html: z.string().trim().min(80),
+  plainText: z.string().trim().min(20),
+  editableSections: z.array(emailTemplateSectionSchema).min(1).max(12),
+  variables: z.array(emailTemplateVariableSchema).default([]),
+  complianceNotes: z.array(z.string().trim().min(1).max(500)).default([]),
+  developerNotes: z.array(z.string().trim().min(1).max(500)).default([]),
+  accessibilityNotes: z.array(z.string().trim().min(1).max(500)).default([]),
+  renderChecklist: z.array(z.string().trim().min(1).max(500)).default([]),
+  missingInfo: z.array(z.string().trim().min(1).max(500)).default([]),
+  promptVersion: z.string().trim().min(1).max(120).default(EMAIL_TEMPLATE_PROMPT_VERSION),
+  generatedAt: z.string().trim().max(80).optional(),
+});
+
+export type EmailTemplateScenario = z.infer<typeof emailTemplateScenarioSchema>;
+export type EmailTemplateTone = z.infer<typeof emailTemplateToneSchema>;
+export type EmailTemplateLanguage = z.infer<typeof emailTemplateLanguageSchema>;
+export type EmailTemplateInput = z.infer<typeof emailTemplateInputSchema>;
+export type EmailTemplateVariable = z.infer<typeof emailTemplateVariableSchema>;
+export type EmailTemplateSection = z.infer<typeof emailTemplateSectionSchema>;
+export type EmailTemplateResult = z.infer<typeof emailTemplateResultSchema>;
+
+export const EMAIL_TEMPLATE_SCENARIOS = emailTemplateScenarioSchema.options;
+export const EMAIL_TEMPLATE_TONES = emailTemplateToneSchema.options;
+export const EMAIL_TEMPLATE_LANGUAGES = emailTemplateLanguageSchema.options;
+
+export function stringifyEmailTemplatePackage(result: EmailTemplateResult): string {
+  const variables = result.variables.length
+    ? `\n\n## Variables\n${result.variables
+        .map((item) => `- {{${item.key}}}: ${item.description || item.example || ""}`.trim())
+        .join("\n")}`
+    : "";
+  const notes = [
+    ["Compliance notes", result.complianceNotes],
+    ["Developer notes", result.developerNotes],
+    ["Accessibility notes", result.accessibilityNotes],
+    ["Render checklist", result.renderChecklist],
+    ["Missing information", result.missingInfo],
+  ]
+    .filter(([, items]) => (items as string[]).length)
+    .map(([title, items]) => `\n\n## ${title}\n${(items as string[]).map((item) => `- ${item}`).join("\n")}`)
+    .join("");
+
+  return `# Email Template Package
+
+Subject: ${result.subject}
+Preheader: ${result.preheader}
+
+## Summary
+${result.summary}
+
+## Plain Text
+${result.plainText}
+${variables}
+${notes}
+
+## MJML
+\`\`\`mjml
+${result.mjml}
+\`\`\`
+
+## HTML
+\`\`\`html
+${result.html}
+\`\`\`
+`;
+}

package/src/lib/tools/gtm-checklist-copy.ts

@@ -0,0 +1,57 @@
+import type { AppLocale } from "../../i18n/locale";
+import { pickLocaleCopy } from "../../i18n/locale-fallback";
+import enGtm from "../../i18n/messages/en/tools/gtm-readiness-checklist";
+import zhGtm from "../../i18n/messages/zh/tools/gtm-readiness-checklist";
+
+import {
+  GTM_CHECKLIST_ITEM_KEYS,
+  type GtmChecklistItemKey,
+} from "./gtm-checklist-structure";
+
+type StringLeafCopy<T> = {
+  readonly [K in keyof T]: T[K] extends string
+    ? string
+    : T[K] extends object
+      ? StringLeafCopy<T[K]>
+      : T[K];
+};
+
+type GtmCopy = StringLeafCopy<typeof zhGtm>;
+type GtmTier = keyof GtmCopy["tiers"];
+
+const copyByLocale = {
+  zh: zhGtm,
+  en: enGtm,
+};
+
+export function getGtmChecklistCopy(locale: AppLocale): GtmCopy {
+  return pickLocaleCopy(copyByLocale, locale) as GtmCopy;
+}
+
+export function getGtmChecklistItemLabel(
+  key: GtmChecklistItemKey,
+  locale: AppLocale,
+): string {
+  return getGtmChecklistCopy(locale).items[key];
+}
+
+export function getGtmChecklistItemKeys(): readonly GtmChecklistItemKey[] {
+  return GTM_CHECKLIST_ITEM_KEYS;
+}
+
+export function getGtmTierLabel(tier: GtmTier, locale: AppLocale): string {
+  return getGtmChecklistCopy(locale).tiers[tier];
+}
+
+export function getGtmRecommendation(tier: GtmTier, locale: AppLocale): string {
+  return getGtmChecklistCopy(locale).recommendations[tier];
+}
+
+/** @deprecated Use getGtmChecklistItemKeys + getGtmChecklistItemLabel — kept for MCP registry imports */
+export const CHECKLIST_ITEMS = GTM_CHECKLIST_ITEM_KEYS.map((key) => ({
+  key,
+  label: {
+    zh: zhGtm.items[key],
+    en: enGtm.items[key],
+  },
+}));

package/src/lib/tools/gtm-checklist-structure.ts

@@ -0,0 +1,37 @@
+/** Checklist structure only — labels live in i18n (`toolsPages.gtmReadinessChecklist`). */
+
+export const GTM_CHECKLIST_ITEM_KEYS = [
+  "positioning_one_liner",
+  "icp_specific",
+  "competitor_diff",
+  "primary_channels",
+  "landing_cta",
+  "social_templates",
+  "north_star_metric",
+  "utm_tracking",
+  "retro_schedule",
+] as const;
+
+export type GtmChecklistItemKey = (typeof GTM_CHECKLIST_ITEM_KEYS)[number];
+
+export const GTM_CHECKLIST_SECTIONS = [
+  {
+    id: "positioning",
+    sectionKey: "positioning",
+    keys: ["positioning_one_liner", "icp_specific", "competitor_diff"],
+  },
+  {
+    id: "channels",
+    sectionKey: "channels",
+    keys: ["primary_channels", "landing_cta", "social_templates"],
+  },
+  {
+    id: "metrics",
+    sectionKey: "metrics",
+    keys: ["north_star_metric", "utm_tracking", "retro_schedule"],
+  },
+] as const satisfies ReadonlyArray<{
+  id: string;
+  sectionKey: "positioning" | "channels" | "metrics";
+  keys: readonly GtmChecklistItemKey[];
+}>;

package/src/lib/tools/image-download.ts

@@ -0,0 +1,68 @@
+const BLOCKED_HOSTS = new Set(["localhost", "127.0.0.1", "0.0.0.0", "::1"]);
+const TOMAKO_PUBLIC_OSS_HOST = "tomako-public.oss-cn-hongkong.aliyuncs.com";
+
+/** Route Tomako-managed OSS objects through the current Tomako origin. */
+export function browserImageUrl(src: string) {
+  if (!src.startsWith("https:")) return src;
+  try {
+    const url = new URL(src);
+    if (url.hostname !== TOMAKO_PUBLIC_OSS_HOST) return src;
+    return `/media/oss${url.pathname}${url.search}`;
+  } catch {
+    return src;
+  }
+}
+
+function isBlockedImageUrl(value: string) {
+  let url: URL;
+  try {
+    url = new URL(value);
+  } catch {
+    return true;
+  }
+
+  if (url.protocol !== "https:") return true;
+  if (BLOCKED_HOSTS.has(url.hostname)) return true;
+  if (/^10\./.test(url.hostname)) return true;
+  if (/^172\.(1[6-9]|2\d|3[0-1])\./.test(url.hostname)) return true;
+  if (/^192\.168\./.test(url.hostname)) return true;
+
+  return false;
+}
+
+export function imageDownloadUrl(src: string) {
+  const browserSrc = browserImageUrl(src);
+  if (browserSrc.startsWith("/media/oss/")) return browserSrc;
+  return `/tools-api/image-download?url=${encodeURIComponent(src)}`;
+}
+
+export async function handleImageDownload(request: Request): Promise<Response> {
+  const imageUrl = new URL(request.url).searchParams.get("url");
+  if (!imageUrl || isBlockedImageUrl(imageUrl)) {
+    return Response.json({ error: "invalid_image_url" }, { status: 400 });
+  }
+
+  const upstream = await fetch(imageUrl, {
+    cache: "no-store",
+    signal: AbortSignal.timeout(30_000),
+  });
+
+  if (!upstream.ok) {
+    return Response.json({ error: "image_fetch_failed" }, { status: upstream.status });
+  }
+
+  const contentType = upstream.headers.get("content-type") ?? "image/png";
+  if (!contentType.startsWith("image/")) {
+    return Response.json({ error: "invalid_image_content" }, { status: 415 });
+  }
+
+  const body = await upstream.arrayBuffer();
+  return new Response(body, {
+    headers: {
+      "Content-Type": contentType,
+      "Content-Disposition": "attachment",
+      "Cache-Control": "no-store",
+      "X-Content-Type-Options": "nosniff",
+    },
+  });
+}

package/src/lib/tools/input-quality.ts

@@ -0,0 +1,97 @@
+const placeholderPattern =
+  /^(test|demo|sample|example|asdf|qwer|lorem ipsum|123+|111+|222+|xxx+|测试|示例|样例|占位|随便写写)$/i;
+
+const vagueOnlyPattern =
+  /^(产品|项目|工具|用户|客户|创业者|开发者|团队|ai|ai工具|app|saas|website|product|tool|users|customers|founders|developers|team)$/i;
+
+export function isClearlyInvalidText(value: string) {
+  const text = value.trim();
+  if (text.length === 0) return true;
+  if (placeholderPattern.test(text)) return true;
+  if (/^\d+$/.test(text)) return true;
+  if (!/[\p{L}\p{N}]/u.test(text)) return true;
+  if (/^(.)\1{3,}$/u.test(text)) return true;
+  return vagueOnlyPattern.test(text);
+}
+
+export function hasAnySignal(value: string, patterns: readonly RegExp[]) {
+  return patterns.some((pattern) => pattern.test(value));
+}
+
+const transcriptSignals = [
+  /受访者/,
+  /用户/,
+  /客户/,
+  /他说/,
+  /她说/,
+  /我/,
+  /我们/,
+  /最近/,
+  /上周/,
+  /昨天/,
+  /过去/,
+  /正在/,
+  /发布/,
+  /上线/,
+  /使用/,
+  /购买/,
+  /付费/,
+  /遇到/,
+  /卡/,
+  /participant/i,
+  /interviewee/i,
+  /user/i,
+  /customer/i,
+  /i\s/,
+  /we\s/i,
+  /recent/i,
+  /last/i,
+  /launched/i,
+  /used/i,
+  /paid/i,
+  /struggled/i,
+];
+
+const recordSignals = [
+  /record\s*\d+/i,
+  /interview\s*\d+/i,
+  /participant/i,
+  /访谈\s*\d*/,
+  /记录\s*\d*/,
+  /受访者/,
+  /用户/,
+  /痛点/,
+  /原话/,
+  /替代方案/,
+  /付费/,
+  /信号/,
+  /pain/i,
+  /quote/i,
+  /alternative/i,
+  /buying signal/i,
+];
+
+export function hasUsableTranscript(value: string) {
+  const text = value.trim();
+  if (isClearlyInvalidText(text)) return false;
+
+  const hasStructure = /[。！？.!?\n：:]/.test(text);
+  const hasSignal = hasAnySignal(text, transcriptSignals);
+
+  return hasSignal && (hasStructure || text.length >= 60);
+}
+
+export function hasMultipleInterviewRecords(value: string) {
+  const text = value.trim();
+  if (isClearlyInvalidText(text)) return false;
+
+  const separators = (text.match(/---|record\s*\d+|interview\s*\d+|访谈\s*\d+|记录\s*\d+/gi) ?? [])
+    .length;
+  const signalCount = recordSignals.reduce(
+    (count, pattern) => count + (pattern.test(text) ? 1 : 0),
+    0,
+  );
+  const paragraphCount = text.split(/\n{2,}|\n-/).filter((part) => part.trim()).length;
+
+  return separators >= 1 || signalCount >= 3 || paragraphCount >= 3;
+}

package/src/lib/tools/logo-generator-schema.ts

@@ -0,0 +1,224 @@
+import { z } from "zod";
+
+export const LOGO_GENERATOR_SCENE = "logo_generation";
+export const LOGO_GENERATOR_RESULT_TYPE = "logo_generation";
+export const LOGO_GENERATOR_PROMPT_ID = "tools.logo-generator.image-agent";
+export const LOGO_GENERATOR_PROMPT_VERSION = "logo-generator.v1";
+export const LOGO_GENERATOR_SVG_SCENE = "logo_svg_conversion";
+export const LOGO_GENERATOR_SVG_RESULT_TYPE = "logo_svg_conversion";
+export const LOGO_GENERATOR_SVG_PROMPT_ID = "tools.logo-generator.svg-agent";
+export const LOGO_GENERATOR_SVG_PROMPT_VERSION = "logo-generator-svg.v1";
+
+export const LOGO_GENERATOR_PROMPT_META = {
+  id: LOGO_GENERATOR_PROMPT_ID,
+  version: LOGO_GENERATOR_PROMPT_VERSION,
+  owner: "growth-tools",
+  riskLevel: "medium",
+  lastReviewedAt: "2026-07-03",
+} as const;
+
+export const logoStyleSchema = z.enum([
+  "minimal",
+  "bold",
+  "friendly",
+  "premium",
+  "futuristic",
+]);
+
+export const logoPaletteSchema = z.enum([
+  "lime",
+  "blue",
+  "coral",
+  "mono",
+  "wine",
+  "custom",
+]);
+
+export const logoHexColorSchema = z.string().regex(/^#[0-9A-Fa-f]{6}$/);
+
+export const logoCustomPaletteSchema = z
+  .object({
+    primary: z.string().trim().optional().or(z.literal("")).default(""),
+    secondary: z.string().trim().optional().or(z.literal("")).default(""),
+    accent: z.string().trim().optional().or(z.literal("")).default(""),
+  })
+  .default({ primary: "", secondary: "", accent: "" });
+
+export const logoFormSchema = z.enum(["wordmark", "symbol", "combination"]);
+
+export const logoPreferenceSchema = z.enum([
+  "trust",
+  "speed",
+  "craft",
+  "ai",
+  "global",
+  "calm",
+]);
+
+export const logoGeometrySchema = z.enum(["rounded", "sharp", "organic"]);
+
+export const logoUsageSchema = z.enum(["web", "app", "social", "deck"]);
+export const logoSchemeCountSchema = z.number().int().min(1).max(5).default(1);
+export const logoGenerationStatusSchema = z.enum(["partial", "final"]);
+
+export const logoGeneratorInputSchema = z
+  .object({
+    productUrl: z.string().trim().url().optional().or(z.literal("")).default(""),
+    productName: z.string().trim().min(1).max(48),
+    productContext: z.string().trim().max(520).optional().default(""),
+    industry: z.string().trim().max(80).optional().default(""),
+    audience: z.string().trim().max(100).optional().default(""),
+    customPalette: logoCustomPaletteSchema,
+    schemeCount: logoSchemeCountSchema,
+    form: logoFormSchema.default("combination"),
+    referenceImageName: z.string().trim().max(120).optional().default(""),
+    referenceImageUrl: z.string().trim().url().optional().or(z.literal("")).default(""),
+  })
+  .superRefine((value, context) => {
+    const hasCustomColor = Object.values(value.customPalette).some(Boolean);
+    if (!hasCustomColor) return;
+    const requiredKeys = ["primary", "secondary", "accent"] as const;
+    for (const key of requiredKeys) {
+      if (!logoHexColorSchema.safeParse(value.customPalette[key]).success) {
+        context.addIssue({
+          code: z.ZodIssueCode.custom,
+          path: ["customPalette", key],
+          message: "Custom palette requires primary, secondary, and accent colors.",
+        });
+      }
+    }
+  });
+
+export const logoDirectionSchema = z.enum([
+  "primaryLockup",
+  "appIcon",
+  "wordmark",
+  "monogram",
+]);
+
+export const logoCandidateSchema = z.object({
+  id: z.string().min(1),
+  direction: logoDirectionSchema,
+  name: z.string().min(1).max(80),
+  imageTaskId: z.string().min(1),
+  imageUrl: z.string().trim().url(),
+  width: z.number().int().positive().optional(),
+  height: z.number().int().positive().optional(),
+  palette: z.object({
+    background: z.string().regex(/^#[0-9A-Fa-f]{6}$/),
+    foreground: z.string().regex(/^#[0-9A-Fa-f]{6}$/),
+    accent: z.string().regex(/^#[0-9A-Fa-f]{6}$/),
+    secondary: z.string().regex(/^#[0-9A-Fa-f]{6}$/).optional(),
+  }),
+  rationale: z.string().min(1).max(420),
+  bestFor: z.array(z.string().min(1).max(120)).min(1).max(4),
+  exportName: z.string().min(1).max(80),
+  generationPrompt: z.string().trim().optional(),
+});
+
+export const logoGeneratorAgentResultSchema = z.object({
+  promptId: z.literal(LOGO_GENERATOR_PROMPT_ID),
+  promptVersion: z.literal(LOGO_GENERATOR_PROMPT_VERSION),
+  generationStatus: logoGenerationStatusSchema.default("final"),
+  completedCount: z.number().int().min(1).max(5).optional(),
+  totalCount: z.number().int().min(1).max(5).optional(),
+  summary: z.string().min(1).max(520),
+  imageTaskId: z.string().min(1),
+  imageUrl: z.string().trim().url(),
+  image: z.object({
+    imageTaskId: z.string().min(1),
+    imageUrl: z.string().trim().url(),
+    width: z.number().int().positive().optional(),
+    height: z.number().int().positive().optional(),
+    model: z.string().trim().optional(),
+    size: z.string().trim().optional(),
+  }),
+  candidates: z.array(logoCandidateSchema).min(1).max(5),
+  implementationNotes: z.array(z.string().min(1).max(180)).min(1).max(6),
+  reviewChecklist: z.array(z.string().min(1).max(180)).min(1).max(6),
+  limitations: z.array(z.string().min(1).max(180)).max(6).default([]),
+  source: z
+    .object({
+      productUrl: z.string().trim().url().optional(),
+      productMetadataUsed: z.boolean().optional(),
+      customPalette: logoCustomPaletteSchema.optional(),
+      referenceImageName: z.string().trim().optional(),
+      referenceImageUrl: z.string().trim().url().optional(),
+      referenceImageUsed: z.boolean().optional(),
+      schemeCount: z.number().int().min(1).max(5).optional(),
+      note: z.string().trim().optional(),
+    })
+    .optional(),
+  generatedAt: z.string().optional(),
+});
+
+export const logoSvgConversionInputSchema = z.object({
+  productName: z.string().trim().min(1).max(48),
+  productUrl: z.string().trim().url().optional().or(z.literal("")).default(""),
+  productContext: z.string().trim().max(520).optional().default(""),
+  form: logoFormSchema.default("combination"),
+  candidate: logoCandidateSchema.pick({
+    id: true,
+    direction: true,
+    name: true,
+    imageTaskId: true,
+    imageUrl: true,
+    palette: true,
+    exportName: true,
+  }),
+});
+
+export const logoSvgConversionResultSchema = z.object({
+  promptId: z.literal(LOGO_GENERATOR_SVG_PROMPT_ID),
+  promptVersion: z.literal(LOGO_GENERATOR_SVG_PROMPT_VERSION),
+  summary: z.string().min(1).max(520),
+  svgText: z.string().min(80),
+  svgDataUrl: z.string().regex(/^data:image\/svg\+xml(?:;charset=utf-8)?,/),
+  svgUrl: z.string().trim().url().optional(),
+  exportName: z.string().min(1).max(100),
+  width: z.number().int().positive(),
+  height: z.number().int().positive(),
+  source: z.object({
+    productName: z.string().trim().min(1).max(80),
+    productUrl: z.string().trim().url().optional(),
+    productContext: z.string().trim().max(520).optional(),
+    form: logoFormSchema,
+    candidateId: z.string().min(1),
+    candidateName: z.string().min(1).max(100),
+    imageTaskId: z.string().min(1),
+    imageUrl: z.string().trim().url(),
+  }),
+  conversion: z.object({
+    mode: z.enum(["potrace-color-layers", "potrace-monochrome"]),
+    pathCount: z.number().int().min(1),
+    colorCount: z.number().int().min(1).max(8),
+    colors: z.array(logoHexColorSchema).min(1).max(8),
+    vectorizedAt: z.string(),
+    notes: z.array(z.string().min(1).max(180)).min(1).max(6),
+  }),
+  limitations: z.array(z.string().min(1).max(180)).max(6).default([]),
+});
+
+export const LOGO_GENERATOR_STYLES = logoStyleSchema.options;
+export const LOGO_GENERATOR_PALETTES = logoPaletteSchema.options;
+export const LOGO_GENERATOR_FORMS = logoFormSchema.options;
+export const LOGO_GENERATOR_PREFERENCES = logoPreferenceSchema.options;
+export const LOGO_GENERATOR_GEOMETRIES = logoGeometrySchema.options;
+export const LOGO_GENERATOR_USAGES = logoUsageSchema.options;
+export const LOGO_GENERATOR_SCHEME_COUNTS = [1, 2, 3, 4, 5] as const;
+
+export type LogoStyle = z.infer<typeof logoStyleSchema>;
+export type LogoPalette = z.infer<typeof logoPaletteSchema>;
+export type LogoCustomPalette = z.infer<typeof logoCustomPaletteSchema>;
+export type LogoForm = z.infer<typeof logoFormSchema>;
+export type LogoPreference = z.infer<typeof logoPreferenceSchema>;
+export type LogoGeometry = z.infer<typeof logoGeometrySchema>;
+export type LogoUsage = z.infer<typeof logoUsageSchema>;
+export type LogoSchemeCount = z.infer<typeof logoSchemeCountSchema>;
+export type LogoGenerationStatus = z.infer<typeof logoGenerationStatusSchema>;
+export type LogoGeneratorInput = z.infer<typeof logoGeneratorInputSchema>;
+export type LogoDirection = z.infer<typeof logoDirectionSchema>;
+export type LogoCandidate = z.infer<typeof logoCandidateSchema>;
+export type LogoGeneratorAgentResult = z.infer<typeof logoGeneratorAgentResultSchema>;
+export type LogoSvgConversionInput = z.infer<typeof logoSvgConversionInputSchema>;
+export type LogoSvgConversionResult = z.infer<typeof logoSvgConversionResultSchema>;