@tomako/tools-runtime 0.1.0

package/src/features/tools/package/package-loaders.ts

@@ -0,0 +1,22 @@
+import type { ToolPackage } from "./types";
+
+const packageLoaders: Record<string, () => Promise<ToolPackage>> = {
+  "user-interview-guide-generator": () =>
+    import("../user-interview-guide-generator/user-interview-guide-generator.package").then((mod) => mod.userInterviewGuideGeneratorPackage),
+  "utm-builder": () =>
+    import("../utm-builder/utm-builder.package").then((mod) => mod.utmBuilderPackage),
+  "slogan-generator": () =>
+    import("../slogan-generator/slogan-generator.package").then((mod) => mod.sloganGeneratorPackage),
+  "investor-matching-planner": () =>
+    import("../investor-matching-planner/investor-matching-planner.package").then((mod) => mod.investorMatchingPlannerPackage),
+  "disclaimer-generator": () =>
+    import("../disclaimer-generator/disclaimer-generator.package").then((mod) => mod.disclaimerGeneratorPackage),
+  "product-positioning-analyzer": () =>
+    import("../product-positioning-analyzer/product-positioning-analyzer.package").then((mod) => mod.productPositioningAnalyzerPackage),
+  "community-post-risk-checker": () =>
+    import("../community-post-risk-checker/community-post-risk-checker.package").then((mod) => mod.communityPostRiskCheckerPackage),
+};
+
+export function loadToolPackage(slug: string): Promise<ToolPackage | undefined> {
+  return packageLoaders[slug]?.();
+}

package/src/features/tools/package/package-registry.ts

@@ -0,0 +1,36 @@
+import { communityPostRiskCheckerPackage } from "../community-post-risk-checker/community-post-risk-checker.package";
+import { disclaimerGeneratorPackage } from "../disclaimer-generator/disclaimer-generator.package";
+import { investorMatchingPlannerPackage } from "../investor-matching-planner/investor-matching-planner.package";
+import { productPositioningAnalyzerPackage } from "../product-positioning-analyzer/product-positioning-analyzer.package";
+import { sloganGeneratorPackage } from "../slogan-generator/slogan-generator.package";
+import { userInterviewGuideGeneratorPackage } from "../user-interview-guide-generator/user-interview-guide-generator.package";
+import { utmBuilderPackage } from "../utm-builder/utm-builder.package";
+
+import type { ToolPackage } from "./types";
+
+/**
+ * ToolPackage 客户端注册表。
+ * widget 是 client component，zod resultSchema 不能跨 RSC 边界序列化，
+ * 因此客户端按 slug 自行解析 package（schema 随 bundle 下发）。
+ * 新 package 由 pnpm tool:new 脚手架自动登记。
+ *
+ * 规模化注意：包数量大后改为按 slug 动态 import 以控制客户端体积。
+ */
+const toolPackages: Record<string, ToolPackage> = {
+  [userInterviewGuideGeneratorPackage.meta.slug]: userInterviewGuideGeneratorPackage,
+  [utmBuilderPackage.meta.slug]: utmBuilderPackage,
+  [sloganGeneratorPackage.meta.slug]: sloganGeneratorPackage,
+  [investorMatchingPlannerPackage.meta.slug]: investorMatchingPlannerPackage,
+  [disclaimerGeneratorPackage.meta.slug]: disclaimerGeneratorPackage,
+  [productPositioningAnalyzerPackage.meta.slug]: productPositioningAnalyzerPackage,
+  [communityPostRiskCheckerPackage.meta.slug]: communityPostRiskCheckerPackage,
+  // tool-factory:package-entries (pnpm tool:new 在此锚点上方插入)
+};
+
+export function getToolPackage(slug: string): ToolPackage | undefined {
+  return toolPackages[slug];
+}
+
+export function listToolPackages(): ToolPackage[] {
+  return Object.values(toolPackages);
+}

package/src/features/tools/package/result-markdown.ts

