target-supabase-sdk 0.2.3 → 0.2.5

package/src/node/fs/sharded-json-state-store.ts

@@ -0,0 +1,157 @@
+import { mkdir, readFile, stat, unlink } from "node:fs/promises";
+import { createJsonFileStateStore, type JsonStatePatch } from "./json-state-store";
+import { resolveRuntimeStatePaths, runtimeStateShardPath } from "./runtime-state-path";
+
+export interface CreateShardedJsonFileStateStoreOptions<T extends object, NK extends keyof T> {
+    /** Monolithic legacy path or shard directory root (see {@link resolveRuntimeStatePaths}). */
+    filePath: string;
+    defaultState: T;
+    /** Top-level keys persisted as separate shard files. */
+    nestedKeys: NK[];
+    updatedAtKey?: keyof T;
+}
+
+function isPlainObject(value: unknown): value is Record<string, unknown> {
+    return value != null && typeof value === "object" && !Array.isArray(value);
+}
+
+function mergeSlice<T extends object>(defaults: T, key: keyof T, patchValue: unknown): T[keyof T] {
+    const base = defaults[key];
+    if (isPlainObject(base) && isPlainObject(patchValue)) {
+        return { ...base, ...patchValue } as T[keyof T];
+    }
+    return patchValue as T[keyof T];
+}
+
+/**
+ * JSON runtime state with **one file per top-level slice** (log-persist registry pattern).
+ * Eliminates cross-slice lost updates when guard/scheduler/worker write concurrently.
+ */
+export function createShardedJsonFileStateStore<T extends object, NK extends keyof T>(
+    options: CreateShardedJsonFileStateStoreOptions<T, NK>,
+): {
+    read(): Promise<T>;
+    write(patch: JsonStatePatch<T, NK>): Promise<T>;
+    reset(): Promise<T>;
+} {
+    const { defaultState, nestedKeys, updatedAtKey } = options;
+    const { stateDir, legacyFilePath } = resolveRuntimeStatePaths(options.filePath);
+
+    type ShardStore = ReturnType<typeof createJsonFileStateStore<object>>;
+    const shardStores = new Map<string, ShardStore>();
+
+    function shardStore(sliceKey: NK): ShardStore {
+        const key = String(sliceKey);
+        let store = shardStores.get(key);
+        if (store == null) {
+            store = createJsonFileStateStore({
+                filePath: runtimeStateShardPath(stateDir, key),
+                defaultState: defaultState[sliceKey] as object,
+            });
+            shardStores.set(key, store);
+        }
+        return store;
+    }
+
+    async function readUpdatedAtFromShardMtimes(): Promise<string> {
+        let maxMtimeMs = 0;
+        for (const sliceKey of nestedKeys) {
+            try {
+                const shardStat = await stat(runtimeStateShardPath(stateDir, String(sliceKey)));
+                maxMtimeMs = Math.max(maxMtimeMs, shardStat.mtimeMs);
+            } catch (error) {
+                if ((error as NodeJS.ErrnoException).code !== "ENOENT") {
+                    throw error;
+                }
+            }
+        }
+        if (maxMtimeMs <= 0) {
+            return defaultState[updatedAtKey as keyof T] as string;
+        }
+        return new Date(maxMtimeMs).toISOString();
+    }
+
+    async function migrateLegacyMonolithicIfPresent(): Promise<void> {
+        if (legacyFilePath == null) {
+            return;
+        }
+
+        let raw: string;
+        try {
+            raw = await readFile(legacyFilePath, "utf8");
+        } catch (error) {
+            if ((error as NodeJS.ErrnoException).code === "ENOENT") {
+                return;
+            }
+            throw error;
+        }
+
+        let parsed: Partial<T>;
+        try {
+            parsed = JSON.parse(raw) as Partial<T>;
+        } catch {
+            await unlink(legacyFilePath).catch(() => undefined);
+            return;
+        }
+
+        await mkdir(stateDir, { recursive: true });
+        for (const sliceKey of nestedKeys) {
+            const slice = parsed[sliceKey];
+            if (slice != null) {
+                await shardStore(sliceKey).write(slice as object);
+            }
+        }
+
+        await unlink(legacyFilePath).catch(() => undefined);
+    }
+
+    return {
+        async read(): Promise<T> {
+            await mkdir(stateDir, { recursive: true });
+            await migrateLegacyMonolithicIfPresent();
+
+            const merged = { ...defaultState } as T;
+            for (const sliceKey of nestedKeys) {
+                merged[sliceKey] = (await shardStore(sliceKey).read()) as T[NK];
+            }
+            if (updatedAtKey != null) {
+                merged[updatedAtKey] = (await readUpdatedAtFromShardMtimes()) as T[keyof T];
+            }
+            return merged;
+        },
+
+        async write(patch: JsonStatePatch<T, NK>): Promise<T> {
+            await mkdir(stateDir, { recursive: true });
+            await migrateLegacyMonolithicIfPresent();
+
+            for (const sliceKey of nestedKeys) {
+                const patchSlice = patch[sliceKey];
+                if (patchSlice == null) {
+                    continue;
+                }
+                const current = await shardStore(sliceKey).read();
+                const nextSlice = mergeSlice(defaultState, sliceKey, {
+                    ...(current as object),
+                    ...(patchSlice as object),
+                });
+                await shardStore(sliceKey).write(nextSlice as object);
+            }
+
+            return this.read();
+        },
+
+        async reset(): Promise<T> {
+            await mkdir(stateDir, { recursive: true });
+
+            for (const sliceKey of nestedKeys) {
+                await shardStore(sliceKey).reset();
+            }
+
+            if (legacyFilePath != null) {
+                await unlink(legacyFilePath).catch(() => undefined);
+            }
+
+            return this.read();
+        },
+    };
+}

