@larose/pi-web 0.3.0

package/dist/server/api.js

@@ -0,0 +1,485 @@
+import { realpath, stat } from "node:fs/promises";
+import { basename, dirname, isAbsolute, relative, resolve, sep } from "node:path";
+import { AppError } from "./errors.js";
+import { validateCwd } from "./session-repository.js";
+const JSON_LIMIT = 64 * 1024;
+function newestModified(sessions) {
+    return sessions.reduce((newest, session) => Math.max(newest, Date.parse(session.modified) || 0), 0);
+}
+function workspaceContextFromGit(context) {
+    return {
+        repositoryRoot: context.repositoryRoot,
+        worktreeRoot: context.worktreeRoot,
+        relativeCwd: context.relativeCwd,
+    };
+}
+function pathIsWithin(parent, candidate) {
+    const child = relative(parent, candidate);
+    return child === "" || (child !== ".." && !child.startsWith(`..${sep}`) && !isAbsolute(child));
+}
+async function nearestExistingDirectory(path) {
+    if (!isAbsolute(path)) {
+        return null;
+    }
+    let candidate = resolve(path);
+    while (true) {
+        try {
+            const canonical = await realpath(candidate);
+            if ((await stat(canonical)).isDirectory()) {
+                return canonical;
+            }
+        }
+        catch (error) {
+            const code = error.code;
+            if (code !== "ENOENT" && code !== "ENOTDIR") {
+                return null;
+            }
+        }
+        const parent = dirname(candidate);
+        if (parent === candidate) {
+            return null;
+        }
+        candidate = parent;
+    }
+}
+function compareText(left, right) {
+    const folded = left.toLocaleLowerCase().localeCompare(right.toLocaleLowerCase());
+    return folded || left.localeCompare(right);
+}
+function compareSessionGroups(left, right) {
+    const recency = newestModified(right.sessions) - newestModified(left.sessions);
+    if (recency !== 0) {
+        return recency;
+    }
+    const name = compareText(basename(left.cwd), basename(right.cwd));
+    return name || compareText(left.cwd, right.cwd);
+}
+function compareWorktrees(group, left, right) {
+    if (left.isLinkedWorktree !== right.isLinkedWorktree) {
+        return left.isLinkedWorktree ? 1 : -1;
+    }
+    const sessionsFor = (worktreeRoot) => group.sessions.filter((session) => session.workspaceContext?.worktreeRoot === worktreeRoot);
+    const leftModified = newestModified(sessionsFor(left.worktreeRoot));
+    const rightModified = newestModified(sessionsFor(right.worktreeRoot));
+    if (leftModified !== rightModified) {
+        return rightModified - leftModified;
+    }
+    const leftHead = left.head.type === "branch" ? left.head.name : left.head.shortCommit;
+    const rightHead = right.head.type === "branch" ? right.head.name : right.head.shortCommit;
+    return compareText(leftHead, rightHead) || compareText(left.worktreeRoot, right.worktreeRoot);
+}
+async function homepageSessionListing(context) {
+    const listing = await context.repository.list();
+    const inspections = new Map();
+    const inspect = (cwd) => {
+        let inspection = inspections.get(cwd);
+        if (!inspection) {
+            inspection = context.gitWorkspaces.inspect(cwd).catch(() => null);
+            inspections.set(cwd, inspection);
+        }
+        return inspection;
+    };
+    const sessions = await Promise.all(listing.groups.flatMap((group) => group.sessions.map(async (session) => {
+        const gitContext = (await inspect(session.cwd))?.context ?? null;
+        let workspaceContext = gitContext ? workspaceContextFromGit(gitContext) : null;
+        if (!workspaceContext) {
+            const ancestor = await nearestExistingDirectory(session.cwd);
+            const ancestorContext = ancestor ? (await inspect(ancestor))?.context : null;
+            const requestedCwd = resolve(session.cwd);
+            if (ancestorContext && pathIsWithin(ancestorContext.worktreeRoot, requestedCwd)) {
+                workspaceContext = {
+                    repositoryRoot: ancestorContext.repositoryRoot,
+                    worktreeRoot: ancestorContext.worktreeRoot,
+                    relativeCwd: relative(ancestorContext.worktreeRoot, requestedCwd) || ".",
+                };
+            }
+        }
+        return { ...session, gitContext, workspaceContext };
+    })));
+    sessions.sort((left, right) => newestModified([right]) - newestModified([left]));
+    const repositories = new Map();
+    const standalone = new Map();
+    for (const session of sessions) {
+        const workspaceContext = session.workspaceContext;
+        if (!workspaceContext) {
+            const group = standalone.get(session.cwd) ?? { type: "standalone", cwd: session.cwd, sessions: [] };
+            group.sessions.push(session);
+            standalone.set(group.cwd, group);
+            continue;
+        }
+        const group = repositories.get(workspaceContext.repositoryRoot) ?? {
+            type: "repository",
+            cwd: workspaceContext.repositoryRoot,
+            repositoryRoot: workspaceContext.repositoryRoot,
+            sessions: [],
+            worktrees: [],
+        };
+        group.sessions.push(session);
+        repositories.set(group.repositoryRoot, group);
+    }
+    await Promise.all([...repositories.values()].map(async (group) => {
+        const rootInspection = await inspect(group.repositoryRoot);
+        if (rootInspection?.context?.repositoryRoot === group.repositoryRoot) {
+            group.worktrees.push(...rootInspection.worktrees);
+        }
+        for (const session of group.sessions) {
+            const gitContext = session.gitContext;
+            if (!gitContext || group.worktrees.some((worktree) => worktree.worktreeRoot === gitContext.worktreeRoot)) {
+                continue;
+            }
+            group.worktrees.push({
+                worktreeRoot: gitContext.worktreeRoot,
+                cwd: gitContext.worktreeRoot,
+                head: gitContext.head,
+                isLinkedWorktree: gitContext.isLinkedWorktree,
+            });
+        }
+        group.worktrees.sort((left, right) => compareWorktrees(group, left, right));
+    }));
+    return {
+        ...listing,
+        groups: [...repositories.values(), ...standalone.values()].sort(compareSessionGroups),
+    };
+}
+function writeJson(response, status, data) {
+    const body = JSON.stringify(data);
+    response.writeHead(status, {
+        "cache-control": "no-store",
+        "content-length": Buffer.byteLength(body),
+        "content-type": "application/json; charset=utf-8",
+    });
+    response.end(body);
+}
+async function readJson(request) {
+    const contentType = request.headers["content-type"]?.split(";", 1)[0]?.trim().toLowerCase();
+    if (contentType !== "application/json") {
+        throw new AppError("unsupported_media_type", "Expected Content-Type: application/json", 415);
+    }
+    const chunks = [];
+    let length = 0;
+    for await (const chunk of request) {
+        const buffer = Buffer.isBuffer(chunk) ? chunk : Buffer.from(chunk);
+        length += buffer.length;
+        if (length > JSON_LIMIT) {
+            throw new AppError("body_too_large", "Request body exceeds 64 KiB", 413);
+        }
+        chunks.push(buffer);
+    }
+    try {
+        return JSON.parse(Buffer.concat(chunks).toString("utf8"));
+    }
+    catch {
+        throw new AppError("invalid_json", "Request body is not valid JSON");
+    }
+}
+function objectBody(value) {
+    if (!value || typeof value !== "object" || Array.isArray(value)) {
+        throw new AppError("invalid_body", "Expected a JSON object");
+    }
+    return value;
+}
+function sessionName(value) {
+    if (value === null || value === "") {
+        return undefined;
+    }
+    if (typeof value !== "string") {
+        throw new AppError("invalid_session_name", "Session name must be a string or null");
+    }
+    const hasControlCharacter = Array.from(value).some((character) => {
+        const code = character.charCodeAt(0);
+        return code <= 31 || code === 127;
+    });
+    if (hasControlCharacter) {
+        throw new AppError("invalid_session_name", "Session name must be a single line without control characters");
+    }
+    const normalized = value.trim();
+    if (!normalized) {
+        return undefined;
+    }
+    if (Array.from(normalized).length > 120) {
+        throw new AppError("invalid_session_name", "Session name must be at most 120 characters");
+    }
+    return normalized;
+}
+function extensionUIResponse(value) {
+    const body = objectBody(value);
+    if (typeof body.id !== "string" || body.id === "") {
+        throw new AppError("invalid_ui_response", "Extension UI response id must be a string");
+    }
+    if (body.cancelled === true) {
+        return { id: body.id, cancelled: true };
+    }
+    if (typeof body.confirmed === "boolean") {
+        return { id: body.id, confirmed: body.confirmed };
+    }
+    if (typeof body.value === "string") {
+        return { id: body.id, value: body.value };
+    }
+    throw new AppError("invalid_ui_response", "Extension UI response requires value, confirmed, or cancelled");
+}
+function routeSession(pathname) {
+    const match = /^\/api\/sessions\/([^/]+)(?:\/(messages|abort|events|extension-ui|name|pending-steering))?$/.exec(pathname);
+    if (!match?.[1]) {
+        return undefined;
+    }
+    try {
+        return {
+            id: decodeURIComponent(match[1]),
+            ...(match[2] ? { action: match[2] } : {}),
+        };
+    }
+    catch {
+        throw new AppError("invalid_path", "The session id is not valid", 400);
+    }
+}
+function eventId(value, label) {
+    if (value === undefined || value === "") {
+        return undefined;
+    }
+    if (Array.isArray(value) || !/^\d+$/.test(value)) {
+        throw new AppError("invalid_event_id", `${label} must be a non-negative integer`);
+    }
+    const parsed = Number(value);
+    if (!Number.isSafeInteger(parsed)) {
+        throw new AppError("invalid_event_id", `${label} must be a non-negative safe integer`);
+    }
+    return parsed;
+}
+function parseLastEventId(request) {
+    const queryValues = new URL(request.url ?? "/", "http://127.0.0.1").searchParams.getAll("lastEventId");
+    if (queryValues.length > 1) {
+        throw new AppError("invalid_event_id", "lastEventId must be supplied at most once");
+    }
+    const headerId = eventId(request.headers["last-event-id"], "Last-Event-ID");
+    const queryId = eventId(queryValues[0], "lastEventId");
+    return headerId ?? queryId;
+}
+function writeSse(response, event) {
+    response.write(`id: ${event.id}\nevent: runtime\ndata: ${JSON.stringify(event.data)}\n\n`);
+}
+function writeHeartbeat(response) {
+    response.write("event: heartbeat\ndata: {}\n\n");
+}
+async function openEvents(request, response, id, context) {
+    const afterId = parseLastEventId(request);
+    const runtime = await context.runtimes.get(id);
+    response.writeHead(200, {
+        "cache-control": "no-cache, no-store",
+        connection: "keep-alive",
+        "content-type": "text/event-stream; charset=utf-8",
+        "x-accel-buffering": "no",
+    });
+    response.write("retry: 2000\n\n");
+    let closed = false;
+    let detach = () => undefined;
+    let heartbeat;
+    const close = () => {
+        if (closed) {
+            return;
+        }
+        closed = true;
+        if (heartbeat) {
+            clearInterval(heartbeat);
+        }
+        detach();
+        if (!response.writableEnded && !response.destroyed) {
+            response.end();
+        }
+    };
+    detach = runtime.attachClient((event) => {
+        if (closed || response.writableEnded || response.destroyed) {
+            return;
+        }
+        writeSse(response, event);
+        if (event.data.type === "runtime_disposed") {
+            close();
+        }
+    });
+    heartbeat = setInterval(() => {
+        if (!closed && !response.writableEnded && !response.destroyed) {
+            writeHeartbeat(response);
+        }
+    }, 15_000);
+    heartbeat.unref();
+    const replay = runtime.events.replay(afterId);
+    response.write(`event: ready\ndata: ${JSON.stringify({ gap: replay.gap, state: runtime.snapshot() })}\n\n`);
+    for (const event of replay.events) {
+        writeSse(response, event);
+    }
+    writeHeartbeat(response);
+    request.once("aborted", close);
+    request.once("close", close);
+    response.once("close", close);
+    response.once("error", close);
+}
+export async function handleApi(request, response, pathname, context) {
+    if (!pathname.startsWith("/api/")) {
+        return false;
+    }
+    if (pathname === "/api/directories") {
+        if (request.method !== "POST") {
+            throw new AppError("method_not_allowed", "Method not allowed", 405);
+        }
+        const body = objectBody(await readJson(request));
+        writeJson(response, 200, await context.directories.suggest(body.path));
+        return true;
+    }
+    if (pathname === "/api/git-workspaces/inspect") {
+        if (request.method !== "POST") {
+            throw new AppError("method_not_allowed", "Method not allowed", 405);
+        }
+        const body = objectBody(await readJson(request));
+        const cwd = await validateCwd(body.cwd);
+        const inspection = await context.gitWorkspaces.inspect(cwd);
+        writeJson(response, 200, { cwd, ...inspection });
+        return true;
+    }
+    if (pathname === "/api/git-workspaces/worktrees") {
+        if (request.method !== "DELETE") {
+            throw new AppError("method_not_allowed", "Method not allowed", 405);
+        }
+        const body = objectBody(await readJson(request));
+        const protectedCwds = [context.repository.startupCwd];
+        for (const id of context.runtimes.activeIds()) {
+            const cwd = context.runtimes.getActive(id)?.snapshot().cwd;
+            if (cwd) {
+                protectedCwds.push(cwd);
+            }
+        }
+        const removed = await context.gitWorkspaces.removeWorktree(await validateCwd(body.cwd), body.worktreeRoot, protectedCwds);
+        writeJson(response, 200, { removed });
+        return true;
+    }
+    if (pathname === "/api/sessions") {
+        if (request.method === "GET") {
+            const listing = await homepageSessionListing(context);
+            const activeSessionIds = context.runtimes.activeIds();
+            const runningSessionIds = activeSessionIds.filter((id) => context.runtimes.getActive(id)?.snapshot().isWorking);
+            writeJson(response, 200, { ...listing, activeSessionIds, runningSessionIds });
+            return true;
+        }
+        if (request.method === "POST") {
+            const body = objectBody(await readJson(request));
+            const hasWorktreeName = Object.hasOwn(body, "worktreeName") && body.worktreeName !== undefined;
+            let preparation;
+            if (hasWorktreeName) {
+                preparation = await context.gitWorkspaces.prepareWorktree(await validateCwd(body.cwd), body.worktreeName);
+            }
+            let created;
+            try {
+                created = await context.repository.createSession(preparation?.cwd ?? body.cwd);
+            }
+            catch (error) {
+                if (!preparation) {
+                    throw error;
+                }
+                try {
+                    await preparation.rollback();
+                }
+                catch (cleanupError) {
+                    const creationMessage = error instanceof AppError ? error.message : "Could not create the Pi session";
+                    const cleanupMessage = cleanupError instanceof AppError ? cleanupError.message : "the new Git resources could not be removed";
+                    throw new AppError("session_create_cleanup_failed", `${creationMessage}. Cleanup also failed: ${cleanupMessage}`, 500, { cause: error });
+                }
+                throw error;
+            }
+            const gitContext = (await context.gitWorkspaces.inspect(created.session.cwd).catch(() => undefined))?.context ?? null;
+            writeJson(response, 201, { session: { ...created.session, gitContext } });
+            return true;
+        }
+        throw new AppError("method_not_allowed", "Method not allowed", 405);
+    }
+    const route = routeSession(pathname);
+    if (!route) {
+        throw new AppError("not_found", "API route not found", 404);
+    }
+    if (!route.action && request.method === "GET") {
+        const session = await context.repository.get(route.id);
+        const runtime = context.runtimes.getActive(route.id);
+        const gitContext = (await context.gitWorkspaces.inspect(session.cwd).catch(() => undefined))?.context ?? null;
+        writeJson(response, 200, {
+            session: { ...session, gitContext },
+            runtime: runtime?.snapshot() ?? null,
+        });
+        return true;
+    }
+    if (!route.action && request.method === "DELETE") {
+        await context.runtimes.delete(route.id);
+        writeJson(response, 200, { deleted: true });
+        return true;
+    }
+    if (route.action === "messages" && request.method === "POST") {
+        const body = objectBody(await readJson(request));
+        if (typeof body.message !== "string") {
+            throw new AppError("invalid_message", "Message must be a string");
+        }
+        const runtime = await context.runtimes.get(route.id);
+        const result = await runtime.send(body.message);
+        writeJson(response, 202, { ...result, state: runtime.snapshot() });
+        return true;
+    }
+    if (route.action === "abort" && request.method === "POST") {
+        objectBody(await readJson(request));
+        await context.repository.get(route.id);
+        const runtime = context.runtimes.getActive(route.id);
+        const result = runtime ? await runtime.abort() : { restoredMessages: [] };
+        writeJson(response, 200, result);
+        return true;
+    }
+    if (route.action === "pending-steering" && request.method === "DELETE") {
+        const body = objectBody(await readJson(request));
+        if (!Number.isSafeInteger(body.index) || body.index < 0) {
+            throw new AppError("invalid_pending_message", "Pending message index must be a non-negative integer");
+        }
+        if (typeof body.message !== "string") {
+            throw new AppError("invalid_pending_message", "Pending message text must be a string");
+        }
+        if (!Array.isArray(body.queue) || body.queue.some((message) => typeof message !== "string")) {
+            throw new AppError("invalid_pending_message", "Pending message queue must be an array of strings");
+        }
+        const runtime = await context.runtimes.get(route.id);
+        await runtime.removePendingSteering(body.index, body.message, body.queue);
+        writeJson(response, 200, { state: runtime.snapshot() });
+        return true;
+    }
+    if (route.action === "name" && request.method === "PUT") {
+        const body = objectBody(await readJson(request));
+        if (!("name" in body)) {
+            throw new AppError("invalid_session_name", "Session name is required");
+        }
+        const runtime = await context.runtimes.get(route.id);
+        const name = runtime.setSessionName(sessionName(body.name));
+        writeJson(response, 200, { name: name ?? null, state: runtime.snapshot() });
+        return true;
+    }
+    if (route.action === "extension-ui" && request.method === "POST") {
+        const responseBody = extensionUIResponse(await readJson(request));
+        const runtime = await context.runtimes.get(route.id);
+        runtime.respondToExtensionUI(responseBody);
+        writeJson(response, 200, { accepted: true });
+        return true;
+    }
+    if (route.action === "events" && request.method === "GET") {
+        await openEvents(request, response, route.id, context);
+        return true;
+    }
+    throw new AppError("method_not_allowed", "Method not allowed", 405);
+}
+export function writeApiError(response, error) {
+    if (response.headersSent || response.writableEnded) {
+        if (!response.writableEnded) {
+            response.end();
+        }
+        return;
+    }
+    if (error instanceof AppError) {
+        writeJson(response, error.status, { error: { code: error.code, message: error.message } });
+        return;
+    }
+    writeJson(response, 500, {
+        error: {
+            code: "internal_error",
+            message: error instanceof Error ? error.message : "Internal server error",
+        },
+    });
+}