@@ -0,0 +1,142 @@
+import type { AppLocale } from "../../../i18n/locale";
+
+import { pickL10n } from "./l10n";
+import type { ResultViewBlock } from "./types";
+
+export function getResultPath(result: unknown, path: string): unknown {
+  let current: unknown = result;
+  for (const key of path.split(".")) {
+    if (current == null || typeof current !== "object") return undefined;
+    current = (current as Record<string, unknown>)[key];
+  }
+  return current;
+}
+
+export function asStringList(value: unknown): string[] {
+  if (!Array.isArray(value)) return [];
+  return value.filter((item): item is string => typeof item === "string");
+}
+
+export function asRecordList(value: unknown): Array<Record<string, unknown>> {
+  if (!Array.isArray(value)) return [];
+  return value.filter(
+    (item): item is Record<string, unknown> =>
+      Boolean(item) && typeof item === "object",
+  );
+}
+
+/** 按结果视图积木序列化为 Markdown，供"复制"按钮与交付使用。 */
+export function resultToMarkdown(
+  title: string,
+  result: unknown,
+  view: ResultViewBlock[],
+  locale: AppLocale,
+): string {
+  const lines: string[] = [`# ${title}`, ""];
+
+  for (const block of view) {
+    if (block.block === "keyValues") {
+      if (block.title) lines.push(`## ${pickL10n(block.title, locale)}`, "");
+      for (const item of block.items) {
+        const value = getResultPath(result, item.path);
+        if (typeof value === "string" && value.trim()) {
+          lines.push(`- **${pickL10n(item.label, locale)}**: ${value}`);
+        }
+        const list = asStringList(value);
+        if (list.length) {
+          lines.push(`- **${pickL10n(item.label, locale)}**:`);
+          for (const entry of list) lines.push(`  - ${entry}`);
+        }
+      }
+      lines.push("");
+    } else if (block.block === "bulletList") {
+      const items = asStringList(getResultPath(result, block.path));
+      if (!items.length) continue;
+      lines.push(`## ${pickL10n(block.title, locale)}`, "");
+      for (const item of items) lines.push(`- ${item}`);
+      lines.push("");
+    } else if (block.block === "bulletGroups") {
+      if (block.title) lines.push(`## ${pickL10n(block.title, locale)}`, "");
+      for (const column of block.columns) {
+        const items = asStringList(getResultPath(result, column.path));
+        if (!items.length) continue;
+        lines.push(`### ${pickL10n(column.label, locale)}`, "");
+        for (const item of items) lines.push(`- ${item}`);
+        lines.push("");
+      }
+    } else if (block.block === "strategicCurve") {
+      const dimensions = pickL10n(block.dimensions, locale);
+      const rows = asRecordList(getResultPath(result, block.path))
+        .map((row) => {
+          const player = row[block.playerField];
+          const values = row[block.valuesField];
+          if (
+            typeof player !== "string" ||
+            !player.trim() ||
+            !Array.isArray(values) ||
+            values.length !== dimensions.length ||
+            values.some(
+              (value) =>
+                typeof value !== "number" ||
+                !Number.isFinite(value) ||
+                value < 0 ||
+                value > block.maxScore,
+            )
+          ) {
+            return null;
+          }
+          return { player, values };
+        })
+        .filter((row): row is { player: string; values: number[] } => row !== null);
+      if (!rows.length) continue;
+      lines.push(`## ${pickL10n(block.title, locale)}`, "");
+      lines.push(`| Player | ${dimensions.join(" | ")} |`);
+      lines.push(`| --- | ${dimensions.map(() => "---").join(" | ")} |`);
+      for (const row of rows) {
+        lines.push(`| ${row.player} | ${row.values.join(" | ")} |`);
+      }
+      lines.push("");
+    } else {
+      const rows = asRecordList(getResultPath(result, block.path));
+      if (!rows.length) continue;
+      lines.push(`## ${pickL10n(block.title, locale)}`, "");
+      for (const row of rows) {
+        const cardTitle = row[block.card.titleField];
+        const meta = block.card.metaField ? row[block.card.metaField] : undefined;
+        const metaSuffix = block.card.metaSuffix
+          ? pickL10n(block.card.metaSuffix, locale)
+          : "";
+        lines.push(
+          `### ${String(cardTitle ?? "")}${meta != null ? `（${String(meta)}${metaSuffix}）` : ""}`,
+        );
+        if (block.card.body) {
+          const body = row[block.card.body.field];
+          if (typeof body === "string" && body.trim()) {
+            const label = block.card.body.label
+              ? `**${pickL10n(block.card.body.label, locale)}**: `
+              : "";
+            lines.push(`${label}${body}`);
+          }
+        }
+        for (const listSpec of block.card.lists ?? []) {
+          const items = asStringList(row[listSpec.field]);
+          if (!items.length) continue;
+          lines.push(`- **${pickL10n(listSpec.label, locale)}**:`);
+          for (const item of items) lines.push(`  - ${item}`);
+        }
+        if (block.card.footer) {
+          const footer = row[block.card.footer.field];
+          if (typeof footer === "string" && footer.trim()) {
+            const label = block.card.footer.label
+              ? `**${pickL10n(block.card.footer.label, locale)}**: `
+              : "";
+            lines.push(`${label}${footer}`);
+          }
+        }
+        lines.push("");
+      }
+    }
+  }
+
+  return lines.join("\n").replace(/\n{3,}/g, "\n\n").trimEnd();
+}

