peachsim 0.1.1469 → 0.1.1477

package/src/host/bridge-host.ts

@@ -1,8 +1,10 @@
-import { spawn } from 'child_process'
+import childProcess, { spawn } from 'child_process'
 import fs from 'fs'
 import { createServer, type IncomingMessage, type ServerResponse } from 'http'
+import os from 'os'
 import path from 'path'
 import { WebSocket, WebSocketServer } from 'ws'
+import { readChromiumQueue } from '../../../../scripts/lib/chromium-admission.ts'
 import {
   scanDevServers,
   type DiscoveredServer,
@@ -2038,6 +2040,7 @@ export class SootSimBridgeHost {
 
   private reapIdleSims(now = Date.now()) {
     const attachedSimIds = new Set(this.cliSimBySocket.values())
+    let reclaimable: { ws: WebSocket; idleMs: number } | null = null
     for (const sim of this.sims.values()) {
       if (attachedSimIds.has(sim.id)) continue
       const automation = this.isAutomationSim(sim)
@@ -2053,13 +2056,38 @@ export class SootSimBridgeHost {
       // never-CLI-driven sims have lastActiveAt 0 — fall back to connectedAt
       // so a freshly opened, not-yet-primary tab isn't reaped on the spot.
       const idleMs = now - Math.max(sim.lastActiveAt, sim.connectedAt)
-      const ttl = automation
-        ? AUTOMATION_SIM_IDLE_REAP_TTL_MS
-        : SootSimBridgeHost.SIM_IDLE_REAP_TTL_MS
+      if (automation) {
+        if (
+          idleMs >= AUTOMATION_SIM_IDLE_REAP_TTL_MS &&
+          idleMs > (reclaimable?.idleMs ?? 0)
+        )
+          reclaimable = { ws: sim.ws, idleMs }
+        continue
+      }
       // terminal close → client closes the window, does not reconnect; the
       // 'close' handler runs rememberDisconnectedSim → this.sims.delete.
-      if (idleMs >= ttl) this.closeSimSocketFromHost(sim.ws)
-    }
+      if (idleMs >= SootSimBridgeHost.SIM_IDLE_REAP_TTL_MS)
+        this.closeSimSocketFromHost(sim.ws)
+    }
+    // an automation sim lives as long as the session that opened it, as a
+    // simulator stays booted between commands; its host closes chrome when that
+    // session exits. an idle one gives up its chromium slot only while another
+    // launch on this machine waits for one, the longest idle first.
+    if (reclaimable && this.chromiumLaunchWaiting())
+      this.closeSimSocketFromHost(reclaimable.ws)
+  }
+
+  private chromiumQueueVerified = new Map<string, boolean>()
+
+  private chromiumLaunchWaiting(): boolean {
+    const queue = readChromiumQueue(
+      { fs, os, path, childProcess },
+      this.chromiumQueueVerified,
+    )
+    const live = new Set(queue.tickets)
+    for (const entry of this.chromiumQueueVerified.keys())
+      if (!live.has(entry)) this.chromiumQueueVerified.delete(entry)
+    return queue.tickets.length > queue.limit
   }
 
   // ping every connected ws; if the previous round's ping went unanswered,

package/src/swift-compile.ts

@@ -15,6 +15,7 @@ import {
 import os from 'node:os'
 import path from 'node:path'
 import { promisify } from 'node:util'
+import { admittedMacBuilderSlot } from './admitted-mac-build'
 import {
   parseSwiftDistributionManifest,
   SWIFT_DISTRIBUTION_MANIFEST,
@@ -2690,13 +2691,13 @@ export function compileSwiftProjectUnit(
   }
   const hash = swiftArtifactHash(input, options.release, moduleRoot)
   return serialize(root, async () => {
-    // a remote builder slot (CONTRAST_REMOTE_BUILD) already admitted this work
-    // and every builder mac carries the pinned toolchain, so it compiles in
-    // place. offloading again from there adds a second workspace and install.
+    // an admitted mac slot already holds the build lock and the pinned
+    // toolchain, so it compiles here. a bare CONTRAST_REMOTE_BUILD value is
+    // only an inherited marker and still dispatches through admission.
     if (
       process.platform === 'darwin' &&
       process.env.TM_SESSION &&
-      !process.env.CONTRAST_REMOTE_BUILD &&
+      !admittedMacBuilderSlot() &&
       process.env.CI !== 'true' &&
       moduleRoot === path.resolve(import.meta.dirname, '../../sootsim-swift') &&
       !swiftDistributionAt(moduleRoot)

package/src/worker-system-chunks.ts

@@ -6,22 +6,23 @@ import { isRecord } from './is-record'
 
 const require = createRequire(import.meta.url)
 const systemRuntime = fs.readFileSync(require.resolve('systemjs/dist/s.min.js'), 'utf8')
-const minifierModule = require.resolve('terser')
+const minifierModule = require.resolve('rolldown/utils')
 type MinifiedWorkerChunk = { code: string; map: string }
 const minifierWorker = `
 const { parentPort, workerData } = require('node:worker_threads');
-const { minify } = require(workerData.module);
+const minifier = import(workerData.module);
 parentPort.on('message', async ({ code, map, keepNames, measurement }) => {
   try {
-    const result = await minify(code, {
+    const { minifySync } = await minifier;
+    const result = minifySync('peach-worker-chunk.js', code, {
       module: true,
-      compress: measurement ? false : { passes: 2 },
-      mangle: !measurement,
-      keep_fnames: keepNames,
-      keep_classnames: keepNames,
-      sourceMap: { content: map },
+      compress: measurement ? false : { keepNames: { function: keepNames, class: keepNames } },
+      mangle: measurement ? false : { keepNames },
+      sourcemap: true,
+      inputMap: JSON.parse(map),
     });
-    parentPort.postMessage({ code: result.code, map: result.map });
+    if (result.errors.length) throw new Error(result.errors.map(error => error.message).join('; '));
+    parentPort.postMessage({ code: result.code, map: result.map && JSON.stringify(result.map) });
   } catch (error) {
     parentPort.postMessage({ error: error instanceof Error ? error.message : String(error) });
   }