// @effect-diagnostics nodeBuiltinImport:off - the suite seeds and grows real// transcript trees on disk, outside the service's Effect FileSystem.import * as NodeFSP from "node:fs/promises";import * as NodeOS from "node:os";import * as NodePath from "node:path"; import { assert, describe, it } from "@effect/vitest";import * as NodeServices from "@effect/platform-node/NodeServices";import { HostProcessEnvironment } from "@t3tools/shared/hostProcess";import { UsageDay, type UsageSummaryInput } from "@t3tools/contracts";import * as Effect from "effect/Effect";import * as Exit from "effect/Exit";import * as Fiber from "effect/Fiber";import * as Layer from "effect/Layer";import * as Scheduler from "effect/Scheduler";import { HttpClient, HttpClientResponse } from "effect/unstable/http"; import * as ServerConfig from "../config.ts";import * as ServerSettings from "../serverSettings.ts";import * as UsageService from "./UsageService.ts"; function claudeLine(id: number, outputTokens: number): string {  return `${JSON.stringify({    type: "assistant",    timestamp: "2026-08-01T10:00:00Z",    requestId: `req_${id}`,    sessionId: "session-1",    message: {      id: `msg_${id}`,      model: "claude-fable-5",      usage: { input_tokens: 10, output_tokens: outputTokens },    },  })}\n`;} const WINDOW: UsageSummaryInput = {  timeZone: "UTC",  sinceDay: UsageDay.make("2026-07-31"),  untilDay: UsageDay.make("2026-08-02"),}; const setup = Effect.gen(function* () {  const home = yield* Effect.promise(() =>    NodeFSP.mkdtemp(NodePath.join(NodeOS.tmpdir(), "usage-service-test-")),  );  yield* Effect.addFinalizer(() =>    Effect.promise(() => NodeFSP.rm(home, { recursive: true, force: true })),  );  const transcriptDir = NodePath.join(home, "claude", "projects", "proj");  yield* Effect.promise(() => NodeFSP.mkdir(transcriptDir, { recursive: true }));  return {    home,    transcript: NodePath.join(transcriptDir, "session.jsonl"),    settings: {      providers: {        claudeAgent: { homePath: NodePath.join(home, "claude") },        codex: { homePath: NodePath.join(home, "codex") },      },    },  };}); const serviceLayers = (input: {  readonly prefix: string;  readonly home: string;  readonly settings: Parameters<typeof ServerSettings.layerTest>[0];  readonly onRatesFetch?: () => void;}) =>  ServerConfig.layerTest(process.cwd(), { prefix: input.prefix }).pipe(    Layer.provideMerge(NodeServices.layer),    Layer.provideMerge(ServerSettings.layerTest(input.settings)),    Layer.provideMerge(      Layer.succeed(        HttpClient.HttpClient,        HttpClient.make((request) =>          Effect.sync(() => {            input.onRatesFetch?.();            // Unparsable rates: every scan retries the fetch, which makes the            // fetch count a boundary-level observation of how many scans ran.            return HttpClientResponse.fromWeb(request, Response.json({}));          }),        ),      ),    ),    Layer.provideMerge(      Layer.succeed(HostProcessEnvironment, { GROK_HOME: NodePath.join(input.home, "grok") }),    ),  ); function totalOutputTokens(summary: { buckets: readonly { totals: { outputTokens: number } }[] }) {  return summary.buckets.reduce((sum, bucket) => sum + bucket.totals.outputTokens, 0);} describe("UsageService", () => {  it.live("counts appended usage on a rescan of a grown transcript", () =>    Effect.gen(function* () {      const { transcript, settings, home } = yield* setup;      yield* Effect.promise(() => NodeFSP.writeFile(transcript, claudeLine(1, 5)));       const service = yield* UsageService.make.pipe(        Effect.provide(serviceLayers({ prefix: "usage-service-grow-test", home, settings })),      );       const first = yield* service.readSummary(WINDOW);      assert.strictEqual(totalOutputTokens(first), 5);       yield* Effect.promise(() => NodeFSP.appendFile(transcript, claudeLine(2, 7)));      const second = yield* service.readSummary(WINDOW);      assert.strictEqual(totalOutputTokens(second), 12);    }).pipe(Effect.scoped),  );   it.live("shares one scan between concurrent identical requests", () =>    Effect.gen(function* () {      const { transcript, settings, home } = yield* setup;      yield* Effect.promise(() => NodeFSP.writeFile(transcript, claudeLine(1, 5)));       let ratesFetches = 0;      const service = yield* UsageService.make.pipe(        Effect.provide(          serviceLayers({            prefix: "usage-service-flight-test",            home,            settings,            onRatesFetch: () => {              ratesFetches += 1;            },          }),        ),      );       const [first, second] = yield* Effect.all(        [service.readSummary(WINDOW), service.readSummary(WINDOW)],        { concurrency: 2 },      );      assert.deepStrictEqual(first, second);      assert.strictEqual(ratesFetches, 1);       // A later request is fresh work again, not a stale cached answer.      yield* service.readSummary(WINDOW);      assert.strictEqual(ratesFetches, 2);    }).pipe(Effect.scoped),  );   it.live("does not orphan an in-flight scan when its first caller is interrupted", () =>    Effect.gen(function* () {      const { settings, home } = yield* setup;      const service = yield* UsageService.make.pipe(        Effect.provide(          serviceLayers({ prefix: "usage-service-interruption-test", home, settings }),        ),      );       let orphanedAt: number | undefined;      for (let interruptAt = 1; interruptAt <= 31; interruptAt += 1) {        const tasks: Array<() => void> = [];        const dispatcher: Scheduler.SchedulerDispatcher = {          scheduleTask: (task) => tasks.push(task),          flush: () => {            let task: (() => void) | undefined;            while ((task = tasks.shift()) !== undefined) task();          },        };         let requestFiber: Fiber.Fiber<unknown, unknown> | undefined;        let requestChecks = 0;        const scheduler: Scheduler.Scheduler = {          executionMode: "async",          makeDispatcher: () => dispatcher,          shouldYield: (fiber) => {            if (fiber !== requestFiber) return false;            requestChecks += 1;            if (requestChecks !== interruptAt) return false;            fiber.interruptUnsafe();            return true;          },        };         // Each candidate needs a distinct key because the broken case leaves        // its entry in the service's private in-flight map. The invalid window        // keeps the real scan synchronous once its detached fiber starts.        const input: UsageSummaryInput = {          ...WINDOW,          sinceDay: UsageDay.make("2026-09-01"),          untilDay: UsageDay.make(`2026-08-${String(interruptAt).padStart(2, "0")}`),        };        const first = yield* service          .readSummary(input)          .pipe(            Effect.exit,            Effect.provideService(Scheduler.Scheduler, scheduler),            Effect.forkChild,          );        requestFiber = first;        yield* Effect.yieldNow;        dispatcher.flush();         const second = yield* service.readSummary(input).pipe(          Effect.match({            onFailure: (error) => error.reason,            onSuccess: () => "success" as const,          }),          Effect.provideService(Scheduler.Scheduler, scheduler),          Effect.forkChild,        );        yield* Effect.yieldNow;        dispatcher.flush();        const secondExit = second.pollUnsafe();        if (secondExit === undefined) {          second.interruptUnsafe();          orphanedAt = interruptAt;          break;        }        if (Exit.isFailure(secondExit)) {          assert.fail("the matching request fiber was interrupted");        }        assert.strictEqual(secondExit.value, "invalidWindow");      }       assert.isUndefined(        orphanedAt,        `interruption left the next matching request pending at scheduler check ${orphanedAt}`,      );    }).pipe(Effect.scoped),  );});