@riemannre3/dsh-roleplay 0.1.3

package/lib/prompt-compiler.js

@@ -0,0 +1,288 @@
+import { DEFAULT_TAVERN_PRESET } from "./preset-runtime.js";
+import { placeWorldbook, substituteCardMacros } from "./worldbook.js";
+import { renderPersonaPrompt } from "./persona-runtime.js";
+export { DEFAULT_TAVERN_PRESET } from "./preset-runtime.js";
+function clean(text) { return text.trim(); }
+function formatWorldInfo(template, content) { return content.length === 0 ? "" : template.includes("{0}") ? template.replaceAll("{0}", content) : content; }
+function resolveOutlets(text, outlets) { return text.replace(/\{\{outlet::([^{}]+)\}\}/gu, (_match, name) => outlets[name.trim()] ?? ""); }
+function estimateMessageTokens(message) { return Math.ceil(message.content.length / 4) + 4; }
+function sourceFor(definition, kind, extra = {}) {
+    return {
+        kind,
+        blockId: definition.marker ?? definition.identifier,
+        promptIdentifier: definition.identifier,
+        ...(definition.marker === undefined ? {} : { marker: definition.marker }),
+        ...extra,
+    };
+}
+function parseExamples(text, values, definition) {
+    const substituted = clean(substituteCardMacros(text, values));
+    if (substituted.length === 0)
+        return [];
+    const messages = [];
+    let current;
+    for (const rawLine of substituted.replaceAll("<START>", "").split(/\r?\n/gu)) {
+        const line = rawLine.trim();
+        if (line.length === 0)
+            continue;
+        const match = line.match(/^([^:：]{1,80})[:：]\s*(.*)$/u);
+        if (match !== null) {
+            const speaker = (match[1] ?? "").trim();
+            const resolvedRole = speaker === values.userName || /^user$/iu.test(speaker) ? "user" : speaker === values.characterName || /^char(?:acter)?$/iu.test(speaker) ? "assistant" : undefined;
+            if (resolvedRole !== undefined) {
+                current = { role: resolvedRole, content: match[2] ?? "", source: sourceFor(definition, "example") };
+                messages.push(current);
+                continue;
+            }
+        }
+        if (current === undefined) {
+            current = { role: "system", content: line, source: sourceFor(definition, "example") };
+            messages.push(current);
+        }
+        else
+            current.content += `\n${line}`;
+    }
+    return messages;
+}
+function depthMessages(placement, chatDefinition) {
+    const grouped = new Map();
+    for (const entry of placement.entries.filter((candidate) => candidate.position === "at_depth")) {
+        const key = `${entry.depth}:${entry.role}`;
+        grouped.set(key, [...(grouped.get(key) ?? []), entry]);
+    }
+    return [...grouped.values()].map((entries) => ({
+        role: entries[0].role,
+        content: entries.map((entry) => entry.content).join("\n\n"),
+        source: sourceFor(chatDefinition, "worldbook", { entryIds: entries.map((entry) => entry.id), position: "at-depth", depth: entries[0].depth }),
+    })).sort((left, right) => (right.source.depth ?? 0) - (left.source.depth ?? 0) || ["system", "user", "assistant"].indexOf(left.role) - ["system", "user", "assistant"].indexOf(right.role));
+}
+function insertAtDepth(messages, injections) {
+    const roleOrder = { user: 0, assistant: 1, system: 2 };
+    const grouped = new Map();
+    for (const injection of injections) {
+        const index = Math.max(0, messages.length - Math.min(messages.length, injection.depth));
+        grouped.set(index, [...(grouped.get(index) ?? []), injection]);
+    }
+    for (const [index, rows] of [...grouped.entries()].sort((left, right) => right[0] - left[0])) {
+        rows.sort((left, right) => left.order - right.order || roleOrder[left.message.role] - roleOrder[right.message.role]);
+        messages.splice(index, 0, ...rows.map((row) => row.message));
+    }
+}
+function compileChatHistory(chat, placement, definition, inChatPrompts, values) {
+    const result = chat.map((message) => ({
+        role: message.role,
+        content: message.content,
+        source: sourceFor(definition, "chat", { sourceIndex: message.sourceIndex }),
+    }));
+    insertAtDepth(result, [
+        ...depthMessages(placement, definition).map((message) => ({ message, depth: message.source.depth ?? 0, order: 100 })),
+        ...inChatPrompts.flatMap((prompt) => {
+            const content = clean(resolveOutlets(substituteCardMacros(prompt.content, values), placement.outlets));
+            return content.length === 0 ? [] : [{ message: { role: prompt.role, content, source: sourceFor(prompt, "preset", { position: "in-chat", depth: prompt.injectionDepth }) }, depth: prompt.injectionDepth, order: prompt.injectionOrder }];
+        }),
+    ]);
+    return result;
+}
+export function normalizeTavernChatMessages(messages) {
+    return messages.flatMap((message, sourceIndex) => {
+        if (message?.role !== "user" && message?.role !== "assistant")
+            return [];
+        if (message?.source?.kind === "plugin" && message.source.plugin !== "compact")
+            return [];
+        const content = typeof message.content === "string" ? message.content : Array.isArray(message.content) ? message.content.filter((part) => part?.type === "text" && typeof part.text === "string").map((part) => part.text).join("\n") : "";
+        if (content.trim().length === 0 || /^\[DSH_RE3_RP_(?:WORLD_CONTEXT|ASSEMBLY)\]/u.test(content))
+            return [];
+        return [{ role: message.role, content, sourceIndex }];
+    });
+}
+function markerMessages(input) {
+    const { definition, card, placement, values } = input;
+    switch (definition.marker) {
+        case "main-prompt": {
+            const text = clean(substituteCardMacros(card.systemPrompt, values)) || clean(substituteCardMacros(definition.content, values)) || `你正在扮演 ${card.title}。请始终以角色身份自然地延续当前对话。`;
+            return [{ role: definition.role, content: text, source: sourceFor(definition, "preset") }];
+        }
+        case "world-info-before": {
+            const text = formatWorldInfo(input.worldInfoFormat, placement.beforeCharacter);
+            return text.length === 0 ? [] : [{ role: definition.role, content: text, source: sourceFor(definition, "worldbook", { entryIds: placement.entries.filter((entry) => entry.position === "before_char").map((entry) => entry.id), position: "before-char" }) }];
+        }
+        case "persona-description": {
+            const text = clean(substituteCardMacros(renderPersonaPrompt(values.userName, input.personaDescription ?? ""), values));
+            return text.length === 0 ? [] : [{ role: definition.role, content: text, source: sourceFor(definition, "preset") }];
+        }
+        case "character-description": {
+            const text = clean(substituteCardMacros(card.description, values));
+            return text.length === 0 ? [] : [{ role: definition.role, content: text, source: sourceFor(definition, "preset") }];
+        }
+        case "character-personality": {
+            const text = clean(substituteCardMacros(card.personality, values));
+            return text.length === 0 ? [] : [{ role: definition.role, content: text, source: sourceFor(definition, "preset") }];
+        }
+        case "scenario": {
+            const text = clean(substituteCardMacros(card.scenario, values));
+            return text.length === 0 ? [] : [{ role: definition.role, content: text, source: sourceFor(definition, "preset") }];
+        }
+        case "world-info-after": {
+            const text = formatWorldInfo(input.worldInfoFormat, placement.afterCharacter);
+            return text.length === 0 ? [] : [{ role: definition.role, content: text, source: sourceFor(definition, "worldbook", { entryIds: placement.entries.filter((entry) => entry.position === "after_char").map((entry) => entry.id), position: "after-char" }) }];
+        }
+        case "example-messages": {
+            const messages = [];
+            if (placement.beforeExamples.length > 0)
+                messages.push({ role: definition.role, content: placement.beforeExamples, source: sourceFor(definition, "worldbook", { entryIds: placement.entries.filter((entry) => entry.position === "before_examples").map((entry) => entry.id), position: "before-examples" }) });
+            messages.push(...parseExamples(card.messageExample, values, definition));
+            if (placement.afterExamples.length > 0)
+                messages.push({ role: definition.role, content: placement.afterExamples, source: sourceFor(definition, "worldbook", { entryIds: placement.entries.filter((entry) => entry.position === "after_examples").map((entry) => entry.id), position: "after-examples" }) });
+            return messages;
+        }
+        case "authors-note": {
+            const text = [placement.authorNoteTop, placement.authorNoteBottom].filter(Boolean).join("\n\n");
+            return text.length === 0 ? [] : [{ role: definition.role, content: text, source: sourceFor(definition, "worldbook", { entryIds: placement.entries.filter((entry) => entry.position === "an_top" || entry.position === "an_bottom").map((entry) => entry.id), position: "authors-note" }) }];
+        }
+        case "chat-history": return compileChatHistory(input.chat, placement, definition, input.inChatPrompts, values);
+        case "post-history-instructions": {
+            const text = clean(substituteCardMacros(card.postHistoryInstructions, values)) || clean(substituteCardMacros(definition.content, values));
+            return text.length === 0 ? [] : [{ role: definition.role, content: text, source: sourceFor(definition, "preset") }];
+        }
+        default: return [];
+    }
+}
+function trimToContext(messages, contextTokens) {
+    let current = messages;
+    let estimatedTokens = current.reduce((sum, message) => sum + estimateMessageTokens(message), 0);
+    let prunedChatMessages = 0;
+    let prunedExampleMessages = 0;
+    if (contextTokens === null)
+        return { messages: current, prunedChatMessages, prunedExampleMessages, estimatedTokens, contextExceeded: false };
+    if (estimatedTokens > contextTokens) {
+        const latestChatIndex = current.reduce((last, message, index) => message.source.kind === "chat" ? index : last, -1);
+        const removable = current.flatMap((message, index) => message.source.kind === "chat" && index !== latestChatIndex ? [index] : []);
+        const removed = new Set();
+        for (const index of removable) {
+            if (estimatedTokens <= contextTokens)
+                break;
+            estimatedTokens -= estimateMessageTokens(current[index]);
+            removed.add(index);
+            prunedChatMessages += 1;
+        }
+        current = current.filter((_message, index) => !removed.has(index));
+    }
+    if (estimatedTokens > contextTokens) {
+        const removed = new Set();
+        for (let index = 0; index < current.length; index += 1) {
+            if (estimatedTokens <= contextTokens)
+                break;
+            if (current[index].source.kind !== "example")
+                continue;
+            estimatedTokens -= estimateMessageTokens(current[index]);
+            removed.add(index);
+            prunedExampleMessages += 1;
+        }
+        current = current.filter((_message, index) => !removed.has(index));
+    }
+    return { messages: current, prunedChatMessages, prunedExampleMessages, estimatedTokens, contextExceeded: estimatedTokens > contextTokens };
+}
+export function compileTavernPrompt(input) {
+    const preset = input.preset ?? DEFAULT_TAVERN_PRESET;
+    const values = { userName: input.userName, characterName: input.card.title, messageVariables: input.messageVariables, localVariables: {}, macroSeed: input.macroSeed };
+    const placement = placeWorldbook(input.activation.active, values);
+    const definitions = new Map(preset.prompts.map((prompt) => [prompt.identifier, prompt]));
+    const enabled = new Map(preset.promptOrder.map((item) => [item.identifier, item.enabled]));
+    const inChatPrompts = preset.prompts.filter((prompt) => prompt.marker === undefined && prompt.injectionPosition === "in-chat" && enabled.get(prompt.identifier) === true);
+    const assembled = [];
+    for (const item of preset.promptOrder) {
+        if (!item.enabled)
+            continue;
+        const definition = definitions.get(item.identifier);
+        if (definition === undefined || definition.injectionPosition === "in-chat" && definition.marker === undefined)
+            continue;
+        if (definition.marker !== undefined)
+            assembled.push(...markerMessages({ definition, card: input.card, personaDescription: input.personaDescription, placement, chat: input.chat, inChatPrompts, values, worldInfoFormat: preset.worldInfoFormat }));
+        else {
+            const content = clean(resolveOutlets(substituteCardMacros(definition.content, values), placement.outlets));
+            if (content.length > 0)
+                assembled.push({ role: definition.role, content, source: sourceFor(definition, "preset") });
+        }
+    }
+    const trimmed = trimToContext(assembled, preset.settings.contextTokens);
+    const messages = trimmed.messages;
+    const blocks = preset.promptOrder.map((item) => {
+        const definition = definitions.get(item.identifier) ?? { identifier: item.identifier, name: item.identifier, role: "system", content: "", systemPrompt: false, injectionPosition: "relative", injectionDepth: 4, injectionOrder: 100, extra: {} };
+        const indexes = messages.flatMap((message, index) => message.source.promptIdentifier === item.identifier ? [index] : []);
+        const text = indexes.map((index) => messages[index].content).join("\n");
+        return {
+            id: definition.marker ?? definition.identifier,
+            promptIdentifier: definition.identifier,
+            ...(definition.marker === undefined ? {} : { marker: definition.marker }),
+            label: definition.name,
+            enabled: item.enabled,
+            role: definition.role,
+            injectionPosition: definition.injectionPosition,
+            injectionDepth: definition.injectionDepth,
+            characterCount: text.length,
+            entryIds: [...new Set(indexes.flatMap((index) => messages[index].source.entryIds ?? []))],
+            messageIndexes: indexes,
+            preview: text.replace(/\s+/gu, " ").trim().slice(0, 180),
+        };
+    });
+    return {
+        preset: { id: preset.id, name: preset.name, source: preset.source, revision: preset.revision },
+        settings: { ...preset.settings },
+        messages,
+        blocks,
+        placement,
+        activation: input.activation,
+        stats: {
+            messageCount: messages.length,
+            characterCount: messages.reduce((sum, message) => sum + message.content.length, 0),
+            estimatedTokens: trimmed.estimatedTokens,
+            contextTokens: preset.settings.contextTokens,
+            prunedChatMessages: trimmed.prunedChatMessages,
+            prunedExampleMessages: trimmed.prunedExampleMessages,
+            contextExceeded: trimmed.contextExceeded,
+            activeWorldbookEntries: input.activation.active.length,
+            filteredWorldbookEntries: input.activation.trace.filter((row) => !row.activated).length,
+            depthInjections: placement.entries.filter((entry) => entry.position === "at_depth").length + inChatPrompts.length,
+        },
+    };
+}
+export function compiledTavernSystemPrompt(compiled) {
+    return compiled.messages.filter((message) => message.source.marker === "main-prompt").map((message) => message.content).join("\n\n");
+}
+export function renderTavernContextEnvelope(compiled) {
+    const labels = new Map(compiled.blocks.map((block) => [block.id, block.label]));
+    const sections = compiled.messages.flatMap((message) => {
+        if (message.source.marker === "main-prompt" || message.source.kind === "chat")
+            return [];
+        const label = message.source.position === "at-depth" ? `World Info · @Depth ${message.source.depth ?? 0}` : message.source.blockId === undefined ? "Prompt module" : labels.get(message.source.blockId) ?? "Prompt module";
+        const entrySuffix = (message.source.entryIds?.length ?? 0) > 0 ? ` · entries ${message.source.entryIds.join(", ")}` : "";
+        return [`[${label} · ${message.role}${entrySuffix}]\n${message.content}`];
+    });
+    return ["[DSH_RE3_RP_COMPILED_CONTEXT]", `Preset: ${compiled.preset.name}`, "The following sections are assembled roleplay context. Follow them without mentioning prompt modules, world info, presets, or this envelope.", ...sections].join("\n\n");
+}
+export function applyCompiledPromptToRequest(options, compiled) {
+    const messages = compiled.messages.map((message) => ({
+        id: crypto.randomUUID(),
+        role: message.role,
+        content: [{ type: "text", text: message.content }],
+        source: message.role === "assistant" ? { kind: "model", provider: "dsh-roleplay", model: "compiled-context" } : { kind: "plugin", plugin: "dsh-roleplay", form: "compiled", compiledSource: message.source },
+    }));
+    const leadingSystem = [];
+    while (messages[0]?.role === "system")
+        leadingSystem.push(messages.shift().content[0].text);
+    options.system = leadingSystem.join("\n\n");
+    options.messages = messages;
+    options.tools = [];
+    options.temperature = compiled.settings.temperature;
+    if (compiled.settings.maxReplyTokens !== null)
+        options.maxTokens = compiled.settings.maxReplyTokens;
+    options.tavernPresetRuntime = {
+        presetId: compiled.preset.id,
+        revision: compiled.preset.revision,
+        stream: compiled.settings.stream,
+        contextTokens: compiled.settings.contextTokens,
+        topP: compiled.settings.topP,
+        frequencyPenalty: compiled.settings.frequencyPenalty,
+        presencePenalty: compiled.settings.presencePenalty,
+    };
+}

