@haywoodmarx/agent-pager 0.1.0

package/dist/src/launch/runtime-composition.js

@@ -0,0 +1,253 @@
+var __rewriteRelativeImportExtension = (this && this.__rewriteRelativeImportExtension) || function (path, preserveJsx) {
+    if (typeof path === "string" && /^\.\.?\//.test(path)) {
+        return path.replace(/\.(tsx)$|((?:\.d)?)((?:\.[^./]+?)?)\.([cm]?)ts$/i, function (m, tsx, d, ext, cm) {
+            return tsx ? preserveJsx ? ".jsx" : ".js" : d && (!ext || !cm) ? m : (d + ext + "." + cm.toLowerCase() + "js");
+        });
+    }
+    return path;
+};
+import { spawn } from "node:child_process";
+import { access, readdir } from "node:fs/promises";
+import { join } from "node:path";
+import { fileURLToPath, pathToFileURL } from "node:url";
+import { Broker } from "../broker/broker.js";
+import { discoverImplementationRegistry, implementationId, } from "../implementations/registry.js";
+import { DirectTerminalProvider, ForegroundTerminalProvider, LaunchService, } from "./launch.js";
+import { spawnForegroundProcess } from "./terminal.js";
+import { systemWorkspaceBranch } from "./workspace-branch.js";
+import { initializePagerStore } from "../configuration.js";
+import { isPlainObject } from "../shared/guards.js";
+export { readRuntimeEnvironment } from "./environment.js";
+/**
+ * Construct the broker from resolved runtime configuration.
+ * @param environment - Resolved Bun runtime configuration.
+ * @returns - Handle that reads the current broker epoch without rotating it, so it does not detach live agents.
+ */
+export function createBroker(environment) {
+    initializePagerStore({
+        config: environment.config,
+        filePath: environment.configPath,
+        storeDirectory: environment.storeDirectory,
+    });
+    const config = environment.config;
+    return new Broker(environment.dbPath, {
+        now: Date.now,
+        workspaceBranch: systemWorkspaceBranch,
+        report: (message) => {
+            process.stderr.write(`${message}\n`);
+        },
+        epochOwner: false,
+        visibilityTimeoutMs: config.visibilityTimeoutMs,
+        redeliveryBaseDelayMs: config.redeliveryBaseDelayMs,
+        redeliveryGiveUpMs: config.redeliveryGiveUpMs,
+        reservationTtlMs: config.reservationTtlMs,
+        leaseTtlMs: config.leaseTtlMs,
+        perPairRateLimit: config.perPairRateLimit,
+        perPairRateWindowMs: config.perPairRateWindowMs,
+        maxInboxMessages: config.maxInboxMessages,
+    });
+}
+/**
+ * Construct the broker `BrokerService` owns for the life of its process.
+ * @param databasePath - Durable SQLite file the broker owns.
+ * @param options - Broker construction options, including the root's clock and report sink.
+ * @returns - Broker instance satisfying the service's declared port.
+ */
+export function openBroker(databasePath, options) {
+    return new Broker(databasePath, options);
+}
+/**
+ * Discover every built-in implementation manifest without a shared product list.
+ * @returns - Registry of validated discovered implementations.
+ */
+export async function createImplementationRegistry() {
+    const root = fileURLToPath(new URL("../implementations", import.meta.url));
+    return discoverImplementationRegistry(root, {
+        listDirectories: async (directory) => {
+            const entries = (await readdir(directory, { withFileTypes: true })).filter((entry) => entry.isDirectory());
+            const implementations = [];
+            for (const entry of entries) {
+                const hasManifest = await Promise.any([
+                    access(join(directory, entry.name, "manifest.js")).then(() => true),
+                    access(join(directory, entry.name, "manifest.ts")).then(() => true),
+                ]).catch(() => false);
+                if (hasManifest)
+                    implementations.push(entry.name);
+            }
+            return implementations;
+        },
+        loadProvider: async (manifestPath) => {
+            const loaded = await import(__rewriteRelativeImportExtension(pathToFileURL(manifestPath).href));
+            return isPlainObject(loaded) ? loaded.default : undefined;
+        },
+    });
+}
+/**
+ * Construct launch orchestration from discovered implementation and terminal providers.
+ * @param broker - Durable broker used by launch orchestration.
+ * @param terminalProviderId - Open terminal-provider identifier to resolve.
+ * @param environment - Resolved Bun runtime configuration.
+ * @param implementations - Registry resolving agent implementations.
+ * @returns - Launch service offering only the requested terminal provider.
+ */
+export async function createLaunchService(broker, terminalProviderId, environment, implementations) {
+    const terminalProvider = await createTerminalProvider(terminalProviderId, environment.processEnv);
+    return new LaunchService(broker, implementations, [terminalProvider], environment.processEnv);
+}
+/**
+ * Compose an interactive launch service from conventionally discovered terminal providers.
+ * @param broker - Durable broker used by launch orchestration.
+ * @param environment - Resolved Bun runtime configuration.
+ * @param implementations - Registry resolving agent implementations.
+ * @param report - Receives each discovered terminal provider that was skipped, and why.
+ * @returns - Launch service offering only the selected provider, and that provider's name.
+ */
+export async function createInteractiveLaunchService(broker, environment, implementations, report) {
+    const discovered = await discoverTerminalProviders(environment.processEnv, report);
+    const foreground = new ForegroundTerminalProvider(spawnForegroundProcess);
+    const selected = await selectInteractiveTerminalProvider(discovered, foreground);
+    return {
+        service: new LaunchService(broker, implementations, [selected], environment.processEnv),
+        terminalProvider: selected.name,
+    };
+}
+/**
+ * Select the highest-priority available interactive provider or the inherited-terminal fallback.
+ * @param candidates - Conventionally discovered optional terminal providers.
+ * @param fallback - Foreground provider used when no optional provider is available.
+ * @returns - The available candidate with the highest priority, or the fallback when none is available.
+ */
+export async function selectInteractiveTerminalProvider(candidates, fallback) {
+    const available = [];
+    for (const provider of candidates) {
+        if (!provider.available || (await provider.available()))
+            available.push(provider);
+    }
+    available.sort((left, right) => (right.interactivePriority ?? 0) - (left.interactivePriority ?? 0));
+    return available[0] ?? fallback;
+}
+async function discoverTerminalProviders(environment, report) {
+    const root = fileURLToPath(new URL("../implementations", import.meta.url));
+    const modules = [];
+    for (const directory of await implementationDirectories(root)) {
+        const modulePath = join(root, directory, "terminal.js");
+        const present = await Promise.any([
+            access(modulePath).then(() => true),
+            access(join(root, directory, "terminal.ts")).then(() => true),
+        ]).catch(() => false);
+        if (!present)
+            continue;
+        try {
+            modules.push({ modulePath, state: "loaded", namespace: await import(__rewriteRelativeImportExtension(pathToFileURL(modulePath).href)) });
+        }
+        catch (error) {
+            modules.push({ modulePath, state: "unloadable", error });
+        }
+    }
+    return adoptTerminalProviders(modules, environment, report);
+}
+/**
+ * Build the provider each discovered terminal module offers, skipping any that cannot build one.
+ *
+ * An interactive launch always has the foreground fallback, so one broken module is named and left
+ * out rather than failing every launch.
+ * @param modules - Discovered `terminal.js` modules, in discovery order.
+ * @param environment - Process environment every provider is built from.
+ * @param report - Receives one line per skipped module, naming it and the reason.
+ * @returns - Providers from every module whose factory built one, in module order.
+ */
+export function adoptTerminalProviders(modules, environment, report) {
+    const skip = (reason) => {
+        report(`pager: ${reason}; skipped`);
+    };
+    const providers = [];
+    for (const discovered of modules) {
+        if (discovered.state === "unloadable") {
+            skip(`terminal provider module could not be loaded: ${discovered.modulePath}: ${errorText(discovered.error)}`);
+            continue;
+        }
+        const module = terminalProviderModule(discovered.namespace, discovered.modulePath);
+        if (!module) {
+            skip(`terminal provider module does not export a factory: ${discovered.modulePath}`);
+            continue;
+        }
+        try {
+            providers.push(module.createTerminalProvider(environment));
+        }
+        catch (error) {
+            skip(errorText(error));
+        }
+    }
+    return providers;
+}
+function errorText(error) {
+    return error instanceof Error ? error.message : String(error);
+}
+/**
+ * Read a loaded `terminal.js` module as the port discovery expects, checking what its factory builds.
+ *
+ * The factory's parameter cannot be checked at runtime, so the provider it returns is, on every call.
+ * @param loaded - Module namespace a dynamic import produced.
+ * @param modulePath - Module path named in a rejection.
+ * @returns - The module's factory, or undefined when it exports none.
+ * @throws {Error} When the factory throws or builds something that is not a terminal provider, naming the module.
+ */
+export function terminalProviderModule(loaded, modulePath) {
+    if (!isPlainObject(loaded))
+        return undefined;
+    const factory = loaded.createTerminalProvider;
+    if (typeof factory !== "function")
+        return undefined;
+    return {
+        createTerminalProvider: (environment) => {
+            let provider;
+            try {
+                provider = Reflect.apply(factory, undefined, [environment]);
+            }
+            catch (error) {
+                throw new Error(`terminal provider module failed to build its provider: ${modulePath}: ${errorText(error)}`, {
+                    cause: error,
+                });
+            }
+            if (!isTerminalProvider(provider)) {
+                throw new Error(`terminal provider module built something that is not a terminal provider: ${modulePath}`);
+            }
+            return provider;
+        },
+    };
+}
+function isTerminalProvider(value) {
+    return (isPlainObject(value) &&
+        typeof value.name === "string" &&
+        value.name.length > 0 &&
+        typeof value.launch === "function" &&
+        (value.available === undefined || typeof value.available === "function") &&
+        (value.interactivePriority === undefined ||
+            (typeof value.interactivePriority === "number" && Number.isFinite(value.interactivePriority))));
+}
+async function implementationDirectories(root) {
+    return (await readdir(root, { withFileTypes: true }))
+        .filter((entry) => entry.isDirectory())
+        .map((entry) => entry.name)
+        .sort();
+}
+async function createTerminalProvider(id, environment) {
+    if (id === "direct") {
+        return new DirectTerminalProvider((command, args, options) => {
+            const child = spawn(command, args, options);
+            return {
+                pid: child.pid,
+                unref: () => {
+                    child.unref();
+                },
+            };
+        });
+    }
+    const validatedId = implementationId(id);
+    const root = fileURLToPath(new URL("../implementations", import.meta.url));
+    const modulePath = join(root, validatedId, "terminal.js");
+    const loaded = terminalProviderModule(await import(__rewriteRelativeImportExtension(pathToFileURL(modulePath).href)), modulePath);
+    if (!loaded)
+        throw new Error(`terminal provider module does not export a factory: ${modulePath}`);
+    return loaded.createTerminalProvider(environment);
+}

package/dist/src/launch/runtime.d.ts

@@ -0,0 +1,79 @@
+import { type RuntimeEnvironment } from "./environment.js";
+/** Lowest Bun release whose SQLite, subprocess, and test behaviour this project is validated against. */
+export declare const MINIMUM_BUN_VERSION = "1.4.2";
+/** Names the environment variable that pins an explicit Bun executable for spawned services. */
+export declare const BUN_PATH_ENVIRONMENT = "PAGER_BUN_PATH";
+/** Names the Node runtime override variable; `resolveBunExecutable` rejects it whenever it holds a non-empty value. */
+export declare const RETIRED_NODE_PATH_ENVIRONMENT = "PAGER_NODE_PATH";
+/** Raised when no executable satisfying the Bun runtime policy can be selected. */
+export declare class BunRuntimeError extends Error {
+    /**
+     * Construct the actionable runtime failure surfaced to operators.
+     * @param message - Explanation naming the executable and version that were rejected.
+     */
+    constructor(message: string);
+}
+/** Supplies the host-identity and executable-probe seams used when selecting the service runtime. */
+export type RuntimeProbe = {
+    /** Reports the Bun version of the current process, or undefined when this process is not Bun. */
+    hostVersion: string | undefined;
+    /** Names the executable running the current process. */
+    execPath: string;
+    /** Lists directories searched for a standalone `bun`, highest precedence first. */
+    searchPath: readonly string[];
+    /**
+     * Report a candidate executable's own Bun version.
+     * @param executable - Absolute path or command probed as a standalone Bun runtime.
+     * @returns - Reported Bun version, or undefined when the executable is not a standalone Bun.
+     */
+    probe(executable: string): string | undefined;
+};
+/**
+ * Report whether a Bun version meets the project floor.
+ *
+ * Only the numeric major, minor, and patch are compared, so a prerelease suffix does not lower a
+ * build below the floor.
+ * @param version - Version string reported by a Bun runtime.
+ * @returns - True when the version is at or above the supported floor.
+ */
+export declare function satisfiesBunVersionFloor(version: string): boolean;
+/**
+ * Fail fast when the current process is not a supported Bun runtime.
+ * @param probe - Host-identity seam, overridden by isolated verification.
+ * @returns - The validated Bun version running this process.
+ */
+export declare function assertSupportedBunRuntime(probe?: Pick<RuntimeProbe, "hostVersion">): string;
+/**
+ * Resolve the Bun executable that must own detached services, wrappers, and gateway children.
+ *
+ * An embedded Bun host such as an editor exposes its own application binary as the process
+ * executable, so the current executable is reused only when it is a reusable standalone `bun`.
+ * @param environment - Process environment supplying the explicit override.
+ * @param overrides - Host-identity and probe seams for isolated verification.
+ * @returns - Absolute path that runs a supported Bun runtime.
+ */
+export declare function resolveBunExecutable(environment?: NodeJS.ProcessEnv, overrides?: Partial<RuntimeProbe>): string;
+/**
+ * Prefer the `bun` a package manager keeps at a stable path over the versioned file it links to.
+ *
+ * A path written into a long-lived file must outlive an upgrade. Homebrew, for one, links
+ * `bin/bun` to a per-version directory that the next upgrade deletes.
+ * @param executable - Resolved Bun executable, typically already a real path.
+ * @param searchPath - Directories searched for a `bun` link, highest precedence first.
+ * @param realPath - Resolves symbolic links; overridden by isolated verification.
+ * @returns - First `bun` on the search path that resolves to the same file, or the executable itself.
+ */
+export declare function stableBunExecutable(executable: string, searchPath?: readonly string[], realPath?: (path: string) => string): string;
+/**
+ * Resolve and pin the standalone Bun executable before an embedded host starts a service.
+ * @param processEnvironment - Environment inherited by the editor host.
+ * @param resolveRuntime - Validated standalone-runtime resolver.
+ * @returns - Runtime environment carrying an explicit absolute Bun selection.
+ */
+export declare function readEmbeddedRuntimeEnvironment(processEnvironment: NodeJS.ProcessEnv, resolveRuntime: (environment: NodeJS.ProcessEnv) => string): RuntimeEnvironment;
+/**
+ * Report the Bun version of another executable without trusting its name.
+ * @param executable - Absolute path or command to probe.
+ * @returns - Reported Bun version, or undefined when the executable is not a standalone Bun.
+ */
+export declare function probeBunVersion(executable: string): string | undefined;

package/dist/src/launch/runtime.js

@@ -0,0 +1,196 @@
+import { execFileSync } from "node:child_process";
+import { accessSync, constants, realpathSync } from "node:fs";
+import { delimiter, isAbsolute, resolve } from "node:path";
+import { readRuntimeEnvironment } from "./environment.js";
+/** Bounds one probe of an external runtime executable. */
+const RUNTIME_PROBE_TIMEOUT_MS = 10_000;
+/** Lowest Bun release whose SQLite, subprocess, and test behaviour this project is validated against. */
+export const MINIMUM_BUN_VERSION = "1.4.2";
+/** Names the environment variable that pins an explicit Bun executable for spawned services. */
+export const BUN_PATH_ENVIRONMENT = "PAGER_BUN_PATH";
+/** Names the Node runtime override variable; `resolveBunExecutable` rejects it whenever it holds a non-empty value. */
+export const RETIRED_NODE_PATH_ENVIRONMENT = "PAGER_NODE_PATH";
+/** Raised when no executable satisfying the Bun runtime policy can be selected. */
+export class BunRuntimeError extends Error {
+    /**
+     * Construct the actionable runtime failure surfaced to operators.
+     * @param message - Explanation naming the executable and version that were rejected.
+     */
+    constructor(message) {
+        super(message);
+        this.name = "BunRuntimeError";
+    }
+}
+/**
+ * Report whether a Bun version meets the project floor.
+ *
+ * Only the numeric major, minor, and patch are compared, so a prerelease suffix does not lower a
+ * build below the floor.
+ * @param version - Version string reported by a Bun runtime.
+ * @returns - True when the version is at or above the supported floor.
+ */
+export function satisfiesBunVersionFloor(version) {
+    const candidate = numericVersion(version);
+    const minimum = numericVersion(MINIMUM_BUN_VERSION);
+    if (!candidate || !minimum)
+        return false;
+    for (let index = 0; index < minimum.length; index += 1) {
+        const difference = (candidate[index] ?? 0) - (minimum[index] ?? 0);
+        if (difference !== 0)
+            return difference > 0;
+    }
+    return true;
+}
+function numericVersion(version) {
+    const match = /^(\d+)\.(\d+)\.(\d+)/u.exec(version);
+    if (!match)
+        return undefined;
+    return [Number(match[1]), Number(match[2]), Number(match[3])];
+}
+/**
+ * Fail fast when the current process is not a supported Bun runtime.
+ * @param probe - Host-identity seam, overridden by isolated verification.
+ * @returns - The validated Bun version running this process.
+ */
+export function assertSupportedBunRuntime(probe = defaultProbe()) {
+    const version = probe.hostVersion;
+    if (version === undefined) {
+        throw new BunRuntimeError(`Pager requires Bun >= ${MINIMUM_BUN_VERSION}; this process is not running under Bun`);
+    }
+    if (!satisfiesBunVersionFloor(version)) {
+        throw new BunRuntimeError(`Pager requires Bun >= ${MINIMUM_BUN_VERSION}; this process runs Bun ${version}`);
+    }
+    return version;
+}
+/**
+ * Resolve the Bun executable that must own detached services, wrappers, and gateway children.
+ *
+ * An embedded Bun host such as an editor exposes its own application binary as the process
+ * executable, so the current executable is reused only when it is a reusable standalone `bun`.
+ * @param environment - Process environment supplying the explicit override.
+ * @param overrides - Host-identity and probe seams for isolated verification.
+ * @returns - Absolute path that runs a supported Bun runtime.
+ */
+export function resolveBunExecutable(environment = process.env, overrides = {}) {
+    const probe = { ...defaultProbe(), ...overrides };
+    if (environment[RETIRED_NODE_PATH_ENVIRONMENT]) {
+        throw new BunRuntimeError(`${RETIRED_NODE_PATH_ENVIRONMENT} is no longer honoured; set ${BUN_PATH_ENVIRONMENT} to a Bun >= ${MINIMUM_BUN_VERSION} executable`);
+    }
+    const configured = environment[BUN_PATH_ENVIRONMENT];
+    if (configured) {
+        if (!isAbsolute(configured)) {
+            throw new BunRuntimeError(`${BUN_PATH_ENVIRONMENT} must name an absolute Bun executable path`);
+        }
+        return validated(configured, probe.probe(configured), "configured by " + BUN_PATH_ENVIRONMENT);
+    }
+    if (probe.hostVersion !== undefined &&
+        isAbsolute(probe.execPath) &&
+        isStandaloneBunPath(probe.execPath) &&
+        satisfiesBunVersionFloor(probe.hostVersion)) {
+        return probe.execPath;
+    }
+    const rejected = [];
+    for (const candidate of bunCandidatesOnPath(probe.searchPath)) {
+        const version = probe.probe(candidate);
+        if (version !== undefined && satisfiesBunVersionFloor(version))
+            return candidate;
+        rejected.push(version === undefined ? `${candidate} (not Bun)` : `${candidate} (Bun ${version})`);
+    }
+    const detail = rejected.length > 0 ? `; rejected ${rejected.join(", ")}` : "";
+    throw new BunRuntimeError(`Pager requires Bun >= ${MINIMUM_BUN_VERSION} on PATH or in ${BUN_PATH_ENVIRONMENT}${detail}`);
+}
+/**
+ * Prefer the `bun` a package manager keeps at a stable path over the versioned file it links to.
+ *
+ * A path written into a long-lived file must outlive an upgrade. Homebrew, for one, links
+ * `bin/bun` to a per-version directory that the next upgrade deletes.
+ * @param executable - Resolved Bun executable, typically already a real path.
+ * @param searchPath - Directories searched for a `bun` link, highest precedence first.
+ * @param realPath - Resolves symbolic links; overridden by isolated verification.
+ * @returns - First `bun` on the search path that resolves to the same file, or the executable itself.
+ */
+export function stableBunExecutable(executable, searchPath = defaultProbe().searchPath, realPath = realpathSync) {
+    const target = tryRealPath(executable, realPath);
+    if (target === undefined)
+        return executable;
+    for (const candidate of bunCandidatesOnPath(searchPath)) {
+        if (tryRealPath(candidate, realPath) === target)
+            return candidate;
+    }
+    return executable;
+}
+function tryRealPath(path, realPath) {
+    try {
+        return realPath(path);
+    }
+    catch {
+        return undefined;
+    }
+}
+/**
+ * Resolve and pin the standalone Bun executable before an embedded host starts a service.
+ * @param processEnvironment - Environment inherited by the editor host.
+ * @param resolveRuntime - Validated standalone-runtime resolver.
+ * @returns - Runtime environment carrying an explicit absolute Bun selection.
+ */
+export function readEmbeddedRuntimeEnvironment(processEnvironment, resolveRuntime) {
+    const environment = readRuntimeEnvironment(processEnvironment);
+    return {
+        ...environment,
+        processEnv: { ...environment.processEnv, [BUN_PATH_ENVIRONMENT]: resolveRuntime(processEnvironment) },
+    };
+}
+/**
+ * Report the Bun version of another executable without trusting its name.
+ * @param executable - Absolute path or command to probe.
+ * @returns - Reported Bun version, or undefined when the executable is not a standalone Bun.
+ */
+export function probeBunVersion(executable) {
+    try {
+        const output = execFileSync(executable, ["-e", "process.stdout.write(String(Bun?.version ?? ''))"], {
+            encoding: "utf8",
+            stdio: ["ignore", "pipe", "ignore"],
+            timeout: RUNTIME_PROBE_TIMEOUT_MS,
+        }).trim();
+        return /^\d+\.\d+\.\d+/u.test(output) ? output : undefined;
+    }
+    catch {
+        return undefined;
+    }
+}
+function defaultProbe() {
+    return {
+        hostVersion: typeof globalThis.Bun === "object" ? Bun.version : undefined,
+        execPath: process.execPath,
+        searchPath: (process.env.PATH ?? "").split(delimiter).filter((entry) => entry.length > 0),
+        probe: probeBunVersion,
+    };
+}
+function validated(executable, version, origin) {
+    if (version === undefined)
+        throw new BunRuntimeError(`${executable} (${origin}) is not a Bun executable`);
+    if (!satisfiesBunVersionFloor(version)) {
+        throw new BunRuntimeError(`${executable} (${origin}) runs Bun ${version}; Pager requires >= ${MINIMUM_BUN_VERSION}`);
+    }
+    return executable;
+}
+function isStandaloneBunPath(execPath) {
+    const name = execPath.slice(execPath.lastIndexOf("/") + 1).toLowerCase();
+    return name === "bun" || name === "bun.exe";
+}
+function bunCandidatesOnPath(searchPath) {
+    const candidates = [];
+    for (const directory of searchPath) {
+        for (const name of ["bun", "bun.exe"]) {
+            const candidate = resolve(directory, name);
+            try {
+                accessSync(candidate, constants.X_OK);
+                candidates.push(candidate);
+            }
+            catch {
+                continue;
+            }
+        }
+    }
+    return candidates;
+}