package/src/node/node-runtime.base.ts

@@ -21,6 +21,16 @@ export interface NodeLoopContext {
     nodeId: string;
 }
 
+/** Shared options for {@link BaseNodeRuntime} and subclasses (e.g. TriggerNode). */
+export interface BaseNodeRuntimeOptions {
+    /**
+     * Called after node logout (or when the node was never registered),
+     * immediately before `process.exit`. Use for best-effort cleanup such as
+     * {@link unregisterServiceAtShutdown}. Errors are logged and ignored.
+     */
+    beforeProcessExit?: () => void | Promise<void>;
+}
+
 export const LOG_TOPIC_NODE = "node";
 const LOG_TOPIC_COMMAND = "command";
 const LOG_TOPIC_PROCESS = "process";
@@ -35,6 +45,7 @@ abstract class BaseNodeRuntime {
     private static readonly NODE_ID_PENDING_ASSIGNMENT = "pending-node-id";
 
     protected readonly runtimeModule: string;
+    private readonly beforeProcessExitHook: (() => void | Promise<void>) | null;
 
     private _localNodeId: string | null = null;
     private _isNodeIdLocked = false;
@@ -63,14 +74,34 @@ abstract class BaseNodeRuntime {
         this._isNodeIdLocked = true;
     }
 
-    protected constructor(runtimeModule: string) {
+    protected constructor(runtimeModule: string, options?: BaseNodeRuntimeOptions) {
         this.runtimeModule = runtimeModule;
+        this.beforeProcessExitHook = options?.beforeProcessExit ?? null;
         this.isRunning = false;
         this.loopCount = 0;
         this.startupTraceId = logManager.generateTraceId();
         this.startupScope = createScope({ module: runtimeModule, traceId: this.startupTraceId });
     }
 
+    private async runBeforeProcessExit(logger: LoggerWithScope): Promise<void> {
+        if (this.beforeProcessExitHook == null) {
+            return;
+        }
+        try {
+            await this.beforeProcessExitHook();
+        } catch (error) {
+            logger.warn("beforeProcessExit 钩子失败（best-effort）", {
+                topic: LOG_TOPIC_PROCESS,
+                data: { error: getErrorMessage(error) },
+            });
+        }
+    }
+
+    private async exitProcess(code: number, logger: LoggerWithScope): Promise<never> {
+        await this.runBeforeProcessExit(logger);
+        process.exit(code);
+    }
+
     /** Hook: task registration, trigger config load, etc. Throw to abort bootstrap. */
     protected abstract onBeforeRegisterNode(logger: LoggerWithScope): Promise<void>;
 
@@ -296,7 +327,7 @@ abstract class BaseNodeRuntime {
         }
 
         this.isRunning = false;
-        this.shutdownPromise = this.runShutdown(options?.trigger).catch((error) => {
+        this.shutdownPromise = this.runShutdown(options?.trigger).catch(async (error) => {
             const logger = createLogger({
                 scope: patchScope({ scope: this.startupScope, patch: { labels: { nodeId: this.getLogNodeId() } } }),
             });
@@ -307,7 +338,7 @@ abstract class BaseNodeRuntime {
                     error: getErrorMessage(error),
                 },
             });
-            process.exit(1);
+            await this.exitProcess(1, logger);
         });
         return this.shutdownPromise;
     }
@@ -324,7 +355,7 @@ abstract class BaseNodeRuntime {
 
         if (this.localNodeId == null) {
             logger.warn("本地節點未註冊，進程退出", { topic: LOG_TOPIC_NODE });
-            process.exit(0);
+            await this.exitProcess(0, logger);
             return;
         }
 
@@ -344,7 +375,7 @@ abstract class BaseNodeRuntime {
                 data: { error: getErrorMessage(error) },
             });
         } finally {
-            process.exit(0);
+            await this.exitProcess(0, logger);
         }
     }
 
