@specific.dev/spectest 0.110.0 → 0.112.0

package/src/harness/phone.py

@@ -0,0 +1,427 @@
+"""SDK-owned JSON-lines adapter for the golden's PJSUA2 and Supertonic runtime.
+
+SIP runs exclusively on this thread; synthesis runs in a background thread so
+INVITE/BYE/retransmissions continue to be serviced while ONNX is busy.
+"""
+import concurrent.futures
+import json
+import os
+import queue
+import sys
+import tempfile
+import threading
+import time
+import wave
+import math
+from array import array
+from phone_recording import StreamingRecording, MEDIA_RATE, PEAK_SAMPLES
+
+# PJSIP writes directly to fd 1. Keep the protocol on a private duplicate.
+protocol = os.fdopen(os.dup(1), "w", buffering=1)
+os.dup2(2, 1)
+import pjsua2 as pj
+
+
+
+def configure_codecs(endpoint):
+    """Offer every installed codec, preferring Opus then higher sample rates."""
+    def preference(codec):
+        name, rate, channels = codec.codecId.lower().split("/")
+        return (name == "opus", int(rate), channels == "1",
+                name in ("g722", "pcma", "pcmu"), codec.priority)
+
+    for index, codec in enumerate(sorted(endpoint.codecEnum2(), key=preference, reverse=True)):
+        endpoint.codecSetPriority(codec.codecId, max(1, 240 - index))
+
+
+class IncomingAudio(pj.AudioMediaPort):
+    """Observe only received PCM; outgoing speech never resets this timer."""
+    def __init__(self):
+        super().__init__()
+        self.last_voice = time.monotonic()
+        fmt = pj.MediaFormatAudio()
+        fmt.type = pj.PJMEDIA_TYPE_AUDIO
+        fmt.id = pj.PJMEDIA_FORMAT_L16
+        fmt.clockRate = 16000
+        fmt.channelCount = 1
+        fmt.bitsPerSample = 16
+        fmt.frameTimeUsec = 20000
+        self.createPort("incoming-silence", fmt)
+
+    def onFrameReceived(self, frame):
+        samples = array("h", bytes(frame.buf))
+        if samples and sum(sample * sample for sample in samples) / len(samples) > 250 ** 2:
+            self.last_voice = time.monotonic()
+
+
+class Recording(pj.AudioMediaPort):
+    """The recording and every clip boundary share the same PCM sample clock.
+
+    The media clock can fall behind monotonic time under load (notably while
+    Python imports the TTS runtime). Wall time is not a position in the recording.
+    """
+    def __init__(self, path):
+        super().__init__()
+        self.frames = 0
+        self.lock = threading.Lock()
+        self.tracks = {"callerPeaks": [], "recipientPeaks": []}
+        self.audio = StreamingRecording(path)
+        self.closed = False
+        fmt = pj.MediaFormatAudio()
+        fmt.type = pj.PJMEDIA_TYPE_AUDIO
+        fmt.id = pj.PJMEDIA_FORMAT_L16
+        fmt.clockRate = MEDIA_RATE
+        fmt.channelCount = 1
+        fmt.bitsPerSample = 16
+        fmt.frameTimeUsec = 20000
+        self.createPort("call-recording", fmt)
+
+    def onFrameReceived(self, frame):
+        pcm = bytes(frame.buf)
+        with self.lock:
+            if not self.closed:
+                self.audio.write(pcm)
+                self.frames += len(pcm) // 2
+
+    @property
+    def offset(self):
+        with self.lock:
+            return self.frames / MEDIA_RATE
+
+    def observe(self, side, pcm):
+        samples = array("h", pcm)
+        if not samples:
+            return
+        peak = max(abs(min(samples)), abs(max(samples))) / 32768
+        with self.lock:
+            if self.closed:
+                return
+            # Meter ports follow the mixed sink in the conference bridge.
+            # Locate this 20ms frame using the recording's PCM clock, never wall time.
+            first = max(0, self.frames - len(samples)) // PEAK_SAMPLES
+            last = max(0, self.frames - 1) // PEAK_SAMPLES
+            peaks = self.tracks[side]
+            peaks.extend([0.0] * max(0, last + 1 - len(peaks)))
+            for index in range(first, last + 1):
+                peaks[index] = max(peaks[index], round(peak, 4))
+
+    def finish(self):
+        with self.lock:
+            self.closed = True
+        return self.audio.finish()
+
+
+class WaveformMeter(pj.AudioMediaPort):
+    """Observe a single direction without creating another audio recording."""
+    def __init__(self, recorder, side):
+        super().__init__()
+        self.recorder, self.side = recorder, side
+        fmt = pj.MediaFormatAudio()
+        fmt.type = pj.PJMEDIA_TYPE_AUDIO
+        fmt.id = pj.PJMEDIA_FORMAT_L16
+        fmt.clockRate = MEDIA_RATE
+        fmt.channelCount = 1
+        fmt.bitsPerSample = 16
+        fmt.frameTimeUsec = 20000
+        self.createPort(side, fmt)
+
+    def onFrameReceived(self, frame):
+        self.recorder.observe(self.side, bytes(frame.buf))
+
+
+class Call(pj.Call):
+    def __init__(self, account, endpoint, directory, session_id):
+        super().__init__(account)
+        self.endpoint = endpoint
+        self.session_id = session_id
+        self.path = os.path.join(directory, session_id + ".webm")
+        self.sealed = False
+        self.capture_error = None
+        self.recorder = Recording(self.path)
+        self.caller_meter = WaveformMeter(self.recorder, "callerPeaks")
+        self.recipient_meter = WaveformMeter(self.recorder, "recipientPeaks")
+        # Keep the sink clocked even during silence, synthesis, and app waits.
+        self.clock = endpoint.audDevManager().getCaptureDevMedia()
+        self.clock.startTransmit(self.recorder)
+        self.started_at_ms = time.time() * 1000
+        self.started = time.monotonic()
+        self.connected = False
+        self.disconnected = False
+        self.status = 0
+        self.media = None
+        self.incoming = IncomingAudio()
+
+    def onCallState(self, _):
+        info = self.getInfo()
+        self.connected = info.state == pj.PJSIP_INV_STATE_CONFIRMED
+        self.disconnected = info.state == pj.PJSIP_INV_STATE_DISCONNECTED
+        self.status = info.lastStatusCode
+
+    def onCallMediaState(self, _):
+        self.media = None
+        info = self.getInfo()
+        for item in info.media:
+            if item.type == pj.PJMEDIA_TYPE_AUDIO and item.status == pj.PJSUA_CALL_MEDIA_ACTIVE:
+                self.media = self.getAudioMedia(item.index)
+                try:
+                    self.media.startTransmit(self.recorder)
+                    self.media.startTransmit(self.recipient_meter)
+                    self.media.startTransmit(self.incoming)
+                except Exception:
+                    self.capture_error = "Could not connect incoming call audio to the recorder"
+                break
+
+
+    def finish_recording(self):
+        if self.sealed:
+            return
+        self.sealed = True
+        result = {"event": "recording", "sessionId": self.session_id,
+                  "startedAtMs": self.started_at_ms, "duration": 0, "bytes": 0,
+                  "contentType": "audio/webm", "peaks": []}
+        try:
+            self.clock.stopTransmit(self.recorder)
+            if self.media is not None:
+                try:
+                    self.media.stopTransmit(self.recorder)
+                    self.media.stopTransmit(self.recipient_meter)
+                except Exception:
+                    pass  # The remote peer may already have removed its port.
+            result.update(self.recorder.finish())
+            peaks = result["peaks"]
+            for side, track in self.recorder.tracks.items():
+                result[side] = (track + [0.0] * max(0, len(peaks) - len(track)))[:len(peaks)]
+            if self.capture_error:
+                result["error"] = self.capture_error
+        except Exception:
+            result["error"] = "Call recording could not be finalized"
+        protocol.write(json.dumps(result) + "\n")
+
+
+class Player(pj.AudioMediaPlayer):
+    def __init__(self):
+        super().__init__()
+        self.done = False
+
+    def onEof2(self):
+        self.done = True
+
+
+def synthesize(data, options, path):
+    import numpy as np
+    from supertonic import TTS
+    # Retain the loaded model for subsequent say calls on this phone.
+    if not hasattr(synthesize, "tts"):
+        synthesize.tts = TTS(model="supertonic-3", model_dir="/opt/spectest/phone/models",
+                             auto_download=False, intra_op_num_threads=2, inter_op_num_threads=1)
+    tts = synthesize.tts
+    np.random.seed(0)
+    style = tts.get_voice_style(data.get("voice", options.get("voice", "F1")))
+    # The high-level synthesize() API splits paragraphs/sentences. Send the
+    # complete utterance to the model in one invocation instead.
+    from supertonic.config import AVAILABLE_LANGUAGES
+    language = data.get("language", "en")
+    if language not in AVAILABLE_LANGUAGES:
+        raise ValueError(f"Unsupported speech language: {language}")
+    text = data["text"]
+    valid, unsupported = tts.model.text_processor.validate_text(text)
+    if not valid:
+        raise ValueError(f"Speech contains {len(unsupported)} unsupported characters")
+    audio, duration = tts.model([text], style, total_step=5,
+                                speed=data.get("speed", 1.05), lang=language)
+    audio = audio.reshape(-1)[:int(float(duration[0]) * tts.sample_rate)]
+    if len(audio) > tts.sample_rate * 60:
+        raise ValueError("Speech exceeds the 60 second limit; use a shorter utterance")
+    # PJSIP's WAV player accepts mono 16-bit PCM and resamples to the SIP codec.
+    pcm = (np.clip(audio, -1, 1) * 32767).astype("<i2")
+    with wave.open(path, "wb") as out:
+        out.setnchannels(1)
+        out.setsampwidth(2)
+        out.setframerate(tts.sample_rate)
+        out.writeframes(pcm.tobytes())
+    return {"duration": len(audio) / tts.sample_rate}
+
+
+
+def main():
+    inbox = queue.Queue()
+    ended = threading.Event()
+
+    def read():
+        try:
+            for line in sys.stdin:
+                inbox.put(json.loads(line))
+        finally:
+            ended.set()
+    threading.Thread(target=read, daemon=True).start()
+    endpoint, account, call = None, None, None
+    options = {}
+    executor = concurrent.futures.ThreadPoolExecutor(max_workers=1)
+
+    def pump():
+        if ended.is_set():
+            raise EOFError()
+        if endpoint:
+            endpoint.libHandleEvents(10)
+            if call and call.disconnected:
+                call.finish_recording()
+            elif call and time.monotonic() - call.started > 900:
+                call.capture_error = "Call exceeded the 15 minute recording limit"
+                call.hangup(pj.CallOpParam())
+        else:
+            time.sleep(0.01)
+
+    def wait(predicate, timeout, live=False):
+        deadline = time.monotonic() + timeout
+        while not predicate():
+            if live and call.disconnected:
+                raise ValueError(f"SIP call ended ({call.status})")
+            if time.monotonic() >= deadline:
+                raise ValueError("SIP operation timed out")
+            pump()
+
+    def hangup():
+        if call and not call.disconnected:
+            call.hangup(pj.CallOpParam())
+            wait(lambda: call.disconnected, 5)
+
+    try:
+        while not ended.is_set():
+            try:
+                data = inbox.get_nowait()
+            except queue.Empty:
+                pump()
+                continue
+            result = {}
+            try:
+                action = data["action"]
+                if call and action != "call":
+                    protocol.write(json.dumps({"event": "operation_started", "id": data["id"],
+                                               "offset": call.recorder.offset}) + "\n")
+                if action == "open":
+                    options = data
+                    endpoint = pj.Endpoint()
+                    endpoint.libCreate()
+                    cfg = pj.EpConfig()
+                    cfg.uaConfig.threadCnt = 0
+                    cfg.uaConfig.mainThreadOnly = True
+                    cfg.logConfig.level = 0
+                    cfg.logConfig.consoleLevel = 0
+                    cfg.medConfig.clockRate = MEDIA_RATE
+                    endpoint.libInit(cfg)
+                    transport = pj.TransportConfig()
+                    transport.port = 0
+                    kind = pj.PJSIP_TRANSPORT_TCP if data.get("transport") == "tcp" else pj.PJSIP_TRANSPORT_UDP
+                    endpoint.transportCreate(kind, transport)
+                    endpoint.libStart()
+                    endpoint.audDevManager().setNullDev()
+                    configure_codecs(endpoint)
+                    ac = pj.AccountConfig()
+                    ac.idUri = data["from"]
+                    ac.sipConfig.proxies.append("sip:" + data["endpoint"] + ";lr;transport=" + data.get("transport", "udp"))
+                    if data.get("username"):
+                        ac.sipConfig.authCreds.append(pj.AuthCredInfo("digest", "*", data["username"], 0, data.get("password", "")))
+                    account = pj.Account()
+                    account.create(ac)
+                elif action == "call":
+                    if call and not call.disconnected:
+                        raise ValueError("Already in a call; hang up before dialing again")
+                    if call:
+                        call.finish_recording()
+                    call = Call(account, endpoint, options["directory"], data["sessionId"])
+                    protocol.write(json.dumps({"event": "operation_started", "id": data["id"],
+                                               "offset": 0}) + "\n")
+                    uri = data["destination"]
+                    if not uri.startswith("sip:"):
+                        uri = "sip:" + uri + "@" + options["endpoint"]
+                    params = pj.CallOpParam(True)
+                    params.opt.audioCount = 1
+                    params.opt.videoCount = 0
+                    call.makeCall(uri, params)
+                    wait(lambda: call.connected and call.media is not None, options.get("timeoutMs", 30000) / 1000, live=True)
+                elif action == "say":
+                    if not call or not call.connected or call.media is None:
+                        raise ValueError("No connected call; call() before say()")
+                    with tempfile.TemporaryDirectory(prefix="spectest-phone-") as tmp:
+                        path = os.path.join(tmp, "speech.wav")
+                        future = executor.submit(synthesize, data, options, path)
+                        wait(future.done, 110, live=True)
+                        result = future.result()
+                        player = Player()
+                        player.createPlayer(path, pj.PJMEDIA_FILE_NO_LOOP)
+                        media = call.media
+                        # Mix what we actually send with the incoming stream in
+                        # the same continuously clocked recorder.
+                        speech_offset = call.recorder.offset
+                        player.startTransmit(call.recorder)
+                        player.startTransmit(call.caller_meter)
+                        player.startTransmit(media)
+                        # Report immediately so interrupted/failed playback also
+                        # keeps its true start. This is relative to the recorder,
+                        # measured in recorded PCM frames, not elapsed wall time.
+                        protocol.write(json.dumps({"event": "speech_started", "id": data["id"],
+                                                   "sessionId": call.session_id, "offset": speech_offset}) + "\n")
+                        try:
+                            wait(lambda: player.done, result["duration"] + 5, live=True)
+                            result["offset"] = call.recorder.offset
+                        finally:
+                            player.stopTransmit(media)
+                            if call.recorder:
+                                player.stopTransmit(call.recorder)
+                                player.stopTransmit(call.caller_meter)
+                            del player
+                elif action == "wait_silence":
+                    if not call or call.disconnected or call.media is None:
+                        raise ValueError("No connected call; cannot wait for silence")
+                    silence = float(data["silenceMs"]) / 1000
+                    timeout = float(data["timeoutMs"]) / 1000
+                    if not math.isfinite(silence) or not math.isfinite(timeout) or silence <= 0 or timeout <= 0:
+                        raise ValueError("Silence duration and timeout must be positive")
+                    # A fresh quiet window starts AFTER the application predicate
+                    # succeeds; quiet heard before that does not satisfy this wait.
+                    began = time.monotonic()
+                    wait(lambda: time.monotonic() - max(began, call.incoming.last_voice) >= silence,
+                         timeout, live=True)
+                    result["offset"] = call.recorder.offset
+                elif action == "position":
+                    if not call:
+                        raise ValueError("No call recording")
+                    result["offset"] = call.recorder.offset
+                elif action == "hangup":
+                    hangup()
+                    if call:
+                        call.finish_recording()
+                else:
+                    raise ValueError("Unknown phone operation")
+                protocol.write(json.dumps({"id": data["id"], **result}) + "\n")
+            except EOFError:
+                raise
+            except Exception as error:
+                # PJSIP error.info() may include SIP identities; report status only.
+                message = str(error) if isinstance(error, ValueError) else f"Phone {data['action']} failed ({type(error).__name__})"
+                if call:
+                    result["offset"] = call.recorder.offset
+                protocol.write(json.dumps({"id": data["id"], **result, "error": message}) + "\n")
+    except EOFError:
+        pass
+    finally:
+        if call and not call.disconnected:
+            try:
+                call.hangup(pj.CallOpParam())
+                for _ in range(20):
+                    endpoint.libHandleEvents(10)
+            except Exception:
+                pass
+        if call:
+            call.finish_recording()
+        call = None
+        if account:
+            account.shutdown()
+            account = None
+        if endpoint:
+            endpoint.libDestroy()
+        executor.shutdown(wait=False, cancel_futures=True)
+
+
+if __name__ == "__main__":
+    main()