package/src/features/tools/package/schema.ts

@@ -0,0 +1,379 @@
+import { z } from "zod";
+
+/**
+ * ToolPackage 的机器校验层。
+ * 供 scripts/tool-factory/validate-tool-packages.mjs 与单测使用；
+ * 运行时组件信任类型系统，不重复解析。
+ *
+ * 注意：resultSchema 字段是 zod 实例（代码），用 z.custom 校验存在性。
+ */
+
+const l10nTextSchema = z.object({
+  en: z.string().trim().min(1),
+  zh: z.string().trim().min(1),
+  "zh-tw": z.string().trim().min(1).optional(),
+});
+
+const l10nTextListSchema = z
+  .object({
+    en: z.array(z.string().trim().min(1)).min(1),
+    zh: z.array(z.string().trim().min(1)).min(1),
+    "zh-tw": z.array(z.string().trim().min(1)).min(1).optional(),
+  })
+  .refine((value) => value.en.length === value.zh.length, {
+    message: "en/zh 列表长度必须一致",
+  });
+
+const sectionImageSchema = z.object({
+  src: z.string().startsWith("/tools/"),
+  alt: l10nTextSchema,
+  side: z.enum(["left", "right"]).optional(),
+  wide: z.boolean().optional(),
+});
+
+const formFieldBase = {
+  id: z
+    .string()
+    .regex(/^[a-z][a-zA-Z0-9]*$/, "字段 id 必须是 camelCase"),
+  label: l10nTextSchema,
+  hint: l10nTextSchema.optional(),
+  placeholder: l10nTextSchema.optional(),
+  required: z.boolean().optional(),
+  invalidMessage: l10nTextSchema.optional(),
+  fullWidth: z.boolean().optional(),
+};
+
+const formFieldSchema = z.discriminatedUnion("kind", [
+  z.object({
+    ...formFieldBase,
+    kind: z.literal("text"),
+    minLength: z.number().int().positive().optional(),
+    maxLength: z.number().int().positive().optional(),
+  }),
+  z.object({
+    ...formFieldBase,
+    kind: z.literal("textarea"),
+    rows: z.number().int().positive().optional(),
+    minLength: z.number().int().positive().optional(),
+    maxLength: z.number().int().positive().optional(),
+  }),
+  z.object({
+    ...formFieldBase,
+    kind: z.literal("select"),
+    options: z
+      .array(z.object({ value: z.string().min(1), label: l10nTextSchema }))
+      .min(2),
+    defaultValue: z.string().min(1),
+  }),
+  z.object({
+    ...formFieldBase,
+    kind: z.literal("toggle"),
+    onLabel: l10nTextSchema,
+    offLabel: l10nTextSchema,
+    defaultValue: z.boolean(),
+  }),
+]);
+
+const resultViewBlockSchema = z.discriminatedUnion("block", [
+  z.object({
+    block: z.literal("keyValues"),
+    title: l10nTextSchema.optional(),
+    items: z
+      .array(
+        z.object({
+          label: l10nTextSchema,
+          path: z.string().min(1),
+          copyable: z.boolean().optional(),
+        }),
+      )
+      .min(1),
+  }),
+  z.object({
+    block: z.literal("bulletList"),
+    title: l10nTextSchema,
+    path: z.string().min(1),
+    tone: z.enum(["neutral", "positive", "risk"]).optional(),
+  }),
+  z.object({
+    block: z.literal("bulletGroups"),
+    title: l10nTextSchema.optional(),
+    columns: z
+      .array(
+        z.object({
+          label: l10nTextSchema,
+          path: z.string().min(1),
+          tone: z.enum(["neutral", "positive", "risk"]).optional(),
+        }),
+      )
+      .min(1),
+  }),
+  z.object({
+    block: z.literal("cardList"),
+    title: l10nTextSchema,
+    path: z.string().min(1),
+    layout: z.enum(["stack", "grid"]).optional(),
+    card: z.object({
+      titleField: z.string().min(1),
+      metaField: z.string().min(1).optional(),
+      metaSuffix: l10nTextSchema.optional(),
+      body: z
+        .object({ field: z.string().min(1), label: l10nTextSchema.optional() })
+        .optional(),
+      lists: z
+        .array(z.object({ field: z.string().min(1), label: l10nTextSchema }))
+        .optional(),
+      footer: z
+        .object({ field: z.string().min(1), label: l10nTextSchema.optional() })
+        .optional(),
+    }),
+  }),
+  z.object({
+    block: z.literal("strategicCurve"),
+    title: l10nTextSchema,
+    path: z.string().min(1),
+    playerField: z.string().min(1),
+    valuesField: z.string().min(1),
+    dimensions: l10nTextListSchema,
+    maxScore: z.number().int().positive(),
+  }),
+]);
+
+const pageSectionSchema = z.discriminatedUnion("kind", [
+  z.object({
+    kind: z.literal("cards"),
+    heading: l10nTextSchema,
+    intro: l10nTextSchema.optional(),
+    items: z.array(z.object({ title: l10nTextSchema, body: l10nTextSchema })).min(2),
+    image: sectionImageSchema.optional(),
+  }),
+  z.object({
+    kind: z.literal("bullets"),
+    heading: l10nTextSchema,
+    intro: l10nTextSchema.optional(),
+    groups: z
+      .array(z.object({ title: l10nTextSchema.optional(), items: l10nTextListSchema }))
+      .min(1),
+    image: sectionImageSchema.optional(),
+  }),
+  z.object({
+    kind: z.literal("paragraphs"),
+    heading: l10nTextSchema,
+    intro: l10nTextSchema.optional(),
+    paragraphs: l10nTextListSchema,
+    image: sectionImageSchema.optional(),
+  }),
+]);
+
+const standardBenefitsSchema = z.object({
+  title: l10nTextSchema,
+  cards: z.tuple([
+    z.object({ title: l10nTextSchema, body: l10nTextSchema }),
+    z.object({ title: l10nTextSchema, body: l10nTextSchema }),
+    z.object({ title: l10nTextSchema, body: l10nTextSchema }),
+  ]),
+});
+
+function standardImageTextSchema(
+  id: "section-primary" | "section-variation" | "section-support",
+) {
+  return z.object({
+    id: z.literal(id),
+    title: l10nTextSchema,
+    body: l10nTextListSchema,
+    image: sectionImageSchema,
+    imageFirst: z.boolean().optional(),
+  });
+}
+
+const standardLandingSchema = z.object({
+  benefits: standardBenefitsSchema,
+  imageTextSections: z.tuple([
+    standardImageTextSchema("section-primary"),
+    standardImageTextSchema("section-variation"),
+    standardImageTextSchema("section-support"),
+  ]),
+  generation: z.object({
+    title: l10nTextSchema,
+    image: sectionImageSchema,
+    steps: z
+      .array(z.object({ title: l10nTextSchema, body: l10nTextSchema }))
+      .min(2)
+      .max(5),
+    ctaLabel: l10nTextSchema,
+  }),
+  faq: z.object({
+    title: l10nTextSchema,
+    intro: l10nTextSchema,
+    ctaLabel: l10nTextSchema,
+  }),
+});
+
+const errorCodeSchema = z.enum([
+  "validation",
+  "authRequired",
+  "submitFailed",
+  "taskFailed",
+  "resultTimeout",
+  "wrongResultType",
+  "invalidResultSchema",
+  "resultWritebackMissing",
+  "computeFailed",
+]);
+
+export const toolPackageSchema = z
+  .object({
+    meta: z.object({
+      slug: z.string().regex(/^[a-z0-9]+(-[a-z0-9]+)*$/),
+      toolType: z.enum(["calculator", "generator", "analyzer", "downloader"]),
+      riskLevel: z.enum(["low", "medium", "high"]).optional(),
+      keywordEvidence: z
+        .string()
+        .min(1)
+        .refine(
+          (value) =>
+            value.startsWith("docs/seo-keyword-briefs/") ||
+            value.startsWith("strategic:") ||
+            value.startsWith("legacy:"),
+          {
+            message:
+              "keywordEvidence 必须指向 docs/seo-keyword-briefs/ 下的 brief、以 strategic: 声明不计 SEO KPI，或以 legacy: 标记待补证据的迁移工具",
+          },
+        ),
+      seo: z.object({
+        publishedAt: z.string().optional(),
+        updatedAt: z.string().min(1),
+        readingTime: z.string().min(1),
+        featured: z.boolean().optional(),
+        ogImage: z.string().startsWith("/tools/").optional(),
+      }),
+      mcp: z
+        .object({ enabled: z.boolean(), toolName: z.string().optional() })
+        .optional(),
+    }),
+    copy: z.object({
+      title: l10nTextSchema,
+      displayTitle: l10nTextSchema.optional(),
+      description: l10nTextSchema,
+      intro: l10nTextSchema,
+      category: l10nTextSchema,
+      keywords: l10nTextListSchema,
+      inputSignal: l10nTextSchema.optional(),
+      outputSignal: l10nTextSchema.optional(),
+      boundarySignal: l10nTextSchema.optional(),
+    }),
+    form: z.array(formFieldSchema).min(1),
+    runtime: z.discriminatedUnion("lane", [
+      z.object({
+        lane: z.literal("agent"),
+        scene: z.string().regex(/^[a-z][a-z0-9_]*$/),
+        resultType: z.string().regex(/^[a-z][a-z0-9_]*$/),
+        skillId: z.string().startsWith("$"),
+        writebackScript: z.string().endsWith(".mjs"),
+        outputContract: z.array(z.string().min(1)).min(3),
+        rules: z.array(z.string().min(1)).min(1),
+        restrictToSkill: z.boolean().optional(),
+        watch: z
+          .object({
+            pollIntervalMs: z.number().int().min(500).optional(),
+            graceWindowMs: z.number().int().min(30_000).optional(),
+          })
+          .optional(),
+      }),
+      z.object({
+        lane: z.literal("direct"),
+        scene: z.string().regex(/^[a-z][a-z0-9_]*$/),
+        system: z.string().max(4_000).optional(),
+        promptTemplate: z
+          .string()
+          .min(40)
+          .refine((value) => value.includes("{{briefJson}}"), {
+            message: "promptTemplate 必须包含 {{briefJson}} 占位符",
+          }),
+        maxTokens: z.number().int().min(256).max(16_000).optional(),
+      }),
+      z.object({
+        lane: z.literal("instant"),
+        compute: z.custom<(...args: unknown[]) => unknown>(
+          (value) => typeof value === "function",
+          { message: "instant 车道必须提供 compute 纯函数" },
+        ),
+      }),
+    ]),
+    resultSchema: z.custom<object>(
+      (value) =>
+        Boolean(value) &&
+        typeof (value as { safeParse?: unknown }).safeParse === "function",
+      { message: "resultSchema 必须是 zod schema 实例" },
+    ),
+    resultView: z.array(resultViewBlockSchema).min(1),
+    widget: z.object({
+      formTitle: l10nTextSchema,
+      formHint: l10nTextSchema,
+      submitLabel: l10nTextSchema.optional(),
+      resultTitle: l10nTextSchema.optional(),
+      pendingTitle: l10nTextSchema.optional(),
+      pendingHint: l10nTextSchema.optional(),
+      errorOverrides: z
+        .partialRecord(
+          errorCodeSchema,
+          z.object({ title: l10nTextSchema, body: l10nTextSchema }),
+        )
+        .optional(),
+    }),
+    page: z.object({
+      workspace: z.object({
+        heading: l10nTextSchema,
+        hint: l10nTextSchema,
+        badge: l10nTextSchema.optional(),
+      }),
+      standard: standardLandingSchema.optional(),
+      sections: z.array(pageSectionSchema).min(3).optional(),
+      faq: z
+        .array(z.object({ question: l10nTextSchema, answer: l10nTextSchema }))
+        .min(3),
+      cta: z
+        .object({
+          heading: l10nTextSchema.optional(),
+          hint: l10nTextSchema,
+          primary: z.object({ href: z.string().startsWith("/"), label: l10nTextSchema }),
+          secondary: z
+            .object({ href: z.string().startsWith("/"), label: l10nTextSchema })
+            .optional(),
+        })
+        .optional(),
+    }),
+    assets: z.object({
+      hero: z
+        .object({ src: z.string().startsWith("/tools/"), alt: l10nTextSchema })
+        .optional(),
+    }),
+  })
+  .superRefine((pkg, ctx) => {
+    const ids = new Set<string>();
+    for (const field of pkg.form) {
+      if (ids.has(field.id)) {
+        ctx.addIssue({
+          code: z.ZodIssueCode.custom,
+          message: `表单字段 id 重复：${field.id}`,
+          path: ["form"],
+        });
+      }
+      ids.add(field.id);
+    }
+    if (!pkg.meta.seo.ogImage) {
+      ctx.addIssue({
+        code: z.ZodIssueCode.custom,
+        message: "registry 工具必须提供 seo.ogImage",
+        path: ["meta", "seo", "ogImage"],
+      });
+    }
+    if (!pkg.page.standard && !pkg.page.sections) {
+      ctx.addIssue({
+        code: z.ZodIssueCode.custom,
+        message: "page 必须提供 workspace-first standard 或 legacy sections",
+        path: ["page"],
+      });
+    }
+  });
+
+export type ToolPackageValidationInput = z.input<typeof toolPackageSchema>;

