@riemannre3/dsh-roleplay 0.1.3

package/lib/compatibility-call-runtime.js

@@ -0,0 +1,34 @@
+export const TAVERN_HELPER_COMPATIBILITY_VERSION = "4.9.3-dsh.1";
+const catalog = [
+    { surface: "TavernHelper", method: "getVariables", dshAction: "读取当前 Session 变量投影", effect: "只读" },
+    { surface: "TavernHelper", method: "getAllVariables", dshAction: "读取当前 Session 的 stat_data 投影", effect: "只读" },
+    { surface: "TavernHelper", method: "replaceVariables", dshAction: "原子替换当前 Session 变量状态", effect: "持久化写入" },
+    { surface: "TavernHelper", method: "insertOrAssignVariables", dshAction: "合并后原子提交当前 Session 变量状态", effect: "持久化写入" },
+    { surface: "TavernHelper", method: "getChatMessages", dshAction: "读取 DSH Session 消息与变量投影", effect: "只读" },
+    { surface: "TavernHelper", method: "setChatMessages", dshAction: "将首条 assistant 消息的 swipe 映射到当前 Session 开场", effect: "持久化写入" },
+    { surface: "TavernHelper", method: "generate", dshAction: "使用当前 Session 绑定生成辅助文本，不写入正式 Conversation", effect: "辅助模型生成" },
+    { surface: "TavernHelper", method: "getWorldbook", dshAction: "读取当前卡绑定的世界书投影", effect: "只读" },
+    { surface: "TavernHelper", method: "getWorldbookNames", dshAction: "读取当前卡世界书名称", effect: "只读" },
+    { surface: "TavernHelper", method: "getCharWorldbookNames", dshAction: "读取当前卡世界书绑定", effect: "只读" },
+    { surface: "TavernHelper", method: "updateWorldbookWith", dshAction: "提交当前 Session 的世界书启用覆盖", effect: "持久化写入" },
+    { surface: "TavernHelper", method: "replaceWorldbook", dshAction: "提交当前 Session 的世界书启用覆盖", effect: "持久化写入" },
+    { surface: "TavernHelper", method: "rebindCharWorldbooks", dshAction: "返回当前卡绑定投影，不改写卡片原件", effect: "本地执行" },
+    { surface: "TavernHelper", method: "createWorldbookEntries", dshAction: "仅返回兼容结果；DSH 当前不创建卡片世界书条目", effect: "本地执行" },
+    { surface: "TavernHelper", method: "eventOn", dshAction: "订阅当前隔离前端事件域", effect: "本地执行" },
+    { surface: "TavernHelper", method: "eventEmit", dshAction: "发布当前隔离前端事件", effect: "本地执行" },
+    { surface: "TavernHelper", method: "initializeGlobal", dshAction: "注册当前卡 companion 与消息 iframe 共享全局", effect: "本地执行" },
+    { surface: "TavernHelper", method: "waitGlobalInitialized", dshAction: "等待当前卡隔离运行域共享全局", effect: "本地执行" },
+    { surface: "TavernHelper", method: "triggerSlash", dshAction: "映射到 DSH 输入框草稿或正式消息提交", effect: "正式消息提交" },
+    { surface: "MVU", method: "variables", dshAction: "读取当前 Session 变量投影", effect: "只读" },
+    { surface: "MVU", method: "getMvuData", dshAction: "读取当前 Session 的 stat_data 投影", effect: "只读" },
+    { surface: "MVU", method: "replaceMvuData", dshAction: "原子替换当前 Session 变量状态", effect: "持久化写入" },
+    { surface: "SillyTavern", method: "getContext", dshAction: "读取当前 DSH Session 消息上下文投影", effect: "只读" },
+    { surface: "SillyTavern", method: "sendMessage", dshAction: "向当前 DSH Session 提交正式玩家消息", effect: "正式消息提交" },
+];
+export function compatibilityCallCatalog() {
+    return catalog.map((item) => ({ ...item }));
+}
+export function describeCompatibilityCall(surface, method) {
+    const found = catalog.find((item) => item.surface === surface && item.method === method);
+    return found === undefined ? undefined : { ...found };
+}

package/lib/ejs-runtime.js