package/dist/server/cli.js

@@ -0,0 +1,51 @@
+#!/usr/bin/env node
+import { startServer } from "./server.js";
+function errorDetails(error) {
+    if (!(error instanceof Error)) {
+        return String(error);
+    }
+    const details = error.stack ?? error.message;
+    return error.cause === undefined ? details : `${details}\nCaused by: ${errorDetails(error.cause)}`;
+}
+process.on("uncaughtExceptionMonitor", (error, origin) => {
+    process.stderr.write(`[pi-web] Uncaught process error (${origin})\n${errorDetails(error)}\n`);
+});
+function readPort(value) {
+    if (!value) {
+        return 31_415;
+    }
+    const port = Number(value);
+    if (!Number.isInteger(port) || port < 0 || port > 65_535) {
+        throw new Error(`Invalid port: ${value}`);
+    }
+    return port;
+}
+async function main() {
+    const port = readPort(process.env.PI_WEB_PORT ?? process.env.PORT);
+    const running = await startServer({ port });
+    const url = `http://${running.hostname}:${running.port}`;
+    process.stdout.write(`Pi Web listening on ${url}\n`);
+    let stopping = false;
+    const stop = async (signal) => {
+        if (stopping) {
+            return;
+        }
+        stopping = true;
+        process.stdout.write(`Pi Web stopping (${signal})\n`);
+        try {
+            await running.close();
+            process.stdout.write("Pi Web stopped\n");
+            process.exitCode = 0;
+        }
+        catch (error) {
+            process.stderr.write(`[pi-web] Failed to stop cleanly\n${errorDetails(error)}\n`);
+            process.exitCode = 1;
+        }
+    };
+    process.once("SIGINT", () => void stop("SIGINT"));
+    process.once("SIGTERM", () => void stop("SIGTERM"));
+}
+main().catch((error) => {
+    process.stderr.write(`Pi Web failed to start\n${errorDetails(error)}\n`);
+    process.exitCode = 1;
+});

