酒馆拆解的维护记录

// Node 模块加载钩子：原样加载酒馆的源码文件，只把指定的依赖模块换成桩。
// 桩模块的导出名 = 全仓库实际 import 了它哪些名字；stubs/<相对 public 的路径>.mjs 里手写了的用手写的，其余给空桩。
import { pathToFileURL, fileURLToPath } from 'node:url';
import fs from 'node:fs';
import path from 'node:path';

const HARNESS = path.dirname(fileURLToPath(import.meta.url));
const ST = process.env.ST_ROOT;
const PUB = path.join(ST, 'public');
const SRC = path.join(ST, 'src');
const STUB_DIR = path.join(HARNESS, 'stubs');
const SHIMS_URL = pathToFileURL(path.join(HARNESS, 'shims.mjs')).href;
const BARE_PARENT = pathToFileURL(path.join(HARNESS, 'package.json')).href;

// public/ 下只有 ST_REAL 列出的模块原样加载，其余一律换成桩；src/ 下只有 ST_STUBS 列出的换成桩
const REAL_FILE = path.join(HARNESS, 'real.txt');
const REAL = new Set([
    ...(process.env.ST_REAL || '').split(','),
    ...(fs.existsSync(REAL_FILE) ? fs.readFileSync(REAL_FILE, 'utf8').split('\n').map(s => s.replace(/#.*$/, '').trim()) : []),
].filter(Boolean));
const SRC_STUBS = new Set(['src/util.js', ...(process.env.ST_STUBS || '').split(',').filter(Boolean)]);
const STUBBED = {
    has(rel) {
        if (rel.startsWith('public' + path.sep)) return !REAL.has(rel);
        return SRC_STUBS.has(rel);
    },
};

function isBare(s) {
    return !(s.startsWith('.') || s.startsWith('/') || s.startsWith('node:') || s.startsWith('file:') || s.startsWith('data:'));
}

// ---------- 扫描：每个模块被 import 了哪些名字 ----------
let importMap = null;
function walk(dir, out = []) {
    for (const e of fs.readdirSync(dir, { withFileTypes: true })) {
        if (e.name === 'node_modules' || e.name.startsWith('.')) continue;
        const p = path.join(dir, e.name);
        if (e.isDirectory()) walk(p, out);
        else if (e.name.endsWith('.js')) out.push(p);
    }
    return out;
}
function resolveSpec(fromFile, spec) {
    if (spec.startsWith('/')) return path.join(PUB, spec);
    if (spec.startsWith('.')) return path.resolve(path.dirname(fromFile), spec);
    return null;
}
function buildImportMap() {
    const map = new Map();
    const add = (target, name) => {
        if (!map.has(target)) map.set(target, new Set());
        map.get(target).add(name);
    };
    const files = [...walk(path.join(PUB, 'scripts')), path.join(PUB, 'script.js'), ...walk(SRC)];
    const re = /(?:import|export)\s+([\s\S]*?)\s+from\s+['"]([^'"]+)['"]/g;
    for (const f of files) {
        const text = fs.readFileSync(f, 'utf8');
        for (const m of text.matchAll(re)) {
            const clause = m[1];
            const target = resolveSpec(f, m[2]);
            if (!target) continue;
            if (/^[\s\S]*\*\s+as\s+\w+/.test(clause) && !clause.includes('{')) { add(target, '*'); continue; }
            const braces = clause.match(/\{([\s\S]*?)\}/);
            if (braces) {
                for (let part of braces[1].split(',')) {
                    part = part.replace(/\/\/.*$/gm, '').replace(/\/\*[\s\S]*?\*\//g, '').trim();
                    if (!part) continue;
                    part = part.replace(/^type\s+/, '');
                    const name = part.split(/\s+as\s+/)[0].trim();
                    if (/^[A-Za-z_$][\w$]*$/.test(name)) add(target, name === 'default' ? 'default' : name);
                }
            }
            const head = clause.replace(/\{[\s\S]*?\}/, '').replace(/,/g, ' ').trim();
            if (/^[A-Za-z_$][\w$]*$/.test(head) && !clause.startsWith('*') && m[0].startsWith('import')) add(target, 'default');
        }
    }
    return map;
}

function exportedNames(file, seen = new Set()) {
    const names = new Set();
    if (!fs.existsSync(file) || seen.has(file)) return names;
    seen.add(file);
    const text = fs.readFileSync(file, 'utf8');
    for (const m of text.matchAll(/export\s+(?:async\s+)?(?:const|let|var|function\*?|class)\s+([A-Za-z_$][\w$]*)/g)) names.add(m[1]);
    for (const m of text.matchAll(/export\s*\{([^}]*)\}(?!\s*from)/g)) {
        for (const p of m[1].split(',')) {
            const n = p.trim().split(/\s+as\s+/).pop().trim();
            if (n) names.add(n);
        }
    }
    for (const m of text.matchAll(/export\s*\{([^}]*)\}\s*from/g)) {
        for (const p of m[1].split(',')) {
            const n = p.trim().split(/\s+as\s+/).pop().trim();
            if (n) names.add(n);
        }
    }
    for (const m of text.matchAll(/export\s*\*\s*from\s*['"]([^'"]+)['"]/g)) {
        const target = m[1].startsWith('.') ? path.resolve(path.dirname(file), m[1]) : m[1];
        for (const n of exportedNames(target, seen)) if (n !== 'default') names.add(n);
    }
    if (/export\s+default\s/.test(text)) names.add('default');
    return names;
}

function wantedMissing(target) {
    importMap ??= buildImportMap();
    const rel = path.relative(ST, target);
    const overrideFile = path.join(STUB_DIR, rel + '.mjs');
    const have = exportedNames(overrideFile);
    const wanted = importMap.get(target) || new Set();
    return { rel, overrideFile, have, missing: [...wanted].filter(n => n !== '*' && n !== 'default' && !have.has(n)), wantsDefault: wanted.has('default') };
}

function genStub(target) {
    const { rel, overrideFile, have, wantsDefault } = wantedMissing(target);
    const lines = [];
    if (fs.existsSync(overrideFile)) lines.push(`export * from ${JSON.stringify(pathToFileURL(overrideFile).href)};`);
    lines.push(`export * from ${JSON.stringify('ststub-auto:' + target)};`);
    if (have.has('default')) lines.push(`export { default } from ${JSON.stringify(pathToFileURL(overrideFile).href)};`);
    else if (wantsDefault) lines.push(`export { default } from ${JSON.stringify('ststub-auto:' + target)};`);
    return lines.join('\n');
}

// 自动空桩单独成模块，只依赖 shims：循环依赖里先被读到也不会卡在初始化之前
function genAuto(target) {
    const { rel, have, missing, wantsDefault } = wantedMissing(target);
    const lines = [`import { anyStub as __any } from ${JSON.stringify(SHIMS_URL)};`];
    for (const n of missing) lines.push(`export const ${n} = __any(${JSON.stringify(rel + ':' + n)});`);
    if (wantsDefault && !have.has('default')) lines.push(`export default __any(${JSON.stringify(rel + ':default')});`);
    return lines.join('\n');
}

export async function resolve(specifier, context, nextResolve) {
    if (specifier.startsWith('ststub-auto:')) return { url: specifier, shortCircuit: true, format: 'module' };
    const parent = context.parentURL?.startsWith('file:') ? fileURLToPath(context.parentURL) : '';
    const inST = parent.startsWith(ST);
    if (inST && specifier.startsWith('/') && !specifier.startsWith(ST)) {
        specifier = pathToFileURL(path.join(PUB, specifier)).href;
    }
    if ((inST || parent.startsWith(STUB_DIR)) && isBare(specifier)) {
        return nextResolve(specifier, { ...context, parentURL: BARE_PARENT });
    }
    const r = await nextResolve(specifier, context);
    if (r.url.startsWith('file:')) {
        const file = fileURLToPath(r.url);
        if (file.startsWith(ST) && STUBBED.has(path.relative(ST, file))) {
            return { url: 'ststub:' + file, shortCircuit: true, format: 'module' };
        }
    }
    return r;
}

export async function load(url, context, nextLoad) {
    if (url.startsWith('ststub-auto:')) {
        return { format: 'module', source: genAuto(url.slice('ststub-auto:'.length)), shortCircuit: true };
    }
    if (url.startsWith('ststub:')) {
        return { format: 'module', source: genStub(url.slice('ststub:'.length)), shortCircuit: true };
    }
    return nextLoad(url, context);
}

// 生成三个桩模块，里面的函数全部从酒馆源码按名字原样切出（extract.mjs），一字不改：
//   stubs/public/script-state.mjs      script.js 的常量和模块级状态（单独成模块，没有 import，循环依赖时先初始化）
//   stubs/public/script.js.mjs         script.js 里用得到的函数；纯界面的几个（渲染消息、图片附件）换成空函数
//   stubs/public/scripts/group-chats.js.mjs  群聊调度函数（原文件没有导出它们）
// script.js / group-chats.js 一加载就要整个前端（顶层等 document ready、操作 DOM），所以不能直接 import。
import fs from 'node:fs';
import path from 'node:path';
import { extractDecls } from './extract.mjs';

const ST = process.env.ST_ROOT;
const PUB = path.join(ST, 'public');
const HERE = path.dirname(new URL(import.meta.url).pathname);
const P = (rel) => JSON.stringify(path.join(PUB, rel));
const listing = (file, decls) => `// 原样切自 ${file}（行号是原文件的）：\n` + decls.map(d => `//   ${d.name}  ${d.startLine}-${d.endLine}`).join('\n');

// ---------- script-state.mjs ----------
const CONSTS = ['neutralCharacterName', 'extension_prompt_types', 'extension_prompt_roles', 'MAX_INJECTION_DEPTH', 'talkativeness_default',
    'depth_prompt_depth_default', 'depth_prompt_role_default', 'default_avatar', 'system_avatar'];
const constDecls = [
    ...extractDecls(path.join(PUB, 'scripts/system-messages.js'), ['system_message_types']),
    ...extractDecls(path.join(PUB, 'script.js'), CONSTS),
];
const STATE = {
    name1: '\'User\'', name2: '\'SillyTavern System\'', chat: '[]', characters: '[]', this_chid: 'undefined',
    chat_metadata: '{}', extension_prompts: '{}', main_api: '\'openai\'', online_status: '\'no_connection\'',
    user_avatar: '\'user-default.png\'', is_send_press: 'false', generation_started: 'new Date()',
    max_context: '8192', amount_gen: '350',
};
fs.writeFileSync(path.join(HERE, 'stubs/public/script-state.mjs'),
    `// 自动生成，勿手改。script.js 的常量和模块级状态；实跑脚本用 __set 改状态。\n${listing('public/script.js 与 public/scripts/system-messages.js', constDecls)}\n`
    + constDecls.map(d => d.text).join('\n') + '\n\n'
    + Object.entries(STATE).map(([k, v]) => `export let ${k} = ${v};`).join('\n') + '\n'
    + `export function __set(key, value) {\n    switch (key) {\n${Object.keys(STATE).map(k => `        case '${k}': ${k} = value; break;`).join('\n')}\n        default: throw new Error('unknown key ' + key);\n    }\n}\n`);

// ---------- script.js.mjs ----------
const fromScript = extractDecls(path.join(PUB, 'script.js'), [
    'getCurrentChatId', 'substituteParams', 'addPersonaDescriptionExtensionPrompt', 'getAllExtensionPrompts',
    'getExtensionPromptByName', 'getExtensionPromptMaxDepth', 'getExtensionPrompt', 'baseChatReplace',
    'createLazyFields', 'getCharacterCardFieldsLazy', 'getCharacterCardFields', 'parseMesExamples',
    'extractMessageBias', 'getBiasStrings', 'flushWIInjections', 'setExtensionPrompt',
    'getExtensionPromptRoleByName', 'removeDepthPrompts', 'syncMesToSwipe', 'syncSwipeToMes', 'ensureSwipes',
    'getMaxContextTokens', 'getMaxResponseTokens', 'getMaxPromptTokens',
    'saveReply', 'cleanUpMessage', 'cleanGroupMessage', 'getStoppingStrings', 'extractMessageFromData',
    'getGeneratingApi', 'getGeneratingModel', 'doChatInject', 'getFirstMessage',
    'substituteParamsExtended', 'getMediaDisplay', 'getMediaIndex', 'substituteParamsLegacy',
    'saveChat', 'getCurrentChatDetails', 'updateMessage', 'removeMacros',
]);
const scriptHeader = `// 自动生成，勿手改。
${listing('public/script.js', fromScript)}
export * from './script-state.mjs';
import { ${[...CONSTS, 'system_message_types', ...Object.keys(STATE)].join(', ')} } from './script-state.mjs';
import { Handlebars } from ${P('lib.js')};
import { power_user, collapseNewlines, fixMarkdown, getCustomStoppingStrings } from ${P('scripts/power-user.js')};
import { persona_description_positions } from ${P('scripts/personas.js')};
import { NOTE_MODULE_NAME, metadata_keys, shouldWIAddPrompt } from ${P('scripts/authors-note.js')};
import { extension_settings } from ${P('scripts/extensions.js')};
import { selected_group, groups, getGroupCharacterCardsLazy, getGroupNames, group_generation_id } from ${P('scripts/group-chats.js')};
import { inject_ids, MEDIA_DISPLAY } from ${P('scripts/constants.js')};
import { MacroEnvBuilder } from ${P('scripts/macros/engine/MacroEnvBuilder.js')};
import { MacroEngine } from ${P('scripts/macros/engine/MacroEngine.js')};
import { getChatCompletionModel, oai_settings } from ${P('scripts/openai.js')};
import { getRegexedString, regex_placement } from ${P('scripts/extensions/regex/engine.js')};
import { escapeRegex, trimToEndSentence } from ${P('scripts/utils.js')};
import { PromptReasoning, parseReasoningInSwipes } from ${P('scripts/reasoning.js')};
import { getInstructStoppingSequences } from ${P('scripts/instruct-mode.js')};
import { getMessageTimeStamp } from ${P('scripts/RossAscends-mods.js')};
import { getTokenCountAsync } from ${P('scripts/tokenizers.js')};
import { eventSource, event_types } from ${P('scripts/events.js')};
import { evaluateMacros } from ${P('scripts/macros.js')};
import { compressRequest } from ${P('scripts/request-compression.js')};
import { uuidv4 } from ${P('scripts/utils.js')};
export { eventSource, event_types };

// ---- 纯界面的函数换成空函数：渲染消息、图片附件、头像缩略图 ----
function addOneMessage() {}
async function processImageAttachment() {}
function getThumbnailUrl() { return ''; }
function statMesProcess() {}
// ---- 其余 script.js 导出，实跑用不到具体行为 ----
export function getRequestHeaders() { return { 'Content-Type': 'application/json' }; }
export function saveSettingsDebounced() {}
export async function saveChatConditional() {}
export async function saveMetadata() {}
export function getCharacterAvatar() { return ''; }
`;
fs.writeFileSync(path.join(HERE, 'stubs/public/script.js.mjs'), scriptHeader + '\n'
    + fromScript.map(d => d.text).join('\n\n')
    + '\nexport { flushWIInjections, addPersonaDescriptionExtensionPrompt, getAllExtensionPrompts, cleanGroupMessage, doChatInject, getFirstMessage, updateMessage };\n');

// ---------- group-chats.js.mjs ----------
const fromGroup = extractDecls(path.join(PUB, 'scripts/group-chats.js'), [
    'group_activation_strategy', 'group_generation_mode',
    'getGroupNames', 'getGroupDepthPrompts', 'getGroupCharacterCardsLazy',
    'activateImpersonate', 'activateSwipe', 'activateListOrder', 'activatePooledOrder', 'activateNaturalOrder',
    'getFirstCharacterMessage',
]);
fs.mkdirSync(path.join(HERE, 'stubs/public/scripts'), { recursive: true });
fs.writeFileSync(path.join(HERE, 'stubs/public/scripts/group-chats.js.mjs'), `// 自动生成，勿手改。
${listing('public/scripts/group-chats.js', fromGroup)}
import { characters, chat, substituteParams, baseChatReplace, getExtensionPromptRoleByName, talkativeness_default, depth_prompt_depth_default, depth_prompt_role_default, createLazyFields, chat_metadata, name1, name2, eventSource, event_types, default_avatar } from ${P('script.js')};
import { getMessageTimeStamp } from ${P('scripts/RossAscends-mods.js')};
const getThumbnailUrl = () => '';
import { shuffle, extractAllWords, onlyUnique } from ${P('scripts/utils.js')};
import { power_user } from ${P('scripts/power-user.js')};
import { extension_settings } from ${P('scripts/extensions.js')};
export let groups = [];
export let selected_group = null;
export function __setGroup(list, id) { groups = list; selected_group = id; }
export let group_generation_id = null;
export function __setGroupGenId(v) { group_generation_id = v; }

` + fromGroup.map(d => d.text).join('\n\n')
    + '\nexport { activateImpersonate, activateSwipe, activateListOrder, activatePooledOrder, activateNaturalOrder, getFirstCharacterMessage };\n');
// ---------- server-count.mjs：服务端按 DeepSeek 分词器数 token 的那几行 ----------
const fromTok = extractDecls(path.join(ST, 'src/endpoints/tokenizers.js'), ['countWebTokenizerTokens']);
fs.writeFileSync(path.join(HERE, 'stubs/server-count.mjs'), `// 自动生成，勿手改。\n${listing('src/endpoints/tokenizers.js', fromTok)}\n`
    + `function guesstimate(str) { return Math.ceil(new TextEncoder().encode(str).length / 3.35); }\n` + fromTok.map(d => d.text).join('\n') + '\n');
console.log('ok', constDecls.length, fromScript.length, fromGroup.length);

// ---------- memory-ext.mjs：摘要扩展里决定「何时摘要、提示词是什么、摘要放哪」的几段 ----------
const MEM = path.join(PUB, 'scripts/extensions/memory/index.js');
const fromMem = extractDecls(MEM, ['MODULE_NAME', 'summary_sources', 'prompt_builders', 'defaultPrompt', 'defaultTemplate', 'defaultSettings',
    'formatMemoryValue', 'getSummaryPromptForNow', 'setMemoryContext']);
fs.writeFileSync(path.join(HERE, 'stubs/memory-ext.mjs'), `// 自动生成，勿手改。\n${listing('public/scripts/extensions/memory/index.js', fromMem)}
import { substituteParamsExtended, setExtensionPrompt, extension_prompt_types, extension_prompt_roles, is_send_press } from ${P('script.js')};
import { extension_settings, getContext } from ${P('scripts/extensions.js')};
import { selected_group, is_group_generating } from ${P('scripts/group-chats.js')};
import { waitUntilCondition, extractAllWords } from ${P('scripts/utils.js')};
const saveChatDebounced = () => {};
` + fromMem.map(d => d.text).join('\n\n') + '\nexport { MODULE_NAME, defaultSettings, formatMemoryValue, getSummaryPromptForNow, setMemoryContext };\n');

// 按名字从酒馆源码里原样切出顶层声明（函数、常量），返回 { name, start, end, text }。
// 切的时候跳过字符串、模板串、注释里的括号；切出来的文本一字不改。
import fs from 'node:fs';

function findEnd(src, from, untilSemicolon = false) {
    let i = from, depth = 0, started = false;
    const stack = [];
    while (i < src.length) {
        const c = src[i], n = src[i + 1];
        if (c === '/' && n === '/') { i = src.indexOf('\n', i); if (i < 0) return src.length; continue; }
        if (c === '/' && n === '*') { i = src.indexOf('*/', i + 2) + 2; continue; }
        if (c === '/') {
            // 正则字面量：斜杠前是运算符、开括号、逗号等，按正则跳过（含字符类里的斜杠）
            let k = i - 1;
            while (k >= 0 && /\s/.test(src[k])) k--;
            if (k < 0 || '(,=:[!&|?{};+-*%<>~^'.includes(src[k]) || /\b(return|typeof|case|in|of)$/.test(src.slice(Math.max(0, k - 6), k + 1))) {
                i++;
                let inClass = false;
                while (i < src.length) {
                    if (src[i] === '\\') { i += 2; continue; }
                    if (src[i] === '[') inClass = true;
                    else if (src[i] === ']') inClass = false;
                    else if (src[i] === '/' && !inClass) break;
                    else if (src[i] === '\n') break;
                    i++;
                }
                i++;
                continue;
            }
        }
        if (c === '\'' || c === '"') {
            i++;
            while (i < src.length && src[i] !== c) { if (src[i] === '\\') i++; i++; }
            i++; continue;
        }
        if (c === '`') {
            i++;
            while (i < src.length && src[i] !== '`') {
                if (src[i] === '\\') { i += 2; continue; }
                if (src[i] === '$' && src[i + 1] === '{') {
                    // 模板里的 ${...}：递归找配对
                    const end = findEnd(src, i + 1);
                    i = end; continue;
                }
                i++;
            }
            i++; continue;
        }
        if (c === '{' || c === '(' || c === '[') { depth++; started = true; stack.push(c); }
        else if (c === '}' || c === ')' || c === ']') {
            depth--; stack.pop();
            if (started && depth === 0 && !untilSemicolon) {
                // 声明到 } 为止；常量声明要吃掉结尾的分号
                let j = i + 1;
                if (src[j] === ';') j++;
                return j;
            }
        } else if (c === ';' && depth === 0 && (untilSemicolon || !started)) { return i + 1; }
        i++;
    }
    return src.length;
}

export function extractDecls(file, names) {
    const src = fs.readFileSync(file, 'utf8');
    const lines = src.split('\n');
    const out = [];
    for (const name of names) {
        const re = new RegExp(`^(export\\s+)?(async\\s+)?(function\\*?\\s+${name}\\s*\\(|(const|let|var)\\s+${name}\\s*=)`, 'm');
        const m = re.exec(src);
        if (!m) throw new Error(`没找到 ${name}`);
        const start = m.index;
        let end;
        if (m[3].startsWith('function')) {
            // 跳过参数表，再找函数体
            const paren = src.indexOf('(', start);
            const afterParams = findEnd(src, paren);
            const brace = src.indexOf('{', afterParams);
            end = findEnd(src, brace);
        } else {
            end = findEnd(src, start + m[0].length, true);
        }
        const startLine = src.slice(0, start).split('\n').length;
        const endLine = src.slice(0, end).split('\n').length;
        out.push({ name, startLine, endLine, text: lines.slice(startLine - 1, endLine).join('\n') });
    }
    return out;
}

// 实跑用的酒馆会话。照 public/script.js 里 Generate() 在 Chat Completion（main_api = 'openai'）路径上的顺序，
// 依次调酒馆自己的函数：世界书、作者注释、Prompt Manager、预算、服务端的 DeepSeek 后处理。
// 这里只有「按顺序调用」的胶水，拼接、筛选、预算、清洗全是酒馆的原函数。注释里的行号都指 public/script.js，另注明的除外。
// 进程里没有 API key：generate() 只产出请求体，由另一个进程发给模型，回包再交给 receive()。
import fs from 'node:fs';
import path from 'node:path';
import zlib from 'node:zlib';
import { fileURLToPath } from 'node:url';

const ST = process.env.ST_ROOT;
const PUB = path.join(ST, 'public');
const HERE = path.dirname(fileURLToPath(import.meta.url));

export const S = await import(path.join(PUB, 'script.js'));
export const OAI = await import(path.join(PUB, 'scripts/openai.js'));
export const PM = await import(path.join(PUB, 'scripts/PromptManager.js'));
export const WI = await import(path.join(PUB, 'scripts/world-info.js'));
export const PU = await import(path.join(PUB, 'scripts/power-user.js'));
export const AN = await import(path.join(PUB, 'scripts/authors-note.js'));
export const MS = await import(path.join(PUB, 'scripts/macros/macro-system.js'));
export const C = await import(path.join(PUB, 'scripts/constants.js'));
export const RX = await import(path.join(PUB, 'scripts/extensions/regex/engine.js'));
export const RS = await import(path.join(PUB, 'scripts/reasoning.js'));
export const G = await import(path.join(PUB, 'scripts/group-chats.js'));
export const EXT = await import(path.join(PUB, 'scripts/extensions.js'));
export const PC = await import(path.join(ST, 'src/prompt-converters.js'));
const { countWebTokenizerTokens } = await import(path.join(HERE, 'stubs/server-count.mjs'));
export const MEM = await import(path.join(HERE, 'stubs/memory-ext.mjs'));

// ---------- token 计数：前端 countTokensOpenAIAsync 发 /api/tokenizers/openai/count，这里在本进程里答 ----------
// 服务端对 DeepSeek 用 SillyTavern-Tokenizers 仓库的 deepseek.json（src/endpoints/tokenizers.js:264、990-995）
const tokenizerFile = path.join(HERE, '../tokenizers/deepseek.json.gz');
// 这个包看到全局有 window/document 就按浏览器加载 wasm，建分词器时临时移开前端的全局桩
const dsTokenizer = await (async () => {
    const saved = { window: globalThis.window, document: globalThis.document };
    delete globalThis.window; delete globalThis.document;
    try {
        const { Tokenizer } = await import('@agnai/web-tokenizers');
        return await Tokenizer.fromJSON(zlib.gunzipSync(fs.readFileSync(tokenizerFile)));
    } finally { Object.assign(globalThis, saved); }
})();
globalThis.__ajax = async (opts) => {
    if (String(opts.url).startsWith('/api/tokenizers/openai/count')) {
        const messages = JSON.parse(opts.data);
        return { token_count: countWebTokenizerTokens(dsTokenizer, messages) };
    }
    throw new Error('unexpected ajax ' + opts.url);
};
// ---------- 服务端的两个聊天接口：前端 fetch 到这里，按服务端的写法落盘 ----------
// /api/chats/save：src/endpoints/chats.js:545-575 → trySaveChat（532-543）把数组逐条 JSON.stringify、按行拼成 JSONL
// /api/characters/chats：列出这张卡已有的聊天文件名
export const DATA_DIR = process.env.ST_DATA || path.join(HERE, '../out/data');
const realFetch = globalThis.fetch;
globalThis.fetch = async (url, init = {}) => {
    const u = String(url);
    if (u === '/api/chats/save') {
        const body = JSON.parse(init.body);
        const cardName = String(body.avatar_url).replace('.png', '');
        const dir = path.join(DATA_DIR, 'chats', cardName);
        fs.mkdirSync(dir, { recursive: true });
        const jsonlData = body.chat?.map(m => JSON.stringify(m)).join('\n');
        fs.writeFileSync(path.join(dir, `${body.file_name}.jsonl`), jsonlData);
        return new Response(JSON.stringify({ ok: true }), { status: 200 });
    }
    if (u === '/api/characters/chats') {
        const body = JSON.parse(init.body);
        const dir = path.join(DATA_DIR, 'chats', String(body.avatar_url).replace('.png', ''));
        const files = fs.existsSync(dir) ? fs.readdirSync(dir).filter(f => f.endsWith('.jsonl')) : [];
        return new Response(JSON.stringify(files.map(f => ({ file_name: f }))), { status: 200 });
    }
    if (u.startsWith('/')) throw new Error('unexpected fetch ' + u);
    return realFetch(url, init);
};

export function countTokens(text) { return dsTokenizer.encode(text).length; }

// 世界书每轮激活了哪些条目：getWorldInfoPrompt 发 WORLD_INFO_ACTIVATED（world-info.js:900-903），这里接住
let lastActivated = [];
let lastPromptReasoning = null;   // receive 里 continue 要用它切掉思考前缀（5509-5512）
S.eventSource.on(S.event_types.WORLD_INFO_ACTIVATED, (entries) => { lastActivated = entries; });

const settingsJson = () => JSON.parse(fs.readFileSync(path.join(ST, 'default/content/settings.json'), 'utf8'));
let initialized = false;
let wiInitialized = false;
let baseOai = null;

/**
 * 新装酒馆 + 一张卡 + 若干本世界书，开一段新聊天。
 * oaiPatch：用户在连接面板上改的设置（换成 DeepSeek、关流式）；其余全是 default/content/settings.json 的出厂值。
 */
export async function init({ card, books = {}, name1 = 'User', persona = '', oaiPatch = {}, wiPatch = {}, powerUserPatch = {}, chatMetadata = {}, globalBooks = [] }) {
    const settings = settingsJson();
    // power_user：出厂设置覆盖模块里的默认值（power-user.js 的 loadPowerUserSettings 做的是同一件事）
    Object.assign(PU.power_user, structuredClone(settings.power_user), powerUserPatch);
    PU.power_user.persona_description = persona;
    if (!initialized) {
        MS.initRegisterMacros();                        // 新宏引擎注册内置宏（macro-system.js:66）
        AN.initAuthorsNote();                           // 作者注释：CHAT_CHANGED 时载入默认值（authors-note.js:476、582）
        initialized = true;
    }
    // 聊天补全设置：Default 预设 + 出厂设置，再叠用户在连接面板上的改动（openai.js:4320 loadOpenAISettings）
    // loadOpenAISettings 和 Prompt Manager 的初始化都是启动时调一次的；之后每次 init 从第一次的快照还原，再叠这次的改动
    if (!baseOai) {
        const preset = fs.readFileSync(path.join(ST, 'default/content/presets/openai/Default.json'), 'utf8');
        OAI.loadOpenAISettings({ openai_setting_names: ['Default'], openai_settings: [preset] }, { ...settings.oai_settings });
        OAI.setupChatCompletionPromptManager(OAI.oai_settings);
        baseOai = structuredClone(OAI.oai_settings);
    }
    for (const [k, v] of Object.entries(baseOai)) OAI.oai_settings[k] = structuredClone(v);
    Object.assign(OAI.oai_settings, structuredClone(oaiPatch));
    // 扩展设置回到出厂（作者注释、摘要、正则）
    EXT.extension_settings.note = { default: '', chara: [], wiAddition: [], allowWIScan: false };
    EXT.extension_settings.memory = {};
    EXT.extension_settings.regex = [];
    // 世界书：出厂设置 + 已有的书（world-info.js:917 setWorldInfoSettings）
    // setWorldInfoSettings 是启动时调一次的（会追加已选的书、注册事件），之后换设置用 updateWorldInfoSettings（world-info.js:819）
    const wiSettings = { ...structuredClone(settings.world_info_settings), ...wiPatch };
    if (!wiInitialized) {
        WI.setWorldInfoSettings({ ...wiSettings, world_info: { globalSelect: [] } }, { world_names: Object.keys(books) });
        wiInitialized = true;
    }
    WI.updateWorldInfoSettings(wiSettings, globalBooks);
    WI.worldInfoCache.clear?.();
    for (const [name, book] of Object.entries(books)) WI.worldInfoCache.set(name, structuredClone(book));
    // 角色和聊天
    S.__set('characters', [{ ...structuredClone(card), avatar: 'seraphina.png', chat: `${card.name} - 实跑` }]);
    S.__set('this_chid', 0);
    S.__set('name1', name1);
    S.__set('name2', card.name);
    S.__set('chat_metadata', structuredClone(chatMetadata));
    S.__set('chat', []);
    S.__set('extension_prompts', {});
    G.__setGroup([], null);
    // getChatResult（7684-7706）：空聊天先放开场白
    const first = S.getFirstMessage();
    if (first.mes) S.chat.push(first);
    await S.eventSource.emit(S.event_types.CHAT_CHANGED, S.getCurrentChatId());
}

/** 群聊：多张卡，selected_group 指向一个群（group-chats.js 的数据形状） */
export function setGroup(cards, group) {
    S.__set('characters', cards.map(c => structuredClone(c)));
    G.__setGroup([group], group.id);
}

export function setCharacter(chid) {
    S.__set('this_chid', chid);
    S.__set('name2', S.characters[chid].name);
}

/**
 * Generate(type) 在 Chat Completion 路径上的拼装。返回发往服务端的 generate_data、服务端发给 DeepSeek 的请求体，
 * 以及这一轮的中间产物（世界书结果、注入表、每条消息的 token 数）。
 */
export async function generate({ type = 'normal', text = '', dryRun = false, quietPrompt = '', skipWIAN = false } = {}) {
    const isContinue = type == 'continue';
    const isImpersonate = type == 'impersonate';
    const chat = S.chat;

    // 4405-4412：regenerate 先删掉最后一条非用户消息
    if (type === 'regenerate' && chat.length && !chat[chat.length - 1].is_user) chat.pop();

    // 4433：bias
    const { messageBias, promptBias } = S.getBiasStrings(text, type);

    // 4447-4454 → sendMessageAsUser（5874-5923）：用户消息先进 chat
    if (text && !['regenerate', 'swipe', 'impersonate', 'quiet', 'continue'].includes(type) && !dryRun) {
        const messageText = RX.getRegexedString(text, RX.regex_placement.USER_INPUT);
        const message = {
            name: S.name1,
            is_user: true,
            is_system: false,
            send_date: new Date().toISOString(),
            mes: S.substituteParams(messageText),
            extra: { isSmallSys: false },
        };
        if (messageBias) message.extra.bias = messageBias;
        S.chat_metadata.tainted = true;
        chat.push(message);
    }

    // 4460-4470：卡字段
    let { description, personality, persona, scenario, mesExamples, system, jailbreak, charDepthPrompt, creatorNotes } = S.getCharacterCardFields();

    // 4472-4486：角色笔记（Character's Note）注册成 IN_CHAT 注入
    S.removeDepthPrompts();
    const groupDepthPrompts = G.getGroupDepthPrompts(G.selected_group, Number(S.this_chid));
    if (G.selected_group && Array.isArray(groupDepthPrompts) && groupDepthPrompts.length > 0) {
        groupDepthPrompts.forEach((value, index) => {
            const role = S.getExtensionPromptRoleByName(value.role);
            S.setExtensionPrompt(C.inject_ids.DEPTH_PROMPT_INDEX(index), value.text, S.extension_prompt_types.IN_CHAT, value.depth, EXT.extension_settings.note.allowWIScan, role);
        });
    } else {
        const depthPromptText = charDepthPrompt || '';
        const depthPromptDepth = S.characters[S.this_chid]?.data?.extensions?.depth_prompt?.depth ?? S.depth_prompt_depth_default;
        const depthPromptRole = S.getExtensionPromptRoleByName(S.characters[S.this_chid]?.data?.extensions?.depth_prompt?.role ?? S.depth_prompt_role_default);
        S.setExtensionPrompt(C.inject_ids.DEPTH_PROMPT, depthPromptText, S.extension_prompt_types.IN_CHAT, depthPromptDepth, EXT.extension_settings.note.allowWIScan, depthPromptRole);
    }

    // 4488-4491：开场白每轮重算宏
    if (chat.length) chat[0].mes = S.substituteParams(chat[0].mes);

    // 4493-4529：参与拼装的消息——隐藏的（is_system）去掉；swipe 时去掉当前这条
    let coreChat = chat.filter(x => !x.is_system);
    if (type === 'swipe') coreChat.pop();
    coreChat = coreChat.map((chatItem, index) => {
        const regexType = chatItem.is_user ? RX.regex_placement.USER_INPUT : RX.regex_placement.AI_OUTPUT;
        const options = { isPrompt: true, depth: (coreChat.length - index - (isContinue ? 2 : 1)) };
        return { ...chatItem, mes: RX.getRegexedString(chatItem.mes, regexType, options), index };
    });
    // 4530-4557：思考内容回放（默认 add_to_prompts 关，只是走一遍）
    const promptReasoning = new RS.PromptReasoning();
    lastPromptReasoning = promptReasoning;
    for (let i = coreChat.length - 1; i >= 0; i--) {
        const depth = coreChat.length - i - (isContinue ? 2 : 1);
        const isPrefix = isContinue && i === coreChat.length - 1;
        coreChat[i] = { ...coreChat[i], mes: promptReasoning.addToMessage(coreChat[i].mes, String(coreChat[i].extra?.reasoning ?? ''), isPrefix, coreChat[i].extra?.reasoning_duration) };
        if (promptReasoning.isLimitReached()) break;
    }

    // 4559-4560：上下文上限（Chat Completion 下 = openai_max_context − openai_max_tokens）
    const this_max_context = S.getMaxPromptTokens();
    // 4562-4573：生成拦截器——这次没装扩展，跳过

    // 4616：示范对话按 <START> 切块
    let mesExamplesArray = S.parseMesExamples(mesExamples, false);

    // 4619：作者注释
    AN.setFloatingPrompt();

    // 4621-4636：世界书
    S.setExtensionPrompt(C.inject_ids.QUIET_PROMPT, quietPrompt || '', S.extension_prompt_types.IN_PROMPT, 0, true);
    const chatForWI = coreChat.map(x => WI.world_info_include_names ? `${x.name}: ${x.mes}` : x.mes).reverse();
    const globalScanData = {
        personaDescription: persona,
        characterDescription: description,
        characterPersonality: personality,
        characterDepthPrompt: charDepthPrompt,
        scenario: scenario,
        creatorNotes: creatorNotes,
        trigger: C.GENERATION_TYPE_TRIGGERS.includes(type) ? type : 'normal',
    };
    lastActivated = [];
    const wiResult = await WI.getWorldInfoPrompt(chatForWI, this_max_context, dryRun, globalScanData);
    const { worldInfoBefore, worldInfoAfter, worldInfoExamples, worldInfoDepth, outletEntries } = wiResult;
    S.setExtensionPrompt(C.inject_ids.QUIET_PROMPT, '', S.extension_prompt_types.IN_PROMPT, 0, true);

    // 4638-4655：世界书里「示范对话前 / 后」的条目并进示范对话
    for (const example of worldInfoExamples) {
        const exampleMessage = example.content;
        if (exampleMessage.length === 0) continue;
        const cleanedExample = S.parseMesExamples(S.baseChatReplace(exampleMessage), false);
        if (example.position === WI.wi_anchor_position.before) mesExamplesArray.unshift(...cleanedExample);
        else mesExamplesArray.push(...cleanedExample);
    }

    // 4664-4681：世界书 @depth 条目注册成 IN_CHAT 注入
    if (skipWIAN !== true) {
        S.flushWIInjections();
        if (Array.isArray(worldInfoDepth)) {
            worldInfoDepth.forEach((e) => {
                const joinedEntries = e.entries.join('\n');
                S.setExtensionPrompt(C.inject_ids.CUSTOM_WI_DEPTH_ROLE(e.depth, e.role), joinedEntries, S.extension_prompt_types.IN_CHAT, e.depth, false, e.role);
            });
        }
        if (outletEntries && typeof outletEntries === 'object' && Object.keys(outletEntries).length > 0) {
            Object.entries(outletEntries).forEach(([key, value]) => {
                S.setExtensionPrompt(C.inject_ids.CUSTOM_WI_OUTLET(key), value.join('\n'), S.extension_prompt_types.NONE, 0);
            });
        }
    }

    // 4684：用户人设
    S.addPersonaDescriptionExtensionPrompt();

    // 4767-4780、4866-4871、4976-4980：continue 时被续写的那条单独拿出来
    let cyclePrompt = '';
    if (isContinue && coreChat.length) {
        cyclePrompt = coreChat[coreChat.length - 1].mes;
        if (!cyclePrompt.endsWith(' ')) cyclePrompt += OAI.oai_settings.continue_postfix;
    }

    // 4833-4836：转成 Chat Completion 的消息
    const oaiMessages = OAI.setOpenAIMessages(coreChat);
    const oaiMessageExamples = OAI.setOpenAIMessageExamples(mesExamplesArray);

    // 5288-5303 → openai.js:1542 prepareOpenAIMessages：槽位、注入、预算
    const extensionPromptsSnapshot = structuredClone(Object.fromEntries(Object.entries(S.extension_prompts).map(([k, v]) => [k, { ...v, filter: undefined }])));
    const [prompt, counts] = await OAI.prepareOpenAIMessages({
        name2: S.name2,
        charDescription: description,
        charPersonality: personality,
        scenario: scenario,
        worldInfoBefore: worldInfoBefore,
        worldInfoAfter: worldInfoAfter,
        extensionPrompts: S.extension_prompts,
        bias: promptBias,
        type: type,
        quietPrompt: quietPrompt,
        quietImage: null,
        cyclePrompt: cyclePrompt,
        systemPromptOverride: system,
        jailbreakPromptOverride: jailbreak,
        messages: oaiMessages,
        messageExamples: oaiMessageExamples,
    }, dryRun);

    // 每条进了上下文的消息的 identifier 和 token 数（ChatCompletion 记账，供 Prompt Manager 显示）
    const cc = OAI.promptManager.messages;
    const ledger = cc ? flattenLedger(cc) : null;

    // openai.js:3138 sendOpenAIRequest → 2691 createGenerationParameters
    const model = OAI.getChatCompletionModel(OAI.oai_settings);
    const { generate_data } = await OAI.createGenerationParameters(OAI.oai_settings, model, type, prompt);

    // 服务端 src/endpoints/backends/chat-completions.js:1071-1139 sendDeepSeekRequest 拼请求体
    const deepseek = buildDeepSeekRequest(generate_data);

    return {
        type, coreChatLength: coreChat.length, this_max_context,
        wi: summarizeWI(wiResult, lastActivated), chatForWI,
        extensionPrompts: extensionPromptsSnapshot,
        prompt, counts, ledger, generate_data, deepseek,
        continueMag: isContinue ? cyclePrompt : '',
    };
}

function flattenLedger(collection) {
    const out = [];
    const walk = (item) => {
        if (item && Array.isArray(item.collection)) {
            for (const x of item.collection) walk(x);
            return;
        }
        if (item && item.role) out.push({ identifier: item.identifier, role: item.role, tokens: item.tokens, content: item.content });
    };
    walk(collection);
    return out;
}

function summarizeWI(r, activated) {
    return {
        before: r.worldInfoBefore, after: r.worldInfoAfter,
        examples: r.worldInfoExamples, depth: r.worldInfoDepth,
        anBefore: r.anBefore, anAfter: r.anAfter, outlets: r.outletEntries,
        activated: activated.map(e => ({ world: e.world, uid: e.uid, comment: e.comment, key: e.key, position: e.position, depth: e.depth, order: e.order })),
    };
}

/** chat-completions.js:1071-1139 里 sendDeepSeekRequest 拼请求体的部分，原样照抄；发请求那步交给别的进程 */
export function buildDeepSeekRequest(body) {
    const request = { body: structuredClone(body) };
    const API_DEEPSEEK = 'https://api.deepseek.com/beta';                              // chat-completions.js:86
    const apiUrl = new URL(request.body.reverse_proxy || API_DEEPSEEK).toString();
    let bodyParams = {};
    if (request.body.logprobs > 0) {
        bodyParams['top_logprobs'] = request.body.logprobs;
        bodyParams['logprobs'] = true;
    }
    const processedMessages = PC.addAssistantPrefix(PC.postProcessPrompt(request.body.messages, PC.PROMPT_PROCESSING_TYPE.SEMI_TOOLS, PC.getPromptNames(request)), bodyParams.tools, 'prefix');
    PC.addReasoningContentToToolCalls(processedMessages);
    if (request.body.include_reasoning && request.body.reasoning_effort) {
        bodyParams['reasoning_effort'] = request.body.reasoning_effort;
    }
    const requestBody = {
        'messages': processedMessages,
        'model': request.body.model,
        'temperature': request.body.temperature,
        'max_tokens': request.body.max_tokens,
        'stream': request.body.stream,
        'presence_penalty': request.body.presence_penalty,
        'frequency_penalty': request.body.frequency_penalty,
        'top_p': request.body.top_p,
        'stop': request.body.stop,
        'seed': request.body.seed,
        'thinking': { type: request.body.include_reasoning ? 'enabled' : 'disabled' },
        ...bodyParams,
    };
    return { url: apiUrl + '/chat/completions', body: JSON.parse(JSON.stringify(requestBody)) };
}

/** Generate 的 onSuccess（5486-5535）：取正文和思考、清洗、存进 chat */
export async function receive({ type = 'normal', data, continueMag = '' }) {
    const isImpersonate = type == 'impersonate';
    const isContinue = type == 'continue';
    let getMessage = S.extractMessageFromData(data);
    let reasoning = RS.extractReasoningFromData(data);
    getMessage = S.cleanUpMessage({ getMessage, isImpersonate, isContinue, displayIncompleteSentences: false });
    reasoning = RX.getRegexedString(reasoning, RX.regex_placement.REASONING);
    if (PU.power_user.trim_spaces) reasoning = reasoning.trim();
    if (isContinue) {
        continueMag = lastPromptReasoning ? lastPromptReasoning.removePrefix(continueMag) : continueMag;
        getMessage = continueMag + getMessage;
    }
    getMessage = S.cleanUpMessage({ getMessage, isImpersonate, isContinue, displayIncompleteSentences: type === 'quiet' });
    if (isImpersonate || type === 'quiet') return { type, getMessage, reasoning };
    const res = await S.saveReply({ type: isContinue ? 'appendFinal' : type, getMessage, reasoning });
    return { ...res, reasoning, message: S.chat[S.chat.length - 1] };
}

export function snapshot() {
    return { chat: structuredClone(S.chat), chat_metadata: structuredClone(S.chat_metadata) };
}

export function stubHits() {
    return Object.fromEntries([...globalThis.__stubHits.entries()].filter(([k]) => !k.startsWith('$(') && !k.startsWith('toastr')));
}