@@ -391,7 +422,7 @@ abstract class BaseNodeRuntime {
         }
 
         this.consecutiveHeartbeatFailures = 0;
-        logger.success("心跳更新成功", {
+        logger.info("心跳更新成功", {
             topic: LOG_TOPIC_NODE,
             data: { lastHeartBeat: formatHeartbeat(lastHeartBeat) },
         });

package/src/node/process/create-managed-child-processes.ts

@@ -0,0 +1,27 @@
+import { createLogger } from "../../shared/log/create-logger";
+import type { ManagedChildProcessesOptions } from "./managed-child-processes";
+import { ManagedChildProcesses } from "./managed-child-processes";
+
+export type CreateManagedChildProcessesOptions = Pick<
+    ManagedChildProcessesOptions,
+    "projectRoot" | "preloadModules" | "useTsx" | "graceMs"
+> & {
+    /** Defaults to `createLogger({ module: "launcher" })`. */
+    logger?: ManagedChildProcessesOptions["logger"];
+};
+
+const DEFAULT_PRELOAD_MODULES = ["./scripts/preload.mjs"] as const;
+
+/**
+ * Standard L3 service child-process registry: node (not tsx), service preload, launcher logger.
+ * Each service keeps a singleton in `src/startup/child-processes.ts`.
+ */
+export function createManagedChildProcesses(options: CreateManagedChildProcessesOptions): ManagedChildProcesses {
+    return new ManagedChildProcesses({
+        projectRoot: options.projectRoot,
+        preloadModules: options.preloadModules ?? DEFAULT_PRELOAD_MODULES,
+        useTsx: options.useTsx ?? false,
+        graceMs: options.graceMs,
+        logger: options.logger ?? createLogger({ module: "launcher" }),
+    });
+}

package/src/node/process/index.ts

@@ -1,5 +1,9 @@
+export type { CreateManagedChildProcessesOptions } from "./create-managed-child-processes";
+export { createManagedChildProcesses } from "./create-managed-child-processes";
 export type {
+    CriticalExitHandler,
     ManagedChildProcessesOptions,
+    SpawnChildOptions,
     SpawnChildResult,
     StopAllChildrenOptions,
 } from "./managed-child-processes";

package/src/node/process/managed-child-processes.ts

@@ -8,7 +8,13 @@ export interface ManagedChildProcessesOptions {
     preloadModules?: readonly string[];
     /** SIGTERM -> wait -> SIGKILL delay (default 5000 ms). */
     graceMs?: number;
-    logger?: Pick<LoggerWithScope, "info" | "warn" | "error">;
+    logger?: Pick<LoggerWithScope, "info" | "warn" | "error" | "critical">;
+    useTsx?: boolean;
+}
+
+export interface SpawnChildOptions {
+    env?: Record<string, string>;
+    useTsx?: boolean;
 }
 
 export interface SpawnChildResult {
@@ -22,6 +28,11 @@ export interface StopAllChildrenOptions {
     extraPids?: readonly number[];
 }
 
+export interface CriticalExitHandler {
+    labels: readonly string[];
+    onCriticalExit: (label: string, code: number | null, signal: NodeJS.Signals | null) => void;
+}
+
 /**
  * Process-local registry for tsx child processes (supervisor, worker, etc.).
  * Each OS process has its own instance - do not expect cross-process PID tracking.
@@ -30,16 +41,24 @@ export class ManagedChildProcesses {
     private readonly projectRoot: string;
     private readonly preloadModules: readonly string[];
     private readonly graceMs: number;
-    private readonly logger?: Pick<LoggerWithScope, "info" | "warn" | "error">;
+    private readonly defaultUseTsx: boolean;
+    private readonly logger?: Pick<LoggerWithScope, "info" | "warn" | "error" | "critical">;
     private readonly byLabel = new Map<string, ChildProcess>();
+    private criticalExitHandler: CriticalExitHandler | null = null;
+    private suppressCriticalExit = false;
 
     constructor(options: ManagedChildProcessesOptions) {
         this.projectRoot = options.projectRoot;
         this.preloadModules = options.preloadModules ?? [];
         this.graceMs = options.graceMs ?? 5_000;
+        this.defaultUseTsx = options.useTsx ?? true;
         this.logger = options.logger;
     }
 
+    setCriticalExitHandler(handler: CriticalExitHandler): void {
+        this.criticalExitHandler = handler;
+    }
+
     get(label: string): ChildProcess | null {
         return this.byLabel.get(label) ?? null;
     }
@@ -55,7 +74,7 @@ export class ManagedChildProcesses {
             .map(([label]) => label);
     }
 
-    spawn(label: string, entryScript: string): SpawnChildResult {
+    spawn(label: string, entryScript: string, spawnOptions?: SpawnChildOptions): SpawnChildResult {
         const existing = this.getRunning(label);
         if (existing != null) {
             return { child: existing, created: false };
@@ -65,14 +84,23 @@ export class ManagedChildProcesses {
             projectRoot: this.projectRoot,
             entryScript,
             preloadModules: this.preloadModules,
+            useTsx: spawnOptions?.useTsx ?? this.defaultUseTsx,
+            env: spawnOptions?.env != null ? { ...process.env, ...spawnOptions.env } : process.env,
         });
 
-        child.on("exit", (code, signal) => {
+        child.on("exit", (code: number | null, signal: NodeJS.Signals | null) => {
             this.logger?.info("child exited", { topic: "process", data: { label, code, signal } });
             const current = this.byLabel.get(label);
             if (current === child) {
                 this.byLabel.delete(label);
             }
+            if (
+                !this.suppressCriticalExit &&
+                this.criticalExitHandler != null &&
+                this.criticalExitHandler.labels.includes(label)
+            ) {
+                this.criticalExitHandler.onCriticalExit(label, code, signal);
+            }
         });
 
         this.byLabel.set(label, child);
@@ -90,20 +118,25 @@ export class ManagedChildProcesses {
     }
 
     async stopAll(options?: StopAllChildrenOptions): Promise<void> {
-        const tracked = [...this.byLabel.values()].filter((child) => isChildProcessRunning(child));
+        this.suppressCriticalExit = true;
+        try {
+            const tracked = [...this.byLabel.values()].filter((child) => isChildProcessRunning(child));
 
-        await Promise.all(tracked.map((child) => this.stopChild(child)));
+            await Promise.all(tracked.map((child) => this.stopChild(child)));
 
-        const extraPids = options?.extraPids ?? [];
-        for (const pid of extraPids) {
-            if (pid == null || tracked.some((child) => child.pid === pid)) {
-                continue;
-            }
-            try {
-                process.kill(pid, "SIGTERM");
-            } catch {
-                // already exited
+            const extraPids = options?.extraPids ?? [];
+            for (const pid of extraPids) {
+                if (pid == null || tracked.some((child) => child.pid === pid)) {
+                    continue;
+                }
+                try {
+                    process.kill(pid, "SIGTERM");
+                } catch {
+                    // already exited
+                }
             }
+        } finally {
+            this.suppressCriticalExit = false;
         }
     }
 

package/src/node/runtime-state/create-service-runtime-state-store.ts

@@ -0,0 +1,125 @@
+import { EMPTY_REGISTRY_SLOT_RUNTIME_STATE } from "../../service/registry-lifecycle";
+import type { JsonStatePatch } from "../fs/json-state-store";
+import { createShardedJsonFileStateStore } from "../fs/sharded-json-state-store";
+import type {
+    DefaultExtraRuntimeSlices,
+    GuardRuntimeSlice,
+    ReadinessRuntimeSlice,
+    SchedulerRuntimeSlice,
+    ServiceRuntimeExtraSlicePatch,
+    ServiceRuntimeNestedKeys,
+    ServiceRuntimeState,
+    WorkerRuntimeSlice,
+} from "./service-runtime-state.types";
+
+const EPOCH_ISO = new Date(0).toISOString();
+
+export interface CreateServiceRuntimeStateStoreOptions<
+    TExtraSlices extends Record<string, object> = DefaultExtraRuntimeSlices,
+> {
+    /**
+     * Monolithic legacy path (`…/state.json`) or shard directory (`…/runtime-state/`).
+     * Legacy files migrate automatically to `dirname/state.json → runtime-state/*.json`.
+     */
+    filePath: string;
+    /** Default values for service-specific top-level nested slices. */
+    extraDefaults?: TExtraSlices;
+}
+
+export interface FinishRunnerTickOptions<TExtraSlices extends Record<string, object> = DefaultExtraRuntimeSlices> {
+    nowMs: number;
+    lastFired: Record<string, string>;
+    postedCount?: number;
+    /** Patch extra slices in the same atomic write as the scheduler tick. */
+    extra?: ServiceRuntimeExtraSlicePatch<TExtraSlices>;
+}
+
+export interface ServiceRuntimeStateStore<TExtraSlices extends Record<string, object> = DefaultExtraRuntimeSlices> {
+    readRuntimeState(): Promise<ServiceRuntimeState<TExtraSlices>>;
+    writeRuntimeState(
+        patch: JsonStatePatch<ServiceRuntimeState<TExtraSlices>, ServiceRuntimeNestedKeys<TExtraSlices>>,
+    ): Promise<ServiceRuntimeState<TExtraSlices>>;
+    resetRuntimeStateForStartup(): Promise<ServiceRuntimeState<TExtraSlices>>;
+    finishRunnerTick(options: FinishRunnerTickOptions<TExtraSlices>): Promise<void>;
+}
+
+function createDefaultServiceRuntimeState<TExtraSlices extends Record<string, object>>(options: {
+    extraDefaults?: TExtraSlices;
+}): ServiceRuntimeState<TExtraSlices> {
+    const readiness: ReadinessRuntimeSlice = {
+        status: "pending",
+        checkedAt: null,
+        message: null,
+        checks: [],
+    };
+    const guard: GuardRuntimeSlice = {
+        nodeId: null,
+        lastCheckAt: null,
+        lastDecision: null,
+        lastSpawnAt: null,
+        spawnCount: 0,
+    };
+    const scheduler: SchedulerRuntimeSlice = {
+        lastTickAt: null,
+        lastPostedCount: 0,
+        lastFired: {},
+    };
+    const worker: WorkerRuntimeSlice = {
+        pid: null,
+        spawnedAt: null,
+        ready: false,
+        registeredTasks: [],
+        readyAt: null,
+    };
+
+    return {
+        updatedAt: EPOCH_ISO,
+        readiness,
+        guard,
+        scheduler,
+        worker,
+        registry: { ...EMPTY_REGISTRY_SLOT_RUNTIME_STATE },
+        ...(options.extraDefaults ?? ({} as TExtraSlices)),
+    };
+}
+
+/** Sharded JSON runtime state (L3 blueprint) — one file per slice under `runtime-state/`. */
+export function createServiceRuntimeStateStore<TExtraSlices extends Record<string, object> = DefaultExtraRuntimeSlices>(
+    options: CreateServiceRuntimeStateStoreOptions<TExtraSlices>,
+): ServiceRuntimeStateStore<TExtraSlices> {
+    type State = ServiceRuntimeState<TExtraSlices>;
+    type NK = ServiceRuntimeNestedKeys<TExtraSlices>;
+
+    const defaultState = createDefaultServiceRuntimeState(options);
+    const nestedKeys = [
+        "readiness",
+        "guard",
+        "scheduler",
+        "worker",
+        "registry",
+        ...(Object.keys(options.extraDefaults ?? {}) as (keyof TExtraSlices & string)[]),
+    ] as NK[];
+
+    const store = createShardedJsonFileStateStore<State, NK>({
+        filePath: options.filePath,
+        defaultState,
+        nestedKeys,
+        updatedAtKey: "updatedAt",
+    });
+
+    return {
+        readRuntimeState: () => store.read(),
+        writeRuntimeState: (patch) => store.write(patch),
+        resetRuntimeStateForStartup: () => store.reset(),
+        finishRunnerTick: async ({ nowMs, lastFired, postedCount, extra }) => {
+            await store.write({
+                scheduler: {
+                    lastTickAt: new Date(nowMs).toISOString(),
+                    lastFired,
+                    ...(postedCount != null ? { lastPostedCount: postedCount } : {}),
+                },
+                ...extra,
+            } as JsonStatePatch<State, NK>);
+        },
+    };
+}

package/src/node/runtime-state/index.ts

@@ -0,0 +1,17 @@
+export type {
+    CreateServiceRuntimeStateStoreOptions,
+    FinishRunnerTickOptions,
+    ServiceRuntimeStateStore,
+} from "./create-service-runtime-state-store";
+export { createServiceRuntimeStateStore } from "./create-service-runtime-state-store";
+export type {
+    GuardRuntimeSlice,
+    ReadinessRuntimeSlice,
+    ReadinessStatus,
+    SchedulerRuntimeSlice,
+    ServiceRuntimeCoreNestedKey,
+    ServiceRuntimeExtraSlicePatch,
+    ServiceRuntimeNestedKeys,
+    ServiceRuntimeState,
+    WorkerRuntimeSlice,
+} from "./service-runtime-state.types";

package/src/node/runtime-state/service-runtime-state.types.ts

@@ -0,0 +1,64 @@
+import type { RegistrySlotRuntimeState } from "../../service/registry-lifecycle";
+
+export type ReadinessStatus = "pending" | "passed" | "failed";
+
+export interface ReadinessRuntimeSlice {
+    status: ReadinessStatus;
+    checkedAt: string | null;
+    message: string | null;
+    checks: { name: string; ok: boolean; detail?: string }[];
+}
+
+export interface GuardRuntimeSlice {
+    nodeId: string | null;
+    lastCheckAt: string | null;
+    lastDecision: string | null;
+    lastSpawnAt: string | null;
+    spawnCount: number;
+}
+
+export interface SchedulerRuntimeSlice {
+    lastTickAt: string | null;
+    lastPostedCount: number;
+    lastFired: Record<string, string>;
+}
+
+export interface WorkerRuntimeSlice {
+    pid: number | null;
+    spawnedAt: string | null;
+    ready: boolean;
+    registeredTasks: string[];
+    readyAt: string | null;
+}
+
+/**
+ * Default when an L3 service has no service-specific runtime state slices.
+ * Use an empty object type (not `Record<string, never>`) so intersecting with core
+ * slices does not add a string index signature that collapses property types to `never`.
+ */
+export type DefaultExtraRuntimeSlices = Record<never, never>;
+
+/**
+ * Cross-process service runtime state persisted to `state.json`.
+ * L3 blueprint: readiness + guard + scheduler + worker + registry.
+ * Extend via extra top-level slices only.
+ */
+export type ServiceRuntimeState<TExtraSlices extends Record<string, object> = DefaultExtraRuntimeSlices> = {
+    updatedAt: string;
+    readiness: ReadinessRuntimeSlice;
+    guard: GuardRuntimeSlice;
+    scheduler: SchedulerRuntimeSlice;
+    worker: WorkerRuntimeSlice;
+    registry: RegistrySlotRuntimeState;
+} & TExtraSlices;
+
+export type ServiceRuntimeCoreNestedKey = "readiness" | "guard" | "scheduler" | "worker" | "registry";
+
+export type ServiceRuntimeNestedKeys<TExtraSlices extends Record<string, object>> =
+    | ServiceRuntimeCoreNestedKey
+    | (keyof TExtraSlices & string);
+
+/** Patch shape for extra top-level slices (one level deep). */
+export type ServiceRuntimeExtraSlicePatch<TExtraSlices extends Record<string, object>> = {
+    [K in keyof TExtraSlices]?: TExtraSlices[K] extends object ? Partial<TExtraSlices[K]> : TExtraSlices[K];
+};

package/src/node/service-guard/index.ts

@@ -0,0 +1,17 @@
+export { registerServiceGuardRunner } from "./register-service-guard-runner";
+export type { RunReadinessGateInput } from "./run-readiness-gate";
+export { runReadinessGate } from "./run-readiness-gate";
+export { runServiceGuardTick } from "./run-service-guard-tick";
+export type {
+    RegisterServiceGuardRunnerOptions,
+    ServiceGuardNodeOptions,
+    ServiceGuardTickInput,
+    ServiceGuardTickResult,
+} from "./service-guard.interface";
+export { SERVICE_GUARD_RUNNER_KEY } from "./service-guard.interface";
+export { ServiceGuardNode } from "./service-guard-node";
+export {
+    getWorkerSpawnCooldownLastAt,
+    markWorkerSpawned,
+    resetWorkerSpawnCooldownForTests,
+} from "./worker-spawn-cooldown";