package/dist/server/directory-browser.js

@@ -0,0 +1,104 @@
+import { opendir, realpath, stat } from "node:fs/promises";
+import { basename, dirname, isAbsolute, resolve } from "node:path";
+import { AppError } from "./errors.js";
+const MAX_DIRECTORY_RESULTS = 50;
+const MAX_SCANNED_ENTRIES = 2_000;
+function unavailableDirectory(error) {
+    return new AppError("directory_unavailable", "The directory cannot be read by the server", 400, { cause: error });
+}
+async function canonicalDirectory(path) {
+    try {
+        const canonical = await realpath(path);
+        return (await stat(canonical)).isDirectory() ? canonical : null;
+    }
+    catch (error) {
+        const code = error.code;
+        if (code === "ENOENT" || code === "ENOTDIR") {
+            return null;
+        }
+        throw unavailableDirectory(error);
+    }
+}
+async function browseTarget(input) {
+    let candidate = resolve(input);
+    let prefix = "";
+    while (true) {
+        const canonical = await canonicalDirectory(candidate);
+        if (canonical) {
+            return { basePath: canonical, prefix };
+        }
+        const parent = dirname(candidate);
+        if (parent === candidate) {
+            throw new AppError("directory_unavailable", "No readable directory exists for this path", 400);
+        }
+        prefix = basename(candidate);
+        candidate = parent;
+    }
+}
+function compareSuggestions(left, right) {
+    const folded = left.name.toLocaleLowerCase().localeCompare(right.name.toLocaleLowerCase());
+    return folded || left.name.localeCompare(right.name) || left.path.localeCompare(right.path);
+}
+export class DirectoryBrowser {
+    async suggest(input) {
+        if (typeof input !== "string" || input.trim() === "") {
+            throw new AppError("invalid_directory_path", "An absolute directory path is required");
+        }
+        const requested = input.trim();
+        if (!isAbsolute(requested)) {
+            throw new AppError("invalid_directory_path", "The directory path must be absolute");
+        }
+        const target = await browseTarget(requested);
+        const foldedPrefix = target.prefix.toLocaleLowerCase();
+        const directories = [];
+        const canonicalPaths = new Set();
+        let scannedEntries = 0;
+        let truncated = false;
+        try {
+            const handle = await opendir(target.basePath);
+            for await (const entry of handle) {
+                scannedEntries += 1;
+                if (scannedEntries > MAX_SCANNED_ENTRIES) {
+                    truncated = true;
+                    break;
+                }
+                if (!entry.name.toLocaleLowerCase().startsWith(foldedPrefix)) {
+                    continue;
+                }
+                const entryPath = resolve(target.basePath, entry.name);
+                let canonical;
+                try {
+                    if (!entry.isDirectory() && !entry.isSymbolicLink()) {
+                        continue;
+                    }
+                    canonical = await realpath(entryPath);
+                    if (!(await stat(canonical)).isDirectory()) {
+                        continue;
+                    }
+                }
+                catch {
+                    continue;
+                }
+                if (!canonicalPaths.has(canonical)) {
+                    canonicalPaths.add(canonical);
+                    directories.push({ name: entry.name, path: canonical });
+                }
+            }
+        }
+        catch (error) {
+            throw unavailableDirectory(error);
+        }
+        directories.sort(compareSuggestions);
+        if (directories.length > MAX_DIRECTORY_RESULTS) {
+            directories.length = MAX_DIRECTORY_RESULTS;
+            truncated = true;
+        }
+        return {
+            input: requested,
+            basePath: target.basePath,
+            prefix: target.prefix,
+            directories,
+            truncated,
+        };
+    }
+}

package/dist/server/errors.js

@@ -0,0 +1,10 @@
+export class AppError extends Error {
+    code;
+    status;
+    constructor(code, message, status = 400, options) {
+        super(message, options);
+        this.name = "AppError";
+        this.code = code;
+        this.status = status;
+    }
+}

package/dist/server/event-buffer.js

@@ -0,0 +1,40 @@
+export class EventBuffer {
+    capacity;
+    events = [];
+    listeners = new Set();
+    nextId = 1;
+    constructor(capacity = 512) {
+        if (!Number.isInteger(capacity) || capacity < 1) {
+            throw new Error("Event capacity must be a positive integer");
+        }
+        this.capacity = capacity;
+    }
+    publish(data) {
+        const event = { id: this.nextId++, data };
+        this.events.push(event);
+        if (this.events.length > this.capacity) {
+            this.events.splice(0, this.events.length - this.capacity);
+        }
+        for (const listener of this.listeners) {
+            listener(event);
+        }
+        return event;
+    }
+    replay(afterId) {
+        if (afterId === undefined) {
+            return { events: [], gap: false };
+        }
+        const oldestId = this.events[0]?.id ?? this.nextId;
+        return {
+            events: this.events.filter((event) => event.id > afterId),
+            gap: afterId < oldestId - 1 || afterId >= this.nextId,
+        };
+    }
+    subscribe(listener) {
+        this.listeners.add(listener);
+        return () => this.listeners.delete(listener);
+    }
+    get latestId() {
+        return this.nextId - 1;
+    }
+}