mu-agent-bridge 1.0.34 → 1.0.39

package/dist/src-ts/session-archive.js

@@ -0,0 +1,509 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.SessionArchive = exports.SESSION_ARCHIVE_LIMITS = void 0;
+const promises_1 = require("node:fs/promises");
+const node_crypto_1 = require("node:crypto");
+const node_path_1 = require("node:path");
+exports.SESSION_ARCHIVE_LIMITS = {
+    maxTextBytes: 64 * 1024,
+    maxSessionBytes: 8 * 1024 * 1024,
+    maxTotalBytes: 256 * 1024 * 1024,
+    retentionDays: 30,
+    maxSessions: 1000,
+    maxTurnsPerSession: 2000,
+    maxListPageSize: 50,
+    maxReadPageSize: 100,
+};
+const META_FILE = "metadata.json";
+const FILE_MODE = 0o600;
+const MAX_METADATA_BYTES = 8 * 1024 * 1024;
+function validTime(value) {
+    return typeof value === "string" && Number.isFinite(Date.parse(value));
+}
+function validReasons(value) {
+    return Array.isArray(value) && value.length <= 32 && value.every((reason) => typeof reason === "string" && reason.length <= 512);
+}
+function validAttachments(value) {
+    return value === undefined || (Array.isArray(value) && value.length <= 8 && value.every((item) => item &&
+        typeof item.filename === "string" && item.filename.length > 0 && item.filename.length <= 512 && !/[\u0000-\u001f\u007f]/.test(item.filename) &&
+        typeof item.contentType === "string" && /^[A-Za-z0-9!#$&^_.+-]+\/[A-Za-z0-9!#$&^_.+-]+$/.test(item.contentType) &&
+        Number.isSafeInteger(item.sizeBytes) && item.sizeBytes >= 0));
+}
+async function boundedRead(path, maximum) {
+    const file = await (0, promises_1.open)(path, "r");
+    try {
+        const info = await file.stat();
+        if (!info.isFile() || info.size > maximum)
+            throw new Error("归档文件大小超出上限");
+        const buffer = Buffer.alloc(info.size + 1);
+        let offset = 0;
+        while (offset < buffer.length) {
+            const { bytesRead } = await file.read(buffer, offset, buffer.length - offset, offset);
+            if (!bytesRead)
+                break;
+            offset += bytesRead;
+        }
+        if (offset > info.size)
+            throw new Error("归档文件读取期间发生变化");
+        return buffer.toString("utf8", 0, offset);
+    }
+    finally {
+        await file.close();
+    }
+}
+function validId(value, label) {
+    if (typeof value !== "string" || value.length === 0 || value.length > 512 || /[\u0000\r\n]/.test(value))
+        throw new Error(`${label}无效`);
+}
+function validSource(value, label) {
+    if (typeof value !== "string" || value.length === 0 || value.length > 4096 || /[\u0000\r\n]/.test(value))
+        throw new Error(`${label}无效`);
+}
+function fileFor(root, sessionId) {
+    return (0, node_path_1.join)(root, `${(0, node_crypto_1.createHash)("sha256").update(sessionId).digest("hex")}.jsonl`);
+}
+function textWithinLimit(text, maxBytes) {
+    if (Buffer.byteLength(text, "utf8") <= maxBytes)
+        return { text, truncated: false };
+    let low = 0;
+    let high = text.length;
+    while (low < high) {
+        const middle = Math.ceil((low + high) / 2);
+        if (Buffer.byteLength(text.slice(0, middle), "utf8") <= maxBytes)
+            low = middle;
+        else
+            high = middle - 1;
+    }
+    if (low > 0 && /[\uD800-\uDBFF]/.test(text[low - 1]))
+        low--;
+    return { text: text.slice(0, low), truncated: true };
+}
+function safeAttachments(items) {
+    if (!items)
+        return undefined;
+    return items.map((item) => ({ filename: item.filename, contentType: item.contentType, sizeBytes: item.sizeBytes }));
+}
+class SessionArchive {
+    directory;
+    limits;
+    now;
+    enabled;
+    queue = Promise.resolve();
+    metadata;
+    metadataCorrupt = false;
+    lastPrunedAt = 0;
+    nextExpiryAt = Infinity;
+    constructor(directory, options = {}) {
+        this.directory = directory;
+        this.enabled = options.enabled === true;
+        this.now = options.now ?? Date.now;
+        this.limits = { ...exports.SESSION_ARCHIVE_LIMITS };
+        for (const key of Object.keys(exports.SESSION_ARCHIVE_LIMITS)) {
+            const value = options.limits?.[key];
+            if (value !== undefined) {
+                if (!Number.isSafeInteger(value) || value <= 0)
+                    throw new Error("归档限额无效");
+                this.limits[key] = Math.min(value, exports.SESSION_ARCHIVE_LIMITS[key]);
+            }
+        }
+    }
+    setEnabled(enabled) { void this.enqueue(async () => { this.enabled = enabled; }); }
+    async flush() { await this.queue; }
+    recordTurns(turns) {
+        return this.enqueue(async () => {
+            for (const turn of turns) {
+                if (this.enabled && turn.completed)
+                    this.validateTurn(turn);
+            }
+            for (const turn of turns)
+                await this.recordTurnInQueue(turn);
+        });
+    }
+    recordTurn(turn) {
+        return this.enqueue(() => this.recordTurnInQueue(turn));
+    }
+    async recordTurnInQueue(turn) {
+        if (!this.enabled || !turn.completed)
+            return;
+        this.validateTurn(turn);
+        const meta = await this.loadMetadata();
+        if (this.metadataCorrupt)
+            throw new Error("归档目录损坏，拒绝覆盖");
+        if (this.now() - this.lastPrunedAt >= 3600_000)
+            await this.pruneRecords(meta);
+        const existing = Object.hasOwn(meta.sessions, turn.sessionId) ? meta.sessions[turn.sessionId] : undefined;
+        if (existing && (existing.source !== turn.source || existing.principal !== turn.principal || existing.channel !== turn.channel || existing.agentPlugin !== turn.agentPlugin))
+            throw new Error("会话来源不一致");
+        if (!existing && Object.keys(meta.sessions).length >= this.limits.maxSessions) {
+            this.markIncomplete(meta, "会话数量超出上限，新会话未归档");
+            await this.saveMetadata(meta);
+            return;
+        }
+        const current = existing ?? {
+            sessionId: turn.sessionId, agentPlugin: turn.agentPlugin, channel: turn.channel, principal: turn.principal,
+            source: turn.source, title: turn.title, firstSeenAt: turn.time, updatedAt: turn.time, turnCount: 0,
+        };
+        if (!existing)
+            Object.defineProperty(meta.sessions, turn.sessionId, { value: current, enumerable: true, writable: true, configurable: true });
+        const path = fileFor(this.directory, turn.sessionId);
+        const previous = await this.readTurns(path, meta, turn.sessionId);
+        const duplicate = previous.turns.some((item) => (turn.messageId && item.messageId === turn.messageId && item.role === turn.role) ||
+            (turn.requestId && item.requestId === turn.requestId && item.role === turn.role && (turn.role === "user" || (!turn.messageId && item.text === turn.text))));
+        for (const reason of previous.missingReasons)
+            this.markSessionIncomplete(current, reason);
+        if (duplicate)
+            return;
+        if (previous.turns.length >= this.limits.maxTurnsPerSession) {
+            this.markSessionIncomplete(current, "会话轮数超出上限");
+            await this.saveMetadata(meta);
+            return;
+        }
+        const limited = textWithinLimit(turn.text, this.limits.maxTextBytes);
+        const stored = {
+            sessionId: turn.sessionId, time: turn.time, role: turn.role, text: limited.text,
+            attachments: safeAttachments(turn.attachments), messageId: turn.messageId, requestId: turn.requestId,
+            ...(limited.truncated ? { truncated: true } : {}),
+        };
+        if (limited.truncated)
+            this.markSessionIncomplete(current, "单条文本超出上限，正文已截断");
+        let line = `${JSON.stringify(stored)}\n`;
+        const existingBytes = await this.fileSize(path);
+        if (existingBytes + Buffer.byteLength(line) > this.limits.maxSessionBytes) {
+            const allowance = this.limits.maxSessionBytes - existingBytes;
+            const fit = this.fitTurn(stored, Math.max(0, allowance));
+            if (!fit) {
+                this.markSessionIncomplete(current, "会话大小超出上限");
+                await this.saveMetadata(meta);
+                return;
+            }
+            line = `${JSON.stringify(fit)}\n`;
+            this.markSessionIncomplete(current, "会话大小超出上限，正文已截断");
+        }
+        await (0, promises_1.mkdir)(this.directory, { recursive: true, mode: 0o700 });
+        try {
+            await (0, promises_1.appendFile)(path, line, { encoding: "utf8", mode: FILE_MODE });
+            await (0, promises_1.chmod)(path, FILE_MODE);
+        }
+        catch (error) {
+            this.markSessionIncomplete(current, "归档正文写入失败");
+            await this.saveMetadata(meta);
+            throw error;
+        }
+        current.turnCount = previous.turns.length + 1;
+        current.updatedAt = current.updatedAt > turn.time ? current.updatedAt : turn.time;
+        this.nextExpiryAt = Math.min(this.nextExpiryAt, Date.parse(turn.time) + this.limits.retentionDays * 86400_000 + 1);
+        await this.saveMetadata(meta);
+    }
+    async listSessions(options = {}) {
+        return this.enqueue(async () => {
+            await this.pruneIfNeeded();
+            const meta = await this.loadMetadata();
+            const limit = Math.min(this.limits.maxListPageSize, Math.max(1, Math.floor(options.limit ?? this.limits.maxListPageSize)));
+            const page = Math.max(1, Math.floor(options.page ?? 1));
+            const allowed = options.sources ? new Set(options.sources) : undefined;
+            const all = Object.values(meta.sessions).filter((session) => (!options.source || session.source === options.source) && (!allowed || allowed.has(session.source)) && (!options.agentPlugin || session.agentPlugin === options.agentPlugin)).sort((a, b) => b.updatedAt.localeCompare(a.updatedAt));
+            const start = (page - 1) * limit;
+            const missingReasons = [...meta.incomplete];
+            return { sessions: structuredClone(all.slice(start, start + limit)), page, limit, total: all.length, hasNext: start + limit < all.length, complete: missingReasons.length === 0, missingReasons };
+        });
+    }
+    async snapshotSessions() {
+        return this.enqueue(async () => {
+            await this.pruneIfNeeded();
+            const meta = await this.loadMetadata();
+            return { sessions: structuredClone(Object.values(meta.sessions).sort((a, b) => b.updatedAt.localeCompare(a.updatedAt))), complete: meta.incomplete.length === 0, missingReasons: [...meta.incomplete] };
+        });
+    }
+    async readSession(sessionId, options = {}) {
+        return this.enqueue(async () => {
+            validId(sessionId, "会话标识");
+            await this.pruneIfNeeded();
+            const meta = await this.loadMetadata();
+            const session = Object.hasOwn(meta.sessions, sessionId) ? meta.sessions[sessionId] : undefined;
+            if (!session)
+                return { turns: [], page: 1, limit: this.limits.maxReadPageSize, total: 0, hasNext: false, complete: false, missingReasons: ["会话不存在"] };
+            const parsed = await this.readTurns(fileFor(this.directory, sessionId), meta, sessionId);
+            const limit = Math.min(this.limits.maxReadPageSize, Math.max(1, Math.floor(options.limit ?? this.limits.maxReadPageSize)));
+            const page = Math.max(1, Math.floor(options.page ?? 1));
+            const start = (page - 1) * limit;
+            const missingReasons = [...new Set([...meta.incomplete, ...parsed.missingReasons, ...(session.missingReasons ?? [])])];
+            return { session: structuredClone(session), turns: parsed.turns.slice(start, start + limit), page, limit, total: parsed.turns.length, hasNext: start + limit < parsed.turns.length, complete: missingReasons.length === 0, missingReasons };
+        });
+    }
+    deleteSession(sessionId) {
+        return this.enqueue(async () => {
+            validId(sessionId, "会话标识");
+            const meta = await this.loadMetadata();
+            if (this.metadataCorrupt)
+                throw new Error("归档目录损坏，拒绝覆盖");
+            try {
+                await (0, promises_1.unlink)(fileFor(this.directory, sessionId));
+            }
+            catch (error) {
+                if (error.code !== "ENOENT") {
+                    if (Object.hasOwn(meta.sessions, sessionId))
+                        this.markSessionIncomplete(meta.sessions[sessionId], "归档正文删除失败");
+                    await this.saveMetadata(meta);
+                    throw error;
+                }
+            }
+            delete meta.sessions[sessionId];
+            await this.saveMetadata(meta);
+        });
+    }
+    clear() {
+        return this.enqueue(async () => {
+            await (0, promises_1.rm)(this.directory, { recursive: true, force: true });
+            this.metadata = undefined;
+            this.metadataCorrupt = false;
+            this.lastPrunedAt = 0;
+            this.nextExpiryAt = Infinity;
+            await (0, promises_1.mkdir)(this.directory, { recursive: true, mode: 0o700 });
+        });
+    }
+    prune() {
+        return this.enqueue(async () => {
+            const meta = await this.loadMetadata();
+            if (this.metadataCorrupt)
+                throw new Error("归档目录损坏，拒绝覆盖");
+            await this.pruneRecords(meta);
+            await this.saveMetadata(meta);
+        });
+    }
+    async pruneIfNeeded() {
+        const meta = await this.loadMetadata();
+        if (this.metadataCorrupt || (this.now() - this.lastPrunedAt < 3600_000 && this.now() < this.nextExpiryAt))
+            return;
+        await this.pruneRecords(meta);
+        if (Object.keys(meta.sessions).length || meta.incomplete.length)
+            await this.saveMetadata(meta);
+    }
+    enqueue(operation) {
+        const result = this.queue.catch(() => undefined).then(operation);
+        this.queue = result.then(() => undefined, () => undefined);
+        return result;
+    }
+    validateTurn(turn) {
+        for (const [value, label] of [[turn.sessionId, "会话标识"], [turn.agentPlugin, "插件标识"], [turn.channel, "通道"]])
+            validId(value, label);
+        validSource(turn.principal, "主体");
+        validSource(turn.source, "来源");
+        if (turn.role !== "user" && turn.role !== "assistant")
+            throw new Error("消息角色无效");
+        if (typeof turn.text !== "string")
+            throw new Error("消息正文无效");
+        if (!validTime(turn.time))
+            throw new Error("消息时间无效");
+        if (!validAttachments(turn.attachments))
+            throw new Error("附件元数据无效");
+        if (turn.title !== undefined && (typeof turn.title !== "string" || turn.title.length > 512))
+            throw new Error("会话标题无效");
+        if (turn.messageId !== undefined)
+            validId(turn.messageId, "消息标识");
+        if (turn.requestId !== undefined)
+            validId(turn.requestId, "请求标识");
+    }
+    fitTurn(turn, allowance) {
+        const base = { ...turn, text: "", truncated: true };
+        const baseBytes = Buffer.byteLength(`${JSON.stringify(base)}\n`);
+        if (baseBytes > allowance)
+            return undefined;
+        let low = 0;
+        let high = turn.text.length;
+        while (low < high) {
+            const middle = Math.ceil((low + high) / 2);
+            if (Buffer.byteLength(`${JSON.stringify({ ...base, text: turn.text.slice(0, middle) })}\n`) <= allowance)
+                low = middle;
+            else
+                high = middle - 1;
+        }
+        if (low > 0 && /[\uD800-\uDBFF]/.test(turn.text[low - 1]))
+            low--;
+        return { ...base, text: turn.text.slice(0, low) };
+    }
+    markSessionIncomplete(session, reason) {
+        session.incomplete = true;
+        session.missingReasons ??= [];
+        if (!session.missingReasons.includes(reason))
+            session.missingReasons.push(reason);
+    }
+    markIncomplete(meta, reason) {
+        if (!meta.incomplete.includes(reason))
+            meta.incomplete.push(reason);
+    }
+    async loadMetadata() {
+        if (this.metadata)
+            return this.metadata;
+        try {
+            const parsed = JSON.parse(await boundedRead((0, node_path_1.join)(this.directory, META_FILE), MAX_METADATA_BYTES));
+            if (parsed.version !== 1 || !parsed.sessions || typeof parsed.sessions !== "object" || Array.isArray(parsed.sessions) || !validReasons(parsed.incomplete) || Object.keys(parsed.sessions).length > exports.SESSION_ARCHIVE_LIMITS.maxSessions)
+                throw new Error("归档目录格式无效");
+            for (const [id, session] of Object.entries(parsed.sessions)) {
+                if (!session || session.sessionId !== id || !Number.isSafeInteger(session.turnCount) || session.turnCount < 0 || session.turnCount > exports.SESSION_ARCHIVE_LIMITS.maxTurnsPerSession || !validTime(session.firstSeenAt) || !validTime(session.updatedAt) ||
+                    (session.title !== undefined && (typeof session.title !== "string" || session.title.length > 512)) ||
+                    (session.incomplete !== undefined && typeof session.incomplete !== "boolean"))
+                    throw new Error("归档目录格式无效");
+                validId(session.sessionId, "目录字段");
+                validSource(session.source, "目录字段");
+                validSource(session.principal, "目录字段");
+                validId(session.agentPlugin, "目录字段");
+                validId(session.channel, "目录字段");
+                if (session.missingReasons !== undefined && !validReasons(session.missingReasons))
+                    throw new Error("归档目录格式无效");
+            }
+            this.metadata = parsed;
+        }
+        catch (error) {
+            if (error.code === "ENOENT") {
+                const files = await (0, promises_1.readdir)(this.directory).catch((failure) => { if (failure.code === "ENOENT")
+                    return []; throw failure; });
+                this.metadataCorrupt = files.some((name) => name.endsWith(".jsonl"));
+                this.metadata = { version: 1, sessions: {}, incomplete: this.metadataCorrupt ? ["归档目录缺失，存在未关联正文"] : [] };
+            }
+            else {
+                this.metadataCorrupt = true;
+                this.metadata = { version: 1, sessions: {}, incomplete: ["归档目录损坏"] };
+            }
+        }
+        return this.metadata;
+    }
+    async saveMetadata(meta) {
+        if (this.metadataCorrupt)
+            throw new Error("归档目录损坏，拒绝覆盖");
+        await this.enforceLimits(meta);
+        await (0, promises_1.mkdir)(this.directory, { recursive: true, mode: 0o700 });
+        await (0, promises_1.chmod)(this.directory, 0o700);
+        const temporary = (0, node_path_1.join)(this.directory, `${META_FILE}.${process.pid}.${Date.now()}.tmp`);
+        try {
+            await (0, promises_1.writeFile)(temporary, `${JSON.stringify(meta)}\n`, { encoding: "utf8", mode: FILE_MODE });
+            await (0, promises_1.chmod)(temporary, FILE_MODE);
+            await (0, promises_1.rename)(temporary, (0, node_path_1.join)(this.directory, META_FILE));
+            await (0, promises_1.chmod)((0, node_path_1.join)(this.directory, META_FILE), FILE_MODE);
+        }
+        catch (error) {
+            this.markIncomplete(meta, "归档目录写入失败");
+            await (0, promises_1.rm)(temporary, { force: true });
+            throw error;
+        }
+        this.metadata = meta;
+    }
+    async readTurns(path, meta, sessionId) {
+        let text;
+        try {
+            text = await boundedRead(path, this.limits.maxSessionBytes);
+        }
+        catch (error) {
+            if (error.code === "ENOENT") {
+                if (meta.sessions[sessionId]?.turnCount)
+                    return { turns: [], missingReasons: ["归档正文缺失"] };
+                return { turns: [], missingReasons: [] };
+            }
+            return { turns: [], missingReasons: [error.message.includes("大小") ? "归档正文大小超出上限" : "归档正文读取失败"] };
+        }
+        const turns = [];
+        const missingReasons = [];
+        for (const line of text.split("\n")) {
+            if (!line.trim())
+                continue;
+            try {
+                const parsed = JSON.parse(line);
+                if (parsed.sessionId !== sessionId || (parsed.role !== "user" && parsed.role !== "assistant") || typeof parsed.text !== "string" || Buffer.byteLength(parsed.text) > this.limits.maxTextBytes || !validTime(parsed.time) || !validAttachments(parsed.attachments) ||
+                    (parsed.truncated !== undefined && typeof parsed.truncated !== "boolean"))
+                    throw new Error("字段无效");
+                if (parsed.messageId !== undefined)
+                    validId(parsed.messageId, "消息标识");
+                if (parsed.requestId !== undefined)
+                    validId(parsed.requestId, "请求标识");
+                if (turns.length >= this.limits.maxTurnsPerSession)
+                    throw new Error("轮数超限");
+                if (parsed.truncated)
+                    missingReasons.push("单条文本已截断");
+                turns.push({ sessionId, role: parsed.role, time: parsed.time, text: parsed.text, attachments: safeAttachments(parsed.attachments), messageId: parsed.messageId, requestId: parsed.requestId, ...(parsed.truncated ? { truncated: true } : {}) });
+            }
+            catch {
+                missingReasons.push("归档存在损坏记录");
+            }
+        }
+        if (turns.length !== meta.sessions[sessionId]?.turnCount)
+            missingReasons.push("归档记录数量与目录不一致");
+        return { turns, missingReasons: [...new Set(missingReasons)] };
+    }
+    async replaceTurns(path, turns) {
+        if (!turns.length) {
+            try {
+                await (0, promises_1.unlink)(path);
+            }
+            catch (error) {
+                if (error.code !== "ENOENT")
+                    throw error;
+            }
+            return;
+        }
+        const temporary = `${path}.${process.pid}.${Date.now()}.tmp`;
+        await (0, promises_1.writeFile)(temporary, turns.map((turn) => `${JSON.stringify(turn)}\n`).join(""), { encoding: "utf8", mode: FILE_MODE });
+        await (0, promises_1.rename)(temporary, path);
+        await (0, promises_1.chmod)(path, FILE_MODE);
+    }
+    async pruneRecords(meta) {
+        const cutoff = this.now() - this.limits.retentionDays * 86400_000;
+        this.nextExpiryAt = Infinity;
+        for (const session of Object.values(meta.sessions)) {
+            const path = fileFor(this.directory, session.sessionId);
+            const parsed = await this.readTurns(path, meta, session.sessionId);
+            for (const reason of parsed.missingReasons)
+                this.markSessionIncomplete(session, reason);
+            const kept = parsed.turns.filter((turn) => Date.parse(turn.time) >= cutoff);
+            for (const turn of kept)
+                this.nextExpiryAt = Math.min(this.nextExpiryAt, Date.parse(turn.time) + this.limits.retentionDays * 86400_000 + 1);
+            if (kept.length !== parsed.turns.length) {
+                this.markSessionIncomplete(session, "历史记录因保留期过期而清理");
+                await this.replaceTurns(path, kept);
+                session.turnCount = kept.length;
+                if (!kept.length) {
+                    delete meta.sessions[session.sessionId];
+                    this.markIncomplete(meta, "历史会话因保留期过期而清理");
+                }
+            }
+        }
+        this.lastPrunedAt = this.now();
+    }
+    async fileSize(path) {
+        try {
+            return (await (0, promises_1.stat)(path)).size;
+        }
+        catch (error) {
+            if (error.code === "ENOENT")
+                return 0;
+            throw error;
+        }
+    }
+    async enforceLimits(meta) {
+        const sessions = Object.values(meta.sessions).sort((a, b) => a.updatedAt.localeCompare(b.updatedAt));
+        const files = await (0, promises_1.readdir)(this.directory).catch(() => []);
+        let total = Buffer.byteLength(`${JSON.stringify(meta)}\n`);
+        for (const name of files.filter((item) => item.endsWith(".jsonl")))
+            total += await this.fileSize((0, node_path_1.join)(this.directory, name));
+        for (const session of sessions) {
+            const metadataBytes = Buffer.byteLength(`${JSON.stringify(meta)}\n`);
+            if (total <= this.limits.maxTotalBytes && metadataBytes <= MAX_METADATA_BYTES)
+                break;
+            if (!Object.hasOwn(meta.sessions, session.sessionId))
+                continue;
+            const path = fileFor(this.directory, session.sessionId);
+            const size = await this.fileSize(path);
+            try {
+                await (0, promises_1.unlink)(path);
+            }
+            catch (error) {
+                if (error.code !== "ENOENT")
+                    throw error;
+            }
+            const before = Buffer.byteLength(`${JSON.stringify(meta)}\n`);
+            delete meta.sessions[session.sessionId];
+            const reason = metadataBytes > MAX_METADATA_BYTES ? "目录元数据超出上限，旧会话已清理" : "归档总大小超出上限，旧会话已清理";
+            this.markIncomplete(meta, reason);
+            total -= size + before - Buffer.byteLength(`${JSON.stringify(meta)}\n`);
+        }
+    }
+}
+exports.SessionArchive = SessionArchive;

package/dist/src-ts/session-history.js

@@ -0,0 +1,2 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });