@femtomc/mu-server 26.2.72 → 26.2.74

package/dist/server_program_orchestration.js

@@ -1,25 +1,34 @@
 import { CronProgramRegistry } from "./cron_programs.js";
 import { HeartbeatProgramRegistry } from "./heartbeat_programs.js";
-const AUTO_RUN_HEARTBEAT_REASON = "auto-run-heartbeat";
+function describeError(err) {
+    if (err instanceof Error) {
+        return err.message;
+    }
+    return String(err);
+}
 export function createServerProgramOrchestration(opts) {
-    const autoRunHeartbeatProgramByJobId = new Map();
     const heartbeatPrograms = new HeartbeatProgramRegistry({
         repoRoot: opts.repoRoot,
         heartbeatScheduler: opts.heartbeatScheduler,
-        runHeartbeat: async (runOpts) => {
-            const result = await opts.controlPlaneProxy.heartbeatRun?.({
-                jobId: runOpts.jobId ?? null,
-                rootIssueId: runOpts.rootIssueId ?? null,
-                reason: runOpts.reason ?? null,
-                wakeMode: runOpts.wakeMode,
-            });
-            return result ?? { ok: false, reason: "not_found" };
-        },
-        activityHeartbeat: async (activityOpts) => {
-            return opts.activitySupervisor.heartbeat({
-                activityId: activityOpts.activityId ?? null,
-                reason: activityOpts.reason ?? null,
+        dispatchWake: async (wakeOpts) => {
+            const wakeResult = await opts.emitOperatorWake({
+                dedupeKey: `heartbeat-program:${wakeOpts.programId}`,
+                message: `Heartbeat wake: ${wakeOpts.title}`,
+                payload: {
+                    wake_source: "heartbeat_program",
+                    source_ts_ms: wakeOpts.triggeredAtMs,
+                    program_id: wakeOpts.programId,
+                    reason: wakeOpts.reason,
+                    metadata: wakeOpts.metadata,
+                },
             });
+            if (wakeResult.status === "coalesced") {
+                return { status: "coalesced", reason: wakeResult.reason };
+            }
+            if (wakeResult.status === "failed") {
+                return { status: "failed", reason: wakeResult.reason };
+            }
+            return { status: "ok" };
         },
         onTickEvent: async (event) => {
             await opts.eventLog.emit("heartbeat_program.tick", {
@@ -32,44 +41,36 @@ export function createServerProgramOrchestration(opts) {
                     program: event.program,
                 },
             });
-            await opts.emitOperatorWake({
-                dedupeKey: `heartbeat-program:${event.program_id}`,
-                message: event.message,
-                payload: {
-                    wake_source: "heartbeat_program",
-                    source_ts_ms: event.ts_ms,
-                    program_id: event.program_id,
-                    status: event.status,
-                    reason: event.reason,
-                    wake_mode: event.program.wake_mode,
-                    target_kind: event.program.target.kind,
-                    target: event.program.target.kind === "run"
-                        ? {
-                            job_id: event.program.target.job_id,
-                            root_issue_id: event.program.target.root_issue_id,
-                        }
-                        : { activity_id: event.program.target.activity_id },
-                },
-            });
         },
     });
     const cronPrograms = new CronProgramRegistry({
         repoRoot: opts.repoRoot,
         heartbeatScheduler: opts.heartbeatScheduler,
-        runHeartbeat: async (runOpts) => {
-            const result = await opts.controlPlaneProxy.heartbeatRun?.({
-                jobId: runOpts.jobId ?? null,
-                rootIssueId: runOpts.rootIssueId ?? null,
-                reason: runOpts.reason ?? null,
-                wakeMode: runOpts.wakeMode,
-            });
-            return result ?? { ok: false, reason: "not_found" };
-        },
-        activityHeartbeat: async (activityOpts) => {
-            return opts.activitySupervisor.heartbeat({
-                activityId: activityOpts.activityId ?? null,
-                reason: activityOpts.reason ?? null,
-            });
+        dispatchWake: async (wakeOpts) => {
+            try {
+                const wakeResult = await opts.emitOperatorWake({
+                    dedupeKey: `cron-program:${wakeOpts.programId}`,
+                    message: `Cron wake: ${wakeOpts.title}`,
+                    payload: {
+                        wake_source: "cron_program",
+                        source_ts_ms: wakeOpts.triggeredAtMs,
+                        program_id: wakeOpts.programId,
+                        reason: wakeOpts.reason,
+                        schedule: wakeOpts.schedule,
+                        metadata: wakeOpts.metadata,
+                    },
+                });
+                if (wakeResult.status === "coalesced") {
+                    return { status: "coalesced", reason: wakeResult.reason };
+                }
+                if (wakeResult.status === "failed") {
+                    return { status: "failed", reason: wakeResult.reason };
+                }
+                return { status: "ok" };
+            }
+            catch (error) {
+                return { status: "failed", reason: describeError(error) };
+            }
         },
         onLifecycleEvent: async (event) => {
             await opts.eventLog.emit("cron_program.lifecycle", {
@@ -93,162 +94,10 @@ export function createServerProgramOrchestration(opts) {
                     program: event.program,
                 },
             });
-            await opts.emitOperatorWake({
-                dedupeKey: `cron-program:${event.program_id}`,
-                message: event.message,
-                payload: {
-                    wake_source: "cron_program",
-                    source_ts_ms: event.ts_ms,
-                    program_id: event.program_id,
-                    status: event.status,
-                    reason: event.reason,
-                    wake_mode: event.program.wake_mode,
-                    target_kind: event.program.target.kind,
-                    target: event.program.target.kind === "run"
-                        ? {
-                            job_id: event.program.target.job_id,
-                            root_issue_id: event.program.target.root_issue_id,
-                        }
-                        : { activity_id: event.program.target.activity_id },
-                },
-            });
         },
     });
-    const findAutoRunHeartbeatProgram = async (jobId) => {
-        const normalizedJobId = jobId.trim();
-        if (!normalizedJobId) {
-            return null;
-        }
-        const knownProgramId = autoRunHeartbeatProgramByJobId.get(normalizedJobId);
-        if (knownProgramId) {
-            const knownProgram = await heartbeatPrograms.get(knownProgramId);
-            if (knownProgram) {
-                return knownProgram;
-            }
-            autoRunHeartbeatProgramByJobId.delete(normalizedJobId);
-        }
-        const programs = await heartbeatPrograms.list({ targetKind: "run", limit: 500 });
-        for (const program of programs) {
-            if (program.metadata.auto_run_job_id !== normalizedJobId) {
-                continue;
-            }
-            autoRunHeartbeatProgramByJobId.set(normalizedJobId, program.program_id);
-            return program;
-        }
-        return null;
-    };
-    const registerAutoRunHeartbeatProgram = async (run) => {
-        if (run.source === "command") {
-            return;
-        }
-        const jobId = run.job_id.trim();
-        if (!jobId || run.status !== "running") {
-            return;
-        }
-        const rootIssueId = typeof run.root_issue_id === "string" ? run.root_issue_id.trim() : "";
-        const metadata = {
-            auto_run_heartbeat: true,
-            auto_run_job_id: jobId,
-            auto_run_root_issue_id: rootIssueId || null,
-            auto_disable_on_terminal: true,
-            run_mode: run.mode,
-            run_source: run.source,
-        };
-        const existing = await findAutoRunHeartbeatProgram(jobId);
-        if (existing) {
-            const result = await heartbeatPrograms.update({
-                programId: existing.program_id,
-                title: `Run heartbeat: ${rootIssueId || jobId}`,
-                target: {
-                    kind: "run",
-                    job_id: jobId,
-                    root_issue_id: rootIssueId || null,
-                },
-                enabled: true,
-                everyMs: opts.autoRunHeartbeatEveryMs,
-                reason: AUTO_RUN_HEARTBEAT_REASON,
-                wakeMode: "next_heartbeat",
-                metadata,
-            });
-            if (result.ok && result.program) {
-                autoRunHeartbeatProgramByJobId.set(jobId, result.program.program_id);
-                await opts.eventLog.emit("run.auto_heartbeat.lifecycle", {
-                    source: "mu-server.runs",
-                    payload: {
-                        action: "updated",
-                        run_job_id: jobId,
-                        run_root_issue_id: rootIssueId || null,
-                        program_id: result.program.program_id,
-                        program: result.program,
-                    },
-                });
-            }
-            return;
-        }
-        const created = await heartbeatPrograms.create({
-            title: `Run heartbeat: ${rootIssueId || jobId}`,
-            target: {
-                kind: "run",
-                job_id: jobId,
-                root_issue_id: rootIssueId || null,
-            },
-            everyMs: opts.autoRunHeartbeatEveryMs,
-            reason: AUTO_RUN_HEARTBEAT_REASON,
-            wakeMode: "next_heartbeat",
-            metadata,
-            enabled: true,
-        });
-        autoRunHeartbeatProgramByJobId.set(jobId, created.program_id);
-        await opts.eventLog.emit("run.auto_heartbeat.lifecycle", {
-            source: "mu-server.runs",
-            payload: {
-                action: "registered",
-                run_job_id: jobId,
-                run_root_issue_id: rootIssueId || null,
-                program_id: created.program_id,
-                program: created,
-            },
-        });
-    };
-    const disableAutoRunHeartbeatProgram = async (disableOpts) => {
-        const program = await findAutoRunHeartbeatProgram(disableOpts.jobId);
-        if (!program) {
-            return;
-        }
-        const metadata = {
-            ...program.metadata,
-            auto_disabled_from_status: disableOpts.status,
-            auto_disabled_reason: disableOpts.reason,
-            auto_disabled_at_ms: Date.now(),
-        };
-        const result = await heartbeatPrograms.update({
-            programId: program.program_id,
-            enabled: false,
-            everyMs: 0,
-            reason: AUTO_RUN_HEARTBEAT_REASON,
-            wakeMode: program.wake_mode,
-            metadata,
-        });
-        autoRunHeartbeatProgramByJobId.delete(disableOpts.jobId.trim());
-        if (!result.ok || !result.program) {
-            return;
-        }
-        await opts.eventLog.emit("run.auto_heartbeat.lifecycle", {
-            source: "mu-server.runs",
-            payload: {
-                action: "disabled",
-                run_job_id: disableOpts.jobId,
-                status: disableOpts.status,
-                reason: disableOpts.reason,
-                program_id: result.program.program_id,
-                program: result.program,
-            },
-        });
-    };
     return {
         heartbeatPrograms,
         cronPrograms,
-        registerAutoRunHeartbeatProgram,
-        disableAutoRunHeartbeatProgram,
     };
 }

package/dist/server_routing.d.ts

@@ -3,7 +3,6 @@ import type { MuConfig } from "./config.js";
 import type { ControlPlaneHandle } from "./control_plane_contract.js";
 import type { CronProgramRegistry } from "./cron_programs.js";
 import type { HeartbeatProgramRegistry } from "./heartbeat_programs.js";
-import type { AutoHeartbeatRunSnapshot } from "./server_program_orchestration.js";
 import type { ServerContext } from "./server.js";
 export type ServerRoutingDependencies = {
     context: ServerContext;
@@ -17,15 +16,7 @@ export type ServerRoutingDependencies = {
         ok: boolean;
     }>;
     getControlPlaneStatus: () => unknown;
-    registerAutoRunHeartbeatProgram: (run: AutoHeartbeatRunSnapshot) => Promise<void>;
-    disableAutoRunHeartbeatProgram: (opts: {
-        jobId: string;
-        status: string;
-        reason: string;
-    }) => Promise<void>;
     describeError: (error: unknown) => string;
     initiateShutdown?: () => Promise<void>;
-    publicDir?: string;
-    mimeTypes?: Record<string, string>;
 };
 export declare function createServerRequestHandler(deps: ServerRoutingDependencies): (request: Request) => Promise<Response>;

package/dist/server_routing.js

@@ -1,30 +1,14 @@
-import { extname, join, resolve } from "node:path";
 import { activityRoutes } from "./api/activities.js";
 import { configRoutes } from "./api/config.js";
 import { controlPlaneRoutes } from "./api/control_plane.js";
 import { cronRoutes } from "./api/cron.js";
 import { eventRoutes } from "./api/events.js";
-import { forumRoutes } from "./api/forum.js";
 import { heartbeatRoutes } from "./api/heartbeats.js";
 import { identityRoutes } from "./api/identities.js";
-import { issueRoutes } from "./api/issues.js";
 import { runRoutes } from "./api/runs.js";
-const DEFAULT_MIME_TYPES = {
-    ".html": "text/html; charset=utf-8",
-    ".js": "text/javascript; charset=utf-8",
-    ".css": "text/css; charset=utf-8",
-    ".json": "application/json",
-    ".png": "image/png",
-    ".jpg": "image/jpeg",
-    ".svg": "image/svg+xml",
-    ".ico": "image/x-icon",
-    ".woff": "font/woff",
-    ".woff2": "font/woff2",
-};
-const DEFAULT_PUBLIC_DIR = join(new URL(".", import.meta.url).pathname, "..", "public");
+import { sessionFlashRoutes } from "./api/session_flash.js";
+import { sessionTurnRoutes } from "./api/session_turn.js";
 export function createServerRequestHandler(deps) {
-    const publicDir = deps.publicDir ?? DEFAULT_PUBLIC_DIR;
-    const mimeTypes = deps.mimeTypes ?? DEFAULT_MIME_TYPES;
     return async (request) => {
         const url = new URL(request.url);
         const path = url.pathname;
@@ -47,121 +31,32 @@ export function createServerRequestHandler(deps) {
                 return Response.json({ error: "shutdown not supported" }, { status: 501, headers });
             }
             const shutdown = deps.initiateShutdown;
-            // Respond before shutting down so the client receives the response.
-            setTimeout(() => { void shutdown(); }, 100);
+            setTimeout(() => {
+                void shutdown();
+            }, 100);
             return Response.json({ ok: true, message: "shutdown initiated" }, { headers });
         }
         if (path === "/api/config") {
             return configRoutes(request, url, deps, headers);
         }
-        if (path === "/api/control-plane/reload" || path === "/api/control-plane/rollback") {
+        if (path === "/api/control-plane/reload" ||
+            path === "/api/control-plane/rollback" ||
+            path === "/api/control-plane/channels") {
             return controlPlaneRoutes(request, url, deps, headers);
         }
         if (path === "/api/status") {
-            const issues = await deps.context.issueStore.list();
-            const openIssues = issues.filter((i) => i.status === "open");
-            const readyIssues = await deps.context.issueStore.ready();
-            const controlPlane = deps.getControlPlaneStatus();
             return Response.json({
                 repo_root: deps.context.repoRoot,
-                open_count: openIssues.length,
-                ready_count: readyIssues.length,
-                control_plane: controlPlane,
+                control_plane: deps.getControlPlaneStatus(),
             }, { headers });
         }
-        if (path === "/api/commands/submit") {
-            if (request.method !== "POST") {
-                return Response.json({ error: "Method Not Allowed" }, { status: 405, headers });
-            }
-            let body;
-            try {
-                body = (await request.json());
-            }
-            catch {
-                return Response.json({ error: "invalid json body" }, { status: 400, headers });
-            }
-            const kind = typeof body.kind === "string" ? body.kind.trim() : "";
-            if (!kind) {
-                return Response.json({ error: "kind is required" }, { status: 400, headers });
-            }
-            let commandText;
-            switch (kind) {
-                case "run_start": {
-                    const prompt = typeof body.prompt === "string" ? body.prompt.trim() : "";
-                    if (!prompt) {
-                        return Response.json({ error: "prompt is required for run_start" }, { status: 400, headers });
-                    }
-                    const maxStepsSuffix = typeof body.max_steps === "number" && Number.isFinite(body.max_steps)
-                        ? ` --max-steps ${Math.max(1, Math.trunc(body.max_steps))}`
-                        : "";
-                    commandText = `mu! run start ${prompt}${maxStepsSuffix}`;
-                    break;
-                }
-                case "run_resume": {
-                    const rootId = typeof body.root_issue_id === "string" ? body.root_issue_id.trim() : "";
-                    const maxSteps = typeof body.max_steps === "number" && Number.isFinite(body.max_steps)
-                        ? ` ${Math.max(1, Math.trunc(body.max_steps))}`
-                        : "";
-                    commandText = `mu! run resume${rootId ? ` ${rootId}` : ""}${maxSteps}`;
-                    break;
-                }
-                case "run_interrupt": {
-                    const rootId = typeof body.root_issue_id === "string" ? body.root_issue_id.trim() : "";
-                    commandText = `mu! run interrupt${rootId ? ` ${rootId}` : ""}`;
-                    break;
-                }
-                case "reload":
-                    commandText = "/mu reload";
-                    break;
-                case "update":
-                    commandText = "/mu update";
-                    break;
-                case "status":
-                    commandText = "/mu status";
-                    break;
-                case "issue_list":
-                    commandText = "/mu issue list";
-                    break;
-                case "issue_get": {
-                    const issueId = typeof body.issue_id === "string" ? body.issue_id.trim() : "";
-                    commandText = `/mu issue get${issueId ? ` ${issueId}` : ""}`;
-                    break;
-                }
-                case "forum_read": {
-                    const topic = typeof body.topic === "string" ? body.topic.trim() : "";
-                    const limit = typeof body.limit === "number" && Number.isFinite(body.limit)
-                        ? ` ${Math.max(1, Math.trunc(body.limit))}`
-                        : "";
-                    commandText = `/mu forum read${topic ? ` ${topic}` : ""}${limit}`;
-                    break;
-                }
-                case "run_list":
-                    commandText = "/mu run list";
-                    break;
-                case "run_status": {
-                    const rootId = typeof body.root_issue_id === "string" ? body.root_issue_id.trim() : "";
-                    commandText = `/mu run status${rootId ? ` ${rootId}` : ""}`;
-                    break;
-                }
-                case "ready":
-                    commandText = "/mu ready";
-                    break;
-                default:
-                    return Response.json({ error: `unknown command kind: ${kind}` }, { status: 400, headers });
-            }
-            try {
-                if (!deps.controlPlaneProxy.submitTerminalCommand) {
-                    return Response.json({ error: "control plane not available" }, { status: 503, headers });
-                }
-                const result = await deps.controlPlaneProxy.submitTerminalCommand({
-                    commandText,
-                    repoRoot: deps.context.repoRoot,
-                });
-                return Response.json({ ok: true, result }, { headers });
-            }
-            catch (err) {
-                return Response.json({ error: `command failed: ${deps.describeError(err)}` }, { status: 500, headers });
-            }
+        if (path === "/api/session-flash" ||
+            path === "/api/session-flash/ack" ||
+            path.startsWith("/api/session-flash/")) {
+            return sessionFlashRoutes(request, url, deps, headers);
+        }
+        if (path === "/api/session-turn") {
+            return sessionTurnRoutes(request, url, deps, headers);
         }
         if (path === "/api/runs" || path.startsWith("/api/runs/")) {
             return runRoutes(request, url, deps, headers);
@@ -178,20 +73,6 @@ export function createServerRequestHandler(deps) {
         if (path === "/api/identities" || path === "/api/identities/link" || path === "/api/identities/unlink") {
             return identityRoutes(request, url, deps, headers);
         }
-        if (path.startsWith("/api/issues")) {
-            const response = await issueRoutes(request, deps.context);
-            headers.forEach((value, key) => {
-                response.headers.set(key, value);
-            });
-            return response;
-        }
-        if (path.startsWith("/api/forum")) {
-            const response = await forumRoutes(request, deps.context);
-            headers.forEach((value, key) => {
-                response.headers.set(key, value);
-            });
-            return response;
-        }
         if (path.startsWith("/api/events")) {
             const response = await eventRoutes(request, deps.context);
             headers.forEach((value, key) => {
@@ -207,23 +88,10 @@ export function createServerRequestHandler(deps) {
                 });
                 return response;
             }
+            return new Response("Not Found", { status: 404, headers });
         }
-        const filePath = resolve(publicDir, `.${path === "/" ? "/index.html" : path}`);
-        if (!filePath.startsWith(publicDir)) {
-            return new Response("Forbidden", { status: 403, headers });
-        }
-        const file = Bun.file(filePath);
-        if (await file.exists()) {
-            const ext = extname(filePath);
-            const mime = mimeTypes[ext] ?? "application/octet-stream";
-            headers.set("Content-Type", mime);
-            return new Response(await file.arrayBuffer(), { status: 200, headers });
-        }
-        const indexPath = join(publicDir, "index.html");
-        const indexFile = Bun.file(indexPath);
-        if (await indexFile.exists()) {
-            headers.set("Content-Type", "text/html; charset=utf-8");
-            return new Response(await indexFile.arrayBuffer(), { status: 200, headers });
+        if (path.startsWith("/api/")) {
+            return Response.json({ error: "Not Found" }, { status: 404, headers });
         }
         return new Response("Not Found", { status: 404, headers });
     };

package/dist/server_runtime.js

@@ -22,7 +22,6 @@ export async function composeServerRuntime(options = {}) {
         : await bootstrapControlPlane({
             repoRoot,
             config: config.control_plane,
-            heartbeatScheduler,
             generation: {
                 generation_id: "control-plane-gen-0",
                 generation_seq: 0,

package/dist/server_types.d.ts

@@ -1,3 +1 @@
-export type ProgramWakeMode = "immediate" | "next_heartbeat";
-export declare function normalizeWakeMode(value: unknown): ProgramWakeMode;
 export declare function toNonNegativeInt(value: unknown, fallback: number): number;

package/dist/server_types.js

@@ -1,10 +1,3 @@
-export function normalizeWakeMode(value) {
-    if (typeof value !== "string") {
-        return "immediate";
-    }
-    const normalized = value.trim().toLowerCase().replaceAll("-", "_");
-    return normalized === "next_heartbeat" ? "next_heartbeat" : "immediate";
-}
 export function toNonNegativeInt(value, fallback) {
     if (typeof value === "number" && Number.isFinite(value)) {
         return Math.max(0, Math.trunc(value));

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "@femtomc/mu-server",
-  "version": "26.2.72",
-  "description": "HTTP API server for mu status, work items, messaging setup, and web UI.",
+  "version": "26.2.74",
+  "description": "HTTP API server for mu control-plane transport/session plus run/activity scheduling coordination.",
   "keywords": [
     "mu",
     "server",
@@ -22,8 +22,7 @@
     }
   },
   "files": [
-    "dist/**",
-    "public/**"
+    "dist/**"
   ],
   "scripts": {
     "build": "tsc -p tsconfig.build.json",
@@ -31,11 +30,8 @@
     "start": "bun run dist/cli.js"
   },
   "dependencies": {
-    "@femtomc/mu-agent": "26.2.72",
-    "@femtomc/mu-control-plane": "26.2.72",
-    "@femtomc/mu-core": "26.2.72",
-    "@femtomc/mu-forum": "26.2.72",
-    "@femtomc/mu-issue": "26.2.72",
-    "@femtomc/mu-orchestrator": "26.2.72"
+    "@femtomc/mu-agent": "26.2.74",
+    "@femtomc/mu-control-plane": "26.2.74",
+    "@femtomc/mu-core": "26.2.74"
   }
 }

package/dist/api/forum.d.ts

@@ -1,2 +0,0 @@
-import type { ServerContext } from "../server.js";
-export declare function forumRoutes(request: Request, context: ServerContext): Promise<Response>;

package/dist/api/forum.js

@@ -1,75 +0,0 @@
-import { DEFAULT_FORUM_TOPICS_LIMIT, ForumStoreValidationError, normalizeForumPrefix, normalizeForumReadLimit, normalizeForumTopic, normalizeForumTopicsLimit, } from "@femtomc/mu-forum";
-async function readJsonBody(request) {
-    let body;
-    try {
-        body = await request.json();
-    }
-    catch {
-        throw new ForumStoreValidationError("invalid json body");
-    }
-    if (!body || typeof body !== "object" || Array.isArray(body)) {
-        throw new ForumStoreValidationError("json body must be an object");
-    }
-    return body;
-}
-function errorResponse(status, message) {
-    return new Response(JSON.stringify({ error: message }), {
-        status,
-        headers: { "Content-Type": "application/json" },
-    });
-}
-function mapForumRouteError(error) {
-    if (error instanceof ForumStoreValidationError) {
-        return errorResponse(400, error.message);
-    }
-    if (error instanceof Error && error.name === "ZodError") {
-        return errorResponse(400, error.message);
-    }
-    console.error("Forum API error:", error);
-    return errorResponse(500, error instanceof Error ? error.message : "Internal server error");
-}
-export async function forumRoutes(request, context) {
-    const url = new URL(request.url);
-    const path = url.pathname.replace("/api/forum", "") || "/";
-    const method = request.method;
-    try {
-        // List topics - GET /api/forum/topics
-        if (path === "/topics" && method === "GET") {
-            const prefix = normalizeForumPrefix(url.searchParams.get("prefix"));
-            const limit = normalizeForumTopicsLimit(url.searchParams.get("limit"), {
-                defaultLimit: DEFAULT_FORUM_TOPICS_LIMIT,
-            });
-            const topics = await context.forumStore.topics(prefix, { limit });
-            return Response.json(topics);
-        }
-        // Read messages - GET /api/forum/read
-        if (path === "/read" && method === "GET") {
-            const topic = normalizeForumTopic(url.searchParams.get("topic"));
-            const limit = normalizeForumReadLimit(url.searchParams.get("limit"));
-            const messages = await context.forumStore.read(topic, limit);
-            return Response.json(messages);
-        }
-        // Post message - POST /api/forum/post
-        if (path === "/post" && method === "POST") {
-            const body = await readJsonBody(request);
-            const topic = normalizeForumTopic(body.topic);
-            if (typeof body.body !== "string" || body.body.trim().length === 0) {
-                return errorResponse(400, "body is required");
-            }
-            const messageBody = body.body;
-            let author = "system";
-            if (body.author != null) {
-                if (typeof body.author !== "string" || body.author.trim().length === 0) {
-                    return errorResponse(400, "author must be a non-empty string when provided");
-                }
-                author = body.author.trim();
-            }
-            const message = await context.forumStore.post(topic, messageBody, author);
-            return Response.json(message, { status: 201 });
-        }
-        return new Response("Not Found", { status: 404 });
-    }
-    catch (error) {
-        return mapForumRouteError(error);
-    }
-}

package/dist/api/issues.d.ts

@@ -1,2 +0,0 @@
-import type { ServerContext } from "../server.js";
-export declare function issueRoutes(request: Request, context: ServerContext): Promise<Response>;