package/dist/src/launch/service-system.d.ts

@@ -0,0 +1,11 @@
+import type { BrokerServiceFilesystemPort, BrokerServiceSchedulerPort } from "./service.js";
+/**
+ * Schedule on the process timers without holding the process open.
+ * @returns - Scheduler whose timers never keep the event loop alive.
+ */
+export declare function systemBrokerServiceScheduler(): BrokerServiceSchedulerPort;
+/**
+ * Operate on the real filesystem.
+ * @returns - Filesystem port over `node:fs`.
+ */
+export declare function systemBrokerServiceFilesystem(): BrokerServiceFilesystemPort;

package/dist/src/launch/service-system.js

@@ -0,0 +1,39 @@
+import { existsSync, mkdirSync, statSync, unlinkSync } from "node:fs";
+/** Largest delay one process timer is armed with; a longer delay fires at this bound instead. */
+const MAXIMUM_TIMER_DELAY_MS = 2_147_483_647;
+/**
+ * Schedule on the process timers without holding the process open.
+ * @returns - Scheduler whose timers never keep the event loop alive.
+ */
+export function systemBrokerServiceScheduler() {
+    return {
+        once: (callback, delayMs) => {
+            const timer = setTimeout(callback, Math.min(delayMs, MAXIMUM_TIMER_DELAY_MS));
+            timer.unref();
+            return () => {
+                clearTimeout(timer);
+            };
+        },
+        recurring: (callback, intervalMs) => {
+            const timer = setInterval(callback, intervalMs);
+            timer.unref();
+            return () => {
+                clearInterval(timer);
+            };
+        },
+    };
+}
+/**
+ * Operate on the real filesystem.
+ * @returns - Filesystem port over `node:fs`.
+ */
+export function systemBrokerServiceFilesystem() {
+    return {
+        exists: existsSync,
+        sizeOf: (path) => statSync(path).size,
+        remove: unlinkSync,
+        createDirectory: (path) => {
+            mkdirSync(path, { recursive: true });
+        },
+    };
+}