vidspotai-shared 1.0.94 → 1.0.96

package/lib/services/demo/demoMusic.js

@@ -0,0 +1,93 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.selectDemoMusic = selectDemoMusic;
+const musicGen_1 = require("../musicGen");
+const logger_1 = require("../../utils/logger");
+/**
+ * Background-music selection for the SaaS Demo Video pipeline (quality pillar #3:
+ * "exciting music, ducked under the voiceover"). Runs in the worker just before
+ * the mux stage — a purely mechanical style → mood/bpm → curated-track lookup, so
+ * it needs no LLM call (mirrors `selectMusicForPlan`'s post-planner rationale for
+ * the agent pipeline).
+ *
+ * Source is the always-on, zero-cost, commercially-licensed curated catalog
+ * (Pixabay Content License) via `searchAllMusicSources`. Product demos want
+ * ENERGY, so the mood floor is uplifting/energetic; `pace`/`motion` push the
+ * tempo up, and only a slow, dark, subtle style relaxes it. Best-effort: if no
+ * track is reachable we return null and the video ships without a bed (never a
+ * hard failure — music is enhancement, not a blocker).
+ */
+const TAG = "[DemoMusic]";
+/**
+ * Map the resolved DemoStyle to a music mood + tempo target. The demo brief is
+ * always "an exciting product demo", so the baseline is upbeat; the levers only
+ * decide HOW driving. `colorMood:"dark"` biases toward a moodier-but-still-driving
+ * track when the pace is already relaxed, otherwise energy wins.
+ */
+function moodForStyle(spec) {
+    const { pace, motion, colorMood } = spec.style;
+    const highEnergy = pace === "fast" || motion === "dynamic";
+    const lowEnergy = pace === "slow" && motion === "subtle";
+    if (highEnergy) {
+        return { mood: "energetic", query: "upbeat energetic product demo", bpmTarget: 124 };
+    }
+    if (lowEnergy) {
+        // Relaxed pace — stay uplifting, or lean cinematic when the look is dark.
+        return colorMood === "dark"
+            ? { mood: "cinematic", query: "cinematic driving product demo", bpmTarget: 96 }
+            : { mood: "uplifting", query: "warm uplifting product demo", bpmTarget: 100 };
+    }
+    // Balanced default — uplifting corporate/product-demo bed.
+    return { mood: "uplifting", query: "uplifting corporate product demo", bpmTarget: 112 };
+}
+/**
+ * HEAD-probe a track URL to confirm it's fetchable before committing it — the
+ * curated catalog points at cdn.pixabay.com, alive today but worth guarding so
+ * a dead CDN edge silently ships no music rather than 404-crashing the mux.
+ * (Same guard shape as `selectMusicForPlan`'s `pickFirstReachable`.)
+ */
+async function firstReachable(tracks) {
+    for (const t of tracks) {
+        try {
+            const controller = new AbortController();
+            const timeout = setTimeout(() => controller.abort(), 5000);
+            const r = await fetch(t.url, { method: "HEAD", signal: controller.signal });
+            clearTimeout(timeout);
+            if (r.ok)
+                return t;
+            logger_1.logger.warn(`${TAG} track HEAD non-2xx, skipping`, { url: t.url, status: r.status });
+        }
+        catch (e) {
+            logger_1.logger.warn(`${TAG} track HEAD failed, skipping`, {
+                url: t.url,
+                err: e instanceof Error ? e.message : String(e),
+            });
+        }
+    }
+    return undefined;
+}
+/**
+ * Pick a reachable background-music bed for a demo. Returns null (never throws)
+ * when nothing is reachable — the caller ships the video without a bed.
+ */
+async function selectDemoMusic(spec) {
+    const { mood, query, bpmTarget } = moodForStyle(spec);
+    try {
+        // Don't pass durationSecMin — every curated track is looped to the video
+        // length in the mux, so a shorter track must not be penalized/disqualified.
+        const result = await (0, musicGen_1.searchAllMusicSources)({ query, mood, bpmTarget, limit: 5 });
+        const track = await firstReachable(result.tracks);
+        if (!track) {
+            logger_1.logger.warn(`${TAG} no reachable track`, { mood, candidateCount: result.tracks.length });
+            return null;
+        }
+        logger_1.logger.info(`${TAG} selected bed`, { trackId: track.id, mood: track.mood, bpm: track.bpm });
+        return { url: track.url, attribution: track.attribution, mood: track.mood, bpm: track.bpm };
+    }
+    catch (e) {
+        logger_1.logger.warn(`${TAG} selection failed — shipping without music`, {
+            err: e instanceof Error ? e.message : String(e),
+        });
+        return null;
+    }
+}

