@tomako/tools-runtime 0.1.0

package/src/features/tools/app-store-screenshot-generator/widget/types.ts

@@ -0,0 +1,60 @@
+import type {
+    AppStoreScreenshotAgentResult,
+    AppStoreScreenshotAsset,
+    AppStoreScreenshotGeneratorInput,
+    AppStoreScreenshotGeneratorOutput,
+} from "../../../../lib/tools/app-store-screenshot-generator-schema";
+
+export type SourceKey = AppStoreScreenshotGeneratorInput["source"];
+export type PlatformKey = AppStoreScreenshotGeneratorInput["platform"];
+export type StyleKey = AppStoreScreenshotGeneratorInput["style"];
+export type OutputLanguageKey = AppStoreScreenshotGeneratorInput["outputLanguage"];
+export type AssetFormat = AppStoreScreenshotAsset["format"];
+
+export type AssetSpec = {
+  id: string;
+  format: AssetFormat;
+  title: string;
+  width: number;
+  height: number;
+  variant: number;
+  slot: number;
+  setSize: number;
+  storyAngle: string;
+  copyIntent: string;
+  composition: string;
+};
+
+export type AssetGenerationFailure = {
+  spec: AssetSpec;
+  message: string;
+  imageTaskId?: string;
+};
+
+export type GeneratedStoreAssetsResult = {
+  output: AppStoreScreenshotGeneratorOutput;
+  failures: AssetGenerationFailure[];
+  reportStatus: AppStoreScreenshotAgentResult["reportStatus"];
+  completedCount: number;
+  totalCount: number;
+  failedCount: number;
+  inProgressTitle?: string;
+  estimatedRemainingSeconds?: number;
+};
+
+export type GenerationPhase = "submitting" | "planning" | "generating" | "finalizing";
+
+export type GenerationProgress = {
+  phase: GenerationPhase;
+  completedCount: number;
+  totalCount: number;
+  failedCount: number;
+  inProgressTitle?: string;
+  estimatedRemainingSeconds?: number;
+};
+
+export type GeneratedAssetSlot = {
+  slot: number;
+  asset?: AppStoreScreenshotAsset;
+  format: AssetFormat;
+};

package/src/features/tools/app-store-screenshot-generator/widget/zip.ts