package/src/harness/phone_recording.py

@@ -0,0 +1,95 @@
+"""Continuous Opus capture. No encoder I/O runs on the SIP media callback."""
+from array import array
+import os
+import queue
+import subprocess
+import threading
+import time
+
+MEDIA_RATE = 48000
+PEAK_SAMPLES = MEDIA_RATE // 20
+
+
+class StreamingRecording:
+    def __init__(self, path):
+        self.path = path
+        self.peaks = []
+        self.frames = 0
+        self.error = None
+        self.closed = threading.Event()
+        # Two seconds of 20ms PCM frames. A stalled encoder fails capture
+        # explicitly instead of blocking SIP or silently dropping audio.
+        self.pending = queue.Queue(maxsize=100)
+        self.encoder = subprocess.Popen([
+            os.environ.get("SPECTEST_PHONE_FFMPEG", "ffmpeg"),
+            "-nostdin", "-hide_banner", "-loglevel", "error", "-y",
+            "-f", "s16le", "-ar", str(MEDIA_RATE), "-ac", "1", "-i", "pipe:0",
+            "-map_metadata", "-1", "-c:a", "libopus", "-b:a", "48k",
+            "-vbr", "on", "-application", "audio", "-threads", "1",
+            "-f", "webm", path,
+        ], stdin=subprocess.PIPE, stdout=subprocess.DEVNULL, stderr=subprocess.DEVNULL)
+        self.writer = threading.Thread(target=self._encode, daemon=True)
+        self.writer.start()
+
+    def write(self, pcm):
+        if self.closed.is_set() or self.error:
+            return
+        try:
+            self.pending.put_nowait(pcm)
+        except queue.Full:
+            self.error = "Phone recording encoder could not keep up with audio"
+
+    def _encode(self):
+        try:
+            while not self.closed.is_set() or not self.pending.empty():
+                try:
+                    pcm = self.pending.get(timeout=0.02)
+                except queue.Empty:
+                    continue
+                samples = array("h", pcm)
+                # Accumulate exact 50ms peaks before compression, including
+                # windows split across the media callback's 20ms frames.
+                offset = 0
+                while offset < len(samples):
+                    index = self.frames // PEAK_SAMPLES
+                    count = min(PEAK_SAMPLES - self.frames % PEAK_SAMPLES, len(samples) - offset)
+                    part = samples[offset:offset + count]
+                    peak = round(max(abs(min(part)), abs(max(part))) / 32768, 4)
+                    if index == len(self.peaks):
+                        self.peaks.append(peak)
+                    else:
+                        self.peaks[index] = max(self.peaks[index], peak)
+                    offset += count
+                    self.frames += count
+                self.encoder.stdin.write(pcm)
+            self.encoder.stdin.close()
+            if self.encoder.wait(timeout=2) != 0:
+                self.error = "Phone recording encoder failed"
+        except Exception:
+            self.error = "Phone recording encoder failed"
+        finally:
+            if self.encoder.poll() is None:
+                self.encoder.kill()
+            self.encoder.wait()
+            try:
+                self.encoder.stdin.close()
+            except OSError:
+                pass
+
+    def finish(self):
+        started = time.monotonic()
+        self.closed.set()
+        self.writer.join(timeout=5)
+        if self.writer.is_alive():
+            self.error = "Phone recording encoder did not finish"
+            self.encoder.kill()
+            self.writer.join(timeout=1)
+        if self.error:
+            raise RuntimeError(self.error)
+        return {
+            "duration": self.frames / MEDIA_RATE,
+            "bytes": os.path.getsize(self.path),
+            "peaks": self.peaks,
+            "contentType": "audio/webm",
+            "encodingFinalizeMs": round((time.monotonic() - started) * 1000, 1),
+        }