package/lib/services/demo/demoPrefill.d.ts

@@ -0,0 +1,76 @@
+import { LlmCaller } from "../agent/llmCaller";
+import { ModelChoice, ModelRouter } from "../agent/modelRouter";
+export interface DemoPrefillFields {
+    productName?: string;
+    tagline?: string;
+    description?: string;
+    audience?: string;
+}
+export interface DemoPrefillResult {
+    fields: DemoPrefillFields;
+    /** How the fields were derived — "llm" polished, or metadata-only fallback. */
+    source: "llm" | "metadata";
+    modelUsed?: ModelChoice;
+    usage?: {
+        promptTokens?: number;
+        completionTokens?: number;
+    };
+}
+/** User-facing error codes the controller maps to 4xx/5xx responses. */
+export type DemoPrefillErrorCode = "invalid_url" | "blocked_host" | "unreachable" | "empty_page";
+export declare class DemoPrefillError extends Error {
+    readonly code: DemoPrefillErrorCode;
+    constructor(code: DemoPrefillErrorCode, message: string);
+}
+export interface DemoPrefillDeps {
+    llm?: LlmCaller;
+    router?: ModelRouter;
+    /** Total fetch timeout per hop (ms). */
+    timeoutMs?: number;
+    /** Max redirect hops to follow (each re-validated against the SSRF guard). */
+    maxRedirects?: number;
+    /** Max response bytes to read (defends against huge pages). */
+    maxBytes?: number;
+}
+export interface DemoPageMeta {
+    title?: string;
+    siteName?: string;
+    ogTitle?: string;
+    ogDescription?: string;
+    metaDescription?: string;
+    jsonLdName?: string;
+    jsonLdDescription?: string;
+    /** De-tagged visible text, capped. */
+    text: string;
+}
+export declare function extractPageMeta(html: string): DemoPageMeta;
+/**
+ * Signals extracted from a product page for the WORKER's gather stage — the
+ * "background autofill" the user never has to click. Deliberately LLM-FREE and
+ * uncharged: it reuses the same SSRF-safe fetch + metadata extraction as the
+ * interactive prefill, but skips the Haiku polish so it's free to run on every
+ * generation. Used to backfill any Basics field the user left blank and to hand
+ * the planner a compact page summary as extra grounding.
+ */
+export interface DemoPageSignals {
+    /** Metadata-derived basics (only the fields we could determine). */
+    fields: DemoPrefillFields;
+    /** A compact page summary for the planner (title/desc + visible-text lead). */
+    summary: string;
+}
+/**
+ * Fetch a product URL and pull LLM-FREE signals for the gather stage: the
+ * metadata-only Basics + a compact summary string. Throws DemoPrefillError on
+ * the same user-facing failures as {@link prefillDemoBasics} (bad URL, blocked
+ * host, unreachable, empty page) — the worker calls this best-effort and
+ * swallows any throw, so a slow/blocked site never fails a generation.
+ */
+export declare function gatherPageSignals(rawUrl: string, deps?: Pick<DemoPrefillDeps, "timeoutMs" | "maxRedirects" | "maxBytes">): Promise<DemoPageSignals>;
+/**
+ * Fetch a product URL and extract Basics fields. Tries LLM polish (Haiku "router"
+ * tier); falls back to metadata-only if the LLM is unconfigured/errors. Throws
+ * DemoPrefillError for user-facing failures (bad URL, blocked host, unreachable,
+ * empty page).
+ */
+export declare function prefillDemoBasics(rawUrl: string, deps?: DemoPrefillDeps): Promise<DemoPrefillResult>;
+//# sourceMappingURL=demoPrefill.d.ts.map

