@pasko70/pibo 1.9.7 → 1.9.9

package/dist/apps/chat/trace.js

@@ -1,572 +0,0 @@
-import { createHash } from "node:crypto";
-import { closeSync, existsSync, openSync, readFileSync, readSync, readdirSync, statSync } from "node:fs";
-import { homedir } from "node:os";
-import { join } from "node:path";
-import { parseSessionEntries, SessionManager } from "@earendil-works/pi-coding-agent";
-import { buildTraceViewFromEvents } from "../../shared/trace-engine.js";
-import { isChatWebSessionArchived } from "./session-metadata.js";
-import { workflowSessionKindFromMetadata } from "../../sessions/workflow-session-kind.js";
-export { compareTraceNodes, sortTraceNodes, nestTraceNodes, flattenTraceNodes, mapTraceNodesById, buildTraceViewFromEvents, traceNodesFromEntries, } from "../../shared/trace-engine.js";
-export const TRACE_TRANSCRIPT_TAIL_MAX_BYTES = 2 * 1024 * 1024;
-export const TRACE_TRANSCRIPT_HISTORY_PAGE_MAX_BYTES = 512 * 1024;
-export const TRACE_TRANSCRIPT_HISTORY_SCAN_MAX_BYTES = 16 * 1024 * 1024;
-export async function loadPiSessionMetadata(session, cwd = process.cwd()) {
-    const piSession = await findPiSession(session, cwd);
-    return metadataFromPiSession(piSession);
-}
-export async function loadPiSessionFastMetadata(session, cwd = process.cwd()) {
-    const piSession = findPiSessionDirectFast(session.piSessionId, cwd)
-        ?? findPiSessionDirect(session.piSessionId, cwd, { fast: true });
-    return metadataFromPiSession(piSession);
-}
-function metadataFromPiSession(piSession) {
-    if (!piSession)
-        return {};
-    let sessionSize;
-    let sessionMtimeMs;
-    try {
-        const stats = statSync(piSession.path);
-        sessionSize = stats.size;
-        sessionMtimeMs = stats.mtimeMs;
-    }
-    catch {
-        // The session list can contain a file that was removed before trace rendering.
-    }
-    return {
-        sessionPath: piSession.path,
-        sessionSize,
-        sessionMtimeMs,
-        name: piSession.name,
-        firstMessage: piSession.firstMessage,
-        modified: piSession.modified,
-    };
-}
-export async function buildSessionNodes(sessions, indexItems, cwd = process.cwd(), unreadCounts = new Map(), options = {}) {
-    const indexByKey = new Map(indexItems.map((item) => [item.piboSessionId, item]));
-    const nodes = new Map();
-    const piSessionsByCwd = new Map();
-    for (const session of sessions) {
-        let metadata = {};
-        if (!session.title && !options.skipPiMetadataFallback) {
-            const sessionCwd = session.workspace ?? cwd;
-            let piSessions = piSessionsByCwd.get(sessionCwd);
-            if (!piSessions) {
-                piSessions = listPiSessions(sessionCwd);
-                piSessionsByCwd.set(sessionCwd, piSessions);
-            }
-            metadata = metadataFromPiSession((await piSessions).find((piSession) => piSession.id === session.piSessionId));
-        }
-        const indexed = indexByKey.get(session.id);
-        nodes.set(session.id, {
-            piboSessionId: session.id,
-            piSessionId: session.piSessionId,
-            parentId: session.parentId,
-            originId: session.originId,
-            profile: session.profile,
-            activeModel: session.activeModel,
-            subagentName: stringValue(session.metadata?.subagentName),
-            workflowSessionKind: workflowSessionKindFromMetadata(session.metadata),
-            title: createSessionTitle(session, metadata),
-            subtitle: session.id,
-            archived: isChatWebSessionArchived(session),
-            status: sessionNodeStatus(indexed?.status),
-            lastActivityAt: indexed?.lastActivityAt ?? indexed?.createdAt ?? session.createdAt,
-            unreadCount: unreadCounts.get(session.id) || undefined,
-            derivedSessions: [],
-            children: [],
-        });
-    }
-    const roots = [];
-    for (const node of nodes.values()) {
-        const parent = node.parentId ? nodes.get(node.parentId) : undefined;
-        if (parent) {
-            parent.children.push(node);
-        }
-        else {
-            roots.push(node);
-        }
-    }
-    for (const node of nodes.values()) {
-        if (!node.originId)
-            continue;
-        const origin = nodes.get(node.originId);
-        if (!origin)
-            continue;
-        origin.derivedSessions.push({
-            piboSessionId: node.piboSessionId,
-            profile: node.profile,
-            subagentName: node.subagentName,
-            workflowSessionKind: node.workflowSessionKind,
-            title: node.title,
-            status: node.status,
-            lastActivityAt: node.lastActivityAt,
-        });
-    }
-    const sortNodes = (items) => {
-        items.sort((left, right) => (right.lastActivityAt ?? "").localeCompare(left.lastActivityAt ?? ""));
-        for (const item of items) {
-            item.derivedSessions.sort((left, right) => (right.lastActivityAt ?? "").localeCompare(left.lastActivityAt ?? ""));
-            sortNodes(item.children);
-        }
-    };
-    sortNodes(roots);
-    return roots;
-}
-function sessionNodeStatus(indexedStatus) {
-    return indexedStatus ?? "idle";
-}
-export async function buildTraceView(input) {
-    const metadata = input.metadata ?? (await loadPiSessionMetadata(input.session, input.session.workspace ?? input.cwd));
-    const allEntries = input.transcriptEntries ?? (metadata.sessionPath ? readEntries(metadata.sessionPath) : []);
-    const sessionStatus = input.status ?? "idle";
-    const view = buildTraceViewFromEvents({
-        session: {
-            id: input.session.id,
-            piSessionId: input.session.piSessionId,
-            title: createSessionTitle(input.session, metadata),
-        },
-        events: input.events,
-        transcriptEntries: allEntries,
-        sessions: input.sessions.map((s) => ({
-            id: s.id,
-            parentId: s.parentId ?? null,
-            originId: s.originId ?? null,
-            updatedAt: s.updatedAt,
-            title: s.title ?? null,
-            metadata: s.metadata,
-        })),
-        status: sessionStatus,
-        latestStreamId: input.latestStreamId,
-        includeRawEvents: input.includeRawEvents,
-        rawEventsLimit: input.rawEventsLimit,
-    });
-    if (input.transcriptOrderOffset && input.transcriptOrderOffset > 0) {
-        offsetTranscriptTraceOrder(view.nodes, input.transcriptOrderOffset);
-    }
-    annotateForkableUserMessageNodes(view.nodes, allEntries);
-    return {
-        ...view,
-        version: createTraceViewVersion({
-            session: input.session,
-            sessions: input.sessions,
-            events: input.events,
-            status: sessionStatus,
-            metadata,
-            latestStreamId: input.latestStreamId,
-        }),
-    };
-}
-export async function loadPiSessionTailEntries(session, cwd = process.cwd(), maxBytes = TRACE_TRANSCRIPT_TAIL_MAX_BYTES) {
-    const metadata = await loadPiSessionMetadata(session, cwd);
-    if (!metadata.sessionPath)
-        return { metadata, entries: [] };
-    return { metadata, entries: readTailEntries(metadata.sessionPath, maxBytes) };
-}
-export function createTraceViewVersion(input) {
-    const relevantSessions = input.sessions
-        .map((session) => ({
-        id: session.id,
-        parentId: session.parentId ?? null,
-        originId: session.originId ?? null,
-        updatedAt: session.updatedAt,
-        title: session.title ?? null,
-    }))
-        .sort((left, right) => left.id.localeCompare(right.id));
-    const eventTail = input.events.at(-1);
-    return createHash("sha1")
-        .update(JSON.stringify({
-        session: {
-            id: input.session.id,
-            piSessionId: input.session.piSessionId,
-            profile: input.session.profile,
-            title: input.session.title ?? null,
-            updatedAt: input.session.updatedAt,
-        },
-        metadata: {
-            sessionPath: input.metadata?.sessionPath ?? null,
-            sessionSize: input.metadata?.sessionSize ?? null,
-            sessionMtimeMs: input.metadata?.sessionMtimeMs ?? null,
-            name: input.metadata?.name ?? null,
-            firstMessage: input.metadata?.firstMessage ?? null,
-            modified: input.metadata?.modified ?? null,
-        },
-        status: input.status ?? "idle",
-        events: {
-            lastSequence: eventTail?.eventSequence ?? null,
-            lastCreatedAt: eventTail?.createdAt ?? null,
-            latestStreamId: input.latestStreamId ?? null,
-        },
-        sessions: relevantSessions,
-    }))
-        .digest("hex");
-}
-const PI_SESSION_LIST_CACHE_TTL_MS = 5_000;
-const PI_SESSION_DIRECT_CACHE_TTL_MS = 5_000;
-const PI_SESSION_FAST_HEAD_BYTES = 64 * 1024;
-const piSessionListCache = new Map();
-const piSessionDirectCache = new Map();
-export async function listPiSessions(cwd = process.cwd()) {
-    const now = Date.now();
-    const cached = piSessionListCache.get(cwd);
-    if (cached && cached.expiresAt > now)
-        return cached.promise;
-    const promise = SessionManager.list(cwd).then((sessions) => sessions.map((session) => ({
-        path: session.path,
-        id: session.id,
-        cwd: session.cwd,
-        name: session.name,
-        parentSessionPath: session.parentSessionPath,
-        created: session.created.toISOString(),
-        modified: session.modified.toISOString(),
-        messageCount: session.messageCount,
-        firstMessage: session.firstMessage,
-    })));
-    piSessionListCache.set(cwd, { expiresAt: now + PI_SESSION_LIST_CACHE_TTL_MS, promise });
-    promise.catch(() => {
-        if (piSessionListCache.get(cwd)?.promise === promise)
-            piSessionListCache.delete(cwd);
-    });
-    return promise;
-}
-function createSessionTitle(session, metadata) {
-    const candidate = session.title || metadata.name || metadata.firstMessage || session.id;
-    return truncateTitle(candidate);
-}
-function truncateTitle(title, maxLength = 56) {
-    const normalized = title.replace(/\s+/g, " ").trim();
-    if (normalized.length <= maxLength)
-        return normalized || "Untitled Session";
-    return `${normalized.slice(0, maxLength - 1)}…`;
-}
-async function findPiSession(piboSession, cwd) {
-    return (findPiSessionDirect(piboSession.piSessionId, cwd) ??
-        (await listPiSessions(cwd)).find((session) => session.id === piboSession.piSessionId));
-}
-function findPiSessionDirectFast(piSessionId, cwd) {
-    const cacheKey = `${cwd}\0${piSessionId}`;
-    const cached = piSessionDirectCache.get(cacheKey);
-    if (!cached || cached.expiresAt <= Date.now())
-        return undefined;
-    try {
-        const stats = statSync(cached.path);
-        if (stats.size === cached.size && stats.mtimeMs === cached.mtimeMs)
-            return cached.item;
-    }
-    catch {
-        piSessionDirectCache.delete(cacheKey);
-    }
-    return undefined;
-}
-function setPiSessionDirectFastCache(piSessionId, cwd, item, stats) {
-    piSessionDirectCache.set(`${cwd}\0${piSessionId}`, {
-        expiresAt: Date.now() + PI_SESSION_DIRECT_CACHE_TTL_MS,
-        path: item.path,
-        size: stats.size,
-        mtimeMs: stats.mtimeMs,
-        item,
-    });
-}
-function findPiSessionDirect(piSessionId, cwd, options = {}) {
-    const sessionDir = defaultPiSessionDir(cwd);
-    if (!existsSync(sessionDir))
-        return undefined;
-    try {
-        const file = readdirSync(sessionDir).find((candidate) => candidate.endsWith(`_${piSessionId}.jsonl`));
-        if (!file)
-            return undefined;
-        const sessionPath = join(sessionDir, file);
-        const stats = statSync(sessionPath);
-        const entries = options.fast
-            ? readHeadEntries(sessionPath, stats.size, PI_SESSION_FAST_HEAD_BYTES)
-            : parseSessionEntries(readFileSync(sessionPath, "utf8"));
-        const header = entries.find((entry) => entry.type === "session");
-        if (header?.id !== piSessionId)
-            return undefined;
-        let name;
-        let firstMessage = "";
-        let messageCount = 0;
-        for (const entry of entries) {
-            if (entry.type === "session_info")
-                name = stringValue(entry.name)?.trim() || undefined;
-            if (entry.type !== "message")
-                continue;
-            messageCount++;
-            if (firstMessage || messageRole(entry) !== "user")
-                continue;
-            firstMessage = extractMessageText(messageContent(entry));
-        }
-        const item = {
-            path: sessionPath,
-            id: piSessionId,
-            cwd: stringValue(header.cwd) ?? cwd,
-            name,
-            parentSessionPath: stringValue(header.parentSession),
-            created: stringValue(header.timestamp) ?? stats.birthtime.toISOString(),
-            modified: options.fast
-                ? stats.mtime.toISOString()
-                : sessionModifiedIso(entries.filter((entry) => entry.type !== "session"), stringValue(header.timestamp), stats.mtime),
-            messageCount,
-            firstMessage: firstMessage || "(no messages)",
-        };
-        if (options.fast)
-            setPiSessionDirectFastCache(piSessionId, cwd, item, stats);
-        return item;
-    }
-    catch {
-        return undefined;
-    }
-}
-function defaultPiSessionDir(cwd) {
-    const agentDir = process.env.PI_CODING_AGENT_DIR ?? join(homedir(), ".pi", "agent");
-    const safePath = `--${cwd.replace(/^[\\/]/, "").replace(/[\\/:]/g, "-")}--`;
-    return join(agentDir, "sessions", safePath);
-}
-function sessionModifiedIso(entries, headerTimestamp, statsMtime) {
-    let lastActivityTime;
-    for (const entry of entries) {
-        if (entry.type !== "message")
-            continue;
-        const timestamp = entry.message.timestamp;
-        if (typeof timestamp === "number") {
-            lastActivityTime = Math.max(lastActivityTime ?? 0, timestamp);
-            continue;
-        }
-        const entryTime = new Date(entry.timestamp).getTime();
-        if (!Number.isNaN(entryTime))
-            lastActivityTime = Math.max(lastActivityTime ?? 0, entryTime);
-    }
-    if (lastActivityTime)
-        return new Date(lastActivityTime).toISOString();
-    const headerTime = headerTimestamp ? new Date(headerTimestamp).getTime() : NaN;
-    return !Number.isNaN(headerTime) ? new Date(headerTime).toISOString() : statsMtime.toISOString();
-}
-function readEntries(path) {
-    if (!existsSync(path))
-        return [];
-    const content = readFileSync(path, "utf8");
-    return parseSessionEntries(content).filter((entry) => entry.type !== "session");
-}
-function readHeadEntries(path, fileSize, maxBytes) {
-    const length = Math.max(1, Math.min(maxBytes, fileSize));
-    const buffer = Buffer.alloc(length);
-    const fd = openSync(path, "r");
-    try {
-        const bytesRead = readSync(fd, buffer, 0, length, 0);
-        let content = buffer.subarray(0, bytesRead).toString("utf8");
-        if (bytesRead < fileSize && !content.endsWith("\n")) {
-            const lastNewline = content.lastIndexOf("\n");
-            if (lastNewline >= 0)
-                content = content.slice(0, lastNewline + 1);
-        }
-        if (!content.trim())
-            return [];
-        return parseSessionEntries(content.endsWith("\n") ? content : `${content}\n`);
-    }
-    finally {
-        closeSync(fd);
-    }
-}
-export function readTailEntries(path, maxBytes = TRACE_TRANSCRIPT_TAIL_MAX_BYTES) {
-    if (!existsSync(path))
-        return [];
-    const stats = statSync(path);
-    if (stats.size <= maxBytes)
-        return readEntries(path);
-    const length = Math.max(1, Math.min(maxBytes, stats.size));
-    const start = stats.size - length;
-    const buffer = Buffer.alloc(length);
-    const fd = openSync(path, "r");
-    try {
-        const bytesRead = readSync(fd, buffer, 0, length, start);
-        let content = buffer.subarray(0, bytesRead).toString("utf8");
-        const firstNewline = content.indexOf("\n");
-        if (start > 0 && firstNewline >= 0)
-            content = content.slice(firstNewline + 1);
-        return parseSessionEntries(content).filter((entry) => entry.type !== "session");
-    }
-    finally {
-        closeSync(fd);
-    }
-}
-export function readTranscriptHistoryPage(path, input = {}) {
-    if (!existsSync(path))
-        return { entries: [], hasOlder: false, scannedBytes: 0, startByte: 0, endByte: 0 };
-    const stats = statSync(path);
-    const fileSize = Math.max(0, stats.size);
-    const initialEnd = input.beforeByte === undefined
-        ? fileSize
-        : Math.max(0, Math.min(input.beforeByte, fileSize));
-    const limit = Math.max(1, Math.min(input.limit ?? 50, 500));
-    const pageBytes = Math.max(1024, Math.min(input.pageBytes ?? TRACE_TRANSCRIPT_HISTORY_PAGE_MAX_BYTES, TRACE_TRANSCRIPT_HISTORY_SCAN_MAX_BYTES));
-    const maxScanBytes = Math.max(pageBytes, Math.min(input.maxScanBytes ?? TRACE_TRANSCRIPT_HISTORY_SCAN_MAX_BYTES, 32 * 1024 * 1024));
-    const beforeTime = input.beforeTimestamp ? Date.parse(input.beforeTimestamp) : undefined;
-    const entries = [];
-    let cursorEnd = initialEnd;
-    let scannedBytes = 0;
-    let nextBeforeByte;
-    while (cursorEnd > 0 && entries.length < limit && scannedBytes < maxScanBytes) {
-        const chunkStart = Math.max(0, cursorEnd - pageBytes);
-        const chunk = readUtf8Range(path, chunkStart, cursorEnd);
-        scannedBytes += cursorEnd - chunkStart;
-        const records = transcriptLineRecords(chunk, chunkStart, cursorEnd);
-        for (let index = records.length - 1; index >= 0; index -= 1) {
-            const record = records[index];
-            const parsed = parseTranscriptLine(record.text);
-            for (let entryIndex = parsed.length - 1; entryIndex >= 0; entryIndex -= 1) {
-                const entry = parsed[entryIndex];
-                if (beforeTime !== undefined && entryTimestampMs(entry) >= beforeTime)
-                    continue;
-                entries.push({ entry, startByte: record.startByte });
-                if (entries.length >= limit) {
-                    nextBeforeByte = record.startByte;
-                    break;
-                }
-            }
-            if (entries.length >= limit)
-                break;
-        }
-        cursorEnd = chunkStart;
-    }
-    if (nextBeforeByte === undefined)
-        nextBeforeByte = cursorEnd > 0 ? cursorEnd : undefined;
-    return {
-        entries: entries.reverse().map((item) => item.entry),
-        nextBeforeByte,
-        hasOlder: nextBeforeByte !== undefined && nextBeforeByte > 0,
-        scannedBytes,
-        startByte: nextBeforeByte ?? 0,
-        endByte: initialEnd,
-    };
-}
-function readUtf8Range(path, start, end) {
-    const length = Math.max(0, end - start);
-    if (length === 0)
-        return "";
-    const buffer = Buffer.alloc(length);
-    const fd = openSync(path, "r");
-    try {
-        const bytesRead = readSync(fd, buffer, 0, length, start);
-        return buffer.subarray(0, bytesRead).toString("utf8");
-    }
-    finally {
-        closeSync(fd);
-    }
-}
-function transcriptLineRecords(content, startByte, endByte) {
-    let text = content;
-    let byteOffset = startByte;
-    if (startByte > 0) {
-        const firstNewline = text.indexOf("\n");
-        if (firstNewline < 0)
-            return [];
-        const skipped = text.slice(0, firstNewline + 1);
-        byteOffset += Buffer.byteLength(skipped, "utf8");
-        text = text.slice(firstNewline + 1);
-    }
-    if (endByte > startByte && text && !text.endsWith("\n")) {
-        const lastNewline = text.lastIndexOf("\n");
-        if (lastNewline >= 0)
-            text = text.slice(0, lastNewline + 1);
-    }
-    const records = [];
-    const segments = text.match(/[^\n]*(?:\n|$)/g) ?? [];
-    for (const segment of segments) {
-        if (!segment)
-            continue;
-        const lineStart = byteOffset;
-        byteOffset += Buffer.byteLength(segment, "utf8");
-        const line = segment.replace(/\r?\n$/, "");
-        if (line.trim())
-            records.push({ text: line, startByte: lineStart });
-    }
-    return records;
-}
-function parseTranscriptLine(line) {
-    try {
-        return parseSessionEntries(`${line}\n`).filter((entry) => entry.type !== "session");
-    }
-    catch {
-        return [];
-    }
-}
-function entryTimestampMs(entry) {
-    const timestamp = entry.timestamp;
-    if (typeof timestamp !== "string")
-        return Number.POSITIVE_INFINITY;
-    const parsed = Date.parse(timestamp);
-    return Number.isFinite(parsed) ? parsed : Number.POSITIVE_INFINITY;
-}
-function offsetTranscriptTraceOrder(nodes, offset) {
-    for (const node of nodes) {
-        if (node.source === "transcript" && node.orderKey) {
-            const transcriptIndex = node.orderKey.transcriptIndex;
-            node.orderKey = {
-                ...node.orderKey,
-                turnSeq: node.orderKey.turnSeq + offset,
-                transcriptIndex: transcriptIndex === undefined ? undefined : transcriptIndex + offset,
-            };
-        }
-        offsetTranscriptTraceOrder(node.children, offset);
-    }
-}
-function annotateForkableUserMessageNodes(nodes, entries) {
-    const candidates = userMessageForkCandidates(entries);
-    if (!candidates.length)
-        return;
-    const used = new Set();
-    for (const node of flattenTraceNodesForForkAnnotation(nodes)) {
-        if (node.type !== "user.message" || node.entryId)
-            continue;
-        const text = stringValue(node.output) ?? stringValue(node.summary) ?? "";
-        const candidate = candidates.find((item) => !used.has(item.entryId) && item.text === text);
-        if (!candidate)
-            continue;
-        node.entryId = candidate.entryId;
-        used.add(candidate.entryId);
-    }
-}
-function flattenTraceNodesForForkAnnotation(nodes) {
-    const flattened = [];
-    const visit = (items) => {
-        for (const item of items) {
-            flattened.push(item);
-            visit(item.children);
-        }
-    };
-    visit(nodes);
-    return flattened;
-}
-function userMessageForkCandidates(entries) {
-    const candidates = [];
-    for (const entry of entries) {
-        if (entry.type !== "message" || messageRole(entry) !== "user")
-            continue;
-        const text = extractMessageText(messageContent(entry));
-        if (text)
-            candidates.push({ entryId: entry.id, text });
-    }
-    return candidates;
-}
-function messageRole(entry) {
-    return entry.type === "message" ? entry.message.role : undefined;
-}
-function messageContent(entry) {
-    return entry.type === "message" ? entry.message.content : undefined;
-}
-function extractMessageText(content) {
-    if (typeof content === "string")
-        return content;
-    if (!Array.isArray(content))
-        return "";
-    return content
-        .map((part) => {
-        if (!part || typeof part !== "object")
-            return "";
-        const typed = part;
-        return typed.type === "text" && typeof typed.text === "string" ? typed.text : "";
-    })
-        .join("");
-}
-function stringValue(value) {
-    return typeof value === "string" ? value : undefined;
-}

