@geminixiang/mikan 1.0.0-beta.8 → 1.0.0-beta.80

package/dist/sessions/session-store.d.ts

@@ -0,0 +1,55 @@
+import { AgentHarness } from "@earendil-works/pi-agent-core";
+import type { AgentHarnessOptions, AgentMessage, Entry } from "@earendil-works/pi-agent-core";
+import type { ImageContent, TextContent } from "@earendil-works/pi-ai";
+import type { SessionContext, SessionCreateInfo, SessionHeader, SessionInspection } from "./types.js";
+import type { McpServerConfig } from "../harness/types.js";
+export declare class SessionStore implements SessionInspection {
+    private readonly sessionFile;
+    private readonly cwd;
+    private state;
+    private writerKey;
+    private mcp;
+    private mutationTail;
+    private closePromise;
+    private closed;
+    private harness;
+    private harnessLane;
+    private constructor();
+    static open(path: string, cwdOverride?: string): Promise<SessionStore>;
+    static inspectExecution(path: string): Promise<{
+        open: boolean;
+        started: boolean;
+        result?: {
+            status: "completed" | "aborted" | "failed" | "declined";
+            endedAt: number;
+        };
+    }>;
+    static inspect(path: string): Promise<SessionInspection>;
+    static create(path: string, cwd: string, options?: SessionCreateInfo): Promise<SessionStore>;
+    static readHeader(path: string): SessionHeader | null;
+    static writeHeaderFile(path: string, cwd: string, options?: SessionCreateInfo): void;
+    static inMemory(cwd?: string): SessionStore;
+    getSessionFile(): string | undefined;
+    isPersisted(): boolean;
+    getCwd(): string;
+    getHeader(): SessionHeader;
+    getSessionId(): string;
+    getLeafId(): Promise<string | null>;
+    getEntry(id: string): Promise<Entry | undefined>;
+    getEntries(): Promise<Entry[]>;
+    getSessionName(): Promise<string | undefined>;
+    getBranch(fromId?: string): Promise<Entry[]>;
+    buildSessionContext(): Promise<SessionContext>;
+    connectMcp(servers: Record<string, McpServerConfig>, signal?: AbortSignal): Promise<import("../harness/types.js").MikanHarnessTool[]>;
+    withMcpInstructions(prompt: string): string;
+    createHarness(options: Omit<AgentHarnessOptions, "session">): Promise<AgentHarness>;
+    appendMessage(message: AgentMessage): Promise<string>;
+    appendCustomEntry(customType: string, data?: unknown): Promise<string>;
+    appendCustomMessageEntry(customType: string, content: string | Array<TextContent | ImageContent>, display: boolean, details?: unknown): Promise<string>;
+    setSessionName(name: string): Promise<void>;
+    close(): Promise<void>;
+    private assertOpen;
+    private mutate;
+    private live;
+}
+//# sourceMappingURL=session-store.d.ts.map

package/dist/sessions/session-store.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"session-store.d.ts","sourceRoot":"","sources":["../../src/sessions/session-store.ts"],"names":[],"mappings":"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"}

package/dist/sessions/session-store.js

