@agents-ensemble/core 0.20.0 → 0.22.0

package/dist/session/worker-session-history.js

@@ -0,0 +1,654 @@
+import { createReadStream } from 'node:fs';
+import { readFile, readdir, stat } from 'node:fs/promises';
+import { homedir } from 'node:os';
+import { extname, isAbsolute, join, resolve } from 'node:path';
+import { createInterface } from 'node:readline';
+import { SessionManager, parseSessionEntries, } from '@earendil-works/pi-coding-agent';
+import { parseIssueUrl } from '../issue/issue-ref.js';
+import { resolveEnsemblePaths } from '../ensemble-paths.js';
+import { resolvePiAcpSessionMapPaths } from '../acp/pi-session-map.js';
+import { findSessionResumeStoreBySelector, listUserLocatedSessionResumeStoresPage, } from './session-resume-store.js';
+const PI_ACP_JSONL_READER_ID = 'pi-acp-jsonl';
+const CODEX_CLI_ROLLOUT_READER_ID = 'codex-cli-rollout-jsonl';
+const CODEX_UUID_PATTERN = /^[0-9a-f]{8}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{12}$/iu;
+const workerSessionHistoryReaders = new Map([
+    [
+        'pi',
+        {
+            id: PI_ACP_JSONL_READER_ID,
+            preset: 'pi',
+            read: async (input) => (await readPiAcpSessionHistoryWithSources(input)).messages,
+            readWithSources: readPiAcpSessionHistoryWithSources,
+        },
+    ],
+    [
+        'codex',
+        {
+            id: CODEX_CLI_ROLLOUT_READER_ID,
+            preset: 'codex',
+            read: async (input) => (await readCodexAcpSessionHistoryWithSources(input)).messages,
+            readWithSources: readCodexAcpSessionHistoryWithSources,
+        },
+    ],
+]);
+export function getWorkerSessionHistoryReaderSupport(preset) {
+    const normalizedPreset = preset?.trim() || undefined;
+    if (!normalizedPreset) {
+        return {
+            preset: null,
+            status: 'unsupported',
+            reason: 'SessionResumeStore に ACP preset がないため、読み取り方式を判定できません。',
+        };
+    }
+    const reader = workerSessionHistoryReaders.get(normalizedPreset);
+    if (reader) {
+        return {
+            preset: normalizedPreset,
+            status: 'supported',
+            reader: reader.id,
+        };
+    }
+    return {
+        preset: normalizedPreset,
+        status: 'unsupported',
+        reason: `ACP preset「${normalizedPreset}」のオフライン transcript reader は未対応です。`,
+    };
+}
+export async function readWorkerSessionHistory(input) {
+    const conductorAgentId = requireNonEmpty(input.conductorAgentId, 'conductorAgentId');
+    const workerName = requireNonEmpty(input.workerName, 'workerName');
+    const located = input.userEnsembleRoot
+        ? await findUserWorkerSessionResumeStore({
+            userEnsembleRoot: input.userEnsembleRoot,
+            conductorAgentId,
+            githubRepo: input.githubRepo,
+            issueUrl: input.issueUrl,
+        })
+        : await findSessionResumeStoreBySelector(requireRepoRoot(input.repoRoot), {
+            githubRepo: input.githubRepo,
+            issueUrl: input.issueUrl,
+            conductorAgentId,
+        });
+    if (!located) {
+        throw new Error(`No saved session found for ${conductorAgentId}.`);
+    }
+    const repoRoot = resolve(input.repoRoot ?? located.resumeStore.repoRoot);
+    const worker = located.resumeStore.workers[workerName];
+    if (!worker) {
+        throw new Error(`No saved worker session found for ${workerName} in ${conductorAgentId}.`);
+    }
+    const support = getWorkerSessionHistoryReaderSupport(worker.acpSpawn?.preset);
+    const base = {
+        conductorAgentId,
+        worker: workerName,
+        ...support,
+    };
+    if (support.status === 'unsupported') {
+        return {
+            ...base,
+            status: 'unsupported',
+            messages: [],
+            ...(input.includeSourceFiles ? { sourceFiles: [] } : {}),
+        };
+    }
+    if (!support.preset) {
+        return {
+            ...base,
+            status: 'unsupported',
+            reason: '対応 reader の ACP preset を解決できません。',
+            messages: [],
+            ...(input.includeSourceFiles ? { sourceFiles: [] } : {}),
+        };
+    }
+    const reader = workerSessionHistoryReaders.get(support.preset);
+    if (!reader) {
+        throw new Error(`Worker session history reader is missing: ${support.preset}`);
+    }
+    if (!worker.acpCwd?.trim()) {
+        return {
+            ...base,
+            status: 'unavailable',
+            reason: 'SessionResumeStore に worker ACP cwd がないため、transcript を照合できません。',
+            messages: [],
+            ...(input.includeSourceFiles ? { sourceFiles: [] } : {}),
+        };
+    }
+    try {
+        const piRuntime = worker.acpSpawn?.piRuntime;
+        let issueNumber;
+        if (piRuntime === 'builtin') {
+            try {
+                issueNumber = parseIssueUrl(located.resumeStore.issueUrl).number;
+            }
+            catch {
+                throw new WorkerSessionHistoryUnavailableError('SessionResumeStore に有効な Issue URL がないため、builtin Pi の保存先を解決できません。');
+            }
+        }
+        const readerInput = {
+            repoRoot,
+            fallbackRepoRoots: [located.resumeStore.repoRoot],
+            ...(input.userEnsembleRoot
+                ? { userEnsembleRoot: input.userEnsembleRoot }
+                : {}),
+            workerName,
+            acpSessionId: worker.acpSessionId,
+            acpCwd: worker.acpCwd,
+            ...(piRuntime
+                ? { piRuntime }
+                : {}),
+            ...(issueNumber !== undefined ? { issueNumber } : {}),
+        };
+        const result = input.includeSourceFiles
+            ? await reader.readWithSources(readerInput)
+            : {
+                messages: await reader.read(readerInput),
+                sourceFiles: [],
+            };
+        return {
+            ...base,
+            status: 'supported',
+            messages: result.messages,
+            ...(input.includeSourceFiles
+                ? { sourceFiles: result.sourceFiles }
+                : {}),
+        };
+    }
+    catch (error) {
+        if (!(error instanceof WorkerSessionHistoryUnavailableError)) {
+            throw error;
+        }
+        return {
+            ...base,
+            status: 'unavailable',
+            reason: error.message,
+            messages: [],
+            ...(input.includeSourceFiles ? { sourceFiles: [] } : {}),
+        };
+    }
+}
+async function findUserWorkerSessionResumeStore(input) {
+    if (!input.githubRepo && !input.issueUrl) {
+        throw new Error('Repository scope is required to read a session; pass githubRepo or issueUrl.');
+    }
+    const page = await listUserLocatedSessionResumeStoresPage({
+        githubRepo: input.githubRepo,
+        issueUrl: input.issueUrl,
+        conductorAgentId: input.conductorAgentId,
+    }, { userEnsembleRoot: input.userEnsembleRoot });
+    if (page.sessions.length > 1) {
+        throw new Error(`Session ${input.conductorAgentId} is ambiguous in this repository; specify issueUrl.`);
+    }
+    return page.sessions[0];
+}
+function requireRepoRoot(value) {
+    if (!value?.trim()) {
+        throw new Error('repoRoot is required to read a repository-scoped session.');
+    }
+    return resolve(value);
+}
+class WorkerSessionHistoryUnavailableError extends Error {
+    constructor(message) {
+        super(message);
+        this.name = 'WorkerSessionHistoryUnavailableError';
+    }
+}
+async function readPiAcpSessionHistoryWithSources(input) {
+    const paths = input.piRuntime === 'builtin'
+        ? resolveEnsemblePaths({
+            repoRoot: input.repoRoot,
+            userEnsembleRoot: input.userEnsembleRoot,
+        })
+        : undefined;
+    let session;
+    let foundMap = false;
+    let malformedMap = false;
+    let sessionMapPaths;
+    if (paths) {
+        const issueNumber = input.issueNumber;
+        if (issueNumber === undefined ||
+            !Number.isSafeInteger(issueNumber) ||
+            issueNumber < 1) {
+            throw new WorkerSessionHistoryUnavailableError('builtin Pi の Issue number がなく、session map を解決できません。');
+        }
+        sessionMapPaths = [
+            ...[input.repoRoot, ...(input.fallbackRepoRoots ?? [])].flatMap((repoRoot) => {
+                const rootPaths = resolveEnsemblePaths({
+                    repoRoot,
+                    userEnsembleRoot: input.userEnsembleRoot,
+                });
+                const mapPaths = resolvePiAcpSessionMapPaths(rootPaths.piWorkerDir(input.workerName, issueNumber), rootPaths.legacyPiWorkerDir(input.workerName));
+                return [mapPaths.upstreamPath, ...mapPaths.compatibilityPaths];
+            }),
+        ];
+    }
+    else {
+        sessionMapPaths = [join(homedir(), '.pi', 'pi-acp', 'session-map.json')];
+    }
+    for (const path of new Set(sessionMapPaths)) {
+        let raw;
+        try {
+            raw = await readFile(path, 'utf8');
+            foundMap = true;
+        }
+        catch (error) {
+            if (isEnoent(error))
+                continue;
+            throw new WorkerSessionHistoryUnavailableError('Pi ACP の session map を読み取れませんでした。');
+        }
+        let parsed;
+        try {
+            parsed = JSON.parse(raw);
+        }
+        catch {
+            malformedMap = true;
+            continue;
+        }
+        session = findPiAcpSessionMapEntry(parsed, input.acpSessionId);
+        if (session)
+            break;
+    }
+    if (!session) {
+        if (!foundMap) {
+            throw new WorkerSessionHistoryUnavailableError('Pi ACP の session map が見つかりません。');
+        }
+        if (malformedMap) {
+            throw new WorkerSessionHistoryUnavailableError('Pi ACP の session map が不正な JSON です。');
+        }
+        throw new WorkerSessionHistoryUnavailableError('Pi ACP の session map に対象 session がありません。');
+    }
+    if (!isAbsolute(session.cwd) || resolve(session.cwd) !== resolve(input.acpCwd)) {
+        throw new WorkerSessionHistoryUnavailableError('Pi ACP session map の cwd が SessionResumeStore と一致しません。');
+    }
+    if (!isAbsolute(session.sessionFile) ||
+        extname(session.sessionFile).toLowerCase() !== '.jsonl') {
+        throw new WorkerSessionHistoryUnavailableError('Pi ACP session map に有効な transcript path がありません。');
+    }
+    let transcriptStat;
+    try {
+        transcriptStat = await stat(session.sessionFile);
+    }
+    catch (error) {
+        if (isEnoent(error)) {
+            throw new WorkerSessionHistoryUnavailableError('Pi ACP session map が指す transcript file が見つかりません。');
+        }
+        throw new WorkerSessionHistoryUnavailableError('Pi ACP transcript file を読み取れませんでした。');
+    }
+    if (!transcriptStat.isFile()) {
+        throw new WorkerSessionHistoryUnavailableError('Pi ACP session map が指す transcript path は file ではありません。');
+    }
+    let transcript;
+    try {
+        transcript = await readFile(session.sessionFile, 'utf8');
+    }
+    catch (error) {
+        if (isEnoent(error)) {
+            throw new WorkerSessionHistoryUnavailableError('Pi ACP session map が指す transcript file が見つかりません。');
+        }
+        throw new WorkerSessionHistoryUnavailableError('Pi ACP transcript file を読み取れませんでした。');
+    }
+    const entries = parseSessionEntries(transcript);
+    const header = getPiSessionHeader(entries[0]);
+    if (!header) {
+        throw new WorkerSessionHistoryUnavailableError('Pi ACP transcript に有効な session header がありません。');
+    }
+    if (header.id !== input.acpSessionId) {
+        throw new WorkerSessionHistoryUnavailableError('Pi ACP transcript の session ID が保存状態と一致しません。');
+    }
+    if (!isAbsolute(header.cwd) ||
+        resolve(header.cwd) !== resolve(input.acpCwd)) {
+        throw new WorkerSessionHistoryUnavailableError('Pi ACP transcript header の cwd が保存状態と一致しません。');
+    }
+    let sessionManager;
+    try {
+        // `open()` persists empty-session initialization and legacy migrations.
+        sessionManager = SessionManager.inMemory(header.cwd, undefined, entries);
+    }
+    catch {
+        throw new WorkerSessionHistoryUnavailableError('Pi ACP transcript を Pi session format として読み取れませんでした。');
+    }
+    if (sessionManager.getSessionId() !== input.acpSessionId) {
+        throw new WorkerSessionHistoryUnavailableError('Pi ACP transcript の session ID が保存状態と一致しません。');
+    }
+    let branch;
+    try {
+        branch = sessionManager.getBranch();
+    }
+    catch {
+        throw new WorkerSessionHistoryUnavailableError('Pi ACP transcript の active branch を読み取れませんでした。');
+    }
+    return {
+        messages: branch.flatMap((entry) => {
+            if (!isSessionMessageEntry(entry))
+                return [];
+            const role = entry.message.role;
+            if (role !== 'user' && role !== 'assistant')
+                return [];
+            const text = extractPiMessageText(entry.message.content);
+            if (!text.trim())
+                return [];
+            const at = getMessageTimestamp(entry);
+            return [
+                {
+                    source: `worker:${input.workerName}`,
+                    providerId: entry.id,
+                    role,
+                    ...(at !== undefined ? { at } : {}),
+                    text,
+                },
+            ];
+        }),
+        sourceFiles: [session.sessionFile],
+    };
+}
+async function readCodexAcpSessionHistoryWithSources(input) {
+    const sessionId = input.acpSessionId.trim();
+    if (!sessionId) {
+        throw new WorkerSessionHistoryUnavailableError('SessionResumeStore に Codex ACP session ID がありません。');
+    }
+    if (!isAbsolute(input.acpCwd)) {
+        throw new WorkerSessionHistoryUnavailableError('SessionResumeStore に有効な Codex ACP cwd がありません。');
+    }
+    const codexHome = resolveCodexHome(input.acpCwd);
+    const rolloutPath = await findCodexAcpRollout(codexHome, sessionId);
+    if (!rolloutPath) {
+        throw new WorkerSessionHistoryUnavailableError('現在の Codex home に対象 session の rollout が見つかりません。');
+    }
+    let decompressor;
+    if (rolloutPath.endsWith('.jsonl.zst')) {
+        const zlib = await import('node:zlib');
+        const createZstdDecompress = zlib.createZstdDecompress;
+        if (!createZstdDecompress) {
+            throw new WorkerSessionHistoryUnavailableError('現在の Node.js は Codex の圧縮 rollout（zstd）に対応していません。');
+        }
+        decompressor = createZstdDecompress();
+    }
+    const sourceStream = createReadStream(rolloutPath);
+    const inputStream = decompressor
+        ? sourceStream.pipe(decompressor)
+        : sourceStream;
+    let streamError;
+    const recordStreamError = (error) => {
+        streamError ??= error;
+    };
+    sourceStream.on('error', (error) => {
+        recordStreamError(error);
+        if (decompressor)
+            decompressor.destroy(error);
+    });
+    if (decompressor)
+        decompressor.on('error', recordStreamError);
+    try {
+        const lines = createInterface({
+            input: inputStream,
+            crlfDelay: Infinity,
+        });
+        let header;
+        let lineNumber = 0;
+        const messages = [];
+        try {
+            for await (const line of lines) {
+                lineNumber += 1;
+                if (!line.trim())
+                    continue;
+                let envelope;
+                try {
+                    envelope = JSON.parse(line);
+                }
+                catch {
+                    throw new WorkerSessionHistoryUnavailableError('Codex CLI rollout の JSONL に不正な行があります。');
+                }
+                if (!header) {
+                    header = getCodexSessionHeader(envelope);
+                    if (!header) {
+                        throw new WorkerSessionHistoryUnavailableError('Codex CLI rollout に有効な session_meta がありません。');
+                    }
+                    if (header.id !== sessionId) {
+                        throw new WorkerSessionHistoryUnavailableError('Codex CLI rollout の session ID が保存状態と一致しません。');
+                    }
+                    if (!isAbsolute(header.cwd) ||
+                        resolve(header.cwd) !== resolve(input.acpCwd)) {
+                        throw new WorkerSessionHistoryUnavailableError('Codex CLI rollout の cwd が保存状態と一致しません。');
+                    }
+                    continue;
+                }
+                const message = codexRolloutMessage(envelope, input.workerName, lineNumber);
+                if (message)
+                    messages.push(message);
+            }
+        }
+        finally {
+            lines.close();
+        }
+        if (streamError) {
+            throw new WorkerSessionHistoryUnavailableError('Codex CLI rollout を読み取れませんでした。');
+        }
+        if (!header) {
+            throw new WorkerSessionHistoryUnavailableError('Codex CLI rollout に有効な session_meta がありません。');
+        }
+        return {
+            messages,
+            sourceFiles: [rolloutPath],
+        };
+    }
+    catch (error) {
+        if (error instanceof WorkerSessionHistoryUnavailableError)
+            throw error;
+        throw new WorkerSessionHistoryUnavailableError('Codex CLI rollout を読み取れませんでした。');
+    }
+    finally {
+        decompressor?.destroy();
+        sourceStream.destroy();
+    }
+}
+function resolveCodexHome(acpCwd) {
+    const configuredHome = process.env.CODEX_HOME;
+    if (configuredHome) {
+        return resolve(acpCwd, configuredHome);
+    }
+    return join(homedir(), '.codex');
+}
+async function findCodexAcpRollout(codexHome, sessionId) {
+    const candidates = [];
+    for (const directoryName of ['sessions', 'archived_sessions']) {
+        const directory = join(codexHome, directoryName);
+        await collectCodexAcpRolloutCandidates(directory, sessionId, candidates);
+    }
+    if (candidates.length > 1) {
+        throw new WorkerSessionHistoryUnavailableError('Codex CLI store に同じ session ID の rollout が複数あり、対象を一意に決められません。');
+    }
+    return candidates[0]?.path;
+}
+async function collectCodexAcpRolloutCandidates(directory, sessionId, candidates) {
+    let entries;
+    try {
+        entries = await readdir(directory, { withFileTypes: true });
+    }
+    catch (error) {
+        if (isEnoent(error))
+            return;
+        throw new WorkerSessionHistoryUnavailableError('Codex CLI store を探索できませんでした。');
+    }
+    const plainRolloutNames = new Set(entries
+        .filter((entry) => entry.isFile() && entry.name.endsWith('.jsonl'))
+        .map((entry) => entry.name));
+    for (const entry of entries) {
+        const path = join(directory, entry.name);
+        if (entry.isDirectory()) {
+            await collectCodexAcpRolloutCandidates(path, sessionId, candidates);
+            continue;
+        }
+        if (!entry.isFile())
+            continue;
+        const plainFileName = codexRolloutPlainFileName(entry.name);
+        if (!plainFileName ||
+            (entry.name.endsWith('.jsonl.zst') &&
+                plainRolloutNames.has(plainFileName))) {
+            continue;
+        }
+        const threadId = codexThreadIdFromRolloutFileName(entry.name);
+        if (threadId !== sessionId)
+            continue;
+        candidates.push({ path });
+    }
+}
+function codexRolloutPlainFileName(fileName) {
+    if (fileName.endsWith('.jsonl.zst'))
+        return fileName.slice(0, -4);
+    if (fileName.endsWith('.jsonl'))
+        return fileName;
+    return undefined;
+}
+function codexThreadIdFromRolloutFileName(fileName) {
+    const plainFileName = codexRolloutPlainFileName(fileName);
+    if (!plainFileName)
+        return undefined;
+    const baseName = plainFileName.slice(0, -'.jsonl'.length);
+    if (!baseName.startsWith('rollout-'))
+        return undefined;
+    const identity = baseName.slice('rollout-'.length);
+    const timestamp = identity.slice(0, 19);
+    if (!/^\d{4}-\d{2}-\d{2}T\d{2}-\d{2}-\d{2}$/u.test(timestamp) ||
+        identity[19] !== '-') {
+        return undefined;
+    }
+    const rolloutIds = identity.slice(20);
+    const separator = rolloutIds.indexOf('_');
+    const threadId = separator < 0 ? rolloutIds : rolloutIds.slice(0, separator);
+    const rolloutId = separator < 0 ? threadId : rolloutIds.slice(separator + 1);
+    if (!threadId || (separator >= 0 && !rolloutIds.slice(separator + 1))) {
+        return undefined;
+    }
+    if (!CODEX_UUID_PATTERN.test(threadId) ||
+        !CODEX_UUID_PATTERN.test(rolloutId) ||
+        !isCodexRolloutTimestamp(timestamp)) {
+        return undefined;
+    }
+    return threadId;
+}
+function isCodexRolloutTimestamp(value) {
+    const isoTimestamp = `${value.slice(0, 10)}T${value.slice(11, 13)}:${value.slice(14, 16)}:${value.slice(17, 19)}Z`;
+    const timestamp = new Date(isoTimestamp);
+    return (Number.isFinite(timestamp.getTime()) &&
+        timestamp.toISOString().slice(0, 19).replaceAll(':', '-') === value);
+}
+function getCodexSessionHeader(value) {
+    if (!isRecord(value) ||
+        value.type !== 'session_meta' ||
+        !isRecord(value.payload) ||
+        typeof value.payload.id !== 'string' ||
+        !value.payload.id.trim() ||
+        typeof value.payload.cwd !== 'string' ||
+        !value.payload.cwd.trim()) {
+        return undefined;
+    }
+    return {
+        id: value.payload.id,
+        cwd: value.payload.cwd,
+    };
+}
+function codexRolloutMessage(value, workerName, lineNumber) {
+    if (!isRecord(value) ||
+        value.type !== 'response_item' ||
+        !isRecord(value.payload) ||
+        value.payload.type !== 'message' ||
+        (value.payload.role !== 'user' && value.payload.role !== 'assistant')) {
+        return undefined;
+    }
+    const text = extractCodexMessageText(value.payload.content);
+    if (!text.trim())
+        return undefined;
+    const ordinal = value.ordinal;
+    const providerId = typeof ordinal === 'number' && Number.isSafeInteger(ordinal)
+        ? `codex:${ordinal}`
+        : `codex:${lineNumber}`;
+    const timestamp = typeof value.timestamp === 'string' ? Date.parse(value.timestamp) : NaN;
+    return {
+        source: `worker:${workerName}`,
+        providerId,
+        role: value.payload.role,
+        ...(Number.isFinite(timestamp) ? { at: timestamp } : {}),
+        text,
+    };
+}
+function extractCodexMessageText(content) {
+    if (typeof content === 'string')
+        return content;
+    if (!Array.isArray(content))
+        return '';
+    return content
+        .filter((block) => isRecord(block) &&
+        (block.type === 'input_text' || block.type === 'output_text') &&
+        typeof block.text === 'string')
+        .map((block) => block.text)
+        .join('');
+}
+function getPiSessionHeader(value) {
+    if (!isRecord(value) ||
+        value.type !== 'session' ||
+        typeof value.id !== 'string' ||
+        !value.id.trim() ||
+        typeof value.cwd !== 'string' ||
+        !value.cwd.trim()) {
+        return undefined;
+    }
+    return { id: value.id, cwd: value.cwd };
+}
+function findPiAcpSessionMapEntry(value, sessionId) {
+    if (!isRecord(value) || value.version !== 1 || !isRecord(value.sessions)) {
+        return undefined;
+    }
+    const entry = value.sessions[sessionId];
+    if (!isRecord(entry) ||
+        entry.sessionId !== sessionId ||
+        typeof entry.cwd !== 'string' ||
+        typeof entry.sessionFile !== 'string') {
+        return undefined;
+    }
+    return {
+        sessionId,
+        cwd: entry.cwd,
+        sessionFile: entry.sessionFile,
+    };
+}
+function isSessionMessageEntry(entry) {
+    return (isRecord(entry) &&
+        entry.type === 'message' &&
+        isRecord(entry.message) &&
+        typeof entry.message.role === 'string');
+}
+function extractPiMessageText(content) {
+    if (typeof content === 'string')
+        return content;
+    if (!Array.isArray(content))
+        return '';
+    return content
+        .filter((block) => isRecord(block) &&
+        block.type === 'text' &&
+        typeof block.text === 'string')
+        .map((block) => block.text)
+        .join('');
+}
+function getMessageTimestamp(entry) {
+    const messageTimestamp = entry.message.timestamp;
+    if (typeof messageTimestamp === 'number' &&
+        Number.isFinite(messageTimestamp)) {
+        return messageTimestamp;
+    }
+    const entryTimestamp = Date.parse(entry.timestamp);
+    return Number.isFinite(entryTimestamp) ? entryTimestamp : undefined;
+}
+function isRecord(value) {
+    return Boolean(value) && typeof value === 'object' && !Array.isArray(value);
+}
+function isEnoent(error) {
+    return (isRecord(error) &&
+        error.code === 'ENOENT');
+}
+function requireNonEmpty(value, name) {
+    const normalized = value.trim();
+    if (!normalized) {
+        throw new Error(`${name} must be a non-empty string.`);
+    }
+    return normalized;
+}
+//# sourceMappingURL=worker-session-history.js.map