real-link-ai 1.6.0

package/dist/lib/thriller-vn.js

@@ -0,0 +1,1106 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.bootstrapThrillerVN = bootstrapThrillerVN;
+const node_fs_1 = require("node:fs");
+const config_js_1 = require("./config.js");
+const DEFAULT_TEMPLATE_PATH = "G:\\Real Link AI\\story\\thriller\\interactive-fiction\\templates\\vn-project\\build\\story.json";
+const DEFAULT_API_BASE = "https://api.real-link.ai";
+const DEFAULT_STYLE_ID = "style.thriller-manor";
+const DEFAULT_STYLE_NAME = "Thriller Manor";
+function normalizeApiBase(api) {
+    return (api || process.env.REAL_LINK_API_URL || DEFAULT_API_BASE).replace(/\/+$/, "");
+}
+async function requestJson(options) {
+    const headers = {};
+    if (options.apiKey)
+        headers["x-api-key"] = options.apiKey;
+    if (options.workspaceId)
+        headers["x-workspace-id"] = options.workspaceId;
+    if (options.bearerToken)
+        headers.authorization = `Bearer ${options.bearerToken}`;
+    let body;
+    if (options.body !== undefined) {
+        headers["content-type"] = "application/json";
+        body = JSON.stringify(options.body);
+    }
+    const response = await fetch(`${options.apiBase}/api/v1${options.path}`, {
+        method: options.method || (options.body !== undefined ? "POST" : "GET"),
+        headers,
+        body,
+    });
+    const json = await response.json();
+    if (!response.ok || !json.ok) {
+        throw new Error(json.error || `HTTP ${response.status}`);
+    }
+    return json.data;
+}
+function readStarter(templatePath) {
+    const resolved = templatePath || process.env.REAL_LINK_STORY_TEMPLATE || DEFAULT_TEMPLATE_PATH;
+    if (!(0, node_fs_1.existsSync)(resolved)) {
+        throw new Error(`Template not found: ${resolved}`);
+    }
+    return JSON.parse((0, node_fs_1.readFileSync)(resolved, "utf8"));
+}
+function inferRole(character) {
+    return character.id.includes("protagonist") ? "player" : "npc";
+}
+function inferVariableCategory(variable) {
+    if (variable.type === "number")
+        return "counter";
+    if (variable.id.startsWith("trust."))
+        return "stat";
+    if (variable.id.startsWith("flag."))
+        return "flag";
+    return "quest";
+}
+function stringifyDefaultValue(value) {
+    if (value === undefined)
+        return "";
+    if (typeof value === "boolean")
+        return value ? "true" : "false";
+    return String(value);
+}
+function pickSpeakerId(node) {
+    const speakers = new Set((node.body || [])
+        .filter((entry) => entry.kind === "dialogue" && entry.speaker)
+        .map((entry) => entry.speaker));
+    return speakers.size === 1 ? Array.from(speakers)[0] : null;
+}
+function flattenNodeText(node, characterNames) {
+    if (node.text)
+        return node.text;
+    return (node.body || [])
+        .map((entry) => {
+        if (!entry.text)
+            return null;
+        if (entry.kind === "dialogue" && entry.speaker) {
+            const speaker = characterNames.get(entry.speaker) || entry.speaker;
+            return `${speaker}: ${entry.text}`;
+        }
+        return entry.text;
+    })
+        .filter((line) => !!line)
+        .join("\n\n");
+}
+function mapNodeType(kind) {
+    if (kind === "ending")
+        return "end";
+    return kind;
+}
+function buildCharacterBio(character) {
+    const profile = character.thrillerProfile || {};
+    const personalityBits = [
+        typeof profile.pressureStyle === "string" ? `Pressure style: ${profile.pressureStyle}.` : null,
+        typeof profile.suspectWeight === "string" ? `Suspicion weight: ${profile.suspectWeight}.` : null,
+    ].filter((value) => !!value);
+    const backgroundBits = [
+        character.description ? `Surface read: ${character.description}` : null,
+        typeof profile.innocentRead === "string" ? `Innocent read: ${profile.innocentRead}` : null,
+        typeof profile.dangerousRead === "string" ? `Dangerous read: ${profile.dangerousRead}` : null,
+    ].filter((value) => !!value);
+    return {
+        appearance: character.description || "",
+        personality: personalityBits.join(" "),
+        background: backgroundBits.join(" "),
+        voice: character.defaultExpression || "neutral",
+    };
+}
+function buildCharacterStats(character) {
+    const profile = character.thrillerProfile || {};
+    return {
+        suspectWeight: typeof profile.suspectWeight === "string" ? profile.suspectWeight : "supporting",
+        pressureStyle: typeof profile.pressureStyle === "string" ? profile.pressureStyle : character.defaultExpression || "neutral",
+    };
+}
+function buildLocationMetadata(location, starter) {
+    const nodeIds = starter.nodes
+        .filter((node) => node.location === location.id)
+        .map((node) => node.id);
+    return {
+        source: "thriller-writing",
+        backgroundHint: location.background || null,
+        narrativeNodeIds: nodeIds,
+        nodeCount: nodeIds.length,
+    };
+}
+function countNodesForCharacter(starter, characterId) {
+    return starter.nodes.filter((node) => Array.isArray(node.cast) && node.cast.some((entry) => entry?.character === characterId)).length;
+}
+function buildClueMetadata(clue) {
+    return {
+        source: "thriller-writing",
+        entityKind: "clue",
+        clueType: clue.kind || "evidence",
+        question: clue.question || "",
+        supports: clue.supports || [],
+        critical: !!clue.critical,
+    };
+}
+function buildThrillerSourceSpec(starter) {
+    return {
+        id: starter.meta.id,
+        title: starter.meta.title,
+        skillId: "thriller-writing",
+        summary: "Authored thriller story package adapted into real-link.ai.",
+        counts: {
+            characters: starter.entities.characters?.length || 0,
+            locations: starter.entities.locations?.length || 0,
+            clues: starter.entities.clues?.length || 0,
+            variables: starter.entities.variables?.length || 0,
+            nodes: starter.nodes.length,
+        },
+    };
+}
+function buildThrillerProjectionSpec() {
+    return {
+        id: "visual-novel",
+        label: "visual novel",
+        capability: "storyworld-vn",
+        publishLabel: "lightweight VN shell",
+    };
+}
+function buildThrillerAssetTargets(starter) {
+    const targets = [];
+    for (const character of starter.entities.characters || []) {
+        targets.push({
+            key: `portrait:${character.id}`,
+            entityId: character.id,
+            entityName: character.name,
+            entityType: "character",
+            role: "portrait",
+        });
+    }
+    for (const location of starter.entities.locations || []) {
+        targets.push({
+            key: `background:${location.id}`,
+            entityId: location.id,
+            entityName: location.name,
+            entityType: "location",
+            role: "background",
+        });
+    }
+    return targets;
+}
+function buildNarrativeGoal(gameName, planSpec) {
+    return [
+        `Adapt the ${planSpec.source.skillId} source package "${planSpec.source.title}" into the real-link.ai story-world workflow for ${gameName}.`,
+        `Create a reusable workspace IP package, preserve authored IDs, project it into a ${planSpec.projection.label} realization, generate core reusable assets, and only publish after the plan DAG is materialized.`,
+    ].join(" ");
+}
+function buildPlanStrategy(planSpec) {
+    const { source, projection } = planSpec;
+    return [
+        `Use ${source.skillId} as the authored source only.`,
+        "First create a studio plan and task DAG.",
+        `Then project the source into reusable workspace IP and a ${projection.label} runtime realization.`,
+        `Source scale: ${source.counts.characters} characters, ${source.counts.locations} locations, ${source.counts.clues} clues, ${source.counts.variables} variables, ${source.counts.nodes} nodes.`,
+        "Generate reusable assets after the story-world entities and style bible exist.",
+    ].join(" ");
+}
+function buildPlanTasks(planSpec) {
+    const { source, projection } = planSpec;
+    const tasks = [
+        {
+            key: "source-audit",
+            title: "Audit source package",
+            description: `Read the authored ${source.skillId} package, extract the reusable story-world contract, and record the adaptation constraints for real-link.ai.`,
+            type: "design",
+            priority: 10,
+            dependsOn: [],
+            requiredCapabilities: [source.skillId, "story-world"],
+        },
+        {
+            key: "style-bible",
+            title: "Seed projection style bible",
+            description: `Create the reusable visual style package and projection rules for the ${projection.label} realization.`,
+            type: "design",
+            priority: 8,
+            dependsOn: [0],
+            requiredCapabilities: ["story-world", projection.capability],
+        },
+        {
+            key: "characters",
+            title: "Seed cast characters",
+            description: `Import ${source.counts.characters} authored characters with reusable identity metadata.`,
+            type: "design",
+            priority: 9,
+            dependsOn: [0],
+            requiredCapabilities: [source.skillId, "story-world"],
+        },
+        {
+            key: "locations",
+            title: "Seed locations",
+            description: `Import ${source.counts.locations} authored locations with atmosphere and narrative coverage metadata.`,
+            type: "design",
+            priority: 8,
+            dependsOn: [0],
+            requiredCapabilities: ["story-world"],
+        },
+        {
+            key: "variables",
+            title: "Seed story variables",
+            description: `Import ${source.counts.variables} authored state variables with design-role metadata and payoff coverage.`,
+            type: "design",
+            priority: 8,
+            dependsOn: [0],
+            requiredCapabilities: ["story-world"],
+        },
+        {
+            key: "dialogue",
+            title: "Seed branching dialogue graph",
+            description: `Import ${source.counts.nodes} authored narrative nodes and preserve branch logic, choice metadata, and evidence references.`,
+            type: "design",
+            priority: 9,
+            dependsOn: [2, 3, 4],
+            requiredCapabilities: [source.skillId, "story-world", projection.capability],
+        },
+        {
+            key: "coverage-review",
+            title: "Review narrative coverage",
+            description: "Check that the story-world projection preserves speakers, locations, clue support links, and branch topology before runtime publish.",
+            type: "qa",
+            priority: 7,
+            dependsOn: [5],
+            requiredCapabilities: ["story-world", projection.capability],
+        },
+    ];
+    if (source.counts.clues > 0) {
+        tasks.splice(4, 0, {
+            key: "clues",
+            title: "Seed narrative clues",
+            description: `Import ${source.counts.clues} authored clues into the evidence registry, not gameplay inventory items.`,
+            type: "design",
+            priority: 8,
+            dependsOn: [0],
+            requiredCapabilities: [source.skillId, "story-world"],
+        });
+        const dialogueTask = tasks.find((task) => task.key === "dialogue");
+        if (dialogueTask) {
+            dialogueTask.dependsOn = [2, 3, 4, 5];
+        }
+        const coverageTask = tasks.find((task) => task.key === "coverage-review");
+        if (coverageTask) {
+            coverageTask.dependsOn = [6];
+        }
+    }
+    if (planSpec.generateAssets) {
+        const styleDependencyIndex = 1;
+        const characterDependencyIndex = 2;
+        const locationDependencyIndex = 3;
+        const assetTaskIndices = [];
+        for (const target of planSpec.assetTargets) {
+            const nextIndex = tasks.length;
+            tasks.push({
+                key: target.key,
+                title: `Generate ${target.role} for ${target.entityName}`,
+                description: `Create a reusable ${target.role} for ${target.entityName} after the entity spec and style bible are in place.`,
+                type: "art",
+                priority: 6,
+                dependsOn: [styleDependencyIndex, target.entityType === "character" ? characterDependencyIndex : locationDependencyIndex],
+                requiredCapabilities: ["story-world", projection.capability],
+            });
+            assetTaskIndices.push(nextIndex);
+        }
+        tasks.push({
+            key: "asset-review",
+            title: "Review asset coverage",
+            description: "Confirm that every planned asset task produced reusable studio assets before publish.",
+            type: "qa",
+            priority: 6,
+            dependsOn: assetTaskIndices,
+            requiredCapabilities: ["story-world", projection.capability],
+        });
+    }
+    if (planSpec.publish) {
+        const finalDependencies = tasks.map((_, index) => index);
+        tasks.push({
+            key: "publish",
+            title: `Publish ${projection.publishLabel}`,
+            description: `Advance the game to release, validate the publish contract, upload the ${projection.label} shell bundle, and finalize the live play URL.`,
+            type: "deploy",
+            priority: 7,
+            dependsOn: finalDependencies,
+            requiredCapabilities: ["story-world", projection.capability],
+        });
+    }
+    return tasks;
+}
+async function registerBootstrapAgent(apiBase, apiKey, workspaceId, gameName, capabilities) {
+    const id = `agent_story_${crypto.randomUUID().replace(/-/g, "").slice(0, 10)}`;
+    const name = `${gameName} Bootstrap`;
+    await requestJson({
+        apiBase,
+        apiKey,
+        workspaceId,
+        path: "/agents/register",
+        body: {
+            id,
+            name,
+            engine: "codex",
+            role: "orchestrator",
+            capabilities,
+        },
+    });
+    return { id, name };
+}
+async function createBootstrapPlan(apiBase, apiKey, workspaceId, gameId, gameName, planSpec, agentId) {
+    const plan = await requestJson({
+        apiBase,
+        apiKey,
+        workspaceId,
+        path: "/plans",
+        body: {
+            gameId,
+            title: `${gameName} story-world adaptation`,
+            goal: buildNarrativeGoal(gameName, planSpec),
+            strategy: buildPlanStrategy(planSpec),
+            constraints: planSpec.constraints,
+            createdBy: agentId,
+        },
+    });
+    const taskBlueprint = buildPlanTasks(planSpec);
+    const decomposition = await requestJson({
+        apiBase,
+        apiKey,
+        workspaceId,
+        path: `/plans/${plan.id}/decompose`,
+        body: {
+            strategy: buildPlanStrategy(planSpec),
+            agentId,
+            tasks: taskBlueprint.map((task) => ({
+                title: task.title,
+                description: task.description,
+                type: task.type,
+                priority: task.priority,
+                dependsOn: task.dependsOn,
+                requiredCapabilities: task.requiredCapabilities,
+            })),
+        },
+    });
+    await requestJson({
+        apiBase,
+        apiKey,
+        workspaceId,
+        path: `/plans/${plan.id}/activate`,
+        body: {},
+    });
+    return {
+        id: plan.id,
+        tasks: decomposition.tasks,
+    };
+}
+async function completeTaskStep(apiBase, apiKey, workspaceId, agentId, taskId, summary) {
+    await requestJson({
+        apiBase,
+        apiKey,
+        workspaceId,
+        path: "/tasks/claim",
+        body: { taskId, agentId },
+    });
+    await requestJson({
+        apiBase,
+        apiKey,
+        workspaceId,
+        path: "/tasks/complete",
+        body: {
+            taskId,
+            agentId,
+            output: { summary },
+        },
+    });
+}
+function escapeHtml(value) {
+    return value
+        .replaceAll("&", "&")
+        .replaceAll("<", "&lt;")
+        .replaceAll(">", "&gt;")
+        .replaceAll('"', "&quot;")
+        .replaceAll("'", "&#39;");
+}
+function buildPublishedFiles(starter) {
+    const storyJson = JSON.stringify(starter, null, 2);
+    const title = starter.meta.title;
+    const indexHtml = `<!doctype html>
+<html lang="en">
+  <head>
+    <meta charset="utf-8" />
+    <meta name="viewport" content="width=device-width, initial-scale=1" />
+    <title>${escapeHtml(title)}</title>
+    <link rel="stylesheet" href="./styles.css" />
+  </head>
+  <body>
+    <div id="app"></div>
+    <script type="module" src="./app.js"></script>
+  </body>
+</html>`;
+    const stylesCss = `:root {
+  color-scheme: dark;
+  --bg-0: #090b10;
+  --bg-1: #121722;
+  --bg-2: rgba(22, 28, 41, 0.92);
+  --line: rgba(214, 202, 170, 0.14);
+  --text-0: #f3efe6;
+  --text-1: #c2bbad;
+  --accent: #c38f5a;
+  --accent-soft: rgba(195, 143, 90, 0.18);
+}
+* { box-sizing: border-box; }
+body {
+  margin: 0;
+  min-height: 100vh;
+  font-family: ui-serif, Georgia, Cambria, "Times New Roman", serif;
+  color: var(--text-0);
+  background:
+    radial-gradient(circle at top, rgba(195, 143, 90, 0.14), transparent 32%),
+    linear-gradient(180deg, #0f1219 0%, #090b10 100%);
+}
+.shell {
+  min-height: 100vh;
+  display: grid;
+  grid-template-columns: minmax(0, 1.4fr) minmax(320px, 420px);
+}
+.stage {
+  position: relative;
+  padding: 56px 40px 36px;
+}
+.backdrop {
+  position: absolute;
+  inset: 0;
+  opacity: 0.22;
+  background:
+    radial-gradient(circle at 18% 18%, rgba(255,255,255,0.1), transparent 25%),
+    linear-gradient(135deg, rgba(195, 143, 90, 0.18), transparent 48%);
+  pointer-events: none;
+}
+.story { position: relative; max-width: 860px; }
+.eyebrow {
+  display: inline-flex;
+  gap: 8px;
+  padding: 6px 10px;
+  border: 1px solid var(--line);
+  background: rgba(9, 11, 16, 0.42);
+  border-radius: 999px;
+  color: var(--text-1);
+  font-size: 12px;
+  letter-spacing: 0.08em;
+  text-transform: uppercase;
+}
+h1 {
+  margin: 18px 0 10px;
+  font-size: clamp(40px, 7vw, 72px);
+  line-height: 0.98;
+  letter-spacing: -0.04em;
+}
+.subtitle { max-width: 560px; color: var(--text-1); font-size: 16px; line-height: 1.6; }
+.panel {
+  margin-top: 28px;
+  padding: 24px;
+  background: linear-gradient(180deg, rgba(17, 22, 31, 0.94), rgba(12, 16, 24, 0.94));
+  border: 1px solid var(--line);
+  border-radius: 24px;
+  backdrop-filter: blur(12px);
+}
+.meta-grid {
+  display: grid;
+  grid-template-columns: repeat(auto-fit, minmax(160px, 1fr));
+  gap: 14px;
+  margin-top: 18px;
+}
+.meta-card {
+  padding: 14px;
+  border: 1px solid var(--line);
+  border-radius: 18px;
+  background: rgba(255,255,255,0.02);
+}
+.meta-card span {
+  display: block;
+  font-size: 11px;
+  color: var(--text-1);
+  text-transform: uppercase;
+  letter-spacing: 0.08em;
+}
+.meta-card strong {
+  display: block;
+  margin-top: 8px;
+  font-size: 15px;
+  font-weight: 600;
+}
+.sidebar {
+  padding: 32px 24px;
+  border-left: 1px solid var(--line);
+  background: rgba(8, 10, 15, 0.74);
+}
+.sidebar h2 {
+  margin: 0 0 14px;
+  font-size: 14px;
+  letter-spacing: 0.08em;
+  text-transform: uppercase;
+  color: var(--text-1);
+}
+.node-title { margin: 0 0 8px; font-size: 28px; }
+.node-copy { white-space: pre-wrap; line-height: 1.7; color: var(--text-0); }
+.choice-list { display: grid; gap: 10px; margin-top: 18px; }
+.choice {
+  width: 100%;
+  text-align: left;
+  border: 1px solid var(--line);
+  background: linear-gradient(180deg, rgba(195, 143, 90, 0.14), rgba(17, 22, 31, 0.92));
+  color: var(--text-0);
+  padding: 14px 16px;
+  border-radius: 16px;
+  cursor: pointer;
+  font: inherit;
+}
+.choice:hover {
+  border-color: rgba(195, 143, 90, 0.4);
+  transform: translateY(-1px);
+}
+.pill-row {
+  display: flex;
+  flex-wrap: wrap;
+  gap: 8px;
+  margin: 12px 0 0;
+}
+.pill {
+  padding: 6px 10px;
+  border-radius: 999px;
+  background: var(--accent-soft);
+  color: #f0d8bd;
+  font-size: 12px;
+}
+.small-list { display: grid; gap: 10px; margin-top: 18px; }
+.small-card {
+  padding: 12px 14px;
+  border-radius: 16px;
+  border: 1px solid var(--line);
+  background: rgba(255,255,255,0.02);
+}
+.small-card strong {
+  display: block;
+  font-size: 14px;
+  margin-bottom: 6px;
+}
+.restart {
+  margin-top: 16px;
+  background: transparent;
+  color: var(--text-1);
+  border: 1px solid var(--line);
+}
+@media (max-width: 980px) {
+  .shell { grid-template-columns: 1fr; }
+  .sidebar { border-left: 0; border-top: 1px solid var(--line); }
+  .stage { padding: 36px 20px 24px; }
+}`;
+    const appJs = `const app = document.getElementById("app");
+const state = { story: null, currentId: null, nodeById: new Map(), locationById: new Map(), characterById: new Map() };
+
+boot().catch((error) => {
+  app.innerHTML = '<main class="stage"><div class="panel"><h1>Bootstrap failed</h1><p class="subtitle">' + error.message + '</p></div></main>';
+});
+
+async function boot() {
+  const response = await fetch("./story.json");
+  state.story = await response.json();
+  for (const node of state.story.nodes) state.nodeById.set(node.id, node);
+  for (const location of state.story.entities.locations || []) state.locationById.set(location.id, location);
+  for (const character of state.story.entities.characters || []) state.characterById.set(character.id, character);
+  state.currentId = state.story.meta.entry;
+  render();
+}
+
+function render() {
+  const node = state.nodeById.get(state.currentId);
+  if (!node) throw new Error("Missing node: " + state.currentId);
+  const location = node.location ? state.locationById.get(node.location) : null;
+  const lines = (node.body || []).map(renderLine).join("");
+  const clues = ((node.thriller && node.thriller.introducesClues) || []).map((id) => '<span class="pill">' + escapeHtml(id.replace(/^clue\\./, "").replace(/[-_]/g, " ")) + '</span>').join("");
+  const cast = (node.cast || []).map((entry) => {
+    const character = state.characterById.get(entry.character);
+    return '<div class="small-card"><strong>' + escapeHtml(character?.name || entry.character) + '</strong><div>' + escapeHtml((character && character.description) || "") + '</div></div>';
+  }).join("");
+  const choices = (node.choices || []).map((choice) =>
+    '<button class="choice" data-next="' + escapeHtml(choice.to || "") + '">' +
+      '<strong>' + escapeHtml(choice.text) + '</strong>' +
+      (choice.thriller && choice.thriller.immediateOutcome ? '<div class="subtitle" style="font-size:13px;margin-top:6px;">' + escapeHtml(choice.thriller.immediateOutcome) + '</div>' : '') +
+    '</button>'
+  ).join("");
+
+  app.innerHTML = '<main class="shell">' +
+    '<section class="stage">' +
+      '<div class="backdrop"></div>' +
+      '<div class="story">' +
+        '<div class="eyebrow"><span>Real Link Storyworld</span><span>' + escapeHtml(node.kind) + '</span></div>' +
+        '<h1>' + escapeHtml(state.story.meta.title) + '</h1>' +
+        '<p class="subtitle">A lightweight dogfood VN shell generated from the same story world package used by real-link.ai for characters, locations, variables, and branching narrative.</p>' +
+        '<div class="panel">' +
+          '<h2 class="node-title">' + escapeHtml(node.title || node.id) + '</h2>' +
+          (location ? '<p class="subtitle">' + escapeHtml(location.name + ' - ' + (location.description || "")) + '</p>' : '') +
+          '<div class="node-copy">' + lines + '</div>' +
+          (clues ? '<div class="pill-row">' + clues + '</div>' : '') +
+          ((node.choices || []).length ? '<div class="choice-list">' + choices + '</div>' : '<button class="choice restart" data-restart="1">Restart from the beginning</button>') +
+        '</div>' +
+      '</div>' +
+    '</section>' +
+    '<aside class="sidebar">' +
+      '<h2>Story World</h2>' +
+      '<div class="meta-grid">' +
+        '<div class="meta-card"><span>Characters</span><strong>' + (state.story.entities.characters || []).length + '</strong></div>' +
+        '<div class="meta-card"><span>Locations</span><strong>' + (state.story.entities.locations || []).length + '</strong></div>' +
+        '<div class="meta-card"><span>Variables</span><strong>' + (state.story.entities.variables || []).length + '</strong></div>' +
+        '<div class="meta-card"><span>Nodes</span><strong>' + state.story.nodes.length + '</strong></div>' +
+      '</div>' +
+      '<h2 style="margin-top:22px;">Cast In Scene</h2>' +
+      '<div class="small-list">' + (cast || '<div class="small-card">No staged cast on this node.</div>') + '</div>' +
+      '<h2 style="margin-top:22px;">North Star</h2>' +
+      '<div class="small-card"><strong>One workspace owns the IP.</strong><div>Characters, lore, branching story, and style live once. Multiple games can project that same package into different runtime forms.</div></div>' +
+    '</aside>' +
+  '</main>';
+
+  app.querySelectorAll("[data-next]").forEach((button) => {
+    button.addEventListener("click", () => {
+      state.currentId = button.getAttribute("data-next");
+      render();
+    });
+  });
+  const restart = app.querySelector("[data-restart]");
+  if (restart) {
+    restart.addEventListener("click", () => {
+      state.currentId = state.story.meta.entry;
+      render();
+    });
+  }
+}
+
+function renderLine(entry) {
+  if (!entry || !entry.text) return "";
+  if (entry.kind === "dialogue" && entry.speaker) {
+    const character = state.characterById.get(entry.speaker);
+    return '<p><strong>' + escapeHtml((character && character.name) || entry.speaker) + ':</strong> ' + escapeHtml(entry.text) + '</p>';
+  }
+  return '<p>' + escapeHtml(entry.text) + '</p>';
+}
+
+function escapeHtml(value) {
+  return String(value)
+    .replaceAll("&", "&amp;")
+    .replaceAll("<", "&lt;")
+    .replaceAll(">", "&gt;")
+    .replaceAll('"', "&quot;")
+    .replaceAll("'", "&#39;");
+}`;
+    return [
+        { path: "index.html", contentType: "text/html", content: indexHtml },
+        { path: "styles.css", contentType: "text/css", content: stylesCss },
+        { path: "app.js", contentType: "application/javascript", content: appJs },
+        { path: "story.json", contentType: "application/json", content: storyJson },
+    ];
+}
+async function bootstrapThrillerVN(options) {
+    const config = (0, config_js_1.loadConfig)();
+    const apiBase = normalizeApiBase(options.api);
+    const starter = readStarter(options.template);
+    const publishFiles = buildPublishedFiles(starter);
+    const generateAssets = typeof options.generateAssets === "boolean" ? options.generateAssets : !!options.publish;
+    const planOnly = !!options.planOnly;
+    const sourceSpec = buildThrillerSourceSpec(starter);
+    const projectionSpec = buildThrillerProjectionSpec();
+    const planSpec = {
+        source: sourceSpec,
+        projection: projectionSpec,
+        publish: !!options.publish,
+        generateAssets,
+        constraints: [
+            "workspace owns reusable IP",
+            `${sourceSpec.skillId} is source package only`,
+            "items remain physical gameplay objects",
+            "narrative clues live in the clue registry",
+            `${projectionSpec.label} is one projection of the same workspace IP package`,
+        ],
+        assetTargets: buildThrillerAssetTargets(starter),
+    };
+    const taskBlueprint = buildPlanTasks(planSpec);
+    const taskIndexByKey = new Map(taskBlueprint.map((task, index) => [task.key, index]));
+    const characterNames = new Map((starter.entities.characters || []).map((character) => [character.id, character.name]));
+    if (options.dryRun) {
+        return {
+            workspaceId: options.workspace || config.workspaceId || null,
+            gameId: null,
+            planId: "plan_dry_run",
+            agentId: "agent_dry_run",
+            tasksCreated: taskBlueprint.length,
+            createdWorkspace: !!options.workspaceName,
+            published: false,
+            starterTitle: starter.meta.title,
+            counts: {
+                characters: starter.entities.characters?.length || 0,
+                locations: starter.entities.locations?.length || 0,
+                variables: starter.entities.variables?.length || 0,
+                clues: starter.entities.clues?.length || 0,
+                nodes: starter.nodes.length,
+                files: publishFiles.length,
+            },
+        };
+    }
+    const explicitWorkspaceId = options.workspace || process.env.REAL_LINK_WORKSPACE_ID || null;
+    let workspaceId = explicitWorkspaceId || (process.env.REAL_LINK_API_KEY ? null : config.workspaceId || null);
+    let apiKey = process.env.REAL_LINK_API_KEY || config.apiKey;
+    const bearerToken = options.bearerToken || process.env.REAL_LINK_BEARER_TOKEN;
+    let createdWorkspace = false;
+    if (options.workspaceName) {
+        if (!bearerToken) {
+            throw new Error("workspace creation requires --bearer-token or REAL_LINK_BEARER_TOKEN");
+        }
+        const workspace = await requestJson({
+            apiBase,
+            path: "/workspaces/create",
+            bearerToken,
+            body: {
+                name: options.workspaceName,
+                description: options.workspaceDescription || `Story world workspace for ${options.name || starter.meta.title}`,
+            },
+        });
+        workspaceId = workspace.id;
+        const keyResult = await requestJson({
+            apiBase,
+            path: `/workspaces/${workspaceId}/api-keys`,
+            bearerToken,
+            body: {
+                name: `${options.name || starter.meta.title} bootstrap`,
+                scopes: ["agent"],
+            },
+        });
+        apiKey = keyResult.key;
+        createdWorkspace = true;
+        if (options.saveConfig) {
+            (0, config_js_1.saveConfig)({
+                ...config,
+                apiUrl: apiBase,
+                apiKey,
+                workspaceId,
+            });
+        }
+    }
+    if (!apiKey) {
+        throw new Error("Missing studio credentials. Provide a valid real-link.ai workspace API key, or create a workspace with a valid real-link.ai bearer token.");
+    }
+    const gameName = options.name || starter.meta.title;
+    const gameDescription = options.description ||
+        "A branching thriller visual novel generated from a reusable story world package inside real-link.ai.";
+    const engine = options.engine || "storyworld-vn";
+    const game = await requestJson({
+        apiBase,
+        apiKey,
+        workspaceId,
+        path: "/games/create",
+        body: {
+            name: gameName,
+            description: gameDescription,
+            engine,
+        },
+    });
+    const gameId = game.id;
+    if (!workspaceId || options.saveConfig) {
+        const games = await requestJson({
+            apiBase,
+            apiKey,
+            workspaceId,
+            path: "/games",
+        });
+        workspaceId = workspaceId || games.find((entry) => entry.id === gameId)?.workspaceId || games[0]?.workspaceId || null;
+        if (options.saveConfig && workspaceId) {
+            (0, config_js_1.saveConfig)({
+                ...config,
+                apiUrl: apiBase,
+                apiKey,
+                workspaceId,
+            });
+        }
+    }
+    const bootstrapAgent = await registerBootstrapAgent(apiBase, apiKey, workspaceId, gameName, ["story-world", sourceSpec.skillId, projectionSpec.capability, "solo-build"]);
+    const plan = await createBootstrapPlan(apiBase, apiKey, workspaceId, gameId, gameName, planSpec, bootstrapAgent.id);
+    if (planOnly) {
+        return {
+            workspaceId,
+            gameId,
+            planId: plan.id,
+            agentId: bootstrapAgent.id,
+            tasksCreated: plan.tasks.length,
+            createdWorkspace,
+            published: false,
+            starterTitle: starter.meta.title,
+            counts: {
+                characters: starter.entities.characters?.length || 0,
+                locations: starter.entities.locations?.length || 0,
+                variables: starter.entities.variables?.length || 0,
+                clues: starter.entities.clues?.length || 0,
+                nodes: starter.nodes.length,
+                files: publishFiles.length,
+            },
+        };
+    }
+    const taskIdByIndex = new Map(plan.tasks.map((task) => [task.index, task.id]));
+    const completeByKey = async (key, summary) => {
+        const taskIndex = taskIndexByKey.get(key);
+        if (taskIndex === undefined)
+            return;
+        const taskId = taskIdByIndex.get(taskIndex);
+        if (!taskId) {
+            throw new Error(`Missing plan task for ${key}`);
+        }
+        await completeTaskStep(apiBase, apiKey, workspaceId, bootstrapAgent.id, taskId, summary);
+    };
+    await completeByKey("source-audit", `Audited ${sourceSpec.skillId} source package ${sourceSpec.id}. Preserved authored IDs for ${sourceSpec.counts.characters} characters, ${sourceSpec.counts.locations} locations, ${sourceSpec.counts.clues} clues, ${sourceSpec.counts.variables} variables, and ${sourceSpec.counts.nodes} nodes.`);
+    await requestJson({
+        apiBase,
+        apiKey,
+        workspaceId,
+        path: "/content/styles",
+        body: {
+            id: DEFAULT_STYLE_ID,
+            gameId,
+            name: DEFAULT_STYLE_NAME,
+            description: "Grounded thriller interiors, warm practicals, cold rain light, cinematic VN framing.",
+            prompt: "cinematic thriller visual novel, grounded interiors, tension-driven blocking, warm tungsten practicals, cold rain light, subtle film grain, realistic anime-noir illustration",
+            negativePrompt: "muddy composition, duplicate characters, comedic tone, bright fantasy daylight",
+            rules: {
+                source: "thriller-writing",
+                northStar: "same workspace IP, multiple game projections",
+            },
+            isDefault: true,
+        },
+    });
+    await completeByKey("style-bible", `Seeded the default ${projectionSpec.label} style bible (${DEFAULT_STYLE_NAME}) with reusable story-world projection rules.`);
+    for (const character of starter.entities.characters || []) {
+        await requestJson({
+            apiBase,
+            apiKey,
+            workspaceId,
+            path: "/content/characters",
+            body: {
+                id: character.id,
+                gameId,
+                name: character.name,
+                role: inferRole(character),
+                bio: buildCharacterBio(character),
+                stats: buildCharacterStats(character),
+                metadata: {
+                    source: "thriller-writing",
+                    thrillerProfile: character.thrillerProfile || {},
+                    defaultExpression: character.defaultExpression || "neutral",
+                    sceneCount: countNodesForCharacter(starter, character.id),
+                },
+            },
+        });
+    }
+    await completeByKey("characters", `Seeded ${sourceSpec.counts.characters} characters with richer source metadata and scene coverage fields.`);
+    for (const location of starter.entities.locations || []) {
+        await requestJson({
+            apiBase,
+            apiKey,
+            workspaceId,
+            path: "/content/locations",
+            body: {
+                id: location.id,
+                gameId,
+                name: location.name,
+                description: location.description || "",
+                locationType: "area",
+                metadata: buildLocationMetadata(location, starter),
+            },
+        });
+    }
+    await completeByKey("locations", `Seeded ${sourceSpec.counts.locations} locations with background hints and narrative node coverage.`);
+    for (const clue of starter.entities.clues || []) {
+        await requestJson({
+            apiBase,
+            apiKey,
+            workspaceId,
+            path: "/content/clues",
+            body: {
+                id: clue.id,
+                gameId,
+                label: clue.label,
+                summary: clue.summary || clue.question || clue.label,
+                clueType: clue.kind || "evidence",
+                question: clue.question || "",
+                supports: clue.supports || [],
+                critical: !!clue.critical,
+                metadata: buildClueMetadata(clue),
+            },
+        });
+    }
+    await completeByKey("clues", `Seeded ${sourceSpec.counts.clues} narrative clues into the evidence registry instead of gameplay inventory items.`);
+    for (const variable of starter.entities.variables || []) {
+        await requestJson({
+            apiBase,
+            apiKey,
+            workspaceId,
+            path: "/content/variables",
+            body: {
+                id: variable.id,
+                gameId,
+                name: variable.id,
+                variableType: variable.type || "boolean",
+                defaultValue: stringifyDefaultValue(variable.default),
+                description: variable.rationale || variable.id,
+                category: inferVariableCategory(variable),
+            },
+        });
+    }
+    await completeByKey("variables", `Seeded ${sourceSpec.counts.variables} story variables with rationale, design role, and payoff coverage.`);
+    for (const node of starter.nodes) {
+        await requestJson({
+            apiBase,
+            apiKey,
+            workspaceId,
+            path: "/content/dialogue",
+            body: {
+                id: node.id,
+                gameId,
+                speakerId: pickSpeakerId(node),
+                nodeType: mapNodeType(node.kind),
+                text: flattenNodeText(node, characterNames),
+                nextNodeId: node.to || node.nextNodeId || null,
+                choices: (node.choices || []).map((choice) => ({
+                    text: choice.text,
+                    nextNodeId: choice.to || null,
+                    condition: choice.condition || null,
+                })),
+                metadata: {
+                    title: node.title || node.id,
+                    source: "thriller-writing",
+                    originalKind: node.kind,
+                    locationId: node.location || null,
+                    cast: node.cast || [],
+                    thriller: node.thriller || {},
+                    presentation: node.presentation || {},
+                    sourceFile: node.source || {},
+                    notes: node.notes || "",
+                    body: node.body || [],
+                    choiceDetails: (node.choices || []).map((choice) => ({
+                        id: choice.id,
+                        text: choice.text,
+                        effects: choice.effects || [],
+                        thriller: choice.thriller || {},
+                    })),
+                },
+            },
+        });
+    }
+    await completeByKey("dialogue", `Seeded ${sourceSpec.counts.nodes} branching nodes with preserved authored IDs, choice details, and clue-introduction metadata.`);
+    const narrativeOverview = await requestJson({
+        apiBase,
+        apiKey,
+        workspaceId,
+        path: `/content/narrative?gameId=${encodeURIComponent(gameId)}`,
+    });
+    await completeByKey("coverage-review", `Narrative review: ${narrativeOverview.summary.nodes} nodes, ${narrativeOverview.summary.branchPoints} branch points, ${narrativeOverview.summary.clues} clues, ${narrativeOverview.summary.danglingEdges} dangling edges, ${narrativeOverview.summary.unreachableNodes} unreachable nodes.`);
+    if (generateAssets) {
+        for (const character of starter.entities.characters || []) {
+            await requestJson({
+                apiBase,
+                apiKey,
+                workspaceId,
+                path: "/content/generate-for",
+                body: {
+                    entityType: "character",
+                    entityId: character.id,
+                    assetRole: "portrait",
+                    prompt: `${character.name}, ${character.description || "thriller character portrait"}`,
+                },
+            });
+            await completeByKey(`portrait:${character.id}`, `Generated reusable portrait for ${character.name} in the workspace IP package.`);
+        }
+        for (const location of starter.entities.locations || []) {
+            await requestJson({
+                apiBase,
+                apiKey,
+                workspaceId,
+                path: "/content/generate-for",
+                body: {
+                    entityType: "location",
+                    entityId: location.id,
+                    assetRole: "background",
+                    prompt: `${location.name}, ${location.description || "thriller location background"}`,
+                },
+            });
+            await completeByKey(`background:${location.id}`, `Generated reusable background for ${location.name} in the workspace IP package.`);
+        }
+        await completeByKey("asset-review", `Generated core asset coverage for ${sourceSpec.counts.characters} characters and ${sourceSpec.counts.locations} locations.`);
+    }
+    let publishUrl;
+    if (options.publish) {
+        await requestJson({
+            apiBase,
+            apiKey,
+            workspaceId,
+            path: "/phases/set",
+            body: {
+                gameId,
+                phaseId: "release",
+                reason: "Thriller VN bootstrap publish",
+            },
+        });
+        await requestJson({
+            apiBase,
+            apiKey,
+            workspaceId,
+            path: "/publish/validate",
+            body: { gameId },
+        });
+        await requestJson({
+            apiBase,
+            apiKey,
+            workspaceId,
+            path: "/publish/upload-batch",
+            body: {
+                gameId,
+                files: publishFiles.map((file) => ({
+                    path: file.path,
+                    contentType: file.contentType,
+                    content: Buffer.from(file.content, "utf8").toString("base64"),
+                })),
+            },
+        });
+        const publish = await requestJson({
+            apiBase,
+            apiKey,
+            workspaceId,
+            path: "/publish/finalize",
+            body: {
+                gameId,
+                version: options.version || "0.1.0",
+                fileCount: publishFiles.length,
+            },
+        });
+        publishUrl = publish.url;
+        await completeByKey("publish", `Published ${projectionSpec.publishLabel} to ${publishUrl}.`);
+    }
+    await requestJson({
+        apiBase,
+        apiKey,
+        workspaceId,
+        path: `/plans/${plan.id}/complete`,
+        body: {},
+    });
+    return {
+        workspaceId,
+        gameId,
+        planId: plan.id,
+        agentId: bootstrapAgent.id,
+        tasksCreated: plan.tasks.length,
+        createdWorkspace,
+        published: !!publishUrl,
+        publishUrl,
+        starterTitle: starter.meta.title,
+        counts: {
+            characters: starter.entities.characters?.length || 0,
+            locations: starter.entities.locations?.length || 0,
+            variables: starter.entities.variables?.length || 0,
+            clues: starter.entities.clues?.length || 0,
+            nodes: starter.nodes.length,
+            files: publishFiles.length,
+        },
+    };
+}
+//# sourceMappingURL=thriller-vn.js.map