@@ -0,0 +1,239 @@
+const nodeProcess = globalThis.process;
+const WorkerConstructor = nodeProcess.getBuiltinModule("node:worker_threads").Worker;
+const tag = /<%([_=#%-]?)([\s\S]*?)([_-]?)%>/gu;
+const prohibitedCode = /\b(?:require|process|window|document|globalThis|eval|Function|fetch|XMLHttpRequest|WebSocket|import|localStorage|sessionStorage)\b/u;
+const literalGetvar = /\bgetvar\s*\(\s*(["'])(.*?)\1/gu;
+export function literalEjsVariableRoots(template) {
+    const roots = new Set();
+    for (const match of template.matchAll(new RegExp(literalGetvar.source, literalGetvar.flags))) {
+        const parts = String(match[2] ?? "")
+            .replace(/\[([^\]]+)\]/gu, ".$1")
+            .split(".")
+            .map((part) => part.replace(/^["']|["']$/gu, ""))
+            .filter(Boolean);
+        if (parts[0]?.toLocaleLowerCase() === "stat_data")
+            parts.shift();
+        const root = parts[0];
+        if (root !== undefined && !["__proto__", "prototype", "constructor"].includes(root))
+            roots.add(root);
+    }
+    return [...roots];
+}
+function runtimeError(code, message, cause) {
+    return Object.assign(new Error(message, cause === undefined ? undefined : { cause }), { code });
+}
+function compileTemplate(template) {
+    const parts = [
+        "(()=>{let __out='';const __append=value=>{if(value!==undefined&&value!==null)__out+=String(value)};",
+    ];
+    let cursor = 0;
+    for (const match of template.matchAll(new RegExp(tag.source, tag.flags))) {
+        const index = match.index ?? cursor;
+        const open = match[1] ?? "";
+        const body = match[2] ?? "";
+        const close = match[3] ?? "";
+        let literal = template.slice(cursor, index);
+        if (open === "_")
+            literal = literal.replace(/\s+$/u, "");
+        if (literal.length > 0)
+            parts.push(`__append(${JSON.stringify(literal)});`);
+        if (open !== "#" && prohibitedCode.test(body))
+            throw runtimeError("ejs_invalid_template", "EJS 模板请求了未授权的宿主能力");
+        if (open === "=")
+            parts.push(`__append(__escape((${body})));`);
+        else if (open === "-")
+            parts.push(`__append((${body}));`);
+        else if (open === "#")
+            parts.push(";");
+        else if (open === "%")
+            parts.push(`__append(${JSON.stringify(`<%${body}${close}%>`)});`);
+        else
+            parts.push(`${body}\n`);
+        cursor = index + match[0].length;
+        if (close === "_") {
+            const whitespace = /^\s+/u.exec(template.slice(cursor));
+            cursor += whitespace?.[0].length ?? 0;
+        }
+        else if (close === "-") {
+            const newline = /^\r?\n/u.exec(template.slice(cursor));
+            cursor += newline?.[0].length ?? 0;
+        }
+    }
+    const tail = template.slice(cursor);
+    if (tail.length > 0)
+        parts.push(`__append(${JSON.stringify(tail)});`);
+    parts.push("return __out})()");
+    return parts.join("");
+}
+function batchProgram(templates, variables, context) {
+    const serializedVariables = JSON.stringify(variables);
+    if (serializedVariables === undefined)
+        throw runtimeError("ejs_invalid_template", "EJS 变量无法序列化");
+    const compiled = templates.map(compileTemplate).join(",\n");
+    return `(()=>{
+const __state=JSON.parse(${JSON.stringify(serializedVariables)});
+const __messageId=${Number.isFinite(context.messageId) ? Math.trunc(context.messageId) : -1};
+const __seed=${JSON.stringify(context.seed ?? "dsh-re3-rp-ejs")};
+const __missing=[];
+const __parts=path=>String(path??'').replace(/\\[([^\\]]+)\\]/g,'.$1').split('.').map(part=>part.replace(/^['"]|['"]$/g,'')).filter(Boolean);
+const __safe=parts=>parts.every(part=>part!=='__proto__'&&part!=='prototype'&&part!=='constructor');
+const __escape=value=>String(value??'').replace(/[&<>"']/g,character=>({'&':'&amp;','<':'&lt;','>':'&gt;','"':'&#34;',"'":'&#39;'}[character]));
+let __randomState=2166136261;for(const character of __seed){__randomState^=character.codePointAt(0)??0;__randomState=Math.imul(__randomState,16777619)}
+Math.random=()=>{__randomState+=0x6D2B79F5;let value=__randomState;value=Math.imul(value^(value>>>15),value|1);value^=value+Math.imul(value^(value>>>7),value|61);return((value^(value>>>14))>>>0)/4294967296};
+function getvar(path,options={}){const original=String(path??'');const parts=__parts(path);if(parts[0]?.toLowerCase()==='stat_data')parts.shift();if(!__safe(parts)){__missing.push(original);return options?.defaults}let current=__state;for(const part of parts){if(current===null||current===undefined||!Object.prototype.hasOwnProperty.call(Object(current),part)){__missing.push(original);return options?.defaults}current=current[part]}return current}
+function getLastMessageId(){return __messageId}
+const __outputs=[${compiled}];return {outputs:__outputs,missingVariables:Array.from(new Set(__missing))}
+})()`;
+}
+export async function createEjsRuntime(options = {}) {
+    const deadlineMs = Math.max(5, Math.min(5_000, options.deadlineMs ?? 50));
+    const memoryLimitBytes = Math.max(4 * 1024 * 1024, Math.min(256 * 1024 * 1024, options.memoryLimitBytes ?? 32 * 1024 * 1024));
+    const maxStackSizeBytes = Math.max(128 * 1024, Math.min(4 * 1024 * 1024, options.maxStackSizeBytes ?? 512 * 1024));
+    const maximumInputBytes = Math.max(64 * 1024, Math.min(64 * 1024 * 1024, options.maximumInputBytes ?? 256 * 1024));
+    const maximumOutputBytes = Math.max(64 * 1024, Math.min(64 * 1024 * 1024, options.maximumOutputBytes ?? 1024 * 1024));
+    const bytes = (value) => new TextEncoder().encode(value).byteLength;
+    let worker;
+    let nextRequestId = 0;
+    let queue = Promise.resolve();
+    let disposed = false;
+    const terminateWorker = async (target) => {
+        if (target === undefined)
+            return;
+        if (worker === target)
+            worker = undefined;
+        try {
+            await target.terminate();
+        }
+        catch { /* Worker may already have crashed. */ }
+    };
+    const ensureWorker = () => {
+        if (disposed)
+            throw runtimeError("ejs_render_failed", "EJS runtime 已关闭");
+        if (worker !== undefined)
+            return worker;
+        const created = new WorkerConstructor(new URL("./ejs-worker.js", import.meta.url), {
+            // `node --input-type=module -e` is useful for release probes, but the
+            // flag is invalid for a file-backed Worker and must not be inherited.
+            execArgv: [],
+        });
+        worker = created;
+        // Request listeners are intentionally short-lived. These lifecycle
+        // listeners remain attached so an idle crash is never an unhandled Worker
+        // error and the next render never reuses a dead cached Worker.
+        created.on("error", () => { if (worker === created)
+            worker = undefined; });
+        created.on("exit", () => { if (worker === created)
+            worker = undefined; });
+        // A forgotten plugin disposer must never keep the DSH process alive.
+        created.unref();
+        return created;
+    };
+    const runProgramNow = async (program) => {
+        const target = ensureWorker();
+        const id = ++nextRequestId;
+        return new Promise((resolve, reject) => {
+            let settled = false;
+            const settle = (handler) => {
+                if (settled)
+                    return;
+                settled = true;
+                clearTimeout(timer);
+                target.off("message", onMessage);
+                target.off("error", onError);
+                target.off("exit", onExit);
+                handler();
+            };
+            const onMessage = (response) => {
+                if (response?.id !== id)
+                    return;
+                settle(() => {
+                    if (response.ok === true)
+                        resolve(response.result);
+                    else
+                        reject(runtimeError("ejs_render_failed", `EJS 渲染失败：${String(response.error?.message ?? "worker error")}`));
+                });
+            };
+            const onError = (cause) => settle(() => {
+                void terminateWorker(target);
+                reject(runtimeError("ejs_render_failed", `EJS Worker 崩溃：${cause.message}`, cause));
+            });
+            const onExit = (code) => settle(() => {
+                void terminateWorker(target);
+                reject(runtimeError("ejs_render_failed", `EJS Worker 异常退出（${code}）`));
+            });
+            const timer = setTimeout(() => settle(() => {
+                void terminateWorker(target);
+                reject(runtimeError("ejs_timeout", "EJS 执行超过墙钟时间边界"));
+            }), Math.max(100, deadlineMs + 100));
+            target.on("message", onMessage);
+            target.once("error", onError);
+            target.once("exit", onExit);
+            target.postMessage({ id, program, deadlineMs, memoryLimitBytes, maxStackSizeBytes });
+        });
+    };
+    const runProgram = (program) => {
+        const scheduled = queue.then(() => runProgramNow(program), () => runProgramNow(program));
+        queue = scheduled.catch(() => undefined);
+        return scheduled;
+    };
+    const runtime = {
+        async render(templates, variables, context = {}) {
+            if (templates.some((template) => typeof template !== "string"))
+                throw runtimeError("ejs_invalid_template", "EJS 模板必须是字符串");
+            const inputBytes = templates.reduce((total, template) => total + bytes(template), 0);
+            if (inputBytes > maximumInputBytes)
+                throw runtimeError("ejs_invalid_template", `EJS 模板超过 ${maximumInputBytes} bytes 安全边界`);
+            // Each evalCode call inside the worker creates a fresh QuickJS
+            // runtime/context. Keeping the WASM host in a terminable Worker also
+            // contains implementation-level aborts instead of risking the DSH loop.
+            const rendered = [];
+            for (const [index, template] of templates.entries()) {
+                const program = batchProgram([template], variables, { ...context, seed: `${context.seed ?? "dsh-re3-rp-ejs"}:${index}` });
+                let result;
+                try {
+                    result = await runProgram(program);
+                }
+                catch (cause) {
+                    const message = cause instanceof Error
+                        ? cause.message
+                        : typeof cause === "object" && cause !== null && typeof cause.message === "string"
+                            ? cause.message
+                            : String(cause);
+                    if (/interrupted/iu.test(message))
+                        throw runtimeError("ejs_timeout", "EJS 执行超过时间边界", cause);
+                    if (/memory|allocation|out of memory/iu.test(message))
+                        throw runtimeError("ejs_memory_limit", "EJS 执行超过内存边界", cause);
+                    throw runtimeError("ejs_render_failed", `EJS 渲染失败：${message}`, cause);
+                }
+                const resultObject = typeof result === "object" && result !== null ? result : undefined;
+                if (!Array.isArray(resultObject?.outputs) || resultObject.outputs.length !== 1 || typeof resultObject.outputs[0] !== "string") {
+                    throw runtimeError("ejs_render_failed", "EJS 渲染结果形状无效");
+                }
+                if (Array.isArray(resultObject.missingVariables) && context.missingVariables !== undefined) {
+                    context.missingVariables.push(...resultObject.missingVariables.filter((value) => typeof value === "string"));
+                }
+                rendered.push(resultObject.outputs[0]);
+            }
+            const outputBytes = rendered.reduce((total, value) => total + bytes(value), 0);
+            if (outputBytes > maximumOutputBytes)
+                throw runtimeError("ejs_memory_limit", `EJS 输出超过 ${maximumOutputBytes} bytes 安全边界`);
+            if (rendered.some((value) => /<%|%>/u.test(value)))
+                throw runtimeError("ejs_unresolved", "EJS 渲染后仍有未解析标签");
+            return rendered;
+        },
+        async dispose() {
+            disposed = true;
+            await terminateWorker(worker);
+        },
+    };
+    try {
+        const selfTest = await runtime.render(["<%= 6 * 7 %>"], {}, { seed: "dsh-re3-rp-ejs-self-test" });
+        if (selfTest[0] !== "42")
+            throw runtimeError("ejs_render_failed", "EJS runtime 自检结果错误");
+    }
+    catch (error) {
+        await runtime.dispose();
+        throw error;
+    }
+    return runtime;
+}

package/lib/ejs-worker.js

@@ -0,0 +1,33 @@
+import variant from "@jitl/quickjs-wasmfile-release-sync";
+import { newQuickJSWASMModuleFromVariant, shouldInterruptAfterDeadline } from "quickjs-emscripten-core";
+const parentPort = globalThis.process.getBuiltinModule("node:worker_threads").parentPort;
+if (parentPort === null)
+    throw new Error("EJS QuickJS worker 缺少 parentPort");
+const quickJS = await newQuickJSWASMModuleFromVariant(variant);
+parentPort.on("message", (request) => {
+    let response;
+    try {
+        response = {
+            id: request.id,
+            ok: true,
+            result: quickJS.evalCode(request.program, {
+                memoryLimitBytes: request.memoryLimitBytes,
+                maxStackSizeBytes: request.maxStackSizeBytes,
+                shouldInterrupt: shouldInterruptAfterDeadline(Date.now() + request.deadlineMs),
+            }),
+        };
+    }
+    catch (cause) {
+        const message = cause instanceof Error
+            ? cause.message
+            : typeof cause === "object" && cause !== null
+                ? JSON.stringify(cause)
+                : String(cause);
+        response = {
+            id: request.id,
+            ok: false,
+            error: { message },
+        };
+    }
+    parentPort.postMessage(response);
+});

package/lib/frontend-runtime.js

@@ -0,0 +1,352 @@
+const CASE_CONTAINERS = {
+    "html-css-display": { runtimeClass: "message_html_css", container: "message-html" },
+    "message-action": { runtimeClass: "message_iframe", container: "message-iframe" },
+    "background-state-panel": { runtimeClass: "background_script_and_message_iframe", container: "message-iframe" },
+    "standalone-host-bridge": { runtimeClass: "standalone_app", container: "standalone" },
+    "required-remote-asset": { runtimeClass: "cross_origin_required_asset", container: "required-asset" },
+};
+const MIXED_MESSAGE_CASES = {
+    "opening-inline-action": { runtimeClass: "formal_message_mixed_projection", capabilities: ["submit_turn"] },
+    "generated-multi-fragment": { runtimeClass: "generated_multi_fragment_projection", capabilities: [] },
+};
+function object(value) {
+    return typeof value === "object" && value !== null && !Array.isArray(value) ? value : undefined;
+}
+function stringArray(value) {
+    return Array.isArray(value) ? value.filter((item) => typeof item === "string") : [];
+}
+function regexDepth(value, minimum) {
+    return typeof value === "number" && Number.isFinite(value) && Number.isInteger(value) && value >= minimum ? value : null;
+}
+export function frontendDefinitionFromExtensions(value) {
+    const extensions = object(value);
+    const suiteId = typeof extensions?.suite_id === "string" ? extensions.suite_id : "";
+    const caseId = typeof extensions?.suite_case_id === "string" ? extensions.suite_case_id : "";
+    const cardId = typeof extensions?.card_id === "string" ? extensions.card_id : "";
+    const fixed = CASE_CONTAINERS[caseId];
+    const mixed = MIXED_MESSAGE_CASES[caseId];
+    if (cardId.length === 0)
+        return undefined;
+    const declaredRuntime = typeof extensions?.runtime_class === "string" ? extensions.runtime_class : "";
+    if (suiteId === "tavern-mixed-message" && mixed !== undefined && declaredRuntime === mixed.runtimeClass) {
+        return {
+            suiteId,
+            caseId,
+            cardId,
+            runtimeClass: mixed.runtimeClass,
+            container: "message-iframe",
+            requiredCapabilities: mixed.capabilities,
+        };
+    }
+    if (suiteId !== "frontend-runtime" || fixed === undefined || declaredRuntime !== fixed.runtimeClass)
+        return undefined;
+    return {
+        suiteId,
+        caseId,
+        cardId,
+        runtimeClass: fixed.runtimeClass,
+        container: fixed.container,
+        requiredCapabilities: stringArray(extensions?.required_capabilities),
+        ...(typeof extensions?.frontend_entry === "string" ? { frontendEntry: extensions.frontend_entry } : {}),
+    };
+}
+export function bridgeCapabilities(definition) {
+    const common = ["connect", "projection.read", "events.read"];
+    if (definition.caseId === "message-action" || (definition.suiteId === "tavern-mixed-message" && definition.caseId === "opening-inline-action"))
+        return [...common, "turn.submit"];
+    if (definition.caseId === "background-state-panel")
+        return [...common, "state.submit", "state.subscribe"];
+    if (definition.caseId === "standalone-host-bridge")
+        return [...common, "turn.submit", "events.subscribe"];
+    if (definition.caseId === "required-remote-asset")
+        return [...common, "asset.resolve"];
+    return common;
+}
+function parseRegexLiteral(value) {
+    if (!value.startsWith("/"))
+        return value.length === 0 ? undefined : { pattern: value, flags: "g" };
+    let closing = -1;
+    for (let index = value.length - 1; index > 0; index -= 1) {
+        if (value[index] !== "/")
+            continue;
+        let escapes = 0;
+        for (let cursor = index - 1; cursor >= 0 && value[cursor] === "\\"; cursor -= 1)
+            escapes += 1;
+        if (escapes % 2 === 0) {
+            closing = index;
+            break;
+        }
+    }
+    if (closing < 1)
+        return undefined;
+    const flags = value.slice(closing + 1);
+    if (!/^[dgimsuvy]*$/u.test(flags))
+        return undefined;
+    return { pattern: value.slice(1, closing), flags };
+}
+export function messageRegexScriptsFromExtensions(value) {
+    const extensions = object(value);
+    const values = Array.isArray(extensions?.regex_scripts) ? extensions.regex_scripts : Array.isArray(extensions?.regex) ? extensions.regex : [];
+    return values.flatMap((entry, index) => {
+        const script = object(entry);
+        // SillyTavern runs a rule in the Markdown/display pass whenever
+        // markdownOnly is true, even if promptOnly is also true. Empty replacement
+        // strings are meaningful hide rules and must not be discarded.
+        if (script === undefined || script.disabled === true || script.markdownOnly !== true)
+            return [];
+        const placements = Array.isArray(script.placement) ? script.placement.filter((item) => Number.isInteger(item)) : [];
+        if (!placements.includes(2))
+            return [];
+        const source = typeof script.findRegex === "string" ? script.findRegex : typeof script.find_regex === "string" ? script.find_regex : "";
+        const parsed = parseRegexLiteral(source);
+        const replacement = typeof script.replaceString === "string" ? script.replaceString : typeof script.replace_string === "string" ? script.replace_string : "";
+        if (parsed === undefined)
+            return [];
+        try {
+            new RegExp(parsed.pattern, parsed.flags);
+        }
+        catch {
+            return [];
+        }
+        return [{
+                id: typeof script.id === "string" ? script.id : `regex-${index}`,
+                name: typeof script.scriptName === "string" && script.scriptName.trim().length > 0 ? script.scriptName.trim() : `正则规则 ${index + 1}`,
+                pattern: parsed.pattern,
+                flags: parsed.flags,
+                replacement,
+                placements,
+                minDepth: regexDepth(script.minDepth, -1),
+                maxDepth: regexDepth(script.maxDepth, 0),
+                runOnEdit: script.runOnEdit !== false,
+                promptOnly: script.promptOnly === true,
+            }];
+    });
+}
+export function projectMessageRegex(text, scripts, macroValues, depth) {
+    const projected = scripts.reduce((value, script) => {
+        if (typeof depth === "number" && script.minDepth !== null && depth < script.minDepth)
+            return value;
+        if (typeof depth === "number" && script.maxDepth !== null && depth > script.maxDepth)
+            return value;
+        return value.replace(new RegExp(script.pattern, script.flags), (match, ...args) => {
+            const groups = typeof args.at(-1) === "object" ? args.at(-1) : undefined;
+            const captures = args.slice(0, groups === undefined ? -2 : -3);
+            // SillyTavern's Regex extension intentionally supports only $0/$1... and
+            // named $<group> references. Treating JavaScript's wider $&/$$/$`/$'
+            // replacement vocabulary as tokens corrupts bundled card scripts.
+            const replacement = script.replacement.replace(/\{\{match\}\}/giu, "$0");
+            const replaced = replacement.replace(/\$(\d+)|\$<([^>]+)>/gu, (_token, numeric, named) => {
+                const capture = numeric === undefined ? groups?.[named ?? ""] : Number(numeric) === 0 ? match : captures[Number(numeric) - 1];
+                return typeof capture === "string" ? capture : "";
+            });
+            if (replaced.length === 0)
+                return "";
+            const trimmed = replaced.trim();
+            const existingFence = /^```(?:html|text)?[ \t]*\r?\n([\s\S]*?)\r?\n```$/iu.exec(trimmed);
+            const candidate = existingFence?.[1] ?? replaced;
+            return /<(?:!doctype|html|head|body|style|script|div|section|details|button|[a-z][\w:-]*\b)/iu.test(candidate)
+                ? `\n\n\`\`\`html\n${candidate}\n\`\`\`\n\n`
+                : replaced;
+        });
+    }, text);
+    return macroValues === undefined ? projected : substituteCardMacros(projected, macroValues);
+}
+export function stripInitvarForDisplay(text) {
+    return text
+        .replace(/<initvar\b[^>]*>[\s\S]*?<\/initvar>/giu, "")
+        .replace(/^(?:[ \t]*\r?\n)+/u, "")
+        .trimEnd();
+}
+// Card control protocols belong to the variable/runtime plane, not the
+// player-visible conversation. Card Regex gets first refusal so an author can
+// deliberately render a status panel; only residue that no card projection
+// consumed is removed here.
+export function stripAssistantControlForDisplay(text) {
+    const withoutReasoning = text.replace(/<(?:think|reasoning)\b[^>]*>[\s\S]*?<\/(?:think|reasoning)>/giu, "");
+    const withoutStandaloneAnalysis = withoutReasoning.replace(/<Analysis\b[^>]*>[\s\S]*?<\/Analysis>/giu, "");
+    const withoutUpdates = withoutStandaloneAnalysis.replace(/<UpdateVariable\b[^>]*>[\s\S]*?<\/UpdateVariable>/giu, "");
+    const opening = /^\s*\[开局\]([\s\S]*?)\[\/开局\]\s*$/u.exec(withoutUpdates);
+    const visible = opening === null ? withoutUpdates : opening[1] ?? "";
+    return visible.replace(/^(?:[ \t]*\r?\n)+/u, "").trimEnd();
+}
+export function stripHtmlFence(value) {
+    const trimmed = value.trim();
+    const fenced = /^```html\s*\n([\s\S]*?)\n```$/iu.exec(trimmed);
+    return fenced?.[1] ?? trimmed;
+}
+function bridgeBootstrap(sessionId) {
+    const encodedSession = JSON.stringify(sessionId).replace(/<\//gu, "<\\/");
+    return `<script>
+(() => {
+  const sessionId = ${encodedSession};
+  const listeners = new Set();
+  const failure = (body, fallback) => Object.assign(new Error(body?.error?.message || body?.error || fallback), { code: body?.error?.code || fallback });
+  async function call(method, payload = {}) {
+    const response = await fetch('/dsh-re3-rp/bridge', {
+      method: 'POST',
+      headers: { 'content-type': 'application/json; charset=utf-8' },
+      body: JSON.stringify({ sessionId, method, payload, operationId: payload.operationId })
+    });
+    const body = await response.json().catch(() => ({}));
+    if (!response.ok || body.ok !== true) throw failure(body, 'bridge_unavailable');
+    return body.result;
+  }
+  window.__dshTavernSubmitHost = Object.freeze({
+    bridgeVersion: 'dsh-roleplay-v1',
+    submitTurn: payload => call('submitTurn', payload)
+  });
+  window.__dshTavernStateHost = Object.freeze({
+    bridgeVersion: 'dsh-roleplay-v1',
+    async getProjection() {
+      const projection = await call('getProjection');
+      return { ...projection.state, state_digest: projection.stateDigest };
+    },
+    subscribe(listener) { listeners.add(listener); return () => listeners.delete(listener); },
+    async submitStateAction(payload) {
+      const result = await call('submitStateAction', payload);
+      const projection = { ...result.projection.state, state_digest: result.projection.stateDigest };
+      const event = { type: 'state_committed', operationId: payload.operationId, projection };
+      for (const listener of listeners) listener(event);
+      return event;
+    }
+  });
+})();
+</script>`;
+}
+export function adaptOpeningFrontendHtml(opening, sessionId, definition) {
+    let body = stripHtmlFence(opening);
+    if (definition.caseId === "message-action")
+        body = body.replaceAll("window.parent.frontendTestHost", "window.__dshTavernSubmitHost");
+    if (definition.caseId === "background-state-panel")
+        body = body.replaceAll("window.parent.frontendTestStateHost", "window.__dshTavernStateHost");
+    const bootstrap = definition.container === "message-iframe" ? bridgeBootstrap(sessionId) : "";
+    return `<!doctype html><html lang="zh-CN"><head><meta charset="utf-8"><meta name="viewport" content="width=device-width,initial-scale=1"></head><body>${bootstrap}${body}</body></html>`;
+}
+function messageText(message) {
+    if (typeof message?.content === "string")
+        return message.content;
+    if (!Array.isArray(message?.content))
+        return "";
+    return message.content.filter((part) => part?.type === "text" && typeof part.text === "string").map((part) => part.text).join("\n");
+}
+const CONVENTIONAL_STATUS_SLOT = "<StatusPlaceHolderImpl/>";
+function isConventionalStatusFrontendScript(script) {
+    if (!script.pattern.includes("StatusPlaceHolderImpl"))
+        return false;
+    if (!/<(?:!doctype|html|head|body|style|script|div|section|details|button|[a-z][\w:-]*\b)/iu.test(script.replacement))
+        return false;
+    try {
+        return new RegExp(script.pattern, script.flags).test(CONVENTIONAL_STATUS_SLOT);
+    }
+    catch {
+        return false;
+    }
+}
+function hasConventionalStatusFrontend(scripts) {
+    return scripts.some(isConventionalStatusFrontendScript);
+}
+function assistantDisplayProjection(text, scripts, afterPlayerTurn) {
+    // TavernHelper cards use the same display slot for both inline MVU replies
+    // and split-step MVU replies whose secondary updater runs outside the prose
+    // response. For a DSH-synthesized slot, keep the rich status renderer while
+    // excluding validation/cleanup Regex that treat a missing inline block as an
+    // error. The formal Session reply remains byte-for-byte unchanged.
+    const hasVariableUpdate = /<UpdateVariable\b[^>]*>[\s\S]*?<\/UpdateVariable>/iu.test(text);
+    if (!afterPlayerTurn || text.includes(CONVENTIONAL_STATUS_SLOT) || !hasConventionalStatusFrontend(scripts)) {
+        return { source: text, scripts };
+    }
+    return {
+        source: `${text}\n\n${CONVENTIONAL_STATUS_SLOT}`,
+        scripts: hasVariableUpdate
+            ? scripts
+            : scripts.filter((script) => !script.pattern.includes("StatusPlaceHolderImpl") || isConventionalStatusFrontendScript(script)),
+    };
+}
+export function projectFrontendMessages(session, regexScripts = [], macroValues) {
+    const nodes = Array.isArray(session?.surface?.nodes) ? session.surface.nodes : [];
+    const formalNodes = nodes.filter((seq) => {
+        const event = session?.events?.[seq];
+        if (event?.type !== "user/message" && event?.type !== "assistant/message")
+            return false;
+        const message = event.data?.message ?? event.data;
+        return message?.source?.kind !== "plugin" && messageText(message).length > 0;
+    });
+    return formalNodes.flatMap((seq, nodeIndex) => {
+        const event = session?.events?.[seq];
+        const message = event.data?.message ?? event.data;
+        const text = messageText(message);
+        const role = event.type === "user/message" ? "user" : "assistant";
+        const isCardOpening = (message?.source?.provider === "dsh-roleplay" || message?.source?.provider === "dsh-re3-rp") && message?.source?.model === "character-card-opening";
+        const afterPlayerTurn = role === "assistant" && !isCardOpening && formalNodes.slice(0, nodeIndex).some((candidateSeq) => session?.events?.[candidateSeq]?.type === "user/message");
+        const display = role === "assistant"
+            ? assistantDisplayProjection(text, regexScripts, afterPlayerTurn)
+            : { source: text, scripts: regexScripts };
+        const depth = formalNodes.length - nodeIndex - 1;
+        const projected = role === "assistant"
+            ? stripAssistantControlForDisplay(projectMessageRegex(stripInitvarForDisplay(display.source), display.scripts, macroValues, depth))
+            : text;
+        return [{ seq, role, text: projected, ...(projected === text ? {} : { rawText: text }) }];
+    });
+}
+export async function waitForCommittedFrontendTurn(options) {
+    const deadline = Date.now() + (options.timeoutMs ?? 10_000);
+    const pollIntervalMs = options.pollIntervalMs ?? 20;
+    do {
+        const messages = options.readMessages();
+        const user = messages.find((message) => message.seq > options.afterSeq && message.role === "user" && message.text === options.userText);
+        const assistant = messages.find((message) => message.seq > (user?.seq ?? Number.MAX_SAFE_INTEGER) && message.role === "assistant");
+        if (user !== undefined && assistant !== undefined) {
+            // Persist only after the complete turn is visible. Repeated flushes while
+            // rc.2 is still projecting the turn can contend with the agent's own
+            // session commit and delay the projection until this request returns.
+            await options.flush();
+            const durableMessages = options.readMessages();
+            const durableUser = durableMessages.find((message) => message.seq > options.afterSeq && message.role === "user" && message.text === options.userText);
+            const durableAssistant = durableMessages.find((message) => message.seq > (durableUser?.seq ?? Number.MAX_SAFE_INTEGER) && message.role === "assistant");
+            if (durableUser !== undefined && durableAssistant !== undefined)
+                return { user: durableUser, assistant: durableAssistant };
+        }
+        if (Date.now() >= deadline)
+            return undefined;
+        await new Promise((resolve) => setTimeout(resolve, pollIntervalMs));
+    } while (true);
+}
+// DSH renders adjacent formal assistant messages as one assistant-step. Keep
+// the formal Session messages separate everywhere else, but mirror that native
+// grouping at the DOM projection seam so one verification/oracle message cannot
+// disable rich rendering for the entire conversation.
+export function groupFrontendMessagesForNativeFlow(messages) {
+    const grouped = [];
+    for (const message of messages) {
+        const previous = grouped.at(-1);
+        if (previous === undefined || previous.role !== message.role || message.role !== "assistant") {
+            grouped.push({ ...message });
+            continue;
+        }
+        const visible = [previous.text, message.text].filter((value) => value.length > 0).join("\n\n");
+        const requiresAdaptation = previous.rawText !== undefined || message.rawText !== undefined;
+        const raw = [previous.rawText ?? previous.text, message.rawText ?? message.text].filter((value) => value.length > 0).join("\n\n");
+        previous.text = visible;
+        if (requiresAdaptation)
+            previous.rawText = raw;
+    }
+    return grouped;
+}
+export function applyFrontendStateAction(caseId, state, payload) {
+    if (caseId !== "background-state-panel")
+        throw Object.assign(new Error("当前卡没有确定性状态动作权限"), { code: "capability_denied" });
+    if (payload.action !== "select_lamp_group" || (payload.value !== "main" && payload.value !== "backup")) {
+        throw Object.assign(new Error("只允许选择 main 或 backup 灯组"), { code: "capability_denied" });
+    }
+    return { ...state, lamp_group: payload.value };
+}
+export function frontendStateDigest(caseId, state) {
+    if (caseId === "background-state-panel")
+        return `lamp-group:${state.lamp_group ?? "main"}`;
+    return `frontend:${caseId}:empty`;
+}
+export function initialFrontendState(caseId) {
+    return caseId === "background-state-panel" ? { lamp_group: "main" } : {};
+}
+import { substituteCardMacros } from "./worldbook.js";
+export { adaptRealCardFrontendHtml } from "./rich-message.js";