@mevdragon/vidfarm-devcli 0.1.0 → 0.2.0

package/dist/src/lib/template-dna.js

@@ -0,0 +1,542 @@
+import { cpSync, existsSync, mkdirSync, readdirSync, readFileSync, writeFileSync } from "node:fs";
+import { readFile, writeFile } from "node:fs/promises";
+import path from "node:path";
+const DEFAULT_MODEL = "gemini-3.1-flash-lite-preview";
+const GEMINI_BASE_URL = "https://generativelanguage.googleapis.com";
+const GENERATED_MODULE_RELATIVE_PATH = "src/template-dna.ts";
+const DEFAULT_NOTES_RELATIVE_PATH = "research/source_notes.md";
+const DEFAULT_PREVIEW_RELATIVE_DIR = "research/preview";
+const DEFAULT_VIRAL_OUTPUT_RELATIVE_PATH = "research/viral_dna.extraction.json";
+const DEFAULT_VISUAL_OUTPUT_RELATIVE_PATH = "research/visual_dna.extraction.json";
+export async function analyzeTemplateDna(input) {
+    const templateDir = path.resolve(input.templateDir);
+    const envFile = path.resolve(input.envFile ?? path.join(process.cwd(), ".env"));
+    const notesPath = path.resolve(input.notesPath ?? path.join(templateDir, DEFAULT_NOTES_RELATIVE_PATH));
+    const previewDir = path.resolve(input.previewDir ?? path.join(templateDir, DEFAULT_PREVIEW_RELATIVE_DIR));
+    const outputPath = path.resolve(input.outputPath ?? path.join(templateDir, input.mode === "viral" ? DEFAULT_VIRAL_OUTPUT_RELATIVE_PATH : DEFAULT_VISUAL_OUTPUT_RELATIVE_PATH));
+    const model = input.model || process.env.GEMINI_MODEL || DEFAULT_MODEL;
+    const apiKey = resolveGeminiApiKey(envFile);
+    const readme = await readOptionalUtf8(notesPath);
+    const previewFiles = listPreviewFiles(previewDir);
+    if (!previewFiles.length) {
+        throw new Error(`No preview media found in ${previewDir}`);
+    }
+    const uploadedFiles = [];
+    try {
+        for (const previewFile of previewFiles) {
+            const uploaded = await uploadFile(apiKey, previewFile);
+            const activeFile = await waitForFileActive(apiKey, uploaded.name);
+            uploadedFiles.push({
+                name: String(activeFile.name),
+                uri: String(activeFile.uri),
+                mimeType: typeof activeFile.mimeType === "string" ? activeFile.mimeType : uploaded.mimeType,
+                displayName: typeof activeFile.displayName === "string" ? activeFile.displayName : path.basename(previewFile),
+                localPath: previewFile
+            });
+        }
+        const prompt = input.mode === "viral"
+            ? buildViralPrompt({ templateId: path.basename(templateDir), readme, uploadedFiles })
+            : buildVisualPrompt({ templateId: path.basename(templateDir), readme, uploadedFiles });
+        const analysis = await generateAnalysis(apiKey, model, prompt, uploadedFiles);
+        if (input.mode === "viral") {
+            validateViralAnalysis(analysis, path.basename(templateDir));
+        }
+        else {
+            validateVisualAnalysis(analysis, path.basename(templateDir));
+        }
+        mkdirSync(path.dirname(outputPath), { recursive: true });
+        await writeFile(outputPath, JSON.stringify(analysis, null, 2) + "\n", "utf8");
+        if (input.syncTemplateModule !== false) {
+            syncTemplateDnaModule({
+                templateDir,
+                linkToOriginal: input.linkToOriginal
+            });
+        }
+        return {
+            mode: input.mode,
+            model,
+            template_dir: templateDir,
+            notes_path: notesPath,
+            preview_dir: previewDir,
+            output_path: outputPath,
+            preview_count: uploadedFiles.length,
+            title: typeof analysis.title === "string" ? analysis.title : null
+        };
+    }
+    finally {
+        for (const uploaded of uploadedFiles) {
+            await deleteFileQuietly(apiKey, uploaded.name);
+        }
+    }
+}
+export function syncTemplateDnaModule(input) {
+    const templateDir = path.resolve(input.templateDir);
+    const modulePath = path.join(templateDir, GENERATED_MODULE_RELATIVE_PATH);
+    const state = loadTemplateDnaModuleState({
+        templateDir,
+        explicitLinkToOriginal: input.linkToOriginal
+    });
+    mkdirSync(path.dirname(modulePath), { recursive: true });
+    writeFileSync(modulePath, renderTemplateDnaModule(state), "utf8");
+    return {
+        module_path: modulePath,
+        link_to_original: state.linkToOriginal,
+        has_viral_analysis: Boolean(state.viralAnalysis),
+        has_visual_analysis: Boolean(state.visualAnalysis)
+    };
+}
+export function stageTemplateDnaInputs(input) {
+    const templateDir = path.resolve(input.templateDir);
+    const notesPath = path.join(templateDir, DEFAULT_NOTES_RELATIVE_PATH);
+    const previewDir = path.join(templateDir, DEFAULT_PREVIEW_RELATIVE_DIR);
+    mkdirSync(path.dirname(notesPath), { recursive: true });
+    mkdirSync(previewDir, { recursive: true });
+    if (input.sourceNotesPath) {
+        cpSync(path.resolve(input.sourceNotesPath), notesPath);
+    }
+    else if (!existsSync(notesPath)) {
+        writeFileSync(notesPath, [
+            "# Source Notes",
+            "",
+            "- original format URL:",
+            "- creator/account:",
+            "- why it wins:",
+            "- what must survive adaptation:",
+            "- what can change for new brands:"
+        ].join("\n") + "\n", "utf8");
+    }
+    const keepPath = path.join(previewDir, ".gitkeep");
+    if (!existsSync(keepPath)) {
+        writeFileSync(keepPath, "", "utf8");
+    }
+    if (input.sourcePreviewDir) {
+        copyDirectoryContents(path.resolve(input.sourcePreviewDir), previewDir);
+    }
+    return {
+        notes_path: notesPath,
+        preview_dir: previewDir
+    };
+}
+export function hasTemplatePreviewMedia(templateDir) {
+    const previewDir = path.join(path.resolve(templateDir), DEFAULT_PREVIEW_RELATIVE_DIR);
+    return listPreviewFiles(previewDir).length > 0;
+}
+function loadTemplateDnaModuleState(input) {
+    const templateDir = path.resolve(input.templateDir);
+    const modulePath = path.join(templateDir, GENERATED_MODULE_RELATIVE_PATH);
+    const existingModule = existsSync(modulePath) ? readFileSync(modulePath, "utf8") : "";
+    const previewDir = path.join(templateDir, DEFAULT_PREVIEW_RELATIVE_DIR);
+    return {
+        linkToOriginal: input.explicitLinkToOriginal ?? extractExistingString(existingModule, "templateLinkToOriginal") ?? "",
+        viralAnalysis: readAnalysisFile(path.join(templateDir, DEFAULT_VIRAL_OUTPUT_RELATIVE_PATH)),
+        visualAnalysis: readAnalysisFile(path.join(templateDir, DEFAULT_VISUAL_OUTPUT_RELATIVE_PATH)),
+        notesPath: DEFAULT_NOTES_RELATIVE_PATH,
+        previewFiles: listPreviewFiles(previewDir).map((filePath) => path.relative(templateDir, filePath).split(path.sep).join("/"))
+    };
+}
+function readAnalysisFile(filePath) {
+    if (!existsSync(filePath)) {
+        return null;
+    }
+    return JSON.parse(readFileSync(filePath, "utf8"));
+}
+function extractExistingString(contents, exportName) {
+    const match = contents.match(new RegExp(`export const ${exportName} = ([\\s\\S]*?);`));
+    if (!match) {
+        return null;
+    }
+    try {
+        return JSON.parse(match[1]);
+    }
+    catch {
+        return null;
+    }
+}
+function renderTemplateDnaModule(state) {
+    const viralSummary = summarizeViralDna(state.viralAnalysis);
+    const visualSummary = summarizeVisualDna(state.visualAnalysis);
+    const viralJson = state.viralAnalysis ? `${JSON.stringify(state.viralAnalysis, null, 2)} as const` : "null";
+    const visualJson = state.visualAnalysis ? `${JSON.stringify(state.visualAnalysis, null, 2)} as const` : "null";
+    return [
+        "// Generated by `vidfarm analyze-viral-dna` and `vidfarm analyze-visual-dna`.",
+        "// Keep source notes in `research/source_notes.md` and reference media in `research/preview/`.",
+        "",
+        `export const templateLinkToOriginal = ${JSON.stringify(state.linkToOriginal)};`,
+        `export const templateSourceNotesPath = ${JSON.stringify(state.notesPath)};`,
+        `export const templatePreviewMediaRelativePaths = ${JSON.stringify(state.previewFiles, null, 2)} as const;`,
+        "",
+        `export const templateViralDna = ${JSON.stringify(viralSummary)};`,
+        `export const templateVisualDna = ${JSON.stringify(visualSummary)};`,
+        "",
+        `export const templateViralDnaAnalysis = ${viralJson};`,
+        "",
+        `export const templateVisualDnaAnalysis = ${visualJson};`,
+        ""
+    ].join("\n");
+}
+function summarizeViralDna(analysis) {
+    if (!analysis) {
+        return "Run `vidfarm analyze-viral-dna --template-dir .` after adding source notes and preview media.";
+    }
+    return [analysis.title.trim(), ...analysis.explanations.map((entry) => entry.trim())]
+        .filter(Boolean)
+        .join(" ");
+}
+function summarizeVisualDna(analysis) {
+    if (!analysis) {
+        return "Run `vidfarm analyze-visual-dna --template-dir .` after adding source notes and preview media.";
+    }
+    const mustPreserve = analysis.must_preserve.slice(0, 3).map((entry) => entry.trim()).filter(Boolean).join("; ");
+    const explanation = analysis.explanations[0]?.trim() ?? "";
+    return [
+        analysis.title.trim(),
+        explanation,
+        mustPreserve ? `Must preserve: ${mustPreserve}.` : ""
+    ].filter(Boolean).join(" ");
+}
+function resolveGeminiApiKey(envFilePath) {
+    if (process.env.GEMINI_API_KEY) {
+        return process.env.GEMINI_API_KEY;
+    }
+    if (!existsSync(envFilePath)) {
+        throw new Error(`GEMINI_API_KEY is missing and env file was not found: ${envFilePath}`);
+    }
+    const env = loadEnvFile(envFilePath);
+    if (!env.GEMINI_API_KEY) {
+        throw new Error(`GEMINI_API_KEY is missing. Checked process env and ${envFilePath}`);
+    }
+    return env.GEMINI_API_KEY;
+}
+function loadEnvFile(filePath) {
+    const text = readFileSync(filePath, "utf8");
+    const env = {};
+    for (const rawLine of text.split(/\r?\n/)) {
+        const line = rawLine.trim();
+        if (!line || line.startsWith("#")) {
+            continue;
+        }
+        const separatorIndex = line.indexOf("=");
+        if (separatorIndex === -1) {
+            continue;
+        }
+        const key = line.slice(0, separatorIndex).trim();
+        let value = line.slice(separatorIndex + 1).trim();
+        if ((value.startsWith("\"") && value.endsWith("\"")) ||
+            (value.startsWith("'") && value.endsWith("'"))) {
+            value = value.slice(1, -1);
+        }
+        env[key] = value;
+    }
+    return env;
+}
+function listPreviewFiles(previewDir) {
+    if (!existsSync(previewDir)) {
+        return [];
+    }
+    return readdirSync(previewDir, { withFileTypes: true })
+        .filter((entry) => entry.isFile() && !entry.name.startsWith("."))
+        .map((entry) => path.join(previewDir, entry.name))
+        .sort((a, b) => a.localeCompare(b));
+}
+async function readOptionalUtf8(filePath) {
+    try {
+        return await readFile(filePath, "utf8");
+    }
+    catch (error) {
+        if (error.code === "ENOENT") {
+            return "";
+        }
+        throw error;
+    }
+}
+function readmeContext(readme, sectionHeading) {
+    if (!readme.trim()) {
+        return "(missing source notes)";
+    }
+    const [beforeSection] = readme.split(sectionHeading);
+    return beforeSection.trim() || "(source notes file was empty)";
+}
+function buildViralPrompt(input) {
+    const mediaSummary = input.uploadedFiles
+        .map((file, index) => `${index + 1}. ${path.basename(file.localPath)} (${file.mimeType || "unknown mime"})`)
+        .join("\n");
+    return [
+        "You are a top-tier viral TikTok strategist.",
+        "You are analyzing one TikTok winning format.",
+        "A template may include multiple preview images or a video. Treat all attached media as ONE format, not separate formats.",
+        "If there are multiple slides, infer the repeated pattern that makes the whole format win.",
+        "If the preview is a video, analyze the visible hook, framing, pacing implication, emotional trigger, native feel, and why the concept spreads.",
+        "Focus on why the creative wins on TikTok: hook, framing, identity signaling, curiosity, emotional tension, status promise, save/share psychology, authority cues, and native execution.",
+        "Be specific to the media. Avoid generic advice and avoid academic language.",
+        "Return strict JSON with this shape and nothing else:",
+        JSON.stringify({
+            title: "Short marketer-style label",
+            explanations: ["", "", "", "", ""]
+        }),
+        "Each explanation must be 2-4 sentences.",
+        "Write in the voice of a sharp viral TikTok marketer.",
+        "",
+        "TEMPLATE",
+        `template_id: ${input.templateId}`,
+        "",
+        "README CONTEXT",
+        readmeContext(input.readme, /^## Template Viral DNA\b/m),
+        "",
+        "ATTACHED MEDIA",
+        mediaSummary
+    ].join("\n");
+}
+function buildVisualPrompt(input) {
+    const mediaSummary = input.uploadedFiles
+        .map((file, index) => `${index + 1}. ${path.basename(file.localPath)} (${file.mimeType || "unknown mime"})`)
+        .join("\n");
+    return [
+        "You are extracting the transferable visual DNA of one TikTok winning format.",
+        "Treat all attached media as ONE format, even if there are multiple slides, frames, or a video.",
+        "Your job is to capture the visual system that should survive adaptation into new proposals.",
+        "Focus on composition, framing, camera feel, text treatment, caption behavior, pacing cues visible on screen, lighting, color logic, safe-zone usage, subject staging, and what makes the asset feel natively TikTok.",
+        "First classify what actually makes the template recognizable at a glance.",
+        "- `character-centric`: recognizability comes mainly from a recurring character, person, mascot, illustrated archetype, or character-design language.",
+        "- `vibe-centric`: recognizability comes mainly from mood, awkwardness, chaos, polish level, emotional tone, texture, lighting, or scene energy.",
+        "- `presentation-centric`: recognizability comes mainly from the presentation mechanic or container, such as a tier list, chat interface, phone screenshot logic, notifications, notes app, mind map, calendar, whiteboard, search bar, or diagram format.",
+        "Choose one dominant `recognition_mode` even for mixed templates, then list any supporting modes in `secondary_recognition_modes`.",
+        "Ignore TikTok app UI and platform chrome completely: no tabs, username rows, caption bar UI, action rail, comments UI, progress bars, watermarks, search bars, or app frames.",
+        "However, keep creator-authored caption behavior in the analysis when it is part of the creative pattern.",
+        "Extract the reusable visual recipe, not the specific identity of one actor, creator, product, or character.",
+        "Be concrete about what should stay visually consistent and what can change across new proposals.",
+        "Return strict JSON with this shape and nothing else:",
+        JSON.stringify({
+            title: "Short visual-system label",
+            recognition_mode: "presentation-centric",
+            secondary_recognition_modes: ["vibe-centric"],
+            presentation_mechanic: "Short label for the dominant visual container or mechanic",
+            character_identity_strength: "low",
+            vibe_lock_strength: "medium",
+            layout_lock_strength: "high",
+            must_preserve: ["", "", "", ""],
+            can_adapt: ["", "", ""],
+            explanations: ["", "", "", "", ""]
+        }),
+        "`recognition_mode` and `secondary_recognition_modes` must only use: `character-centric`, `vibe-centric`, `presentation-centric`.",
+        "`character_identity_strength`, `vibe_lock_strength`, and `layout_lock_strength` must only use: `none`, `low`, `medium`, `high`.",
+        "`must_preserve` should list the most binding visual rules that make the template recognizable.",
+        "`can_adapt` should list what can safely change for new brands or concepts without breaking the format.",
+        "Each explanation must be 2-4 sentences.",
+        "Write in the voice of a sharp creative director for TikTok-native performance media.",
+        "",
+        "TEMPLATE",
+        `template_id: ${input.templateId}`,
+        "",
+        "README CONTEXT",
+        readmeContext(input.readme, /^## Template Visual DNA\b/m),
+        "",
+        "ATTACHED MEDIA",
+        mediaSummary
+    ].join("\n");
+}
+function inferMimeType(filePath) {
+    const ext = path.extname(filePath).toLowerCase();
+    if (ext === ".png")
+        return "image/png";
+    if (ext === ".jpg" || ext === ".jpeg")
+        return "image/jpeg";
+    if (ext === ".webp")
+        return "image/webp";
+    if (ext === ".mp4")
+        return "video/mp4";
+    if (ext === ".mov")
+        return "video/quicktime";
+    if (ext === ".webm")
+        return "video/webm";
+    return "application/octet-stream";
+}
+function unwrapFilePayload(payload) {
+    return (payload.file ?? payload);
+}
+async function uploadFile(apiKey, filePath) {
+    const fileBuffer = await readFile(filePath);
+    const mimeType = inferMimeType(filePath);
+    const displayName = path.basename(filePath);
+    const startResponse = await fetch(`${GEMINI_BASE_URL}/upload/v1beta/files?key=${apiKey}`, {
+        method: "POST",
+        headers: {
+            "X-Goog-Upload-Protocol": "resumable",
+            "X-Goog-Upload-Command": "start",
+            "X-Goog-Upload-Header-Content-Length": String(fileBuffer.length),
+            "X-Goog-Upload-Header-Content-Type": mimeType,
+            "Content-Type": "application/json"
+        },
+        body: JSON.stringify({
+            file: {
+                display_name: displayName
+            }
+        })
+    });
+    if (!startResponse.ok) {
+        throw new Error(`Failed to start upload for ${filePath}: ${startResponse.status} ${await startResponse.text()}`);
+    }
+    const uploadUrl = startResponse.headers.get("x-goog-upload-url");
+    if (!uploadUrl) {
+        throw new Error(`Upload URL missing for ${filePath}`);
+    }
+    const finalizeResponse = await fetch(uploadUrl, {
+        method: "POST",
+        headers: {
+            "Content-Length": String(fileBuffer.length),
+            "X-Goog-Upload-Offset": "0",
+            "X-Goog-Upload-Command": "upload, finalize"
+        },
+        body: fileBuffer
+    });
+    if (!finalizeResponse.ok) {
+        throw new Error(`Failed to upload ${filePath}: ${finalizeResponse.status} ${await finalizeResponse.text()}`);
+    }
+    const payload = await finalizeResponse.json();
+    const file = unwrapFilePayload(payload);
+    if (typeof file.name !== "string") {
+        throw new Error(`Upload response missing file name for ${filePath}`);
+    }
+    return {
+        name: file.name,
+        uri: typeof file.uri === "string" ? file.uri : "",
+        mimeType: typeof file.mimeType === "string" ? file.mimeType : mimeType,
+        displayName
+    };
+}
+async function getFile(apiKey, fileName) {
+    const response = await fetch(`${GEMINI_BASE_URL}/v1beta/${fileName}?key=${apiKey}`);
+    if (!response.ok) {
+        throw new Error(`Failed to fetch ${fileName}: ${response.status} ${await response.text()}`);
+    }
+    return unwrapFilePayload(await response.json());
+}
+async function waitForFileActive(apiKey, fileName) {
+    for (let attempt = 0; attempt < 60; attempt += 1) {
+        const file = await getFile(apiKey, fileName);
+        if (file.state === "ACTIVE") {
+            return file;
+        }
+        if (typeof file.state === "string" && file.state !== "PROCESSING") {
+            throw new Error(`File ${fileName} entered unexpected state ${file.state}`);
+        }
+        await delay(1000);
+    }
+    throw new Error(`Timed out waiting for ${fileName} to become ACTIVE`);
+}
+async function generateAnalysis(apiKey, model, prompt, uploadedFiles) {
+    const response = await fetch(`${GEMINI_BASE_URL}/v1beta/models/${model}:generateContent?key=${apiKey}`, {
+        method: "POST",
+        headers: {
+            "Content-Type": "application/json"
+        },
+        body: JSON.stringify({
+            contents: [
+                {
+                    role: "user",
+                    parts: [
+                        { text: prompt },
+                        ...uploadedFiles.map((file) => ({
+                            fileData: {
+                                mimeType: file.mimeType,
+                                fileUri: file.uri
+                            }
+                        }))
+                    ]
+                }
+            ],
+            generationConfig: {
+                temperature: 0.7,
+                responseMimeType: "application/json"
+            }
+        })
+    });
+    if (!response.ok) {
+        throw new Error(`Gemini request failed (${response.status}): ${await response.text()}`);
+    }
+    const payload = await response.json();
+    const candidates = Array.isArray(payload.candidates) ? payload.candidates : [];
+    const first = candidates[0];
+    const content = first?.content;
+    const parts = Array.isArray(content?.parts) ? content.parts : [];
+    const text = parts
+        .map((part) => {
+        const record = part;
+        return typeof record.text === "string" ? record.text : "";
+    })
+        .join("\n")
+        .trim();
+    if (!text) {
+        throw new Error("Gemini returned no text content");
+    }
+    const normalized = text
+        .replace(/^```json\s*/i, "")
+        .replace(/^```\s*/i, "")
+        .replace(/\s*```$/, "")
+        .trim();
+    return JSON.parse(normalized);
+}
+function validateViralAnalysis(analysis, templateId) {
+    if (typeof analysis.title !== "string" || !analysis.title.trim()) {
+        throw new Error(`${templateId} analysis is missing title`);
+    }
+    if (!Array.isArray(analysis.explanations) || analysis.explanations.length !== 5) {
+        throw new Error(`${templateId} analysis must include exactly 5 explanations`);
+    }
+    for (const explanation of analysis.explanations) {
+        if (typeof explanation !== "string" || !explanation.trim()) {
+            throw new Error(`${templateId} analysis contains an empty explanation`);
+        }
+    }
+}
+function validateVisualAnalysis(analysis, templateId) {
+    if (typeof analysis.title !== "string" || !analysis.title.trim()) {
+        throw new Error(`${templateId} analysis is missing title`);
+    }
+    const recognitionModes = new Set(["character-centric", "vibe-centric", "presentation-centric"]);
+    if (!recognitionModes.has(String(analysis.recognition_mode || "").trim())) {
+        throw new Error(`${templateId} analysis has invalid recognition_mode`);
+    }
+    if (!Array.isArray(analysis.secondary_recognition_modes) ||
+        analysis.secondary_recognition_modes.some((mode) => !recognitionModes.has(String(mode || "").trim()))) {
+        throw new Error(`${templateId} analysis has invalid secondary_recognition_modes`);
+    }
+    const strengths = new Set(["none", "low", "medium", "high"]);
+    if (!strengths.has(String(analysis.character_identity_strength || "").trim())) {
+        throw new Error(`${templateId} analysis has invalid character_identity_strength`);
+    }
+    if (!strengths.has(String(analysis.vibe_lock_strength || "").trim())) {
+        throw new Error(`${templateId} analysis has invalid vibe_lock_strength`);
+    }
+    if (!strengths.has(String(analysis.layout_lock_strength || "").trim())) {
+        throw new Error(`${templateId} analysis has invalid layout_lock_strength`);
+    }
+    if (typeof analysis.presentation_mechanic !== "string" || !analysis.presentation_mechanic.trim()) {
+        throw new Error(`${templateId} analysis is missing presentation_mechanic`);
+    }
+    if (!Array.isArray(analysis.must_preserve) || analysis.must_preserve.length < 3) {
+        throw new Error(`${templateId} analysis must include at least 3 must_preserve rules`);
+    }
+    if (!Array.isArray(analysis.can_adapt) || analysis.can_adapt.length < 2) {
+        throw new Error(`${templateId} analysis must include at least 2 can_adapt rules`);
+    }
+    if (!Array.isArray(analysis.explanations) || !analysis.explanations.length) {
+        throw new Error(`${templateId} analysis must include at least 1 explanation`);
+    }
+}
+async function deleteFileQuietly(apiKey, fileName) {
+    try {
+        await fetch(`${GEMINI_BASE_URL}/v1beta/${fileName}?key=${apiKey}`, { method: "DELETE" });
+    }
+    catch { }
+}
+function copyDirectoryContents(sourceDir, destinationDir) {
+    mkdirSync(destinationDir, { recursive: true });
+    for (const entry of readdirSync(sourceDir, { withFileTypes: true })) {
+        if (!entry.name.startsWith(".")) {
+            cpSync(path.join(sourceDir, entry.name), path.join(destinationDir, entry.name), { recursive: true });
+        }
+    }
+}
+function delay(ms) {
+    return new Promise((resolve) => setTimeout(resolve, ms));
+}

package/dist/src/lib/template-style-options.js

@@ -0,0 +1,49 @@
+export const STARTER_TEMPLATE_FONT_OPTIONS = [
+    {
+        id: "source_code_pro",
+        label: "Source Code Pro",
+        family: "Source Code Pro",
+        assetFile: "SourceCodePro[wght].ttf"
+    },
+    {
+        id: "montserrat",
+        label: "Montserrat",
+        family: "Montserrat",
+        assetFile: "Montserrat[wght].ttf"
+    },
+    {
+        id: "yesteryear",
+        label: "Yesteryear",
+        family: "Yesteryear",
+        assetFile: "Yesteryear-Regular.ttf"
+    },
+    {
+        id: "dm_serif_display",
+        label: "DM Serif Display",
+        family: "DM Serif Display",
+        assetFile: "DMSerifDisplay-Regular.ttf"
+    },
+    {
+        id: "abel",
+        label: "Abel",
+        family: "Abel",
+        assetFile: "Abel-Regular.ttf"
+    }
+];
+export const STARTER_TEMPLATE_TEXT_BACKGROUND_COLOR_OPTIONS = [
+    { id: "black", label: "Black", hex: "#000000" },
+    { id: "red", label: "Red", hex: "#EA403F" },
+    { id: "orange", label: "Orange", hex: "#FF933D" },
+    { id: "yellow", label: "Yellow", hex: "#F2CD46" },
+    { id: "lime_green", label: "Lime Green", hex: "#78C25E" },
+    { id: "teal", label: "Teal", hex: "#77C8A6" },
+    { id: "light_blue", label: "Light Blue", hex: "#3496F0" },
+    { id: "dark_blue", label: "Dark Blue", hex: "#3496F0" },
+    { id: "violet", label: "Violet", hex: "#5756D4" },
+    { id: "pink", label: "Pink", hex: "#F7D7E9" },
+    { id: "brown", label: "Brown", hex: "#A3895B" },
+    { id: "dark_green", label: "Dark Green", hex: "#32523B" },
+    { id: "blue_gray", label: "Blue Gray", hex: "#2F688C" },
+    { id: "light_gray", label: "Light Gray", hex: "#92979E" },
+    { id: "dark_gray", label: "Dark Gray", hex: "#333333" }
+];

package/dist/src/registry.js

@@ -1,10 +1,57 @@
-import { demoTemplate } from "../templates/template_0000/demo-template.js";
-const templates = [demoTemplate];
-export const templateRegistry = {
+import { database } from "./db.js";
+import { template0000Definition } from "../templates/template_0000/src/template.js";
+import { loadTemplateFromModule } from "./services/template-loader.js";
+import { TemplateCertificationService } from "./services/template-certification.js";
+class TemplateRegistry {
+    localTemplates = new Map([[
+            template0000Definition.id,
+            template0000Definition
+        ]]);
+    runtimeTemplates = new Map();
+    certification = new TemplateCertificationService();
+    initialized = false;
+    initPromise = null;
+    async ensureInitialized() {
+        if (this.initialized) {
+            return;
+        }
+        if (this.initPromise) {
+            return this.initPromise;
+        }
+        this.initPromise = (async () => {
+            for (const template of this.localTemplates.values()) {
+                const skillPath = template.skillPath;
+                if (!skillPath) {
+                    throw new Error(`Local template ${template.id} is missing skillPath.`);
+                }
+                const report = await this.certification.certify({ template, skillPath });
+                if (!report.passed) {
+                    throw new Error(`Local template ${template.id} failed certification.`);
+                }
+            }
+            for (const release of database.getActiveTemplateReleases()) {
+                const template = await loadTemplateFromModule(release.modulePath);
+                this.runtimeTemplates.set(release.templateId, {
+                    ...template,
+                    skillPath: release.skillPath
+                });
+            }
+            this.initialized = true;
+            this.initPromise = null;
+        })();
+        return this.initPromise;
+    }
     list() {
-        return templates;
-    },
+        return [...this.localTemplates.values(), ...this.runtimeTemplates.values()].sort((a, b) => a.id.localeCompare(b.id));
+    }
     get(templateId) {
-        return templates.find((template) => template.id === templateId) ?? null;
+        return this.findTemplate(templateId, this.runtimeTemplates) ?? this.findTemplate(templateId, this.localTemplates);
+    }
+    registerRuntimeTemplate(template) {
+        this.runtimeTemplates.set(template.id, template);
+    }
+    findTemplate(templateKey, source) {
+        return source.get(templateKey) ?? [...source.values()].find((template) => template.slugId === templateKey) ?? null;
     }
-};
+}
+export const templateRegistry = new TemplateRegistry();

package/dist/src/runtime.js

@@ -1,8 +1,10 @@
 import { serve } from "@hono/node-server";
 import app from "./app.js";
 import { config } from "./config.js";
+import { templateRegistry } from "./registry.js";
 import { Worker } from "./worker.js";
-export function startRuntime() {
+export async function startRuntime() {
+    await templateRegistry.ensureInitialized();
     const worker = new Worker();
     worker.start();
     const server = serve({