package/lib/rich-message.js

@@ -0,0 +1,176 @@
+const rawHtmlDocument = /^\s*<(?:!doctype|html|body|style|div|section|details)\b/iu;
+const htmlFragment = /^\s*<(?:!doctype|[a-z][\w:-]*)(?:\s|>)[\s\S]*>\s*$/iu;
+const fencedHtml = /```html\s*\r?\n([\s\S]*?)\r?\n```/giu;
+const fencedUntypedHtmlDocument = /```[ \t]*\r?\n(\s*<(?:!doctype|html)\b[\s\S]*?)\r?\n```/giu;
+const htmlTag = /<!--[\s\S]*?-->|<![^>]*>|<\/?([a-z][\w:-]*)\b(?:\s+(?:"[^"]*"|'[^']*'|[^'"<>])*)?\s*\/?>/giu;
+const rawTextElement = /<(script|style|template)\b(?:\s+(?:"[^"]*"|'[^']*'|[^'"<>])*)?\s*>[\s\S]*?<\/\1\s*>/giu;
+const voidHtmlTags = new Set(["area", "base", "br", "col", "embed", "hr", "img", "input", "link", "meta", "param", "source", "track", "wbr"]);
+const crossBoundaryContainerTags = new Set(["article", "aside", "body", "details", "dialog", "div", "fieldset", "footer", "form", "header", "html", "main", "nav", "ol", "section", "table", "tbody", "tfoot", "thead", "ul"]);
+function leavesOpenHtmlContainer(value) {
+    const stack = [];
+    const structuralHtml = value.replace(rawTextElement, "");
+    for (const match of structuralHtml.matchAll(new RegExp(htmlTag.source, htmlTag.flags))) {
+        const token = match[0];
+        const tag = match[1]?.toLowerCase();
+        if (tag === undefined || token.startsWith("<!--") || token.startsWith("<!"))
+            continue;
+        if (token.startsWith("</")) {
+            const matchingIndex = stack.lastIndexOf(tag);
+            if (matchingIndex >= 0)
+                stack.splice(matchingIndex);
+            continue;
+        }
+        if (token.endsWith("/>") || voidHtmlTags.has(tag))
+            continue;
+        stack.push(tag);
+    }
+    return stack.some((tag) => crossBoundaryContainerTags.has(tag) || tag.includes("-"));
+}
+function escapeCrossBoundaryProse(value) {
+    // `<content>` is a common card control wrapper, not player prose. In the
+    // original shared message DOM the browser consumes it as markup; do the same
+    // without allowing arbitrary prose HTML to become executable in the iframe.
+    const visible = value
+        .replace(/(?:^|\r?\n)[ \t]*<\/?content\b[^>]*>[ \t]*(?=\r?\n|$)/giu, "\n")
+        .trim();
+    if (visible.length === 0)
+        return "";
+    const escaped = visible
+        .replaceAll("&", "&amp;")
+        .replaceAll("<", "&lt;")
+        .replaceAll(">", "&gt;")
+        .replaceAll('"', "&quot;")
+        .replaceAll("'", "&#39;");
+    return `<div data-dsh-cross-boundary-prose style="white-space: pre-wrap">${escaped}</div>`;
+}
+function stitchCrossBoundaryWrapper(blocks) {
+    const openingIndex = blocks.findIndex((block, index) => block.kind === "html"
+        && index < blocks.length - 1
+        && leavesOpenHtmlContainer(block.content));
+    if (openingIndex < 0)
+        return [...blocks];
+    const content = blocks.slice(openingIndex)
+        .map((block) => block.kind === "html" ? block.content : escapeCrossBoundaryProse(block.content))
+        .filter((value) => value.length > 0)
+        .join("\n");
+    return [...blocks.slice(0, openingIndex), { kind: "html", content }];
+}
+// Message iframes are expanded by the Host, so their previous viewport height
+// must never participate in the next measurement. In particular,
+// documentElement.scrollHeight is pinned to an already-tall iframe and cannot
+// shrink after a card switches from a long page to a short page.
+export function measureRichFrameContentHeight(metrics) {
+    const finite = (value) => Number.isFinite(value) ? value : 0;
+    const bodyTop = Math.min(0, finite(metrics.bodyRectTop));
+    const bodyBottom = Math.max(finite(metrics.bodyScrollHeight), finite(metrics.bodyOffsetHeight), finite(metrics.bodyRectBottom) - bodyTop);
+    // A viewport-relative card can keep body at exactly the current iframe
+    // height while moving the rest of its UI into overflow:auto descendants.
+    // Add that clipped extent so repeated resize receipts grow the viewport
+    // until the outer DSH conversation owns the vertical scroll surface.
+    const nestedOverflow = Math.max(0, finite(metrics.nestedScrollableOverflowHeight ?? 0));
+    return Math.max(72, Math.ceil(bodyBottom + nestedOverflow));
+}
+// Real cards can legitimately be many screens tall, so the Host owns one
+// generous outer-scroll surface. Still cap a forged or broken resize receipt
+// before it can create a billion-pixel layout in the conversation.
+export function clampRichFrameHeight(value) {
+    if (!Number.isFinite(value))
+        return 72;
+    return Math.max(72, Math.min(40_000, Math.ceil(value)));
+}
+// The accepted SillyTavern reference profile exposes EjsTemplate as enabled.
+// Real-card environment checks read this exact public context path. Keeping the
+// compatibility value in one builder prevents the iframe bootstrap from
+// drifting into an incomplete, card-specific mock.
+export function buildSillyTavernCompatibilityContext(messageCount, currentMessageId) {
+    const safeCount = Number.isFinite(messageCount) ? Math.max(0, Math.trunc(messageCount)) : 0;
+    const safeMessageId = Number.isFinite(currentMessageId) ? Math.trunc(currentMessageId) : -1;
+    return {
+        chat: Array.from({ length: safeCount }, () => ({})),
+        chatId: safeMessageId,
+        extensionSettings: { EjsTemplate: { enabled: true } },
+    };
+}
+export function alignProjectedRoles(flowRoles, projectedRoles) {
+    const aligned = Array.from({ length: flowRoles.length }, () => null);
+    let projectedIndex = 0;
+    for (let flowIndex = 0; flowIndex < flowRoles.length && projectedIndex < projectedRoles.length; flowIndex += 1) {
+        if (flowRoles[flowIndex] !== projectedRoles[projectedIndex])
+            continue;
+        aligned[flowIndex] = projectedIndex;
+        projectedIndex += 1;
+    }
+    return projectedIndex === projectedRoles.length ? aligned : null;
+}
+export function splitRichMessage(text) {
+    if (rawHtmlDocument.test(text))
+        return [{ kind: "html", content: text.trim() }];
+    // Some real Tavern cards prepend a fenced <style> block to an opening whose
+    // document root is a custom element (for example <welcome>). Treat that
+    // combination as one frontend document so the style and markup share an
+    // iframe instead of leaking hundreds of HTML lines into native prose.
+    const fencedDocumentCount = [...text.matchAll(new RegExp(fencedHtml.source, fencedHtml.flags))].length
+        + [...text.matchAll(new RegExp(fencedUntypedHtmlDocument.source, fencedUntypedHtmlDocument.flags))].length;
+    if (fencedDocumentCount <= 1) {
+        const stitched = text
+            .replace(fencedHtml, (_match, content) => content)
+            // SillyTavern cards in the wild also fence complete HTML documents without
+            // an `html` language label. Only unwrap documents whose first tag proves
+            // their intent; ordinary untyped code fences remain prose/code.
+            .replace(fencedUntypedHtmlDocument, (_match, content) => content)
+            .trim();
+        if (htmlFragment.test(stitched))
+            return [{ kind: "html", content: stitched }];
+    }
+    const blocks = [];
+    const expression = new RegExp(fencedHtml.source, fencedHtml.flags);
+    let cursor = 0;
+    for (const match of text.matchAll(expression)) {
+        const index = match.index ?? cursor;
+        const before = text.slice(cursor, index).trim();
+        if (before.length > 0)
+            blocks.push({ kind: "prose", content: before });
+        blocks.push({ kind: "html", content: match[1] ?? "" });
+        cursor = index + match[0].length;
+    }
+    const after = text.slice(cursor).trim();
+    if (after.length > 0)
+        blocks.push({ kind: "prose", content: after });
+    if (blocks.length === 0)
+        blocks.push({ kind: "prose", content: text });
+    // Some Tavern display Regex rules deliberately open a visual wrapper when a
+    // control tag starts and rely on the shared SillyTavern message DOM to close
+    // it at the end of the message. An iframe boundary would otherwise close the
+    // wrapper before the following prose. Compose only that structural case;
+    // balanced authored fragments keep the ordinary native prose/iframe flow.
+    return stitchCrossBoundaryWrapper(blocks);
+}
+// The authored documents run in a sandboxed data document with a unique
+// origin. Rewrite only the well-known SillyTavern parent-window access points
+// used by the accepted real cards; ordinary parent.postMessage remains
+// untouched for resize notices.
+export function adaptRealCardFrontendHtml(value) {
+    return value
+        .replaceAll("window.parent.document", "window.__dshCompatDocument")
+        .replaceAll("window.top.document", "window.__dshCompatDocument")
+        .replaceAll("parent.document", "window.__dshCompatDocument")
+        .replaceAll("top.document", "window.__dshCompatDocument")
+        .replaceAll("window.parent?.SillyTavern", "window.__dshSillyTavern")
+        .replaceAll("window.top?.SillyTavern", "window.__dshSillyTavern")
+        .replaceAll("window.parent.SillyTavern", "window.__dshSillyTavern")
+        .replaceAll("window.top.SillyTavern", "window.__dshSillyTavern")
+        .replaceAll("window.parent?.TavernHelper", "window.__dshTavernHelper")
+        .replaceAll("window.top?.TavernHelper", "window.__dshTavernHelper")
+        .replaceAll("window.parent.TavernHelper", "window.__dshTavernHelper")
+        .replaceAll("window.top.TavernHelper", "window.__dshTavernHelper")
+        .replaceAll("window.parent?.Mvu", "window.__dshMvu")
+        .replaceAll("window.top?.Mvu", "window.__dshMvu")
+        .replaceAll("window.parent.Mvu", "window.__dshMvu")
+        .replaceAll("window.top.Mvu", "window.__dshMvu")
+        // Bundled card code sometimes aliases the frame first (`const host =
+        // window.top`) and only reads SillyTavern APIs afterwards. Keep resize
+        // postMessages pointed at the host, then collapse any remaining top/parent
+        // aliases to the compatibility globals installed inside the data document.
+        .replaceAll("window.parent.postMessage", "parent.postMessage")
+        .replace(/window\.(?:parent|top)(?![\w$])/gu, "window");
+}