package/src/features/tools/package/to-tool-module.ts

@@ -0,0 +1,20 @@
+import type { ToolModule } from "../types";
+import { loadToolPackage } from "./package-loaders";
+import { createPackageContainer } from "./package-container";
+import { createPackageToolSpec } from "./to-tool-spec";
+import type { ToolPackage } from "./types";
+
+/** package → 标准 ToolModule：registry/路由/sitemap/MCP 零改动接入。 */
+export function createPackageToolModule(pkg: ToolPackage): ToolModule {
+  return {
+    spec: createPackageToolSpec(pkg),
+    Container: createPackageContainer(pkg),
+  };
+}
+
+export async function loadPackageToolModule(
+  slug: string,
+): Promise<ToolModule | undefined> {
+  const pkg = await loadToolPackage(slug);
+  return pkg ? createPackageToolModule(pkg) : undefined;
+}

package/src/features/tools/package/to-tool-spec.ts

@@ -0,0 +1,52 @@
+import type { ToolLocaleCopy, ToolSpec } from "../types";
+import type { L10nText, L10nTextList, ToolPackage } from "./types";
+
+function localeCopy(
+  pkg: ToolPackage,
+  locale: "en" | "zh" | "zh-tw",
+): ToolLocaleCopy | undefined {
+  const pick = (text: L10nText) => text[locale];
+  const pickList = (list: L10nTextList) => list[locale];
+  const title = pick(pkg.copy.title);
+  const description = pick(pkg.copy.description);
+  if (!title || !description) return undefined;
+
+  return {
+    title,
+    displayTitle: pkg.copy.displayTitle ? pick(pkg.copy.displayTitle) : undefined,
+    description,
+    intro: pick(pkg.copy.intro),
+    category: pick(pkg.copy.category) ?? pkg.copy.category.en,
+    keywords: pickList(pkg.copy.keywords) ?? pkg.copy.keywords.en,
+    inputSignal: pkg.copy.inputSignal ? pick(pkg.copy.inputSignal) : undefined,
+    outputSignal: pkg.copy.outputSignal ? pick(pkg.copy.outputSignal) : undefined,
+    boundarySignal: pkg.copy.boundarySignal
+      ? pick(pkg.copy.boundarySignal)
+      : undefined,
+  };
+}
+
+/** Serializable package metadata for lists, SEO, sitemaps, and MCP generation. */
+export function createPackageToolSpec(pkg: ToolPackage): ToolSpec {
+  const zhTw = localeCopy(pkg, "zh-tw");
+
+  return {
+    slug: pkg.meta.slug,
+    toolType: pkg.meta.toolType,
+    riskLevel: pkg.meta.riskLevel,
+    locales: {
+      en: localeCopy(pkg, "en")!,
+      zh: localeCopy(pkg, "zh")!,
+      ...(zhTw ? { "zh-tw": zhTw } : {}),
+    },
+    seo: {
+      publishedAt: pkg.meta.seo.publishedAt,
+      updatedAt: pkg.meta.seo.updatedAt,
+      readingTime: pkg.meta.seo.readingTime,
+      featured: pkg.meta.seo.featured,
+      ogImage: pkg.meta.seo.ogImage,
+    },
+    mcp: pkg.meta.mcp,
+    widget: { id: pkg.meta.slug, mode: "package" },
+  };
+}