@nimbus-sh/core 0.3.0 → 0.4.0

package/src/runtime/session-process-supervisor.ts

@@ -67,6 +67,8 @@ export class SessionProcessSupervisor {
   private terminators = new Map<number, () => void>();
   /** Fires after every appendOutput/markExit once log persistence is wired. */
   private logActivity: (() => void) | null = null;
+  /** Fires once per pid on its first terminal transition; see setOnTerminal. */
+  private onTerminalCb: ((pid: number) => void) | null = null;
 
   // ── Lifecycle / PID authority ─────────────────────────────────────────
 
@@ -130,10 +132,33 @@ export class SessionProcessSupervisor {
     return this.table.setUmask(pid, umask);
   }
 
+  /**
+   * Observe every pid's FIRST transition out of `running`, whichever door it
+   * leaves by — exit(), kill(), a facet's self-reported exit, a timeout abort:
+   * all of them end here, which is what makes this one callback a complete
+   * seam for per-pid durable state (the resident-launch journal) that must be
+   * released exactly when the process ends and never before.
+   *
+   * One slot, owned by the FacetManager. A second subscriber would mean two
+   * owners of process-end policy; grow this into a list only when a second
+   * genuine owner exists.
+   */
+  setOnTerminal(cb: (pid: number) => void): void {
+    this.onTerminalCb = cb;
+  }
+
+  private fireTerminal(pid: number, wasRunning: boolean): void {
+    if (!wasRunning || !this.onTerminalCb) return;
+    if (this.table.get(pid)?.state === 'running') return;
+    try { this.onTerminalCb(pid); } catch { /* the process is gone regardless */ }
+  }
+
   /** Mark a process as exited. First terminal state wins. */
   exit(pid: number, exitCode: number): void {
+    const wasRunning = this.table.get(pid)?.state === 'running';
     this.table.exit(pid, exitCode);
     this.terminators.delete(pid);
+    this.fireTerminal(pid, wasRunning);
   }
 
   /**
@@ -141,9 +166,11 @@ export class SessionProcessSupervisor {
    * stdin can't outlive the process.
    */
   kill(pid: number): boolean {
+    const wasRunning = this.table.get(pid)?.state === 'running';
     const killed = this.table.kill(pid);
     this.terminate(pid);
     this.input.close(pid);
+    this.fireTerminal(pid, wasRunning);
     return killed;
   }
 

package/src/workspace/nimbus-workspace.ts

@@ -352,11 +352,15 @@ async function registerWasmRuntimes(deps: {
   const [
     { makeBashRunnerFactory },
     { makeCPythonRunnerFactory },
+    { makeRubyRunnerFactory },
+    { makeClangRunnerFactory },
     { wasmRunnerSpec },
     { buildRuntimeHandler },
   ] = await Promise.all([
     import('../runtime/bash-runner.js'),
     import('../runtime/cpython-runner.js'),
+    import('../runtime/ruby-runner.js'),
+    import('../runtime/clang-runner.js'),
     import('../runtime/wasm-runner.js'),
     import('../runtime/runtime-registry.js'),
   ]);
@@ -391,8 +395,13 @@ async function registerWasmRuntimes(deps: {
     'bash-runner': makeBashRunnerFactory({ facets: deps.facets, vfs: deps.vfs }),
     // No `startResident`: a workspace owns no actor that could outlive the
     // call, so a program that keeps serving is refused by name rather than
-    // run as a one-shot that dies with it.
+    // run as a one-shot that dies with it. Same for ruby, where a script is
+    // the shape that may bind a port.
     'cpython-runner': makeCPythonRunnerFactory({ facets: deps.facets, vfs: deps.vfs }),
+    'ruby-runner': makeRubyRunnerFactory({
+      facets: deps.facets, vfs: deps.vfs, registry: deps.registry,
+    }),
+    'clang-runner': makeClangRunnerFactory({ facets: deps.facets, vfs: deps.vfs }),
   };
   rehydrateInstalledRuntimesView(
     deps.vfs.as(CRED_KERNEL),