package/lib/services/demo/demoPrefill.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"demoPrefill.d.ts","sourceRoot":"","sources":["../../../src/services/demo/demoPrefill.ts"],"names":[],"mappings":"AAGA,OAAO,EAAE,SAAS,EAAE,MAAM,oBAAoB,CAAC;AAE/C,OAAO,EAAE,WAAW,EAAE,WAAW,EAAE,MAAM,sBAAsB,CAAC;AA0BhE,MAAM,WAAW,iBAAiB;IAChC,WAAW,CAAC,EAAE,MAAM,CAAC;IACrB,OAAO,CAAC,EAAE,MAAM,CAAC;IACjB,WAAW,CAAC,EAAE,MAAM,CAAC;IACrB,QAAQ,CAAC,EAAE,MAAM,CAAC;CACnB;AAED,MAAM,WAAW,iBAAiB;IAChC,MAAM,EAAE,iBAAiB,CAAC;IAC1B,+EAA+E;IAC/E,MAAM,EAAE,KAAK,GAAG,UAAU,CAAC;IAC3B,SAAS,CAAC,EAAE,WAAW,CAAC;IACxB,KAAK,CAAC,EAAE;QAAE,YAAY,CAAC,EAAE,MAAM,CAAC;QAAC,gBAAgB,CAAC,EAAE,MAAM,CAAA;KAAE,CAAC;CAC9D;AAED,wEAAwE;AACxE,MAAM,MAAM,oBAAoB,GAC5B,aAAa,GACb,cAAc,GACd,aAAa,GACb,YAAY,CAAC;AAEjB,qBAAa,gBAAiB,SAAQ,KAAK;aAEvB,IAAI,EAAE,oBAAoB;gBAA1B,IAAI,EAAE,oBAAoB,EAC1C,OAAO,EAAE,MAAM;CAKlB;AAED,MAAM,WAAW,eAAe;IAC9B,GAAG,CAAC,EAAE,SAAS,CAAC;IAChB,MAAM,CAAC,EAAE,WAAW,CAAC;IACrB,wCAAwC;IACxC,SAAS,CAAC,EAAE,MAAM,CAAC;IACnB,8EAA8E;IAC9E,YAAY,CAAC,EAAE,MAAM,CAAC;IACtB,+DAA+D;IAC/D,QAAQ,CAAC,EAAE,MAAM,CAAC;CACnB;AA6ID,MAAM,WAAW,YAAY;IAC3B,KAAK,CAAC,EAAE,MAAM,CAAC;IACf,QAAQ,CAAC,EAAE,MAAM,CAAC;IAClB,OAAO,CAAC,EAAE,MAAM,CAAC;IACjB,aAAa,CAAC,EAAE,MAAM,CAAC;IACvB,eAAe,CAAC,EAAE,MAAM,CAAC;IACzB,UAAU,CAAC,EAAE,MAAM,CAAC;IACpB,iBAAiB,CAAC,EAAE,MAAM,CAAC;IAC3B,sCAAsC;IACtC,IAAI,EAAE,MAAM,CAAC;CACd;AA+ED,wBAAgB,eAAe,CAAC,IAAI,EAAE,MAAM,GAAG,YAAY,CAc1D;AA4ED;;;;;;;GAOG;AACH,MAAM,WAAW,eAAe;IAC9B,oEAAoE;IACpE,MAAM,EAAE,iBAAiB,CAAC;IAC1B,+EAA+E;IAC/E,OAAO,EAAE,MAAM,CAAC;CACjB;AAKD;;;;;;GAMG;AACH,wBAAsB,iBAAiB,CACrC,MAAM,EAAE,MAAM,EACd,IAAI,GAAE,IAAI,CAAC,eAAe,EAAE,WAAW,GAAG,cAAc,GAAG,UAAU,CAAM,GAC1E,OAAO,CAAC,eAAe,CAAC,CAqC1B;AAED;;;;;GAKG;AACH,wBAAsB,iBAAiB,CACrC,MAAM,EAAE,MAAM,EACd,IAAI,GAAE,eAAoB,GACzB,OAAO,CAAC,iBAAiB,CAAC,CA8C5B"}

package/lib/services/demo/demoPrefill.js