package/src/index.ts

@@ -1,3 +1,5 @@
+export type { Phone, PhoneOptions, CallOptions, SpeechOptions } from "./phone.js";
+import type { Phone, PhoneOptions } from "./phone.js";
 import type { Android, AndroidApp } from "./android.js";
 export type { Android, AndroidApp, AndroidElement, AndroidRecordingOptions } from "./android.js";
 // Spectest SDK. The user's single `spectest/index.ts` calls
@@ -1959,6 +1961,12 @@ export interface TestContext<
    * That is what makes "this tool is protected" a test.
    */
   mcp(url: string, opts?: McpOptions): Promise<Mcp>;
+  /**
+   * Open a SIP phone connected to a service in the environment. Both sides
+   * are recorded continuously for the whole call, including pauses between
+   * operations. Calls close and recordings finalize at case end.
+   */
+  phone(options: PhoneOptions): Promise<Phone>;
   /**
    * Open the headless browser. Backed by Chromium-over-CDP inside the VM.
    *
@@ -2380,22 +2388,23 @@ export interface Project<
   /**
    * Prepare a new interactive environment, after normal setup and the shared
    * warm-template snapshot. Runs on both cold starts and warm restores from
-   * the dashboard or `spectest env start`, before the environment is ready.
+   * the dashboard (seed checkbox on) or `spectest env start --seed`, before
+   * the environment is ready. Skipped when seeding is not requested.
    * Never runs for tests, snapshot forks, or resuming a stopped environment.
    * Uses the same context as `setup`; throw to fail the start.
    */
