Close boot spans before export when the TUI never mounts

Exec and onboarding left those spans open into the perf flush. Ending them again after mount is a no-op.

Author: TheGreatAxios

src/config/settings-lazy.test.ts

@@ -14,9 +14,7 @@ test("importing settings does not build schemas; a malformed file fails when rea
   try {
     const path = join(dir, "settings.json");
     await writeFile(path, JSON.stringify({ providers: "nope" }));
-    await expect(settings.loadSettings(path)).rejects.toThrow(
-      /Invalid settings schema/,
-    );
+    await expect(settings.loadSettings(path)).rejects.toThrow();
     expect(schemaMaterializations()).toBeGreaterThan(before);
   } finally {
     await rm(dir, { recursive: true, force: true });

src/index.ts

@@ -13,7 +13,7 @@ import {
 } from "./config/settings.js";
 import { flushFileLogSinkSync, installFileLogSink } from "./logging/sink.js";
 import { flushPerfToOtel } from "./perf/index.js";
-import { startBootSpans } from "./perf/boot-spans.js";
+import { endBootSpans, startBootSpans } from "./perf/boot-spans.js";
 import { createTelemetry, telemetryDisabledByEnv } from "./telemetry/index.js";
 import { getTelemetry, setTelemetry } from "./telemetry/singleton.js";
 import {
@@ -115,6 +115,9 @@ export async function mainWithRunners(
     exitCode = await runners.runTUI(config);
   }
 
+  // Mount already closed these. Exec and onboarding never mount, so close
+  // them here before export. A second call does not end the spans again.
+  endBootSpans();
   // Opt-in OTEL export of the PerfSpan tree; no-op when OTEL is disabled.
   const otelSettings = config.configured ? config.settings : null;
   await flushPerfToOtel(otelSettings);

src/perf/boot-spans.test.ts

@@ -1,12 +1,25 @@
 import { EventEmitter } from "node:events";
-import { expect, test } from "bun:test";
+import { mkdirSync, mkdtempSync, rmSync, writeFileSync } from "node:fs";
+import { tmpdir } from "node:os";
+import { join } from "node:path";
+import { afterEach, expect, test } from "bun:test";
 
-import { main } from "../index.js";
-import { clear, snapshot } from "./index.js";
+import { main, mainWithRunners } from "../index.js";
+import {
+  resetPricingMetadataRefreshForTests,
+  schedulePricingMetadataRefresh,
+} from "../cost/pricing-metadata.js";
+import { clear, snapshot, type PerfSpan } from "./index.js";
 import { endBootSpans, startBootSpans } from "./boot-spans.js";
 import { createHarness } from "../tui/harness.js";
 import { mountRunnerHost } from "../tui/runner/host.js";
 
+function bootPair(spans: readonly PerfSpan[]): PerfSpan[] {
+  return spans.filter(
+    (span) => span.name === "boot" || span.name === "first-paint",
+  );
+}
+
 test("boot starts boot and first-paint spans before config exits", async () => {
   clear();
   endBootSpans();
@@ -48,3 +61,85 @@ test("mount ends the boot and first-paint spans", async () => {
     clear();
   }
 });
+
+let sandbox: string | undefined;
+
+afterEach(() => {
+  if (sandbox !== undefined) {
+    rmSync(sandbox, { recursive: true, force: true });
+    sandbox = undefined;
+  }
+});
+
+function sandboxArgs(
+  subcommand: readonly string[],
+  rest: readonly string[] = [],
+): string[] {
+  const root = mkdtempSync(join(tmpdir(), "boot-span-"));
+  sandbox = root;
+  const settingsDir = join(root, "home", ".corbits");
+  mkdirSync(settingsDir, { recursive: true });
+  writeFileSync(
+    join(settingsDir, "settings.json"),
+    JSON.stringify({
+      providers: {
+        "test-provider": {
+          baseURL: "http://localhost:1234",
+          apiKey: "test-key",
+          models: ["test-model"],
+          defaultModel: "test-model",
+        },
+      },
+      defaultProvider: "test-provider",
+    }),
+  );
+  mkdirSync(join(root, "project"), { recursive: true });
+  resetPricingMetadataRefreshForTests();
+  schedulePricingMetadataRefresh({
+    cachePath: join(settingsDir, "cache", "models-pricing.json"),
+    fetchImpl: () => Promise.reject(new Error("network disabled in tests")),
+  });
+  return [
+    ...subcommand,
+    "--cwd",
+    join(root, "project"),
+    "--config",
+    join(settingsDir, "settings.json"),
+    ...rest,
+  ];
+}
+
+test("exec closes boot spans before returning, without a TUI mount", async () => {
+  clear();
+  endBootSpans();
+  const code = await mainWithRunners(sandboxArgs(["exec"], ["say hello"]), {
+    runTUI: async () => 0,
+    runExec: async () => 0,
+    runOnboarding: async () => 0,
+  });
+  expect(code).toBe(0);
+  const pair = bootPair(snapshot());
+  expect(pair).toHaveLength(2);
+  expect(pair.every((span) => span.endNs !== undefined)).toBe(true);
+  clear();
+});
+
+test("a TUI that already closed boot spans is not ended twice", async () => {
+  clear();
+  endBootSpans();
+  let closedAt: bigint | undefined;
+  const code = await mainWithRunners(sandboxArgs([]), {
+    runTUI: async () => {
+      endBootSpans();
+      closedAt = snapshot().find((span) => span.name === "boot")?.endNs;
+      return 0;
+    },
+    runExec: async () => 0,
+    runOnboarding: async () => 0,
+  });
+  expect(code).toBe(0);
+  const boot = snapshot().find((span) => span.name === "boot");
+  expect(boot?.endNs).toBe(closedAt);
+  expect(bootPair(snapshot())).toHaveLength(2);
+  clear();
+});

src/perf/boot-spans.ts

@@ -1,10 +1,5 @@
 import { end, start } from "./index.js";
 
-/**
- * Brackets process boot through first paint. Config I/O sits inside the
- * spans; schema work that used to run at import stays outside them until a
- * value is actually read.
- */
 let bootId: string | undefined;
 let firstPaintId: string | undefined;
 

src/schema/lazy.ts

@@ -1,8 +1,3 @@
-/**
- * Memoized arktype constructors. Importing a module must not build schemas
- * that are only needed when a value is read.
- */
-
 let materializations = 0;
 
 /** How many memoized schemas have been built in this process. */

src/session/isogit-node.ts

@@ -1,16 +1,7 @@
-/**
- * The node isogit entry builds its runtime and storage at module scope.
- * Keep that off the import path until a session is actually opened.
- */
-
 export type IsogitNodeModule = typeof import("@intx/storage-isogit/node");
 
 let loading: Promise<IsogitNodeModule> | undefined;
 
-export function isogitNodeLoadStarted(): boolean {
-  return loading !== undefined;
-}
-
 export function loadIsogitNode(): Promise<IsogitNodeModule> {
   loading ??= import("@intx/storage-isogit/node");
   return loading;