@femtomc/mu-server 26.2.40 → 26.2.42

package/dist/heartbeat_programs.js

@@ -0,0 +1,415 @@
+import { join } from "node:path";
+import { FsJsonlStore } from "@femtomc/mu-core/node";
+const HEARTBEAT_PROGRAMS_FILENAME = "heartbeats.jsonl";
+function defaultNowMs() {
+    return Date.now();
+}
+function normalizeTarget(input) {
+    if (!input || typeof input !== "object" || Array.isArray(input)) {
+        return null;
+    }
+    const record = input;
+    const kind = typeof record.kind === "string" ? record.kind.trim().toLowerCase() : "";
+    if (kind === "run") {
+        const jobId = typeof record.job_id === "string" ? record.job_id.trim() : "";
+        const rootIssueId = typeof record.root_issue_id === "string" ? record.root_issue_id.trim() : "";
+        if (!jobId && !rootIssueId) {
+            return null;
+        }
+        return {
+            kind: "run",
+            job_id: jobId || null,
+            root_issue_id: rootIssueId || null,
+        };
+    }
+    if (kind === "activity") {
+        const activityId = typeof record.activity_id === "string" ? record.activity_id.trim() : "";
+        if (!activityId) {
+            return null;
+        }
+        return {
+            kind: "activity",
+            activity_id: activityId,
+        };
+    }
+    return null;
+}
+function sanitizeMetadata(value) {
+    if (!value || typeof value !== "object" || Array.isArray(value)) {
+        return {};
+    }
+    return { ...value };
+}
+function normalizeProgram(row) {
+    if (!row || typeof row !== "object" || Array.isArray(row)) {
+        return null;
+    }
+    const record = row;
+    const programId = typeof record.program_id === "string" ? record.program_id.trim() : "";
+    const title = typeof record.title === "string" ? record.title.trim() : "";
+    const target = normalizeTarget(record.target);
+    if (!programId || !title || !target) {
+        return null;
+    }
+    const everyMsRaw = record.every_ms;
+    const everyMs = typeof everyMsRaw === "number" && Number.isFinite(everyMsRaw)
+        ? Math.max(0, Math.trunc(everyMsRaw))
+        : 0;
+    const createdAt = typeof record.created_at_ms === "number" && Number.isFinite(record.created_at_ms)
+        ? Math.trunc(record.created_at_ms)
+        : defaultNowMs();
+    const updatedAt = typeof record.updated_at_ms === "number" && Number.isFinite(record.updated_at_ms)
+        ? Math.trunc(record.updated_at_ms)
+        : createdAt;
+    const lastTriggeredAt = typeof record.last_triggered_at_ms === "number" && Number.isFinite(record.last_triggered_at_ms)
+        ? Math.trunc(record.last_triggered_at_ms)
+        : null;
+    const lastResultRaw = typeof record.last_result === "string" ? record.last_result.trim().toLowerCase() : null;
+    const lastResult = lastResultRaw === "ok" ||
+        lastResultRaw === "not_found" ||
+        lastResultRaw === "not_running" ||
+        lastResultRaw === "failed"
+        ? lastResultRaw
+        : null;
+    const reason = typeof record.reason === "string" && record.reason.trim().length > 0 ? record.reason.trim() : "scheduled";
+    return {
+        v: 1,
+        program_id: programId,
+        title,
+        enabled: record.enabled !== false,
+        every_ms: everyMs,
+        reason,
+        target,
+        metadata: sanitizeMetadata(record.metadata),
+        created_at_ms: createdAt,
+        updated_at_ms: updatedAt,
+        last_triggered_at_ms: lastTriggeredAt,
+        last_result: lastResult,
+        last_error: typeof record.last_error === "string" ? record.last_error : null,
+    };
+}
+function sortPrograms(programs) {
+    return [...programs].sort((a, b) => {
+        if (a.created_at_ms !== b.created_at_ms) {
+            return a.created_at_ms - b.created_at_ms;
+        }
+        return a.program_id.localeCompare(b.program_id);
+    });
+}
+export class HeartbeatProgramRegistry {
+    #store;
+    #heartbeatScheduler;
+    #runHeartbeat;
+    #activityHeartbeat;
+    #onTickEvent;
+    #nowMs;
+    #programs = new Map();
+    #loaded = null;
+    constructor(opts) {
+        this.#heartbeatScheduler = opts.heartbeatScheduler;
+        this.#runHeartbeat = opts.runHeartbeat;
+        this.#activityHeartbeat = opts.activityHeartbeat;
+        this.#onTickEvent = opts.onTickEvent;
+        this.#nowMs = opts.nowMs ?? defaultNowMs;
+        this.#store =
+            opts.store ??
+                new FsJsonlStore(join(opts.repoRoot, ".mu", HEARTBEAT_PROGRAMS_FILENAME));
+    }
+    #scheduleId(programId) {
+        return `heartbeat-program:${programId}`;
+    }
+    #snapshot(program) {
+        return {
+            ...program,
+            target: program.target.kind === "run" ? { ...program.target } : { ...program.target },
+            metadata: { ...program.metadata },
+        };
+    }
+    async #ensureLoaded() {
+        if (!this.#loaded) {
+            this.#loaded = this.#load();
+        }
+        await this.#loaded;
+    }
+    async #load() {
+        const rows = await this.#store.read();
+        for (const row of rows) {
+            const normalized = normalizeProgram(row);
+            if (!normalized) {
+                continue;
+            }
+            this.#programs.set(normalized.program_id, normalized);
+        }
+        for (const program of this.#programs.values()) {
+            this.#applySchedule(program);
+        }
+    }
+    async #persist() {
+        const rows = sortPrograms([...this.#programs.values()]);
+        await this.#store.write(rows);
+    }
+    #applySchedule(program) {
+        const scheduleId = this.#scheduleId(program.program_id);
+        if (!program.enabled || program.every_ms <= 0) {
+            this.#heartbeatScheduler.unregister(scheduleId);
+            return;
+        }
+        this.#heartbeatScheduler.register({
+            activityId: scheduleId,
+            everyMs: program.every_ms,
+            handler: async ({ reason }) => {
+                return await this.#tickProgram(program.program_id, reason ?? undefined);
+            },
+        });
+    }
+    async #emitTickEvent(event) {
+        if (!this.#onTickEvent) {
+            return;
+        }
+        await this.#onTickEvent(event);
+    }
+    async #tickProgram(programId, reason) {
+        const program = this.#programs.get(programId);
+        if (!program) {
+            return { status: "skipped", reason: "not_found" };
+        }
+        if (!program.enabled) {
+            return { status: "skipped", reason: "disabled" };
+        }
+        const heartbeatReason = reason?.trim() || program.reason || "scheduled";
+        const nowMs = Math.trunc(this.#nowMs());
+        program.last_triggered_at_ms = nowMs;
+        program.updated_at_ms = nowMs;
+        try {
+            const result = program.target.kind === "run"
+                ? await this.#runHeartbeat({
+                    jobId: program.target.job_id,
+                    rootIssueId: program.target.root_issue_id,
+                    reason: heartbeatReason,
+                })
+                : await this.#activityHeartbeat({
+                    activityId: program.target.activity_id,
+                    reason: heartbeatReason,
+                });
+            if (result.ok) {
+                program.last_result = "ok";
+                program.last_error = null;
+                void this.#persist().catch(() => {
+                    // Best effort persistence on background ticks.
+                });
+                void this.#emitTickEvent({
+                    ts_ms: nowMs,
+                    program_id: program.program_id,
+                    message: `heartbeat program tick: ${program.title}`,
+                    status: "ok",
+                    reason: heartbeatReason,
+                    program: this.#snapshot(program),
+                }).catch(() => {
+                    // best effort only
+                });
+                return { status: "ran" };
+            }
+            if (result.reason === "not_running") {
+                program.last_result = "not_running";
+                program.last_error = null;
+                void this.#persist().catch(() => {
+                    // Best effort persistence on background ticks.
+                });
+                void this.#emitTickEvent({
+                    ts_ms: nowMs,
+                    program_id: program.program_id,
+                    message: `heartbeat program skipped (not running): ${program.title}`,
+                    status: "not_running",
+                    reason: result.reason,
+                    program: this.#snapshot(program),
+                }).catch(() => {
+                    // best effort only
+                });
+                return { status: "skipped", reason: "not_running" };
+            }
+            if (result.reason === "not_found") {
+                program.last_result = "not_found";
+                program.last_error = null;
+                void this.#persist().catch(() => {
+                    // Best effort persistence on background ticks.
+                });
+                void this.#emitTickEvent({
+                    ts_ms: nowMs,
+                    program_id: program.program_id,
+                    message: `heartbeat program skipped (not found): ${program.title}`,
+                    status: "not_found",
+                    reason: result.reason,
+                    program: this.#snapshot(program),
+                }).catch(() => {
+                    // best effort only
+                });
+                return { status: "skipped", reason: "not_found" };
+            }
+            program.last_result = "failed";
+            program.last_error = result.reason ?? "heartbeat_program_tick_failed";
+            void this.#persist().catch(() => {
+                // Best effort persistence on background ticks.
+            });
+            void this.#emitTickEvent({
+                ts_ms: nowMs,
+                program_id: program.program_id,
+                message: `heartbeat program failed: ${program.title}`,
+                status: "failed",
+                reason: program.last_error,
+                program: this.#snapshot(program),
+            }).catch(() => {
+                // best effort only
+            });
+            return { status: "failed", reason: program.last_error };
+        }
+        catch (err) {
+            program.last_result = "failed";
+            program.last_error = err instanceof Error ? err.message : String(err);
+            void this.#persist().catch(() => {
+                // Best effort persistence on background ticks.
+            });
+            void this.#emitTickEvent({
+                ts_ms: nowMs,
+                program_id: program.program_id,
+                message: `heartbeat program failed: ${program.title}`,
+                status: "failed",
+                reason: program.last_error,
+                program: this.#snapshot(program),
+            }).catch(() => {
+                // best effort only
+            });
+            return { status: "failed", reason: program.last_error };
+        }
+    }
+    async list(opts = {}) {
+        await this.#ensureLoaded();
+        const limit = Math.max(1, Math.min(500, Math.trunc(opts.limit ?? 100)));
+        return sortPrograms([...this.#programs.values()])
+            .filter((program) => {
+            if (typeof opts.enabled === "boolean" && program.enabled !== opts.enabled) {
+                return false;
+            }
+            if (opts.targetKind && program.target.kind !== opts.targetKind) {
+                return false;
+            }
+            return true;
+        })
+            .slice(0, limit)
+            .map((program) => this.#snapshot(program));
+    }
+    async get(programId) {
+        await this.#ensureLoaded();
+        const program = this.#programs.get(programId.trim());
+        return program ? this.#snapshot(program) : null;
+    }
+    async create(opts) {
+        await this.#ensureLoaded();
+        const title = opts.title.trim();
+        if (!title) {
+            throw new Error("heartbeat_program_title_required");
+        }
+        const target = normalizeTarget(opts.target);
+        if (!target) {
+            throw new Error("heartbeat_program_invalid_target");
+        }
+        const nowMs = Math.trunc(this.#nowMs());
+        const program = {
+            v: 1,
+            program_id: `hb-${crypto.randomUUID().slice(0, 12)}`,
+            title,
+            enabled: opts.enabled !== false,
+            every_ms: typeof opts.everyMs === "number" && Number.isFinite(opts.everyMs)
+                ? Math.max(0, Math.trunc(opts.everyMs))
+                : 15_000,
+            reason: opts.reason?.trim() || "scheduled",
+            target,
+            metadata: sanitizeMetadata(opts.metadata),
+            created_at_ms: nowMs,
+            updated_at_ms: nowMs,
+            last_triggered_at_ms: null,
+            last_result: null,
+            last_error: null,
+        };
+        this.#programs.set(program.program_id, program);
+        this.#applySchedule(program);
+        await this.#persist();
+        return this.#snapshot(program);
+    }
+    async update(opts) {
+        await this.#ensureLoaded();
+        const program = this.#programs.get(opts.programId.trim());
+        if (!program) {
+            return { ok: false, reason: "not_found", program: null };
+        }
+        if (typeof opts.title === "string") {
+            const title = opts.title.trim();
+            if (!title) {
+                throw new Error("heartbeat_program_title_required");
+            }
+            program.title = title;
+        }
+        if (typeof opts.everyMs === "number" && Number.isFinite(opts.everyMs)) {
+            program.every_ms = Math.max(0, Math.trunc(opts.everyMs));
+        }
+        if (typeof opts.reason === "string") {
+            program.reason = opts.reason.trim() || "scheduled";
+        }
+        if (typeof opts.enabled === "boolean") {
+            program.enabled = opts.enabled;
+        }
+        if (opts.target) {
+            const target = normalizeTarget(opts.target);
+            if (!target) {
+                return { ok: false, reason: "invalid_target", program: this.#snapshot(program) };
+            }
+            program.target = target;
+        }
+        if (opts.metadata) {
+            program.metadata = sanitizeMetadata(opts.metadata);
+        }
+        program.updated_at_ms = Math.trunc(this.#nowMs());
+        this.#applySchedule(program);
+        await this.#persist();
+        return { ok: true, reason: null, program: this.#snapshot(program) };
+    }
+    async remove(programId) {
+        await this.#ensureLoaded();
+        const normalizedId = programId.trim();
+        if (!normalizedId) {
+            return { ok: false, reason: "missing_target", program: null };
+        }
+        const program = this.#programs.get(normalizedId);
+        if (!program) {
+            return { ok: false, reason: "not_found", program: null };
+        }
+        this.#heartbeatScheduler.unregister(this.#scheduleId(program.program_id));
+        this.#programs.delete(normalizedId);
+        await this.#persist();
+        return { ok: true, reason: null, program: this.#snapshot(program) };
+    }
+    async trigger(opts) {
+        await this.#ensureLoaded();
+        const programId = opts.programId?.trim() || "";
+        if (!programId) {
+            return { ok: false, reason: "missing_target", program: null };
+        }
+        const program = this.#programs.get(programId);
+        if (!program) {
+            return { ok: false, reason: "not_found", program: null };
+        }
+        if (!program.enabled) {
+            return { ok: false, reason: "not_running", program: this.#snapshot(program) };
+        }
+        const tick = await this.#tickProgram(program.program_id, opts.reason?.trim() || "manual");
+        if (tick.status === "failed") {
+            return { ok: false, reason: "failed", program: this.#snapshot(program) };
+        }
+        return { ok: true, reason: null, program: this.#snapshot(program) };
+    }
+    stop() {
+        for (const program of this.#programs.values()) {
+            this.#heartbeatScheduler.unregister(this.#scheduleId(program.program_id));
+        }
+        this.#programs.clear();
+    }
+}

package/dist/heartbeat_scheduler.d.ts

@@ -0,0 +1,38 @@
+export type HeartbeatRunResult = {
+    status: "ran";
+    durationMs?: number;
+} | {
+    status: "skipped";
+    reason: string;
+} | {
+    status: "failed";
+    reason: string;
+};
+export type HeartbeatTickHandler = (opts: {
+    activityId: string;
+    reason?: string;
+}) => Promise<HeartbeatRunResult> | HeartbeatRunResult;
+export type ActivityHeartbeatSchedulerOpts = {
+    nowMs?: () => number;
+    defaultCoalesceMs?: number;
+    retryMs?: number;
+    minIntervalMs?: number;
+};
+export declare class ActivityHeartbeatScheduler {
+    #private;
+    constructor(opts?: ActivityHeartbeatSchedulerOpts);
+    register(opts: {
+        activityId: string;
+        everyMs: number;
+        handler: HeartbeatTickHandler;
+        coalesceMs?: number;
+    }): void;
+    requestNow(activityIdRaw: string, opts?: {
+        reason?: string;
+        coalesceMs?: number;
+    }): boolean;
+    unregister(activityIdRaw: string): boolean;
+    has(activityIdRaw: string): boolean;
+    listActivityIds(): string[];
+    stop(): void;
+}

package/dist/heartbeat_scheduler.js

@@ -0,0 +1,238 @@
+const DEFAULT_COALESCE_MS = 250;
+const DEFAULT_RETRY_MS = 1_000;
+const DEFAULT_MIN_INTERVAL_MS = 2_000;
+const HOOK_REASON_PREFIX = "hook:";
+const REASON_PRIORITY = {
+    RETRY: 0,
+    INTERVAL: 1,
+    DEFAULT: 2,
+    ACTION: 3,
+};
+function defaultNowMs() {
+    return Date.now();
+}
+function normalizeActivityId(value) {
+    const trimmed = value.trim();
+    if (trimmed.length === 0) {
+        throw new Error("activity_id_required");
+    }
+    return trimmed;
+}
+function normalizeReason(reason) {
+    if (typeof reason !== "string") {
+        return "requested";
+    }
+    const trimmed = reason.trim();
+    return trimmed.length > 0 ? trimmed : "requested";
+}
+function isActionReason(reason) {
+    if (reason === "manual" || reason === "exec-event") {
+        return true;
+    }
+    return reason.startsWith(HOOK_REASON_PREFIX);
+}
+function resolveReasonPriority(reason) {
+    if (reason === "retry") {
+        return REASON_PRIORITY.RETRY;
+    }
+    if (reason === "interval") {
+        return REASON_PRIORITY.INTERVAL;
+    }
+    if (isActionReason(reason)) {
+        return REASON_PRIORITY.ACTION;
+    }
+    return REASON_PRIORITY.DEFAULT;
+}
+function toMs(value, fallback, min) {
+    if (typeof value !== "number" || !Number.isFinite(value)) {
+        return fallback;
+    }
+    return Math.max(min, Math.trunc(value));
+}
+export class ActivityHeartbeatScheduler {
+    #states = new Map();
+    #nowMs;
+    #defaultCoalesceMs;
+    #retryMs;
+    #minIntervalMs;
+    constructor(opts = {}) {
+        this.#nowMs = opts.nowMs ?? defaultNowMs;
+        this.#defaultCoalesceMs = Math.max(0, Math.trunc(opts.defaultCoalesceMs ?? DEFAULT_COALESCE_MS));
+        this.#retryMs = Math.max(100, Math.trunc(opts.retryMs ?? DEFAULT_RETRY_MS));
+        this.#minIntervalMs = Math.max(100, Math.trunc(opts.minIntervalMs ?? DEFAULT_MIN_INTERVAL_MS));
+    }
+    #clearWakeTimer(state) {
+        if (state.wakeTimer) {
+            clearTimeout(state.wakeTimer);
+            state.wakeTimer = null;
+        }
+        state.wakeDueAt = null;
+        state.wakeKind = null;
+    }
+    #disposeState(state) {
+        if (state.intervalTimer) {
+            clearInterval(state.intervalTimer);
+            state.intervalTimer = null;
+        }
+        this.#clearWakeTimer(state);
+        state.pendingWake = null;
+        state.running = false;
+        state.scheduled = false;
+    }
+    #queuePendingWakeReason(state, reason) {
+        const normalized = normalizeReason(reason);
+        const next = {
+            reason: normalized,
+            priority: resolveReasonPriority(normalized),
+            requestedAt: this.#nowMs(),
+        };
+        if (!state.pendingWake) {
+            state.pendingWake = next;
+            return;
+        }
+        if (next.priority > state.pendingWake.priority) {
+            state.pendingWake = next;
+            return;
+        }
+        if (next.priority === state.pendingWake.priority && next.requestedAt >= state.pendingWake.requestedAt) {
+            state.pendingWake = next;
+        }
+    }
+    #schedule(state, coalesceMs, kind = "normal") {
+        const delay = Math.max(0, Math.trunc(Number.isFinite(coalesceMs) ? coalesceMs : this.#defaultCoalesceMs));
+        const dueAt = this.#nowMs() + delay;
+        if (state.wakeTimer) {
+            // Retry cooldown should remain in force.
+            if (state.wakeKind === "retry") {
+                return;
+            }
+            if (typeof state.wakeDueAt === "number" && state.wakeDueAt <= dueAt) {
+                return;
+            }
+            this.#clearWakeTimer(state);
+        }
+        state.wakeDueAt = dueAt;
+        state.wakeKind = kind;
+        state.wakeTimer = setTimeout(() => {
+            void this.#flush(state.activityId, delay, kind);
+        }, delay);
+        state.wakeTimer.unref?.();
+    }
+    async #flush(activityId, delay, kind) {
+        const state = this.#states.get(activityId);
+        if (!state) {
+            return;
+        }
+        this.#clearWakeTimer(state);
+        state.scheduled = false;
+        if (state.running) {
+            state.scheduled = true;
+            this.#schedule(state, delay, kind);
+            return;
+        }
+        const reason = state.pendingWake?.reason;
+        state.pendingWake = null;
+        state.running = true;
+        let result;
+        const startedAt = this.#nowMs();
+        try {
+            result = await state.handler({ activityId, reason: reason ?? undefined });
+            if (result.status === "ran" && result.durationMs == null) {
+                result = {
+                    status: "ran",
+                    durationMs: Math.max(0, Math.trunc(this.#nowMs() - startedAt)),
+                };
+            }
+        }
+        catch (err) {
+            result = {
+                status: "failed",
+                reason: err instanceof Error ? err.message : String(err),
+            };
+        }
+        state.running = false;
+        // If the activity was removed while the handler was running, bail out quietly.
+        if (this.#states.get(activityId) !== state) {
+            return;
+        }
+        if (result.status === "failed") {
+            this.#queuePendingWakeReason(state, reason ?? "retry");
+            this.#schedule(state, this.#retryMs, "retry");
+        }
+        else if (result.status === "skipped" && result.reason === "requests-in-flight") {
+            this.#queuePendingWakeReason(state, reason ?? "retry");
+            this.#schedule(state, this.#retryMs, "retry");
+        }
+        if (state.pendingWake || state.scheduled) {
+            this.#schedule(state, state.coalesceMs, "normal");
+        }
+    }
+    register(opts) {
+        const activityId = normalizeActivityId(opts.activityId);
+        const existing = this.#states.get(activityId);
+        if (existing) {
+            this.#disposeState(existing);
+            this.#states.delete(activityId);
+        }
+        const state = {
+            activityId,
+            everyMs: toMs(opts.everyMs, this.#minIntervalMs, this.#minIntervalMs),
+            coalesceMs: Math.max(0, Math.trunc(opts.coalesceMs ?? this.#defaultCoalesceMs)),
+            handler: opts.handler,
+            pendingWake: null,
+            scheduled: false,
+            running: false,
+            intervalTimer: null,
+            wakeTimer: null,
+            wakeDueAt: null,
+            wakeKind: null,
+        };
+        state.intervalTimer = setInterval(() => {
+            this.requestNow(activityId, { reason: "interval", coalesceMs: 0 });
+        }, state.everyMs);
+        state.intervalTimer.unref?.();
+        this.#states.set(activityId, state);
+    }
+    requestNow(activityIdRaw, opts) {
+        const activityId = activityIdRaw.trim();
+        if (activityId.length === 0) {
+            return false;
+        }
+        const state = this.#states.get(activityId);
+        if (!state) {
+            return false;
+        }
+        this.#queuePendingWakeReason(state, opts?.reason);
+        this.#schedule(state, opts?.coalesceMs ?? state.coalesceMs, "normal");
+        return true;
+    }
+    unregister(activityIdRaw) {
+        const activityId = activityIdRaw.trim();
+        if (activityId.length === 0) {
+            return false;
+        }
+        const state = this.#states.get(activityId);
+        if (!state) {
+            return false;
+        }
+        this.#disposeState(state);
+        this.#states.delete(activityId);
+        return true;
+    }
+    has(activityIdRaw) {
+        const activityId = activityIdRaw.trim();
+        if (activityId.length === 0) {
+            return false;
+        }
+        return this.#states.has(activityId);
+    }
+    listActivityIds() {
+        return [...this.#states.keys()];
+    }
+    stop() {
+        for (const state of this.#states.values()) {
+            this.#disposeState(state);
+        }
+        this.#states.clear();
+    }
+}

package/dist/index.d.ts

@@ -1,6 +1,12 @@
 export type { MuConfig, MuConfigPatch, MuConfigPresence } from "./config.js";
 export { applyMuConfigPatch, DEFAULT_MU_CONFIG, getMuConfigPath, muConfigPresence, normalizeMuConfig, readMuConfigFile, redactMuConfigSecrets, writeMuConfigFile, } from "./config.js";
+export type { ControlPlaneActivityEvent, ControlPlaneActivityEventKind, ControlPlaneActivityMutationResult, ControlPlaneActivitySnapshot, ControlPlaneActivityStatus, ControlPlaneActivitySupervisorOpts, } from "./activity_supervisor.js";
+export { ControlPlaneActivitySupervisor } from "./activity_supervisor.js";
+export type { HeartbeatProgramOperationResult, HeartbeatProgramRegistryOpts, HeartbeatProgramSnapshot, HeartbeatProgramTarget, HeartbeatProgramTickEvent, } from "./heartbeat_programs.js";
+export { HeartbeatProgramRegistry } from "./heartbeat_programs.js";
 export type { ActiveAdapter, ControlPlaneConfig, ControlPlaneHandle } from "./control_plane.js";
 export { bootstrapControlPlane, detectAdapters } from "./control_plane.js";
+export type { HeartbeatRunResult, HeartbeatTickHandler, ActivityHeartbeatSchedulerOpts } from "./heartbeat_scheduler.js";
+export { ActivityHeartbeatScheduler } from "./heartbeat_scheduler.js";
 export type { ServerContext, ServerOptions, ServerWithControlPlane } from "./server.js";
 export { createContext, createServer, createServerAsync } from "./server.js";