@workerdeck/server 1.2.0 → 1.4.0

package/build/index.d.mts

@@ -39,6 +39,7 @@ type SessionRegistryOptions = {
 declare class SessionRegistry {
   #private;
   constructor(options?: SessionRegistryOptions);
+  observe(listener: (runner: Runner) => void): () => void;
   create(config: SessionRunnerConfig): Runner;
   prepare(config: SessionRunnerConfig): Runner;
   adopt(runner: Runner): Runner;
@@ -216,20 +217,12 @@ type QueueServerOptions = {
   webhookRetryDelayMs?: number;
   onEvent?: (event: JobEvent) => void;
 };
-/** A point-in-time answer to "is it safe to stop yet?", as reported while draining. */
 type DrainReport = {
-  /** Sessions mid-turn. These resolve on their own, so the drain waits for them. */
   working: string[];
-  /**
-   * Sessions blocked on a human — a pending approval. The drain names these but never waits for them: nothing about
-   * shutting down will answer the prompt, so waiting is a hang with better manners.
-   */
   awaitingHuman: string[];
-  /** True when the deadline passed with work still running. */
   timedOut: boolean;
 };
 type DrainOptions = {
-  /** Overall budget. The drain gives up and reports rather than blocking shutdown forever. */
   timeoutMs?: number;
   pollMs?: number;
   onProgress?: (report: DrainReport) => void;
@@ -243,10 +236,6 @@ type WorkerServer = {
   listen: (port: number, host?: string) => Promise<{
     port: number;
   }>;
-  /**
-   * Let running turns finish before `close()`. A courtesy, never a correctness requirement: records are written
-   * continuously, so a hard stop already loses nothing. Refuses new sessions for as long as it runs.
-   */
   drain: (options?: DrainOptions) => Promise<DrainReport>;
   close: () => Promise<void>;
 };

package/build/index.mjs

@@ -732,12 +732,6 @@ async function handleHostFiles(ctx, req, res, pathname) {
 }
 //#endregion
 //#region src/routes/create-vet.ts
-/**
-* The one create-validation ladder, run by both create doors — `POST /sessions` and the
-* `session` block of `POST /jobs`. The scope design claims the two are indistinguishable, so
-* the order and the refusals have to come from a single place rather than two copies that can
-* drift. Mutates `req`: strips inert fields and pins the resolved profile name.
-*/
 function vetCreateRequest(ctx, req, auth) {
 	const { availability, factory } = ctx;
 	const refusedScope = factory.applyScope(req, auth);
@@ -2662,9 +2656,15 @@ function serveWindow(held, now) {
 var SessionRegistry = class {
 	#sessions = /* @__PURE__ */ new Map();
 	#options;
+	#observers = /* @__PURE__ */ new Set();
 	constructor(options = {}) {
 		this.#options = options;
 	}
+	observe(listener) {
+		this.#observers.add(listener);
+		for (const runner of this.#sessions.values()) listener(runner);
+		return () => void this.#observers.delete(listener);
+	}
 	create(config) {
 		return this.adopt(new SessionRunner(config));
 	}
@@ -2679,7 +2679,10 @@ var SessionRegistry = class {
 	register(runner) {
 		const existing = this.#sessions.get(runner.id);
 		this.#sessions.set(runner.id, runner);
-		if (existing !== runner) this.#options.onRegister?.(runner);
+		if (existing !== runner) {
+			this.#options.onRegister?.(runner);
+			for (const listener of this.#observers) listener(runner);
+		}
 		return runner;
 	}
 	get(id) {
@@ -2898,15 +2901,7 @@ function createSessionFactory(deps) {
 }
 //#endregion
 //#region src/server.ts
-/** How long a client gets to acknowledge the shutdown close frame before its socket is torn down. */
 const SOCKET_CLOSE_GRACE_MS = 250;
-/**
-* Split live sessions into "will finish by itself" and "needs a person".
-*
-* `sessionState` is the vocabulary the dashboard, the session list and `workerdeck guard` already sort by, and it
-* draws exactly the line a drain needs: `working` covers starting/running and running subagents, while `attention`
-* covers a pending approval. Re-spelling that set here is how the two definitions would drift apart.
-*/
 function surveyDrain(registry) {
 	const working = [];
 	const awaitingHuman = [];