@kici-dev/orchestrator 0.17.0 → 0.19.0

package/dist/scaler/pending-scale-sweeper.d.ts

@@ -1,24 +1,21 @@
 export interface PendingScaleSweeperOptions {
     /**
-     * Re-drive callback — the dispatcher's `retryPendingScaleRequests` bound to
-     * the `sweep` trigger. Returns the number of jobs re-driven (logged when > 0).
+     * The dispatcher's `retryPendingScaleRequests` bound to the `sweep` trigger. Returns the
+     * number of jobs re-driven (logged when > 0).
      */
     redrive: () => Promise<number>;
-    /** Sweep interval in milliseconds. */
     intervalMs: number;
 }
 /**
  * Leader-gated periodic backstop for the scaler capacity-freed re-drive.
  *
- * The capacity-freed hook (`ScalerManager.onCapacityFreed`) handles the common
- * case with near-zero latency, but it can miss edge cases: a spawn that failed
- * silently, a reservation freed on a non-leader coordinator, or a lost event.
- * This sweeper re-runs the SAME `retryPendingScaleRequests` on a timer so a
- * pending at-capacity job is never stranded past one interval.
+ * `ScalerManager.onCapacityFreed` handles the common case at near-zero latency but can miss a
+ * spawn that failed silently, a reservation freed on a non-leader coordinator, or a lost event.
+ * Re-running the SAME `retryPendingScaleRequests` on a timer strands no pending at-capacity job
+ * past one interval.
  *
- * Modeled on `HostRosterReaper` / `EventRetryScanner`: started/stopped via the
- * Raft leadership callbacks, a single timer cleared on `stop()`. Leader-only so
- * multiple coordinators don't each drive the same queue.
+ * Like `HostRosterReaper` / `EventRetryScanner`, it follows the Raft leadership callbacks with
+ * one timer cleared on `stop()`; leader-only so coordinators don't each drive the same queue.
  */
 export declare class PendingScaleSweeper {
     private readonly redrive;

package/dist/scaler/reap-orphans.d.ts

@@ -1,24 +1,20 @@
 import type { ScalerConfig } from './index.js';
-/** Per-scaler orphan counts, keyed by scaler name. */
+/** Keyed by scaler name. */
 export type ReapCounts = Record<string, number>;
 /**
- * Reap orphan Firecracker resources (dead-VM chroots + TAPs) for every
- * `firecracker` scaler in the config. Safe to run alongside a live
- * orchestrator: the reap is liveness-driven and only touches dead VMs.
+ * Reap dead-VM chroots and TAPs for every `firecracker` scaler. Safe alongside
+ * a live orchestrator: the reap is liveness-driven and only touches dead VMs.
  */
 export declare function reapFirecrackerOrphans(scalerConfig: ScalerConfig): Promise<ReapCounts>;
 /**
- * Reap orphan container resources for every `container` scaler. Unlike the FC
- * reap, container cleanup is unconditional (it removes every kici-managed
- * container), so callers MUST ensure the orchestrator is NOT running before
- * invoking this — otherwise live agents are killed. The CLI command enforces
- * this via the /health gate.
+ * Unlike the FC reap, container cleanup removes every kici-managed container,
+ * so callers MUST ensure the orchestrator is NOT running, or live agents are
+ * killed. The CLI command enforces this via the /health gate.
  */
 export declare function reapContainerOrphans(scalerConfig: ScalerConfig): Promise<ReapCounts>;
 /**
- * Reap orphans for all supported backends. Firecracker is always reaped
- * (liveness-driven, safe). Containers are reaped only when includeContainers
- * is set (caller has confirmed the orchestrator is down).
+ * Firecracker is always reaped (liveness-driven, safe); containers only when
+ * includeContainers is set (the caller confirmed the orchestrator is down).
  */
 export declare function reapAllOrphans(opts: {
     scalerConfig: ScalerConfig;

package/dist/scaler/resolve-container-auth.d.ts

@@ -1,12 +1,9 @@
 /**
  * Resolve a job's container spec into something a runtime can pull with.
  *
- * The lock carries credential REFERENCES (`<context>:<secret-name>`), never
- * material — so somebody has to turn those into an authconfig, and three call
- * sites need the identical answer: the agent's container sandbox, the container
- * scaler backend, and the bare-metal backend in container mode. One resolver
- * keeps them from drifting into three subtly different readings of the same
- * lock field.
+ * The lock carries credential REFERENCES (`<context>:<secret-name>`), never material. The
+ * agent's container sandbox, the container scaler backend and the bare-metal backend in
+ * container mode share this one resolver so their readings of the lock field cannot drift.
  */
 import type { LockJob } from '@kici-dev/engine';
 import type { ResolvedContainerSpawn } from './types.js';
@@ -21,25 +18,19 @@ export interface ResolveContainerSpawnDeps {
     resolveSecret: (qualifiedRef: string) => Promise<string | undefined>;
 }
 /**
- * Resolve just the registry credentials for a job's container.
- *
- * Split out of {@link resolveContainerSpawn} because the two consumers diverge
- * for a dockerfile build: there is no image for the SCALER to spawn an agent
- * from, but the AGENT still needs credentials to pull the Dockerfile's own
- * `FROM` base.
- *
- * Returns `undefined` when the job declared no credentials at all.
+ * Resolve just the registry credentials for a job's container; `undefined` when the job
+ * declared none. Separate from {@link resolveContainerSpawn} because for a dockerfile build the
+ * SCALER has no image to spawn from, but the AGENT still needs credentials for the `FROM` base.
  */
 export declare function resolveContainerRegistryAuth(container: LockContainer, deps: ResolveContainerSpawnDeps): Promise<NonNullable<ResolvedContainerSpawn['authconfig']> | undefined>;
 /**
- * Turn a lock `container` field into an image plus, when the job declared
- * credentials, an authconfig for the registry that image lives in.
+ * Turn a lock `container` field into an image plus, when the job declared credentials, an
+ * authconfig for that image's registry.
  *
- * Returns `undefined` for a job with no container at all — and for a job that
- * BUILDS its image, because the scaler cannot spawn an agent from an image that
- * does not exist yet. That job is run by an ordinary agent, which nests the
- * container after it has cloned and built. So a caller can treat "no container",
- * "container without auth" and "container built from a dockerfile" distinctly.
+ * Returns `undefined` for no container, and for a job that BUILDS its image: the scaler cannot
+ * spawn from an image that does not exist yet, so an ordinary agent runs it and nests the
+ * container after clone and build. A caller can treat "no container", "container without auth"
+ * and "container built from a dockerfile" distinctly.
  */
 export declare function resolveContainerSpawn(container: LockContainer, deps: ResolveContainerSpawnDeps): Promise<ResolvedContainerSpawn | undefined>;
 //# sourceMappingURL=resolve-container-auth.d.ts.map

package/dist/scaler/scaler-events.d.ts

@@ -1,11 +1,8 @@
 /**
  * Orchestrator-side entry point for the event scaler's event vocabulary.
  *
- * The schemas and constants themselves live in `@kici-dev/engine` so the SDK —
- * the only KiCI package a workflow file may import — shares one source of truth
- * with the emitting side. This module re-exports them (plus the reserved
- * prefix) so orchestrator call sites keep a single local import for the whole
- * vocabulary.
+ * The schemas live in `@kici-dev/engine` so the SDK — the only KiCI package a
+ * workflow file may import — shares one source of truth with the emitting side.
  */
 export { KICI_EVENT_NAME_PREFIX, SCALER_EVENT_NAMES, ScaleDownReason, ScalerScaleUpPayload, ScalerScaleDownPayload, } from '@kici-dev/engine';
 //# sourceMappingURL=scaler-events.d.ts.map