@@ -0,0 +1,635 @@
+import { closeSync, existsSync, fstatSync, ftruncateSync, mkdirSync, mkdtempSync, openSync, readFileSync, readSync, realpathSync, rmSync, statSync, writeFileSync, } from "node:fs";
+import { tmpdir } from "node:os";
+import { basename, dirname, join, resolve } from "node:path";
+import { AgentHarness, laneState, operationResult, createBranchSummaryMessage, createCompactionSummaryMessage, createCustomMessage, JsonlSessionRepo, JSONL_STORAGE_VERSION, MemorySessionRepo, TODO_CONTEXT, uuidv7, value, } from "@earendil-works/pi-agent-core";
+import { NodeExecutionEnv } from "@earendil-works/pi-agent-core/node";
+import { atomicWritePrivateFile } from "../file-guards.js";
+import { CURRENT_SESSION_VERSION } from "./types.js";
+import { loadMcpTools, formatMcpServerInstructions } from "../harness/mcp.js";
+import * as log from "../log.js";
+import { isRecord } from "../unknown-values.js";
+const MIKAN_METADATA = value("mikan", "metadata");
+const activeWriterKeys = new Map();
+function canonicalSessionPath(path) {
+    const absolute = resolve(path);
+    if (existsSync(absolute))
+        return realpathSync(absolute);
+    const parent = dirname(absolute);
+    mkdirSync(parent, { recursive: true });
+    return join(realpathSync(parent), basename(absolute));
+}
+function sessionWriterKey(path) {
+    if (!existsSync(path))
+        return `path:${path}`;
+    const stats = statSync(path);
+    return `inode:${stats.dev}:${stats.ino}:${stats.birthtimeMs}`;
+}
+function isStaleClaim(key, claimedPath) {
+    if (!key.startsWith("inode:"))
+        return false;
+    return sessionWriterKey(claimedPath) !== key;
+}
+function claimWriter(key, path) {
+    const claimedPath = activeWriterKeys.get(key);
+    if (claimedPath !== undefined && !isStaleClaim(key, claimedPath)) {
+        throw new Error(`Session file already has an active writer: ${path}`);
+    }
+    activeWriterKeys.set(key, path);
+}
+function acquireWriter(path) {
+    const canonical = canonicalSessionPath(path);
+    const key = sessionWriterKey(canonical);
+    claimWriter(key, canonical);
+    return { path: canonical, key };
+}
+function releaseWriter(key) {
+    activeWriterKeys.delete(key);
+}
+function promotePendingWriter(pathKey, path) {
+    const inodeKey = sessionWriterKey(path);
+    if (inodeKey === pathKey)
+        return pathKey;
+    claimWriter(inodeKey, path);
+    activeWriterKeys.delete(pathKey);
+    return inodeKey;
+}
+function toDurable(input) {
+    return input === undefined ? input : JSON.parse(JSON.stringify(input));
+}
+class SessionFormatError extends Error {
+}
+const HEADER_CHUNK_SIZE = 4096;
+const MAX_HEADER_BYTES = 1024 * 1024;
+function readHeaderLine(filePath) {
+    const fd = openSync(filePath, "r");
+    const chunks = [];
+    let total = 0;
+    try {
+        while (total < MAX_HEADER_BYTES) {
+            const chunk = Buffer.allocUnsafe(Math.min(HEADER_CHUNK_SIZE, MAX_HEADER_BYTES - total));
+            const bytesRead = readSync(fd, chunk, 0, chunk.length, null);
+            if (bytesRead === 0)
+                break;
+            const data = chunk.subarray(0, bytesRead);
+            const newline = data.indexOf(0x0a);
+            chunks.push(newline < 0 ? data : data.subarray(0, newline));
+            total += newline < 0 ? bytesRead : newline;
+            if (newline >= 0)
+                break;
+        }
+    }
+    finally {
+        closeSync(fd);
+    }
+    if (total >= MAX_HEADER_BYTES) {
+        throw new SessionFormatError(`Session file header exceeds ${MAX_HEADER_BYTES} bytes: ${filePath}`);
+    }
+    return Buffer.concat(chunks).toString("utf-8");
+}
+function parseCurrentHeader(filePath, firstLine) {
+    const trimmed = firstLine.trim();
+    if (!trimmed)
+        throw new SessionFormatError(`Session file has a blank header line: ${filePath}`);
+    let parsed;
+    try {
+        parsed = JSON.parse(trimmed);
+    }
+    catch {
+        throw new SessionFormatError(`Session file header is not valid JSON: ${filePath}`);
+    }
+    if (!isMetadataRecord(parsed)) {
+        throw new SessionFormatError(`Session file has an unrecognized header: ${filePath}`);
+    }
+    const record = parsed;
+    if (record.type === "session" || (record.kind === "header" && record.version === 4)) {
+        const generation = record.type === "session" ? "legacy v3" : "Pi 0.84 v4";
+        throw new SessionFormatError(`Session file uses the ${generation} format: ${filePath}. Run \`mikan sessions migrate\` before starting this mikan version.`);
+    }
+    if (record.kind !== "header" ||
+        record.v !== CURRENT_SESSION_VERSION ||
+        record.storageVersion !== JSONL_STORAGE_VERSION ||
+        typeof record.id !== "string" ||
+        typeof record.createdAt !== "number" ||
+        typeof record.cwd !== "string") {
+        throw new SessionFormatError(`Session file has an unrecognized header: ${filePath}`);
+    }
+    return parsed;
+}
+function metadataFromHeader(header, path) {
+    return {
+        id: header.id,
+        createdAt: header.createdAt,
+        storageVersion: header.storageVersion,
+        cwd: header.cwd,
+        path,
+        modifiedAt: 0,
+        parentSessionId: header.parentSessionId,
+        legacyParentSessionPath: header.legacyParentSessionPath,
+    };
+}
+function parseMikanMetadata(filePath) {
+    let current;
+    for (const line of readFileSync(filePath, "utf-8").split("\n").slice(1)) {
+        for (const write of parseMetadataWrites(line)) {
+            if (write.op === "delete")
+                current = undefined;
+            else if (write.op === "set" && isMetadataRecord(write.value))
+                current = write.value;
+        }
+    }
+    return current;
+}
+function isMetadataRecord(input) {
+    return isRecord(input);
+}
+function parseMetadataWrites(line) {
+    let transaction;
+    try {
+        transaction = JSON.parse(line);
+    }
+    catch {
+        return [];
+    }
+    const writes = Array.isArray(transaction) ? transaction : [transaction];
+    return writes.filter((write) => isMetadataRecord(write) &&
+        write.kind === "value" &&
+        write.namespace === "mikan" &&
+        write.key === "metadata");
+}
+function fileFingerprint(path) {
+    const fd = openSync(path, "r");
+    try {
+        const stats = fstatSync(fd);
+        return `${stats.dev}:${stats.ino}:${stats.size}:${stats.mtimeMs}`;
+    }
+    finally {
+        closeSync(fd);
+    }
+}
+function materializePendingFile(path, header, expectedFingerprint) {
+    const content = `${JSON.stringify(header)}\n`;
+    if (expectedFingerprint === null) {
+        mkdirSync(dirname(path), { recursive: true });
+        const fd = openSync(path, "wx", 0o600);
+        try {
+            writeFileSync(fd, content);
+        }
+        finally {
+            closeSync(fd);
+        }
+        return;
+    }
+    const fd = openSync(path, "r+");
+    try {
+        const stats = fstatSync(fd);
+        const actual = `${stats.dev}:${stats.ino}:${stats.size}:${stats.mtimeMs}`;
+        if (actual !== expectedFingerprint) {
+            throw new Error(`Session file changed before pending session materialization: ${path}`);
+        }
+        ftruncateSync(fd, 0);
+        writeFileSync(fd, content);
+    }
+    finally {
+        closeSync(fd);
+    }
+}
+function buildHeader(cwd, options) {
+    const metadata = options?.parentSession === undefined
+        ? undefined
+        : { parentSessionPath: options.parentSession };
+    return {
+        header: {
+            v: CURRENT_SESSION_VERSION,
+            kind: "header",
+            id: options?.id ?? uuidv7(),
+            storageVersion: JSONL_STORAGE_VERSION,
+            createdAt: Date.now(),
+            cwd,
+            parentSessionId: options?.parentSessionId,
+            legacyParentSessionPath: options?.parentSession,
+        },
+        metadata,
+    };
+}
+function headerView(header, metadata) {
+    const parentSession = typeof metadata?.parentSessionPath === "string"
+        ? metadata.parentSessionPath
+        : header.legacyParentSessionPath;
+    return {
+        type: "session",
+        version: CURRENT_SESSION_VERSION,
+        id: header.id,
+        timestamp: new Date(header.createdAt).toISOString(),
+        cwd: header.cwd,
+        parentSessionId: header.parentSessionId,
+        parentSession,
+        metadata,
+    };
+}
+async function openFileSession(path, header) {
+    const sessionRepo = new JsonlSessionRepo({
+        fileSystem: new NodeExecutionEnv({ cwd: process.cwd() }),
+        sessionsRoot: dirname(path),
+    });
+    try {
+        const session = await sessionRepo.open(metadataFromHeader(header, path), TODO_CONTEXT);
+        return { session, repo: sessionRepo };
+    }
+    catch (error) {
+        await sessionRepo.close(TODO_CONTEXT);
+        throw error;
+    }
+}
+async function withSessionSnapshot(path, read) {
+    const resolvedPath = canonicalSessionPath(path);
+    const dir = mkdtempSync(join(tmpdir(), "mikan-session-inspect-"));
+    const snapshot = join(dir, basename(resolvedPath));
+    let opened;
+    try {
+        writeFileSync(snapshot, readFileSync(resolvedPath), { mode: 0o600, flag: "wx" });
+        const header = parseCurrentHeader(resolvedPath, readHeaderLine(snapshot));
+        opened = await openFileSession(snapshot, header);
+        return await read(opened.session, header);
+    }
+    finally {
+        try {
+            await opened?.session.close(TODO_CONTEXT);
+        }
+        finally {
+            try {
+                await opened?.repo.close(TODO_CONTEXT);
+            }
+            finally {
+                rmSync(dir, { recursive: true, force: true });
+            }
+        }
+    }
+}
+async function mainBranch(session, create) {
+    const existing = await session.branch("main", TODO_CONTEXT);
+    if (existing || !create)
+        return existing;
+    return session.createBranch("main", null, TODO_CONTEXT);
+}
+function isContextMessage(message) {
+    return (message.role !== "assistant" ||
+        (message.stopReason !== "error" &&
+            message.stopReason !== "aborted" &&
+            message.stopReason !== "deferred"));
+}
+function buildContext(entries) {
+    const compactionIndex = entries.findLastIndex((entry) => entry.type === "compaction");
+    const visibleEntries = entries.slice(Math.max(0, compactionIndex));
+    const messages = [];
+    for (const entry of visibleEntries) {
+        if (entry.type === "message") {
+            if (isContextMessage(entry.message))
+                messages.push(entry.message);
+        }
+        else if (entry.type === "compaction") {
+            messages.push(createCompactionSummaryMessage(entry.summary, entry.tokensBefore, entry.timestamp), ...entry.retainedTail.filter(isContextMessage));
+        }
+        else if (entry.type === "branch_summary" && entry.summary) {
+            messages.push(createBranchSummaryMessage(entry.summary, entry.fromId, entry.timestamp));
+        }
+    }
+    return { messages };
+}
+class CachedSessionInspection {
+    constructor(header, entries, name, branch, context) {
+        this.header = header;
+        this.entries = entries;
+        this.name = name;
+        this.branch = branch;
+        this.context = context;
+    }
+    getHeader() {
+        return structuredClone(this.header);
+    }
+    async getEntries() {
+        return structuredClone(this.entries);
+    }
+    async getSessionName() {
+        return this.name;
+    }
+    async getBranch(fromId) {
+        if (fromId === undefined)
+            return structuredClone(this.branch);
+        const byId = new Map(this.entries.map((entry) => [entry.id, entry]));
+        const result = [];
+        let current = byId.get(fromId);
+        while (current) {
+            result.push(current);
+            current = current.parentId === null ? undefined : byId.get(current.parentId);
+        }
+        return result.toReversed();
+    }
+    async buildSessionContext() {
+        return structuredClone(this.context);
+    }
+}
+export class SessionStore {
+    constructor(sessionFile, cwd, state, writerKey) {
+        this.sessionFile = sessionFile;
+        this.cwd = cwd;
+        this.state = state;
+        this.writerKey = writerKey;
+        this.mutationTail = Promise.resolve();
+        this.closed = false;
+    }
+    static async open(path, cwdOverride) {
+        const writer = acquireWriter(path);
+        const writerPath = writer.path;
+        try {
+            if (!existsSync(writerPath)) {
+                const cwd = cwdOverride ?? process.cwd();
+                const built = buildHeader(cwd);
+                return new SessionStore(writerPath, cwd, { kind: "pending", ...built, fingerprint: null }, writer.key);
+            }
+            const firstLine = readHeaderLine(writerPath);
+            if (firstLine.trim().length === 0) {
+                const cwd = cwdOverride ?? process.cwd();
+                const built = buildHeader(cwd);
+                return new SessionStore(writerPath, cwd, { kind: "pending", ...built, fingerprint: fileFingerprint(writerPath) }, writer.key);
+            }
+            const header = parseCurrentHeader(writerPath, firstLine);
+            const opened = await openFileSession(writerPath, header);
+            const metadata = (await opened.session.getValue(MIKAN_METADATA, TODO_CONTEXT))?.value;
+            return new SessionStore(writerPath, cwdOverride ?? header.cwd, { kind: "live", header, metadata, ...opened }, writer.key);
+        }
+        catch (error) {
+            releaseWriter(writer.key);
+            throw error;
+        }
+    }
+    static async inspectExecution(path) {
+        return withSessionSnapshot(path, async (session) => {
+            const state = (await session.getValue(laneState("main"), TODO_CONTEXT))?.value;
+            const result = state?.lastOperationId
+                ? (await session.getValue(operationResult(state.lastOperationId), TODO_CONTEXT))?.value
+                : undefined;
+            return {
+                open: state?.currentOperationId != null,
+                started: state?.currentOperationId != null || state?.lastOperationId != null,
+                result: result ? { status: result.status, endedAt: result.endedAt } : undefined,
+            };
+        });
+    }
+    static async inspect(path) {
+        return withSessionSnapshot(path, async (session, header) => {
+            const metadata = (await session.getValue(MIKAN_METADATA, TODO_CONTEXT))?.value;
+            const entries = await session.findEntries({ order: "asc" }, TODO_CONTEXT);
+            const name = await session.getName(TODO_CONTEXT);
+            const branchObject = await mainBranch(session, false);
+            const branch = branchObject
+                ? await branchObject.findEntries({ order: "oldestFirst" }, TODO_CONTEXT)
+                : [];
+            const context = buildContext(branch);
+            return new CachedSessionInspection(headerView(header, metadata), entries, name, branch, context);
+        });
+    }
+    static async create(path, cwd, options) {
+        const writer = acquireWriter(path);
+        const writerPath = writer.path;
+        let leaseKey = writer.key;
+        let opened;
+        try {
+            const built = buildHeader(cwd, options);
+            mkdirSync(dirname(writerPath), { recursive: true });
+            writeFileSync(writerPath, `${JSON.stringify(built.header)}\n`, { mode: 0o600, flag: "wx" });
+            leaseKey = promotePendingWriter(leaseKey, writerPath);
+            opened = await openFileSession(writerPath, built.header);
+            if (built.metadata) {
+                await opened.session.setValue(MIKAN_METADATA, built.metadata, TODO_CONTEXT);
+            }
+            return new SessionStore(writerPath, cwd, { kind: "live", ...built, ...opened }, leaseKey);
+        }
+        catch (error) {
+            if (opened) {
+                await opened.session.close(TODO_CONTEXT).catch(() => undefined);
+                await opened.repo.close(TODO_CONTEXT).catch(() => undefined);
+            }
+            releaseWriter(leaseKey);
+            throw error;
+        }
+    }
+    static readHeader(path) {
+        let firstLine;
+        try {
+            firstLine = readHeaderLine(path);
+        }
+        catch {
+            return null;
+        }
+        if (firstLine.trim().length === 0)
+            return null;
+        try {
+            const header = parseCurrentHeader(path, firstLine);
+            return headerView(header, parseMikanMetadata(path));
+        }
+        catch (error) {
+            if (error instanceof SessionFormatError && /legacy v3|Pi 0\.84 v4/.test(error.message)) {
+                throw error;
+            }
+            return null;
+        }
+    }
+    static writeHeaderFile(path, cwd, options) {
+        mkdirSync(dirname(path), { recursive: true });
+        const built = buildHeader(cwd, options);
+        atomicWritePrivateFile(path, `${JSON.stringify(built.header)}\n`);
+    }
+    static inMemory(cwd = process.cwd()) {
+        const built = buildHeader(cwd);
+        return new SessionStore(null, cwd, { kind: "pending", ...built, fingerprint: null }, null);
+    }
+    getSessionFile() {
+        this.assertOpen();
+        return this.sessionFile ?? undefined;
+    }
+    isPersisted() {
+        this.assertOpen();
+        return this.sessionFile !== null;
+    }
+    getCwd() {
+        this.assertOpen();
+        return this.cwd;
+    }
+    getHeader() {
+        this.assertOpen();
+        return headerView(this.state.header, this.state.metadata);
+    }
+    getSessionId() {
+        this.assertOpen();
+        return this.state.header.id;
+    }
+    async getLeafId() {
+        this.assertOpen();
+        if (this.state.kind === "pending")
+            return null;
+        return (await mainBranch(this.state.session, false))?.getTipId(TODO_CONTEXT) ?? null;
+    }
+    async getEntry(id) {
+        this.assertOpen();
+        if (this.state.kind === "pending")
+            return undefined;
+        return this.state.session.getEntry(id, TODO_CONTEXT);
+    }
+    async getEntries() {
+        this.assertOpen();
+        if (this.state.kind === "pending")
+            return [];
+        return this.state.session.findEntries({ order: "asc" }, TODO_CONTEXT);
+    }
+    async getSessionName() {
+        this.assertOpen();
+        if (this.state.kind === "pending")
+            return undefined;
+        return this.state.session.getName(TODO_CONTEXT);
+    }
+    async getBranch(fromId) {
+        this.assertOpen();
+        if (this.state.kind === "pending")
+            return [];
+        if (fromId !== undefined) {
+            return this.state.session.scanBranch({ start: fromId, order: "oldestFirst" }, TODO_CONTEXT);
+        }
+        const branchObject = await mainBranch(this.state.session, false);
+        return branchObject ? branchObject.findEntries({ order: "oldestFirst" }, TODO_CONTEXT) : [];
+    }
+    async buildSessionContext() {
+        return buildContext(await this.getBranch());
+    }
+    async connectMcp(servers, signal) {
+        return this.mutate(async () => {
+            if (this.mcp)
+                throw new Error("SessionStore already has MCP connections");
+            this.mcp = await loadMcpTools(servers, signal);
+            for (const error of this.mcp.errors) {
+                log.logWarning(`MCP server unavailable: ${error.server}`, error.error);
+            }
+            signal?.throwIfAborted();
+            return this.mcp.tools;
+        });
+    }
+    withMcpInstructions(prompt) {
+        const instructions = formatMcpServerInstructions(this.mcp?.instructions ?? []);
+        return instructions ? `${prompt}\n\n${instructions}` : prompt;
+    }
+    async createHarness(options) {
+        return this.mutate(async () => {
+            if (this.harness)
+                throw new Error("SessionStore already has an attached harness");
+            const { session } = await this.live();
+            const { harness } = await AgentHarness.create({ ...options, session }, TODO_CONTEXT);
+            this.harness = harness;
+            this.harnessLane = await harness.lane("main", TODO_CONTEXT);
+            return harness;
+        });
+    }
+    async appendMessage(message) {
+        return this.mutate(async () => {
+            if (this.harnessLane)
+                return this.harnessLane.appendMessage(toDurable(message), TODO_CONTEXT);
+            const branchObject = await mainBranch((await this.live()).session, true);
+            if (!branchObject)
+                throw new Error("Failed to create main session branch");
+            return branchObject.appendMessage(toDurable(message), TODO_CONTEXT);
+        });
+    }
+    async appendCustomEntry(customType, data) {
+        return this.mutate(async () => {
+            if (this.harnessLane) {
+                return this.harnessLane.appendCustomEntry(customType, toDurable(data), TODO_CONTEXT);
+            }
+            const branchObject = await mainBranch((await this.live()).session, true);
+            if (!branchObject)
+                throw new Error("Failed to create main session branch");
+            return branchObject.appendCustomEntry(customType, toDurable(data), TODO_CONTEXT);
+        });
+    }
+    async appendCustomMessageEntry(customType, content, display, details) {
+        return this.appendMessage(toDurable(createCustomMessage(customType, content, display, details, Date.now())));
+    }
+    async setSessionName(name) {
+        await this.mutate(async () => (await this.live()).session.setName(name.trim() || undefined, TODO_CONTEXT));
+    }
+    async close() {
+        if (this.closePromise)
+            return this.closePromise;
+        this.closed = true;
+        this.closePromise = this.mutationTail
+            .then(async () => {
+            try {
+                await this.mcp?.dispose();
+            }
+            finally {
+                if (this.state.kind === "live") {
+                    try {
+                        if (this.harness)
+                            await this.harness.close(TODO_CONTEXT);
+                        else
+                            await this.state.session.close(TODO_CONTEXT);
+                    }
+                    finally {
+                        await this.state.repo?.close(TODO_CONTEXT);
+                    }
+                }
+            }
+        })
+            .finally(() => {
+            if (this.writerKey !== null)
+                releaseWriter(this.writerKey);
+        });
+        return this.closePromise;
+    }
+    assertOpen() {
+        if (this.closed)
+            throw new Error("SessionStore is closed");
+    }
+    mutate(operation) {
+        this.assertOpen();
+        const result = this.mutationTail.then(operation);
+        this.mutationTail = result.then(() => undefined, () => undefined);
+        return result;
+    }
+    async live() {
+        if (this.state.kind === "live")
+            return this.state;
+        const pending = this.state;
+        const sessionFile = this.sessionFile;
+        if (sessionFile === null) {
+            const repo = new MemorySessionRepo();
+            const session = await repo.create({
+                id: pending.header.id,
+                parentSessionId: pending.header.parentSessionId,
+            }, TODO_CONTEXT);
+            const live = {
+                kind: "live",
+                header: pending.header,
+                metadata: pending.metadata,
+                session,
+                repo,
+            };
+            this.state = live;
+            return live;
+        }
+        materializePendingFile(sessionFile, pending.header, pending.fingerprint);
+        if (this.writerKey === null)
+            throw new Error("Pending session must have a writer lease");
+        this.writerKey = promotePendingWriter(this.writerKey, sessionFile);
+        const opened = await openFileSession(sessionFile, pending.header);
+        if (pending.metadata) {
+            await opened.session.setValue(MIKAN_METADATA, pending.metadata, TODO_CONTEXT);
+        }
+        const live = {
+            kind: "live",
+            header: pending.header,
+            metadata: pending.metadata,
+            ...opened,
+        };
+        this.state = live;
+        return live;
+    }
+}
+//# sourceMappingURL=session-store.js.map