@@ -0,0 +1,435 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.DemoPrefillError = void 0;
+exports.extractPageMeta = extractPageMeta;
+exports.gatherPageSignals = gatherPageSignals;
+exports.prefillDemoBasics = prefillDemoBasics;
+const promises_1 = require("dns/promises");
+const net_1 = require("net");
+const zod_1 = require("zod");
+const llmCallerRegistry_1 = require("../agent/llmCallerRegistry");
+const modelRouter_1 = require("../agent/modelRouter");
+/**
+ * SaaS Demo Video Generator — "Autofill from URL" (plan §9 / Basics step helper).
+ *
+ * A FAST, SYNCHRONOUS product-basics extractor for the wizard: given a product
+ * URL, fetch the page server-side (SSRF-guarded), parse its OpenGraph / meta /
+ * JSON-LD / visible text, then run ONE cheap Claude Haiku pass to turn that into
+ * clean, distinct fields (productName / tagline / description / audience). If the
+ * LLM call fails, we degrade to a metadata-only best-effort so the button still
+ * fills something.
+ *
+ * This is deliberately SEPARATE from the worker's heavy gather stage
+ * (`websiteCapture` puppeteer screenshots + `githubBrand`): those run async
+ * during generation and cost real time; this is a sub-second form helper. It is
+ * uncharged (a Haiku call over a few KB of text is negligible).
+ */
+// ── Field length caps (mirror the frontend wizard's maxLength on each Field) ──
+const CAP = {
+    productName: 120,
+    tagline: 240,
+    description: 2000,
+    audience: 240,
+};
+class DemoPrefillError extends Error {
+    constructor(code, message) {
+        super(message);
+        this.code = code;
+        this.name = "DemoPrefillError";
+    }
+}
+exports.DemoPrefillError = DemoPrefillError;
+// ── SSRF guard ───────────────────────────────────────────────────────────────
+/** IPv4/IPv6 ranges we must never fetch (cloud metadata, loopback, LAN, etc.). */
+function isPrivateAddress(ip) {
+    const v = (0, net_1.isIP)(ip);
+    if (v === 4) {
+        const p = ip.split(".").map(Number);
+        if (p.length !== 4 || p.some((n) => Number.isNaN(n)))
+            return true;
+        const a = p[0];
+        const b = p[1];
+        if (a === 10)
+            return true; // 10.0.0.0/8
+        if (a === 127)
+            return true; // loopback
+        if (a === 0)
+            return true; // "this" network
+        if (a === 169 && b === 254)
+            return true; // link-local incl. 169.254.169.254
+        if (a === 172 && b >= 16 && b <= 31)
+            return true; // 172.16.0.0/12
+        if (a === 192 && b === 168)
+            return true; // 192.168.0.0/16
+        if (a === 100 && b >= 64 && b <= 127)
+            return true; // CGNAT 100.64.0.0/10
+        if (a >= 224)
+            return true; // multicast / reserved
+        return false;
+    }
+    if (v === 6) {
+        const lower = ip.toLowerCase();
+        if (lower === "::1" || lower === "::")
+            return true; // loopback / unspecified
+        if (lower.startsWith("fc") || lower.startsWith("fd"))
+            return true; // ULA fc00::/7
+        if (lower.startsWith("fe80"))
+            return true; // link-local
+        // IPv4-mapped (::ffff:a.b.c.d) — extract and re-check as v4.
+        const mapped = lower.match(/::ffff:(\d+\.\d+\.\d+\.\d+)$/);
+        if (mapped?.[1])
+            return isPrivateAddress(mapped[1]);
+        return false;
+    }
+    return true; // not an IP literal ⇒ treat as unsafe
+}
+/**
+ * Validate a URL is a public http(s) target: parseable, http/https, not a
+ * localhost-ish hostname, and every resolved IP is public. Throws a
+ * DemoPrefillError otherwise. Called on the initial URL AND every redirect hop.
+ */
+async function assertPublicHttpUrl(raw) {
+    let url;
+    try {
+        url = new URL(raw);
+    }
+    catch {
+        throw new DemoPrefillError("invalid_url", "That doesn't look like a valid URL.");
+    }
+    if (url.protocol !== "http:" && url.protocol !== "https:") {
+        throw new DemoPrefillError("invalid_url", "Only http(s) URLs are supported.");
+    }
+    const host = url.hostname.replace(/^\[|\]$/g, ""); // strip IPv6 brackets
+    // Obvious internal hostnames — reject before any DNS.
+    const lowered = host.toLowerCase();
+    if (lowered === "localhost" ||
+        lowered.endsWith(".localhost") ||
+        lowered.endsWith(".local") ||
+        lowered.endsWith(".internal") ||
+        lowered === "metadata.google.internal") {
+        throw new DemoPrefillError("blocked_host", "That host isn't reachable.");
+    }
+    // Literal IP ⇒ check directly; hostname ⇒ resolve every address and check all.
+    if ((0, net_1.isIP)(host)) {
+        if (isPrivateAddress(host)) {
+            throw new DemoPrefillError("blocked_host", "That host isn't reachable.");
+        }
+        return url;
+    }
+    let addresses;
+    try {
+        addresses = await (0, promises_1.lookup)(host, { all: true });
+    }
+    catch {
+        throw new DemoPrefillError("unreachable", "We couldn't reach that site.");
+    }
+    if (addresses.length === 0 || addresses.some((a) => isPrivateAddress(a.address))) {
+        throw new DemoPrefillError("blocked_host", "That host isn't reachable.");
+    }
+    return url;
+}
+// ── Fetch (SSRF-safe, manual redirects) ──────────────────────────────────────
+async function safeFetchHtml(initialUrl, deps) {
+    let target = initialUrl;
+    for (let hop = 0; hop <= deps.maxRedirects; hop++) {
+        const url = await assertPublicHttpUrl(target);
+        const controller = new AbortController();
+        const timer = setTimeout(() => controller.abort(), deps.timeoutMs);
+        let res;
+        try {
+            res = await fetch(url.toString(), {
+                method: "GET",
+                redirect: "manual",
+                signal: controller.signal,
+                headers: {
+                    // A real UA — some sites 403 headless clients; Accept HTML only.
+                    "user-agent": "Mozilla/5.0 (compatible; VidSpotAIBot/1.0; +https://vidspotai.com/bot)",
+                    accept: "text/html,application/xhtml+xml,application/xml;q=0.9,*/*;q=0.8",
+                },
+            });
+        }
+        catch {
+            throw new DemoPrefillError("unreachable", "We couldn't reach that site.");
+        }
+        finally {
+            clearTimeout(timer);
+        }
+        // Manual redirect handling — re-validate the next hop against the guard.
+        if (res.status >= 300 && res.status < 400) {
+            const location = res.headers.get("location");
+            if (!location) {
+                throw new DemoPrefillError("unreachable", "That site redirected nowhere.");
+            }
+            target = new URL(location, url).toString();
+            continue;
+        }
+        if (!res.ok) {
+            throw new DemoPrefillError("unreachable", "That site returned an error.");
+        }
+        const ctype = res.headers.get("content-type") ?? "";
+        if (ctype && !/(text\/html|application\/xhtml|text\/plain|application\/xml)/i.test(ctype)) {
+            throw new DemoPrefillError("empty_page", "That link isn't a web page we can read.");
+        }
+        // Read at most maxBytes so a giant page can't exhaust memory.
+        const buf = await res.arrayBuffer();
+        const bytes = new Uint8Array(buf).subarray(0, deps.maxBytes);
+        return new TextDecoder("utf-8", { fatal: false }).decode(bytes);
+    }
+    throw new DemoPrefillError("unreachable", "That site redirected too many times.");
+}
+function decodeEntities(s) {
+    return s
+        .replace(/&amp;/g, "&")
+        .replace(/&lt;/g, "<")
+        .replace(/&gt;/g, ">")
+        .replace(/&quot;/g, '"')
+        .replace(/&#0*39;|&#x0*27;|&apos;/gi, "'")
+        .replace(/&nbsp;/g, " ")
+        .replace(/&#(\d+);/g, (_, d) => String.fromCodePoint(Number(d)))
+        .replace(/&#x([0-9a-f]+);/gi, (_, h) => String.fromCodePoint(parseInt(h, 16)));
+}
+function escapeRegex(s) {
+    return s.replace(/[.*+?^${}()|[\]\\]/g, "\\$&");
+}
+/** Read a <meta property|name="key" content="..."> value, attribute-order agnostic. */
+function metaContent(html, key) {
+    const k = escapeRegex(key);
+    const patterns = [
+        new RegExp(`<meta[^>]+(?:property|name)=["']${k}["'][^>]*content=["']([^"']*)["']`, "i"),
+        new RegExp(`<meta[^>]+content=["']([^"']*)["'][^>]*(?:property|name)=["']${k}["']`, "i"),
+    ];
+    for (const re of patterns) {
+        const m = html.match(re);
+        const v = m?.[1]?.trim();
+        if (v)
+            return decodeEntities(v);
+    }
+    return undefined;
+}
+/** Best-effort JSON-LD name/description from the first Product/SoftwareApplication/Org node. */
+function jsonLd(html) {
+    const blocks = html.match(/<script[^>]+type=["']application\/ld\+json["'][^>]*>([\s\S]*?)<\/script>/gi);
+    if (!blocks)
+        return {};
+    for (const block of blocks) {
+        const body = block.replace(/^[\s\S]*?>/, "").replace(/<\/script>$/i, "");
+        let parsed;
+        try {
+            parsed = JSON.parse(body);
+        }
+        catch {
+            continue;
+        }
+        const nodes = Array.isArray(parsed)
+            ? parsed
+            : parsed && typeof parsed === "object" && Array.isArray(parsed["@graph"])
+                ? (parsed["@graph"])
+                : [parsed];
+        for (const node of nodes) {
+            if (!node || typeof node !== "object")
+                continue;
+            const obj = node;
+            const name = typeof obj.name === "string" ? obj.name.trim() : undefined;
+            const description = typeof obj.description === "string" ? obj.description.trim() : undefined;
+            if (name || description) {
+                return {
+                    name: name ? decodeEntities(name) : undefined,
+                    description: description ? decodeEntities(description) : undefined,
+                };
+            }
+        }
+    }
+    return {};
+}
+function extractVisibleText(html) {
+    const stripped = html
+        .replace(/<script[\s\S]*?<\/script>/gi, " ")
+        .replace(/<style[\s\S]*?<\/style>/gi, " ")
+        .replace(/<noscript[\s\S]*?<\/noscript>/gi, " ")
+        .replace(/<head[\s\S]*?<\/head>/gi, " ")
+        .replace(/<svg[\s\S]*?<\/svg>/gi, " ")
+        .replace(/<[^>]+>/g, " ");
+    return decodeEntities(stripped).replace(/\s+/g, " ").trim().slice(0, 4000);
+}
+function extractPageMeta(html) {
+    const titleMatch = html.match(/<title[^>]*>([\s\S]*?)<\/title>/i);
+    const ld = jsonLd(html);
+    return {
+        title: titleMatch?.[1] ? decodeEntities(titleMatch[1].trim()) : undefined,
+        siteName: metaContent(html, "og:site_name"),
+        ogTitle: metaContent(html, "og:title") ?? metaContent(html, "twitter:title"),
+        ogDescription: metaContent(html, "og:description") ?? metaContent(html, "twitter:description"),
+        metaDescription: metaContent(html, "description"),
+        jsonLdName: ld.name,
+        jsonLdDescription: ld.description,
+        text: extractVisibleText(html),
+    };
+}
+// ── Metadata-only fallback (no LLM) ──────────────────────────────────────────
+function truncate(s, cap) {
+    if (!s)
+        return undefined;
+    const t = s.trim();
+    return t ? t.slice(0, cap) : undefined;
+}
+function firstSentence(s) {
+    if (!s)
+        return undefined;
+    const m = s.trim().match(/^.*?[.!?](?:\s|$)/);
+    return (m?.[0] ?? s).trim();
+}
+function metadataOnlyFields(meta) {
+    // Strip a common " — tagline" / " | Site" suffix off <title> for the name.
+    const rawName = meta.siteName ?? meta.jsonLdName ?? meta.ogTitle ?? meta.title;
+    const productName = rawName?.split(/\s+[|–—\-]\s+/)[0];
+    const desc = meta.metaDescription ?? meta.ogDescription ?? meta.jsonLdDescription;
+    return {
+        productName: truncate(productName, CAP.productName),
+        tagline: truncate(firstSentence(desc), CAP.tagline),
+        description: truncate(desc, CAP.description),
+        audience: undefined, // rarely in metadata — LLM fills this
+    };
+}
+// ── LLM polish ───────────────────────────────────────────────────────────────
+const PolishSchema = zod_1.z.object({
+    productName: zod_1.z.string().default(""),
+    tagline: zod_1.z.string().default(""),
+    description: zod_1.z.string().default(""),
+    audience: zod_1.z.string().default(""),
+});
+function buildPolishSystem() {
+    return [
+        "You extract product-marketing basics from a company/product web page.",
+        "Return four concise fields, grounded ONLY in the provided page content — never invent facts.",
+        "",
+        "- productName: the product or brand name (no tagline, no domain).",
+        "- tagline: ONE short value-proposition line, ≤12 words, no trailing period.",
+        "- description: 1–3 plain sentences on what the product does and its main value.",
+        "- audience: who it's for (role/industry/company-type), if discernible.",
+        "",
+        "If a field can't be determined from the content, return an empty string for it.",
+        "Prefer the site's own words. No marketing fluff you can't support from the page.",
+    ].join("\n");
+}
+function buildPolishUser(url, meta) {
+    const lines = [`URL: ${url}`];
+    if (meta.siteName)
+        lines.push(`og:site_name: ${meta.siteName}`);
+    if (meta.title)
+        lines.push(`<title>: ${meta.title}`);
+    if (meta.ogTitle)
+        lines.push(`og:title: ${meta.ogTitle}`);
+    if (meta.ogDescription)
+        lines.push(`og:description: ${meta.ogDescription}`);
+    if (meta.metaDescription)
+        lines.push(`meta description: ${meta.metaDescription}`);
+    if (meta.jsonLdName)
+        lines.push(`schema.org name: ${meta.jsonLdName}`);
+    if (meta.jsonLdDescription)
+        lines.push(`schema.org description: ${meta.jsonLdDescription}`);
+    if (meta.text)
+        lines.push("", "Visible page text (truncated):", meta.text);
+    return lines.join("\n");
+}
+/** Merge LLM output over the metadata fallback (LLM wins per-field when non-empty). */
+function mergeFields(llm, fallback) {
+    return {
+        productName: truncate(llm.productName || fallback.productName, CAP.productName),
+        tagline: truncate(llm.tagline || fallback.tagline, CAP.tagline),
+        description: truncate(llm.description || fallback.description, CAP.description),
+        audience: truncate(llm.audience || fallback.audience, CAP.audience),
+    };
+}
+/** Cap the planner-facing summary so it never balloons vision/text token cost. */
+const SUMMARY_CAP = 1200;
+/**
+ * Fetch a product URL and pull LLM-FREE signals for the gather stage: the
+ * metadata-only Basics + a compact summary string. Throws DemoPrefillError on
+ * the same user-facing failures as {@link prefillDemoBasics} (bad URL, blocked
+ * host, unreachable, empty page) — the worker calls this best-effort and
+ * swallows any throw, so a slow/blocked site never fails a generation.
+ */
+async function gatherPageSignals(rawUrl, deps = {}) {
+    const html = await safeFetchHtml(rawUrl, {
+        timeoutMs: deps.timeoutMs ?? 8000,
+        maxRedirects: deps.maxRedirects ?? 4,
+        maxBytes: deps.maxBytes ?? 1500000,
+    });
+    const meta = extractPageMeta(html);
+    const hasSignal = Boolean(meta.title || meta.ogTitle || meta.metaDescription || meta.ogDescription) ||
+        meta.text.length > 40;
+    if (!hasSignal) {
+        throw new DemoPrefillError("empty_page", "We couldn't read anything useful from that page.");
+    }
+    // Compose a compact planner summary from the strongest signals, de-duplicated.
+    const parts = [
+        meta.ogTitle ?? meta.title,
+        meta.ogDescription ?? meta.metaDescription ?? meta.jsonLdDescription,
+        meta.text,
+    ].filter((p) => Boolean(p && p.trim()));
+    const seen = new Set();
+    const summary = parts
+        .filter((p) => {
+        const key = p.trim().toLowerCase();
+        if (seen.has(key))
+            return false;
+        seen.add(key);
+        return true;
+    })
+        .join(" — ")
+        .slice(0, SUMMARY_CAP)
+        .trim();
+    return {
+        fields: metadataOnlyFields(meta),
+        summary,
+    };
+}
+/**
+ * Fetch a product URL and extract Basics fields. Tries LLM polish (Haiku "router"
+ * tier); falls back to metadata-only if the LLM is unconfigured/errors. Throws
+ * DemoPrefillError for user-facing failures (bad URL, blocked host, unreachable,
+ * empty page).
+ */
+async function prefillDemoBasics(rawUrl, deps = {}) {
+    const html = await safeFetchHtml(rawUrl, {
+        timeoutMs: deps.timeoutMs ?? 8000,
+        maxRedirects: deps.maxRedirects ?? 4,
+        maxBytes: deps.maxBytes ?? 1500000,
+    });
+    const meta = extractPageMeta(html);
+    const fallback = metadataOnlyFields(meta);
+    const hasSignal = Boolean(meta.title || meta.ogTitle || meta.metaDescription || meta.ogDescription) ||
+        meta.text.length > 40;
+    if (!hasSignal) {
+        throw new DemoPrefillError("empty_page", "We couldn't read anything useful from that page.");
+    }
+    const llm = deps.llm ?? (0, llmCallerRegistry_1.getLlmCaller)();
+    const router = deps.router ?? new modelRouter_1.ModelRouter();
+    const model = router.pickFor("router");
+    const fallbackModel = router.fallbackFor("router");
+    try {
+        const result = await llm.structured({
+            model,
+            fallbackModel,
+            messages: [
+                { role: "system", content: buildPolishSystem() },
+                { role: "user", content: buildPolishUser(rawUrl, meta) },
+            ],
+            schema: PolishSchema,
+            schemaName: "DemoBasics",
+            temperature: 0.2,
+            maxTokens: 500,
+        });
+        const polished = PolishSchema.parse(result.data);
+        return {
+            fields: mergeFields(polished, fallback),
+            source: "llm",
+            modelUsed: result.usedFallback && fallbackModel ? fallbackModel : model,
+            usage: result.usage,
+        };
+    }
+    catch {
+        // LLM unconfigured / rate-limited / malformed → still return metadata.
+        return { fields: fallback, source: "metadata" };
+    }
+}

package/lib/services/demo/demoRevisePrompt.d.ts

@@ -0,0 +1,17 @@
+import { DemoSpec } from "../../schemas/demoSpec.schema";
+import { DemoAuthorPromptOpts } from "./demoAuthorPrompt";
+/**
+ * Build the reviser system prompt: the full author prompt (vocabulary + rules +
+ * quality bar) plus the REVISION MODE preamble. `allowCustomScenes` threads the
+ * worker's `DEMO_CODEGEN_ENABLED` gate exactly as the author does, so a revision
+ * can only introduce a `custom` scene when the codegen agent that fills it is on.
+ */
+export declare function buildDemoReviseSystemPrompt(opts?: DemoAuthorPromptOpts): string;
+/**
+ * Build the reviser user turn: the current spec (as JSON) + the enumerated
+ * citable images (product screenshots + the user's per-edit reference images) +
+ * the user's natural-language change request. Images are attached separately as
+ * `imageUrls` (mirrors the author).
+ */
+export declare function buildDemoReviseUserText(spec: DemoSpec, instruction: string, productScreenshotUrls: string[] | undefined, referenceImageUrls: string[] | undefined): string;
+//# sourceMappingURL=demoRevisePrompt.d.ts.map

package/lib/services/demo/demoRevisePrompt.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"demoRevisePrompt.d.ts","sourceRoot":"","sources":["../../../src/services/demo/demoRevisePrompt.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,QAAQ,EAAE,MAAM,+BAA+B,CAAC;AACzD,OAAO,EACL,oBAAoB,EAErB,MAAM,oBAAoB,CAAC;AA6B5B;;;;;GAKG;AACH,wBAAgB,2BAA2B,CACzC,IAAI,GAAE,oBAAyB,GAC9B,MAAM,CAER;AAqCD;;;;;GAKG;AACH,wBAAgB,uBAAuB,CACrC,IAAI,EAAE,QAAQ,EACd,WAAW,EAAE,MAAM,EACnB,qBAAqB,EAAE,MAAM,EAAE,GAAG,SAAS,EAC3C,kBAAkB,EAAE,MAAM,EAAE,GAAG,SAAS,GACvC,MAAM,CAYR"}