-  setupInteractive?: ProjectSetupFn<S, F>;
+  interactive?: { seed?: ProjectSetupFn<S, F> };
   tests?: TestSuite<S, F>;
 }
 
 /**
- * Context handed to the project-level `setup` and `setupInteractive` hooks: the full
+ * Context handed to the project-level `setup` and `interactive.seed` hooks: the full
  * {@link SpectestContext}, minus only what a timeline gives a test
  * (testName, parent, browser/mobile/terminal). Everything a test can do
  * to the environment — exec, fetch, `svc`/`fakes` helpers, `poll`,
  * `dnsName`, `certificate`, `startService`, and project-file access via
  * `projectRoot`/`readProjectFile` — is available here too. Normal `setup`
- * state is captured into the shared warm template; `setupInteractive`
+ * state is captured into the shared warm template; `interactive.seed`
  * state belongs only to the new interactive environment.
  */
 export interface ProjectSetupContext<
@@ -2445,8 +2454,8 @@ export interface ProjectOpts<
 > {
   /** Optional project-level setup. See `Project.setup`. */
   setup?: ProjectSetupFn<S, F>;
-  /** Optional interactive-only setup. See `Project.setupInteractive`. */
-  setupInteractive?: ProjectSetupFn<S, F>;
+  /** Optional interactive-only setup. See `Project.interactive`. */
+  interactive?: { seed?: ProjectSetupFn<S, F> };
   /** Test cases for this project's suite. */
   tests?: TestCase<unknown, S, F>[];
 }