package/dist/apps/chat/types/event-store.js

@@ -1 +0,0 @@
-export {};

package/dist/apps/chat/types/read-model.js

@@ -1 +0,0 @@
-export {};

package/dist/apps/chat/types/rooms.js

@@ -1,36 +0,0 @@
-export const CHAT_ROOM_ID_METADATA_KEY = "chatRoomId";
-const CHAT_ROOM_ARCHIVED_AT_METADATA_KEY = "chatRoomArchivedAt";
-const CHAT_ROOM_WORKSPACE_METADATA_KEY = "workspace";
-export function chatRoomIdFromMetadata(metadata) {
-    const value = metadata?.[CHAT_ROOM_ID_METADATA_KEY];
-    return typeof value === "string" && value.length > 0 ? value : undefined;
-}
-export function withChatRoomId(metadata, roomId) {
-    return { ...(metadata ?? {}), [CHAT_ROOM_ID_METADATA_KEY]: roomId };
-}
-export function isDefaultPiboRoom(room) {
-    return room.metadata.default === true;
-}
-export function isPiboRoomArchived(room) {
-    return typeof room.metadata[CHAT_ROOM_ARCHIVED_AT_METADATA_KEY] === "string";
-}
-export function roomWorkspaceFromMetadata(metadata) {
-    const value = metadata?.[CHAT_ROOM_WORKSPACE_METADATA_KEY];
-    return typeof value === "string" && value.length > 0 ? value : undefined;
-}
-export function withPiboRoomArchived(metadata, archived) {
-    const next = { ...(metadata ?? {}) };
-    if (archived)
-        next[CHAT_ROOM_ARCHIVED_AT_METADATA_KEY] = new Date().toISOString();
-    else
-        delete next[CHAT_ROOM_ARCHIVED_AT_METADATA_KEY];
-    return next;
-}
-export function withPiboRoomWorkspace(metadata, workspace) {
-    const next = { ...(metadata ?? {}) };
-    if (workspace)
-        next[CHAT_ROOM_WORKSPACE_METADATA_KEY] = workspace;
-    else
-        delete next[CHAT_ROOM_WORKSPACE_METADATA_KEY];
-    return next;
-}