@@ -0,0 +1,119 @@
+export type ZipFileInput = {
+  path: string;
+  data: Uint8Array;
+};
+
+export function createZipBlob(files: readonly ZipFileInput[]): Blob {
+  const localParts: Uint8Array[] = [];
+  const centralParts: Uint8Array[] = [];
+  let offset = 0;
+  const now = new Date();
+  const { dosDate, dosTime } = toDosDateTime(now);
+
+  files.forEach((file) => {
+    const name = encodeText(file.path);
+    const crc = crc32(file.data);
+    const localHeader = new Uint8Array(30);
+    const local = new DataView(localHeader.buffer);
+    local.setUint32(0, 0x04034b50, true);
+    local.setUint16(4, 20, true);
+    local.setUint16(6, 0x0800, true);
+    local.setUint16(8, 0, true);
+    local.setUint16(10, dosTime, true);
+    local.setUint16(12, dosDate, true);
+    local.setUint32(14, crc, true);
+    local.setUint32(18, file.data.length, true);
+    local.setUint32(22, file.data.length, true);
+    local.setUint16(26, name.length, true);
+    local.setUint16(28, 0, true);
+    localParts.push(localHeader, name, file.data);
+
+    const centralHeader = new Uint8Array(46);
+    const central = new DataView(centralHeader.buffer);
+    central.setUint32(0, 0x02014b50, true);
+    central.setUint16(4, 20, true);
+    central.setUint16(6, 20, true);
+    central.setUint16(8, 0x0800, true);
+    central.setUint16(10, 0, true);
+    central.setUint16(12, dosTime, true);
+    central.setUint16(14, dosDate, true);
+    central.setUint32(16, crc, true);
+    central.setUint32(20, file.data.length, true);
+    central.setUint32(24, file.data.length, true);
+    central.setUint16(28, name.length, true);
+    central.setUint16(30, 0, true);
+    central.setUint16(32, 0, true);
+    central.setUint16(34, 0, true);
+    central.setUint16(36, 0, true);
+    central.setUint32(38, 0, true);
+    central.setUint32(42, offset, true);
+    centralParts.push(centralHeader, name);
+
+    offset += localHeader.length + name.length + file.data.length;
+  });
+
+  const centralSize = centralParts.reduce((sum, part) => sum + part.length, 0);
+  const end = new Uint8Array(22);
+  const endView = new DataView(end.buffer);
+  endView.setUint32(0, 0x06054b50, true);
+  endView.setUint16(8, files.length, true);
+  endView.setUint16(10, files.length, true);
+  endView.setUint32(12, centralSize, true);
+  endView.setUint32(16, offset, true);
+  endView.setUint16(20, 0, true);
+
+  return new Blob([...localParts, ...centralParts, end].map(toBlobPart), {
+    type: "application/zip",
+  });
+}
+
+export function toBlobPart(part: Uint8Array): BlobPart {
+  return part.buffer.slice(part.byteOffset, part.byteOffset + part.byteLength) as ArrayBuffer;
+}
+
+export function toDosDateTime(date: Date): { dosDate: number; dosTime: number } {
+  const year = Math.max(date.getFullYear(), 1980);
+  const dosDate = ((year - 1980) << 9) | ((date.getMonth() + 1) << 5) | date.getDate();
+  const dosTime = (date.getHours() << 11) | (date.getMinutes() << 5) | Math.floor(date.getSeconds() / 2);
+  return { dosDate, dosTime };
+}
+
+export function crc32(data: Uint8Array): number {
+  let crc = 0xffffffff;
+
+  for (const byte of data) {
+    crc = CRC32_TABLE[(crc ^ byte) & 0xff] ^ (crc >>> 8);
+  }
+
+  return (crc ^ 0xffffffff) >>> 0;
+}
+
+export const CRC32_TABLE = new Uint32Array(
+  Array.from({ length: 256 }, (_, index) => {
+    let crc = index;
+    for (let bit = 0; bit < 8; bit += 1) {
+      crc = crc & 1 ? 0xedb88320 ^ (crc >>> 1) : crc >>> 1;
+    }
+    return crc >>> 0;
+  }),
+);
+
+export function encodeText(value: string): Uint8Array {
+  return new TextEncoder().encode(value);
+}
+
+export function slugForFileName(value: string) {
+  return value
+    .toLowerCase()
+    .replace(/[^a-z0-9]+/gi, "-")
+    .replace(/^-|-$/g, "")
+    .slice(0, 60);
+}
+
+export function escapeXml(value: string) {
+  return value
+    .replace(/&/g, "&amp;")
+    .replace(/</g, "&lt;")
+    .replace(/>/g, "&gt;")
+    .replace(/"/g, "&quot;");
+}

package/src/features/tools/build-in-public-story-generator/build-in-public-story-generator.container.tsx

@@ -0,0 +1,135 @@
+import { createToolGuideTranslator } from "../shared/tool-message-translator";
+import { BuildInPublicStoryGenerator } from "./widget";
+
+import {
+    ToolCardGrid,
+    ToolFaqSection,
+    ToolPlainTextGrid,
+    ToolSection,
+    type ToolFaqItem,
+    type ToolTextCard,
+} from "../shared/tool-content-sections";
+import { ToolCta } from "../shared/tool-cta";
+import {
+    ToolGuideSection,
+    ToolImageVisual,
+    ToolWorkspaceSection,
+} from "../shared/tool-guide-section";
+import { ToolPageShell } from "../shared/tool-page-shell";
+import type { ToolPageProps } from "../types";
+
+export async function BuildInPublicStoryGeneratorContainer({
+  locale,
+  spec,
+}: ToolPageProps) {
+  const t = await createToolGuideTranslator(
+    locale,
+    "toolsPages.buildInPublicStoryGenerator.guide",
+  );
+  const outputItems = t.raw("outputItems") as readonly ToolTextCard[];
+  const supportItems = t.raw("supportItems") as readonly string[];
+  const boundaryItems = t.raw("boundaryItems") as readonly string[];
+  const platformItems = t.raw("platformItems") as readonly string[];
+  const reviewItems = t.raw("reviewItems") as readonly string[];
+  const whyTomakoItems = t.raw("whyTomakoItems") as readonly ToolTextCard[];
+  const standardItems = t.raw("standardItems") as readonly string[];
+  const faqItems = t.raw("faqItems") as readonly ToolFaqItem[];
+
+  return (
+    <ToolPageShell
+      heroBackgroundAlt={t("heroVisualAlt")}
+      heroBackgroundImage="/tools/build-in-public-story-generator-hero.webp"
+      heroVariant="immersive"
+      locale={locale}
+      spec={spec}
+    >
+      <ToolWorkspaceSection
+        badge={t("workspaceBadge")}
+        heading={t("workspaceHeading")}
+        hint={t("workspaceHint")}
+      >
+        <BuildInPublicStoryGenerator />
+      </ToolWorkspaceSection>
+      <ToolSection heading={t("outputs")}>
+        <ToolCardGrid items={outputItems} columns="four" />
+      </ToolSection>
+      <ToolGuideSection
+        heading={t("supportHeading")}
+        visual={
+          <ToolImageVisual
+            alt={t("supportVisualAlt")}
+            src="/tools/build-in-public-story-generator-value.webp"
+            wide
+          />
+        }
+      >
+        <ToolPlainTextGrid items={supportItems} />
+      </ToolGuideSection>
+      <ToolGuideSection
+        heading={t("platformHeading")}
+        reverse
+        visual={
+          <ToolImageVisual
+            alt={t("platformVisualAlt")}
+            src="/tools/build-in-public-story-generator-platforms.webp"
+            wide
+          />
+        }
+      >
+        <ToolPlainTextGrid items={platformItems} />
+      </ToolGuideSection>
+      <ToolGuideSection
+        heading={t("boundaryHeading")}
+        visual={
+          <ToolImageVisual
+            alt={t("boundaryVisualAlt")}
+            src="/tools/build-in-public-story-generator-risk.webp"
+            wide
+          />
+        }
+      >
+        <ToolPlainTextGrid items={boundaryItems} />
+      </ToolGuideSection>
+      <ToolSection heading={t("whyTomakoHeading")}>
+        <ToolCardGrid items={whyTomakoItems} columns="four" />
+      </ToolSection>
+      <ToolGuideSection
+        heading={t("reviewHeading")}
+        reverse
+        visual={
+          <ToolImageVisual
+            alt={t("reviewVisualAlt")}
+            src="/tools/build-in-public-story-generator-workspace.webp"
+            wide
+          />
+        }
+      >
+        <ToolPlainTextGrid items={reviewItems} />
+      </ToolGuideSection>
+      <ToolGuideSection
+        heading={t("standardHeading")}
+        visual={
+          <ToolImageVisual
+            alt={t("standardVisualAlt")}
+            src="/tools/build-in-public-story-generator-value.webp"
+            wide
+          />
+        }
+      >
+        <ToolPlainTextGrid items={standardItems} />
+      </ToolGuideSection>
+      <ToolFaqSection heading={t("faq")} items={faqItems} />
+      <ToolCta
+        hint={t("ctaHint")}
+        primary={{
+          href: "/tools/social-platform-asset-adapter",
+          label: t("ctaPrimary"),
+        }}
+        secondary={{
+          href: "/tools/cold-start-channel-selector",
+          label: t("ctaSecondary"),
+        }}
+      />
+    </ToolPageShell>
+  );
+}

package/src/features/tools/build-in-public-story-generator/build-in-public-story-generator.spec.ts

@@ -0,0 +1,15 @@
+import type { ToolSpec } from "../types";
+
+export const buildInPublicStoryGeneratorSpec: ToolSpec = {
+  slug: "build-in-public-story-generator",
+  toolType: "generator",
+  riskLevel: "medium",
+  seo: {
+    "publishedAt": "2026-06-30",
+    "updatedAt": "2026-06-30",
+    "readingTime": "8 min",
+    "featured": false,
+    "ogImage": "/tools/build-in-public-story-generator-hero.webp"
+  },
+  widget: {"id":"build-in-public-story-generator","mode":"custom"},
+};

package/src/features/tools/build-in-public-story-generator/widget/build-in-public-story-generator.tsx

@@ -0,0 +1,314 @@
+"use client";
+import {
+    copyTextToClipboard,
+    downloadTextFile
+} from "../../../../components/tools/workspace";
+import { Button } from "@tomako/ui/button";
+import { Field, Input, Textarea } from "@tomako/ui/input";
+import {
+    Select,
+    SelectContent,
+    SelectItem,
+    SelectTrigger,
+    SelectValue,
+} from "@tomako/ui/select";
+import { useLocale, useTranslations } from "../../../../i18n/client";
+import {
+    buildInPublicBoundaries,
+    buildInPublicStages,
+    buildInPublicStoryBriefSchema,
+    type BuildInPublicBoundary,
+    type BuildInPublicChannel,
+    type BuildInPublicStage,
+    type BuildInPublicStoryBrief
+} from "../../../../lib/tools/build-in-public-story-generator-schema";
+import {
+    createBuildInPublicStory,
+    stringifyBuildInPublicStory,
+} from "../../../../lib/tools/build-in-public-story-generator.format";
+import { AlertTriangle, FileText } from "lucide-react";
+import { useMemo, useRef, useState } from "react";
+import { defaultBrief, isWeakText } from "./helpers";
+import { PreviewPanel } from "./preview-panels";
+import { StoryResult } from "./result-shell";
+import type { GeneratorState } from "./types";
+
+export function BuildInPublicStoryGenerator() {
+  const locale = useLocale();
+  const language = locale === "en" ? "en" : "zh";
+  const t = useTranslations("toolsPages.buildInPublicStoryGenerator.widget");
+  const resultRef = useRef<HTMLDivElement>(null);
+  const [brief, setBrief] = useState<BuildInPublicStoryBrief>(() =>
+    defaultBrief(language),
+  );
+  const [state, setState] = useState<GeneratorState>({ phase: "idle" });
+  const [copied, setCopied] = useState(false);
+  const [activeChannel, setActiveChannel] =
+    useState<BuildInPublicChannel>("indieHackers");
+
+  const stageLabels = t.raw("stages") as Record<BuildInPublicStage, string>;
+  const boundaryLabels = t.raw("boundaries") as Record<BuildInPublicBoundary, string>;
+  const channelLabels = t.raw("channels") as Record<BuildInPublicChannel, string>;
+
+  const statusText = useMemo(() => {
+    if (state.phase === "done") return t("status.done");
+    if (state.phase === "error") return t("status.error");
+    return t("status.idle");
+  }, [state.phase, t]);
+
+  function updateBrief<T extends keyof BuildInPublicStoryBrief>(
+    key: T,
+    value: BuildInPublicStoryBrief[T],
+  ) {
+    setBrief((prev) => ({ ...prev, [key]: value, language }));
+  }
+
+  function validateBrief() {
+    const parsed = buildInPublicStoryBriefSchema.safeParse({ ...brief, language });
+    if (!parsed.success) return { ok: false as const, code: "validation" as const };
+    if (
+      isWeakText(parsed.data.productContext, 5) ||
+      isWeakText(parsed.data.thisWeek, 8) ||
+      isWeakText(parsed.data.feedbackAsk, 3)
+    ) {
+      return { ok: false as const, code: "weakInput" as const };
+    }
+    return { ok: true as const, data: parsed.data };
+  }
+
+  function generateStory() {
+    const parsed = validateBrief();
+    window.setTimeout(
+      () => resultRef.current?.scrollIntoView({ behavior: "smooth", block: "start" }),
+      20,
+    );
+
+    if (!parsed.ok) {
+      setState({ phase: "error", code: parsed.code });
+      setCopied(false);
+      return;
+    }
+
+    const result = createBuildInPublicStory(parsed.data);
+    setActiveChannel(result.drafts[0]?.channel ?? "indieHackers");
+    setState({ phase: "done", result });
+    setCopied(false);
+  }
+
+  function reset() {
+    setBrief(defaultBrief(language));
+    setState({ phase: "idle" });
+    setCopied(false);
+    setActiveChannel("indieHackers");
+  }
+
+  async function copyResult() {
+    if (state.phase !== "done") return;
+    const copiedToClipboard = await copyTextToClipboard(
+      stringifyBuildInPublicStory(state.result),
+    );
+    if (copiedToClipboard) {
+      setCopied(true);
+      window.setTimeout(() => setCopied(false), 1600);
+    }
+  }
+
+  function downloadResult() {
+    if (state.phase !== "done") return;
+    downloadTextFile({
+      filename: "build-in-public-story-drafts.md",
+      text: stringifyBuildInPublicStory(state.result),
+    });
+  }
+
+  return (
+    <div className="grid gap-6">
+      <section className="overflow-hidden rounded-[1.5rem] border border-[#D8D4CA] bg-white shadow-[0_18px_60px_rgba(17,17,17,0.08)]">
+        <div className="grid lg:grid-cols-[minmax(0,0.98fr)_minmax(320px,0.62fr)]">
+          <form
+            className="bg-white p-5 md:p-7"
+            onSubmit={(event) => {
+              event.preventDefault();
+              generateStory();
+            }}
+          >
+            <div className="mb-6">
+              <p className="inline-flex items-center gap-2 rounded-full bg-[#111111] px-3 py-1.5 text-xs font-semibold text-white">
+                <FileText aria-hidden className="size-4 text-[#F2C2B4]" />
+                {t("formTitle")}
+              </p>
+              <p className="mt-3 max-w-2xl text-sm leading-6 text-[#555555]">
+                {t("formHint")}
+              </p>
+            </div>
+
+            <div className="grid gap-4">
+              <div className="grid gap-4 md:grid-cols-[minmax(0,1fr)_220px]">
+                <Field label={t("productNameLabel")}>
+                  <Input
+                    className="h-12 rounded-2xl border-[#CFC9BC] bg-white px-4 text-[15px]"
+                    onChange={(event) => updateBrief("productName", event.target.value)}
+                    placeholder={t("productNamePlaceholder")}
+                    value={brief.productName}
+                  />
+                </Field>
+                <Field label={t("stageLabel")}>
+                  <Select
+                    onValueChange={(value) =>
+                      updateBrief("stage", value as BuildInPublicStage)
+                    }
+                    value={brief.stage}
+                  >
+                    <SelectTrigger className="h-12 w-full rounded-2xl border-[#CFC9BC] bg-white px-4 text-[15px]">
+                      <SelectValue />
+                    </SelectTrigger>
+                    <SelectContent>
+                      {buildInPublicStages.map((stage) => (
+                        <SelectItem key={stage} value={stage}>
+                          {stageLabels[stage]}
+                        </SelectItem>
+                      ))}
+                    </SelectContent>
+                  </Select>
+                </Field>
+              </div>
+
+              <Field label={t("productContextLabel")}>
+                <Textarea
+                  className="min-h-28 rounded-2xl border-[#CFC9BC] bg-white px-4 py-3 text-[15px]"
+                  onChange={(event) => updateBrief("productContext", event.target.value)}
+                  placeholder={t("productContextPlaceholder")}
+                  value={brief.productContext}
+                />
+              </Field>
+
+              <Field label={t("thisWeekLabel")}>
+                <Textarea
+                  className="min-h-32 rounded-2xl border-[#CFC9BC] bg-white px-4 py-3 text-[15px]"
+                  onChange={(event) => updateBrief("thisWeek", event.target.value)}
+                  placeholder={t("thisWeekPlaceholder")}
+                  value={brief.thisWeek}
+                />
+              </Field>
+
+              <Field label={t("feedbackAskLabel")}>
+                <Textarea
+                  className="min-h-24 rounded-2xl border-[#CFC9BC] bg-white px-4 py-3 text-[15px]"
+                  onChange={(event) => updateBrief("feedbackAsk", event.target.value)}
+                  placeholder={t("feedbackAskPlaceholder")}
+                  value={brief.feedbackAsk}
+                />
+              </Field>
+
+              <details className="rounded-2xl border border-[#D8D4CA] bg-[#F8F7F2] p-4">
+                <summary className="cursor-pointer text-sm font-semibold text-[#111111]">
+                  {t("advancedTitle")}
+                </summary>
+                <div className="mt-4 grid gap-4">
+                  <Field label={t("gtmStrategyLabel")}>
+                    <Textarea
+                      className="min-h-24 rounded-2xl border-[#CFC9BC] bg-white px-4 py-3 text-[15px]"
+                      onChange={(event) => updateBrief("gtmStrategy", event.target.value)}
+                      placeholder={t("gtmStrategyPlaceholder")}
+                      value={brief.gtmStrategy}
+                    />
+                  </Field>
+                  <div className="grid gap-4 md:grid-cols-2">
+                    <Field label={t("metricsLabel")}>
+                      <Textarea
+                        className="min-h-24 rounded-2xl border-[#CFC9BC] bg-white px-4 py-3 text-[15px]"
+                        onChange={(event) => updateBrief("metrics", event.target.value)}
+                        placeholder={t("metricsPlaceholder")}
+                        value={brief.metrics}
+                      />
+                    </Field>
+                    <Field label={t("uncertaintyLabel")}>
+                      <Textarea
+                        className="min-h-24 rounded-2xl border-[#CFC9BC] bg-white px-4 py-3 text-[15px]"
+                        onChange={(event) => updateBrief("uncertainty", event.target.value)}
+                        placeholder={t("uncertaintyPlaceholder")}
+                        value={brief.uncertainty}
+                      />
+                    </Field>
+                  </div>
+                  <Field label={t("boundaryLabel")}>
+                    <Select
+                      onValueChange={(value) =>
+                        updateBrief("publicBoundary", value as BuildInPublicBoundary)
+                      }
+                      value={brief.publicBoundary}
+                    >
+                      <SelectTrigger className="h-12 w-full rounded-2xl border-[#CFC9BC] bg-white px-4 text-[15px]">
+                        <SelectValue />
+                      </SelectTrigger>
+                      <SelectContent>
+                        {buildInPublicBoundaries.map((boundary) => (
+                          <SelectItem key={boundary} value={boundary}>
+                            {boundaryLabels[boundary]}
+                          </SelectItem>
+                        ))}
+                      </SelectContent>
+                    </Select>
+                  </Field>
+                </div>
+              </details>
+
+              <Button
+                className="h-12 w-full rounded-2xl bg-[#111111] px-5 text-[15px] text-white hover:bg-[#2A2A2A]"
+                type="submit"
+              >
+                {t("generate")}
+              </Button>
+            </div>
+          </form>
+
+          <PreviewPanel
+            labels={t.raw("previewItems") as readonly string[]}
+            state={state}
+            status={statusText}
+            visualAlt={t("workspaceVisualAlt")}
+          />
+        </div>
+      </section>
+
+      <section ref={resultRef}>
+        {state.phase === "idle" ? null : (
+          <div className="rounded-[1.5rem] border border-[#D8D4CA] bg-white p-5 shadow-[0_18px_60px_rgba(17,17,17,0.08)] md:p-7">
+            {state.phase === "error" ? (
+              <div className="rounded-[1.25rem] border border-[#F1C2B8] bg-[#FFF1EC] p-5">
+                <div className="flex items-start gap-3">
+                  <AlertTriangle
+                    aria-hidden
+                    className="mt-1 size-5 shrink-0 text-[#A83A24]"
+                  />
+                  <div>
+                    <h3 className="text-lg font-semibold text-[#7A2818]">
+                      {t(`errors.${state.code}.title`)}
+                    </h3>
+                    <p className="mt-2 text-sm leading-6 text-[#7A2818]">
+                      {t(`errors.${state.code}.body`)}
+                    </p>
+                  </div>
+                </div>
+              </div>
+            ) : null}
+
+            {state.phase === "done" ? (
+              <StoryResult
+                activeChannel={activeChannel}
+                channelLabels={channelLabels}
+                copied={copied}
+                onActiveChannelChange={setActiveChannel}
+                onCopy={() => void copyResult()}
+                onDownload={downloadResult}
+                onReset={reset}
+                result={state.result}
+                t={t}
+              />
+            ) : null}
+          </div>
+        )}
+      </section>
+    </div>
+  );
+}

package/src/features/tools/build-in-public-story-generator/widget/constants.ts

@@ -0,0 +1,3 @@
+
+export const placeholderPattern =
+  /^(test|demo|sample|example|asdf|qwer|lorem ipsum|123+|111+|222+|xxx+|测试|示例)$/i;

package/src/features/tools/build-in-public-story-generator/widget/helpers.ts

@@ -0,0 +1,25 @@
+import type { BuildInPublicStoryBrief } from "../../../../lib/tools/build-in-public-story-generator-schema";
+import { placeholderPattern } from "./constants";
+
+export function defaultBrief(language: BuildInPublicStoryBrief["language"]): BuildInPublicStoryBrief {
+  return {
+    productName: "",
+    productContext: "",
+    stage: "beta",
+    thisWeek: "",
+    feedbackAsk: "",
+    gtmStrategy: "",
+    metrics: "",
+    uncertainty: "",
+    publicBoundary: "blurMetrics",
+    language,
+  };
+}
+
+export function isWeakText(value: string, minWords: number) {
+  const text = value.trim();
+  if (!text) return true;
+  if (placeholderPattern.test(text)) return true;
+  if (/^\d+$/.test(text)) return true;
+  return text.split(/\s+/).filter(Boolean).length < minWords && text.length < 42;
+}

package/src/features/tools/build-in-public-story-generator/widget/index.ts

@@ -0,0 +1,7 @@
+"use client";
+
+import dynamic from "next/dynamic";
+
+export const BuildInPublicStoryGenerator = dynamic(() =>
+  import("./build-in-public-story-generator").then((module) => module.BuildInPublicStoryGenerator),
+);