@@ -2511,7 +2520,7 @@ export interface DefinedEnvironment<
   ): TestGroup<P, S, F>;
   /** Bundle this environment with a test suite into the project default
    * export. Pass tests as a plain array for the common case, or an
-   * options bag to attach `setup` or `setupInteractive`. (Fakes are declared on
+   * options bag to attach `setup` or `interactive.seed`. (Fakes are declared on
    * `defineEnvironment`, not here.) */
   project(tests?: TestCase<unknown, S, F>[]): Project<S, F>;
   project(opts: ProjectOpts<S, F>): Project<S, F>;
@@ -2663,7 +2672,7 @@ export function defineEnvironment<
       : (arg ?? {});
     const proj: Project<S, F> = { environment: config };
     if (opts.setup) proj.setup = opts.setup;
-    if (opts.setupInteractive) proj.setupInteractive = opts.setupInteractive;
+    if (opts.interactive) proj.interactive = opts.interactive;
     if (fakes) proj.fakes = fakes;
     if (opts.tests && opts.tests.length > 0) {
       // Explicit suite (single-file / legacy layout): the tests are listed

package/src/interactive-setup.test.ts

@@ -22,7 +22,7 @@ for (const withHook of [false, true]) {
         }});
         export default env.project({
           setup: () => { calls.push("baseline"); },
-          ${withHook ? `setupInteractive: async (ctx) => {
+          ${withHook ? `interactive: { seed: async (ctx) => {
             calls.push("interactive");
             console.log("seeding demo data");
             await globalThis.seedGate;
@@ -35,7 +35,7 @@ for (const withHook of [false, true]) {
             if (typeof result.exitCode !== "number" || !result.stdout.includes("seed demo")) {
               throw new Error("exec result not plain: " + JSON.stringify(result));
             }
-          },` : ""}
+          } },` : ""}
         });
       `);
       const script = `