import {
EnvironmentId,
ProviderDriverKind,
ServerSelfUpdateError,
ProviderInstanceId,
type ProviderInstallState,
type ProviderSetupInput,
ServerObservability,
EnvironmentThemeId,
UsageLimitSourceId,
type ServerConfig,
type ServerConfigStreamEvent,
type ServerLifecycleWelcomePayload,
WS_METHODS,
} from "@t3tools/contracts";
import { describe, expect, it } from "@effect/vitest";
import { vi } from "vite-plus/test";
import * as Cause from "effect/Cause";
import * as Deferred from "effect/Deferred";
import * as Duration from "effect/Duration";
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 Option from "effect/Option";
import * as Queue from "effect/Queue";
import * as Ref from "effect/Ref";
import * as Schema from "effect/Schema";
import * as Stream from "effect/Stream";
import * as SubscriptionRef from "effect/SubscriptionRef";
import { AsyncResult, Atom, AtomRegistry } from "effect/reactivity";
import * as TestClock from "effect/testing/TestClock";
import { RpcClientError } from "effect/rpc";
import * as Socket from "effect/socket/Socket";
import {
AVAILABLE_CONNECTION_STATE,
PrimaryConnectionTarget,
type PreparedConnection,
type SupervisorConnectionState,
} from "../connection/model.ts";
import * as EnvironmentRegistry from "../connection/registry.ts";
import * as EnvironmentSupervisor from "../connection/supervisor.ts";
import { RpcPermissionGuard } from "../rpc/client.ts";
import * as Persistence from "../platform/persistence.ts";
import type { WsRpcProtocolClient } from "../rpc/protocol.ts";
import type { RpcSession } from "../rpc/session.ts";
import {
applyServerWelcomeEvent,
createServerEnvironmentAtoms,
serverUpdateStateAtom,
makeEnvironmentServerWelcomeState,
makeEnvironmentServerConfigState,
isLegacyUpdateHandoffLoss,
recordFetchedWorkspaceSnapshot,
withFetchedWorkspaceSnapshots,
matchesServerUpdateReadyEvent,
matchesServerUpdateResumeEvent,
nudgeReconnectDuringUpdateRestart,
resolveServerConfigValue,
resolveServerWelcomeState,
resolveServerUpdateProgressResult,
serverUpdateStateForProgressEvent,
serverUpdateStateForServerVersion,
validateServerUpdateReadyEvent,
waitForNextEnvironmentReconnect,
waitForDesktopUpdateTarget,
runDesktopCommitWithReconnectObserver,
} from "./server.ts";
import { applyServerConfigProjection } from "./serverConfigProjection.ts";
const CONFIG = {
availableEditors: [],
issues: [],
keybindings: {},
keybindingsConfigPath: null,
observability: null,
providers: [],
settings: {},
environment: { capabilities: { environmentThemes: true } },
} as unknown as ServerConfig;
const snapshotEvent = (config: ServerConfig): ServerConfigStreamEvent => ({
version: 1,
type: "snapshot",
config,
});
const TARGET = new PrimaryConnectionTarget({
environmentId: EnvironmentId.make("environment-1"),
label: "Test environment",
httpBaseUrl: "https://environment.example.test",
wsBaseUrl: "wss://environment.example.test",
});
function session(client: WsRpcProtocolClient): RpcSession {
return {
client,
initialConfig: Effect.succeed(CONFIG),
subscribeServerConfig: (input = {}) => client.subscribeServerConfig(input),
ready: Effect.void,
probe: Effect.void,
inboundFrames: Effect.succeed(0),
closed: Effect.never,
};
}
describe("update restart reconnect nudges", () => {
it.effect("retries a desktop commit that was lost before delivery", () =>
Effect.gen(function* () {
const readyEvents =
yield* Queue.unbounded<Parameters<typeof matchesServerUpdateReadyEvent>[1]>();
const ready = (serverVersion: string) =>
({
version: 1 as const,
sequence: 1,
type: "ready" as const,
payload: {
at: "2026-09-01T00:00:00.000Z",
environment: { serverVersion },
},
}) as Parameters<typeof matchesServerUpdateReadyEvent>[1];
yield* Queue.offerAll(readyEvents, [ready("0.0.30"), ready("0.0.31")]);
const retries = yield* Ref.make(0);
const disconnect = new RpcClientError.RpcClientError({
reason: new Socket.SocketCloseError({ code: 1006 }),
});
const result = yield* waitForDesktopUpdateTarget(
"0.0.31",
Queue.take(readyEvents),
Ref.update(retries, (count) => count + 1).pipe(Effect.andThen(Effect.fail(disconnect))),
);
expect(result.payload.environment.serverVersion).toBe("0.0.31");
expect(yield* Ref.get(retries)).toBe(1);
}),
);
it.effect("observes a fast reconnect even when the caller awaits it later", () =>
Effect.gen(function* () {
const states = yield* Queue.unbounded<{ readonly phase: string }>();
const reconnected = yield* waitForNextEnvironmentReconnect(Stream.fromQueue(states)).pipe(
Effect.forkChild,
);
yield* Queue.offerAll(states, [
{ phase: "connected" },
{ phase: "backoff" },
{ phase: "connected" },
]);
yield* Fiber.join(reconnected);
}),
);
it.effect("arms the retry observer before a commit can disconnect", () =>
Effect.gen(function* () {
const allowSubscription = yield* Deferred.make<void>();
const subscriptionStarted = yield* Deferred.make<void>();
const states = yield* Queue.unbounded<{ readonly phase: string }>();
const commits = yield* Ref.make(0);
const disconnect = new RpcClientError.RpcClientError({
reason: new Socket.SocketCloseError({ code: 1006 }),
});
const stateChanges = Stream.unwrap(
Deferred.succeed(subscriptionStarted, undefined).pipe(
Effect.andThen(Deferred.await(allowSubscription)),
Effect.as(Stream.fromQueue(states)),
),
);
const retry = yield* runDesktopCommitWithReconnectObserver(
stateChanges,
Ref.update(commits, (count) => count + 1).pipe(
Effect.andThen(Queue.offerAll(states, [{ phase: "backoff" }, { phase: "connected" }])),
Effect.andThen(Effect.fail(disconnect)),
),
).pipe(Effect.flip, Effect.forkChild);
yield* Deferred.await(subscriptionStarted);
expect(yield* Ref.get(commits)).toBe(0);
yield* Deferred.succeed(allowSubscription, undefined);
yield* Queue.offer(states, { phase: "connected" });
expect(yield* Fiber.join(retry)).toBe(disconnect);
expect(yield* Ref.get(commits)).toBe(1);
}),
);
it.effect("retries once per backoff entry instead of only the first", () =>
Effect.gen(function* () {
const retries = yield* Ref.make(0);
const states = [
{ phase: "backoff" },
{ phase: "connecting" },
{ phase: "backoff" },
{ phase: "backoff" },
];
yield* nudgeReconnectDuringUpdateRestart({
stateChanges: Stream.fromIterable(states),
retryNow: Ref.update(retries, (count) => count + 1),
interval: Duration.zero,
});
expect(yield* Ref.get(retries)).toBe(3);
}),
);
it.effect("retries rejected credentials only while the update restart is in progress", () =>
Effect.gen(function* () {
const retries = yield* Ref.make(0);
yield* nudgeReconnectDuringUpdateRestart({
stateChanges: Stream.fromIterable([
{ phase: "blocked", lastFailure: { reason: "permission" } },
{
phase: "blocked",
lastFailure: {
reason: "authentication",
detail: "The environment credential is invalid.",
},
},
{ phase: "blocked", lastFailure: { reason: "configuration" } },
]),
retryNow: Ref.update(retries, (count) => count + 1),
interval: Duration.zero,
});
expect(yield* Ref.get(retries)).toBe(1);
}),
);
});
describe("accepted server update recovery", () => {
it.effect.each([
{ loss: "interrupt", resumes: true },
{ loss: "socket", resumes: true },
{ loss: "server_error", resumes: false },
{ loss: "no_progress", resumes: false },
{ loss: "cancel", resumes: false },
{ loss: "socket", method: "respawn", resumes: true },
{ loss: "socket", method: "desktop-managed", resumes: false },
] as const)("handles $loss with $method and recovery=$resumes", (scenario) =>
Effect.gen(function* () {
const { loss, resumes } = scenario;
const method = "method" in scenario ? scenario.method : "boot-service";
const observing = yield* Deferred.make<void>();
const cancelFiber = yield* Deferred.make<Fiber.Fiber<unknown, unknown>>();
const oldReadyObserved = yield* Deferred.make<void>();
const readyEvents =
yield* Queue.unbounded<Parameters<typeof matchesServerUpdateReadyEvent>[1]>();
const config = {
...CONFIG,
environment: {
...CONFIG.environment,
serverVersion: "0.0.30",
capabilities: { serverSelfUpdate: method, serverSelfUpdateProgress: true },
},
} as ServerConfig;
const client = {
[WS_METHODS.subscribeServerConfig]: () => Stream.never,
[WS_METHODS.subscribeServerLifecycle]: () =>
Stream.fromEffect(Deferred.succeed(observing, undefined)).pipe(
Stream.drain,
Stream.concat(Stream.fromQueue(readyEvents)),
Stream.tap((event) =>
event.payload.environment.serverVersion === "0.0.30"
? Deferred.succeed(oldReadyObserved, undefined)
: Effect.void,
),
),
[WS_METHODS.serverUpdateServerWithProgress]: () =>
(loss === "no_progress"
? Stream.empty
: Stream.make({ type: "progress" as const, stage: "downloading" as const })
).pipe(
Stream.concat(
Stream.fromEffect(
loss === "cancel"
? Effect.fiber.pipe(
Effect.flatMap((fiber) => Deferred.succeed(cancelFiber, fiber)),
Effect.andThen(Effect.never),
)
: loss === "interrupt"
? Effect.interrupt
: Effect.fail(
loss === "server_error"
? new ServerSelfUpdateError({
reason: "Archive verification failed.",
})
: new RpcClientError.RpcClientError({
reason: new Socket.SocketCloseError({ code: 1006 }),
}),
),
),
),
),
} as unknown as WsRpcProtocolClient;
const supervisor = EnvironmentSupervisor.EnvironmentSupervisor.of({
target: TARGET,
state: yield* SubscriptionRef.make(AVAILABLE_CONNECTION_STATE),
session: yield* SubscriptionRef.make(Option.some(session(client))),
prepared: yield* SubscriptionRef.make(Option.none<PreparedConnection>()),
connect: Effect.void,
disconnect: Effect.void,
retryNow: Effect.void,
});
const run: EnvironmentRegistry.EnvironmentRegistry["Service"]["run"] = (_id, effect) =>
Effect.provideService(effect, EnvironmentSupervisor.EnvironmentSupervisor, supervisor);
const runStream: EnvironmentRegistry.EnvironmentRegistry["Service"]["runStream"] = (
_id,
stream,
) => Stream.provideService(stream, EnvironmentSupervisor.EnvironmentSupervisor, supervisor);
const environmentRegistry = EnvironmentRegistry.EnvironmentRegistry.of({
run,
runStream,
followStream: runStream,
stateChanges: () => Stream.never,
retryNow: () => Effect.void,
} as unknown as EnvironmentRegistry.EnvironmentRegistry["Service"]);
const runtime = Atom.runtime(
Layer.mergeAll(
Layer.succeed(EnvironmentRegistry.EnvironmentRegistry, environmentRegistry),
Layer.succeed(RpcPermissionGuard, { authorize: () => Effect.void }),
Layer.succeed(Persistence.EnvironmentCacheStore, {
loadServerConfig: () => Effect.succeedNone,
} as unknown as Persistence.EnvironmentCacheStore["Service"]),
),
);
const atoms = createServerEnvironmentAtoms(runtime, {
initialConfigValueAtom: () => Atom.make(config),
});
const registry = yield* Effect.acquireRelease(Effect.sync(AtomRegistry.make), (value) =>
Effect.sync(() => value.dispose()),
);
const pending = atoms.updateServer.run(registry, {
environmentId: TARGET.environmentId,
input: { targetVersion: "0.0.31" },
});
if (loss === "cancel") {
yield* Fiber.interrupt(yield* Deferred.await(cancelFiber));
const cancelled = yield* Effect.promise(() => pending);
expect(cancelled._tag).toBe("Failure");
if (cancelled._tag === "Failure")
expect(Cause.hasInterruptsOnly(cancelled.cause)).toBe(true);
expect(registry.get(serverUpdateStateAtom(TARGET.environmentId))).toEqual({
status: "idle",
});
expect(yield* Deferred.isDone(observing)).toBe(false);
return;
}
const first = yield* Effect.raceFirst(
Effect.promise(() => pending).pipe(Effect.as("settled")),
Deferred.await(observing).pipe(Effect.as("observing")),
);
if (!resumes) {
expect(first).toBe("settled");
expect(AsyncResult.isFailure(yield* Effect.promise(() => pending))).toBe(true);
expect(registry.get(serverUpdateStateAtom(TARGET.environmentId))).toMatchObject({
status: "failed",
});
return;
}
expect(first).toBe("observing");
expect(registry.get(serverUpdateStateAtom(TARGET.environmentId))).toMatchObject({
status: "running",
stage: "resuming",
});
const ready = (serverVersion: string) =>
({
version: 1,
sequence: 1,
type: "ready",
payload: { at: "2026-09-01T00:00:00.000Z", environment: { serverVersion } },
}) as Parameters<typeof matchesServerUpdateReadyEvent>[1];
yield* Queue.offer(readyEvents, ready("0.0.30"));
yield* Deferred.await(oldReadyObserved);
expect(registry.get(serverUpdateStateAtom(TARGET.environmentId))).toMatchObject({
status: "running",
});
yield* Queue.offer(readyEvents, ready("0.0.31"));
expect(AsyncResult.isSuccess(yield* Effect.promise(() => pending))).toBe(true);
expect(registry.get(serverUpdateStateAtom(TARGET.environmentId))).toEqual({
status: "idle",
});
}).pipe(Effect.scoped),
);
});
const makeConfigPersistenceHarness = Effect.fn("test.makeConfigPersistenceHarness")(function* (
saveServerConfig: Persistence.EnvironmentCacheStore["Service"]["saveServerConfig"],
) {
const events = yield* Queue.unbounded<ServerConfigStreamEvent>();
const client = {
[WS_METHODS.subscribeServerConfig]: () => Stream.fromQueue(events),
} as unknown as WsRpcProtocolClient;
const supervisor = EnvironmentSupervisor.EnvironmentSupervisor.of({
target: TARGET,
state: yield* SubscriptionRef.make(AVAILABLE_CONNECTION_STATE),
session: yield* SubscriptionRef.make(Option.some(session(client))),
prepared: yield* SubscriptionRef.make(Option.none<PreparedConnection>()),
connect: Effect.void,
disconnect: Effect.void,
retryNow: Effect.void,
});
const cache = Persistence.EnvironmentCacheStore.of({
loadShell: () => Effect.succeedNone,
saveShell: () => Effect.void,
loadThread: () => Effect.succeedNone,
saveThread: () => Effect.void,
removeThread: () => Effect.void,
loadServerConfig: () => Effect.succeedSome(CONFIG),
saveServerConfig,
loadVcsRefs: () => Effect.succeedNone,
saveVcsRefs: () => Effect.void,
removeVcsRefs: () => Effect.void,
clearVcsRefs: () => Effect.void,
clear: () => Effect.void,
});
const state = yield* makeEnvironmentServerConfigState({
environmentThemes: true,
usageLimitSources: true,
}).pipe(
Effect.provideService(EnvironmentSupervisor.EnvironmentSupervisor, supervisor),
Effect.provideService(Persistence.EnvironmentCacheStore, cache),
);
const send = Effect.fn("test.sendConfigEvent")(function* (event: ServerConfigStreamEvent) {
yield* Queue.offer(events, event);
return yield* SubscriptionRef.changes(state).pipe(
Stream.filter(Option.isSome),
Stream.map((value) => value.value),
Stream.filter((projection) => projection.latestEvent === event),
Stream.runHead,
Effect.map(Option.getOrThrow),
);
});
return { send };
});
describe("server state projection", () => {
it.effect("skips duplicate keybinding saves but persists changed keybindings", () =>
Effect.gen(function* () {
const saved = yield* Ref.make<ReadonlyArray<ServerConfig>>([]);
const keybindingsEvent = (key: string): ServerConfigStreamEvent => ({
version: 1,
type: "keybindingsUpdated",
payload: {
keybindings: [
{
command: "terminal.toggle",
shortcut: {
key,
metaKey: false,
ctrlKey: false,
shiftKey: false,
altKey: false,
modKey: true,
},
},
],
issues: [],
},
});
yield* Effect.scoped(
Effect.gen(function* () {
const h = yield* makeConfigPersistenceHarness((_id, config) =>
Ref.update(saved, (values) => [...values, config]),
);
const first = yield* h.send(keybindingsEvent("p"));
yield* TestClock.adjust("500 millis");
expect(yield* Ref.get(saved)).toEqual([first.config]);
yield* h.send(keybindingsEvent("p"));
yield* TestClock.adjust("10 seconds");
expect(yield* Ref.get(saved)).toEqual([first.config]);
const changed = yield* h.send(keybindingsEvent("q"));
yield* TestClock.adjust("10 seconds");
expect(yield* Ref.get(saved)).toEqual([first.config, changed.config]);
}),
);
}),
);
it.effect(
"compares nested durable values independently of key order and omitted undefined fields",
() =>
Effect.gen(function* () {
const saved = yield* Ref.make<ReadonlyArray<ServerConfig>>([]);
const observability = {
logsDirectoryPath: "/synthetic/logs",
localTracingEnabled: false,
otlpTracesEnabled: false,
otlpMetricsEnabled: false,
otlpLogsEnabled: false,
};
yield* Effect.scoped(
Effect.gen(function* () {
const h = yield* makeConfigPersistenceHarness((_id, config) =>
Ref.update(saved, (values) => [...values, config]),
);
const first = yield* h.send(snapshotEvent({ ...CONFIG, observability }));
yield* TestClock.adjust("500 millis");
const reordered = Object.fromEntries(
Object.entries(observability).toReversed(),
) as typeof observability;
for (const next of [
{ ...CONFIG, observability: reordered },
{ ...CONFIG, observability: { ...reordered, otlpTracesUrl: undefined } },
{ ...CONFIG, observability: { ...observability } },
]) {
const encode = Schema.encodeEffect(Schema.fromJsonString(ServerObservability));
expect(JSON.parse(yield* encode(next.observability))).toEqual(
JSON.parse(yield* encode(observability)),
);
const projection = yield* h.send(snapshotEvent(next));
expect(projection.config.observability).toEqual(next.observability);
yield* TestClock.adjust("10 seconds");
expect.soft(yield* Ref.get(saved)).toEqual([first.config]);
}
const writesBeforeChange = (yield* Ref.get(saved)).length;
const changed = yield* h.send(
snapshotEvent({
...CONFIG,
observability: { ...observability, otlpTracesUrl: "https://traces.example.test" },
}),
);
yield* TestClock.adjust("10 seconds");
expect((yield* Ref.get(saved)).length).toBe(writesBeforeChange + 1);
expect((yield* Ref.get(saved)).at(-1)).toEqual(changed.config);
}),
);
}),
);
it.effect("saves once across transient themes, usage sources and stall updates", () =>
Effect.gen(function* () {
const saved = yield* Ref.make<ReadonlyArray<ServerConfig>>([]);
yield* Effect.scoped(
Effect.gen(function* () {
const h = yield* makeConfigPersistenceHarness((_id, config) =>
Ref.update(saved, (values) => [...values, config]),
);
yield* h.send(snapshotEvent(CONFIG));
yield* TestClock.adjust("500 millis");
expect((yield* Ref.get(saved)).length).toBe(1);
for (const event of [
{
version: 1,
type: "environmentThemesUpdated",
payload: {
themes: [
{
id: EnvironmentThemeId.make("theme-test"),
name: "Test theme",
appearance: "dark",
},
],
},
},
{
version: 1,
type: "usageLimitSourcesUpdated",
payload: {
sources: [
{
id: UsageLimitSourceId.make("source-test"),
kind: "cliproxy",
label: "Test source",
checkedAt: "2026-10-20T07:50:37.633Z",
accounts: [],
},
],
},
},
snapshotEvent({
...CONFIG,
lastEventLoopStall: {
detectedAt: "2026-10-20T07:50:37.633Z",
durationMs: 1000,
loadAverage: 1,
cpuCount: 8,
},
}),
] satisfies ReadonlyArray<ServerConfigStreamEvent>) {
const projection = yield* h.send(event);
expect(projection.latestEvent).toBe(event);
if (event.type === "environmentThemesUpdated")
expect(projection.config.environmentThemes).toEqual(event.payload.themes);
if (event.type === "usageLimitSourcesUpdated")
expect(projection.config.usageLimitSources).toEqual(event.payload.sources);
yield* TestClock.adjust("10 seconds");
}
}),
);
expect(yield* Ref.get(saved)).toEqual([CONFIG]);
}),
);
it.effect("flushes pending durable changes after a transient event", () =>
Effect.gen(function* () {
const saved = yield* Ref.make<ReadonlyArray<ServerConfig>>([]);
const changed = { ...CONFIG, keybindingsConfigPath: "/changed/keybindings.json" };
yield* Effect.scoped(
Effect.gen(function* () {
const h = yield* makeConfigPersistenceHarness((_id, config) =>
Ref.update(saved, (values) => [...values, config]),
);
yield* h.send(snapshotEvent(CONFIG));
yield* TestClock.adjust("500 millis");
yield* h.send(snapshotEvent(changed));
yield* h.send({ version: 1, type: "environmentThemesUpdated", payload: { themes: [] } });
}),
);
expect(yield* Ref.get(saved)).toEqual([CONFIG, changed]);
}),
);
it.effect("retries a failed durable save on a transient event", () =>
Effect.gen(function* () {
const attempts = yield* Ref.make<ReadonlyArray<ServerConfig>>([]);
yield* Effect.scoped(
Effect.gen(function* () {
const h = yield* makeConfigPersistenceHarness((_id, config) =>
Effect.gen(function* () {
const values = yield* Ref.updateAndGet(attempts, (values) => [...values, config]);
if (values.length === 1)
return yield* new Persistence.ConnectionPersistenceError({
operation: "save-server-config",
message: "test failure",
});
}),
);
yield* h.send(snapshotEvent(CONFIG));
yield* TestClock.adjust("500 millis");
yield* h.send({ version: 1, type: "usageLimitSourcesUpdated", payload: { sources: [] } });
yield* TestClock.adjust("10 seconds");
}),
);
expect(yield* Ref.get(attempts)).toEqual([CONFIG, CONFIG]);
}),
);
it("only treats a legacy transport interruption as an unacknowledged handoff", () => {
expect(isLegacyUpdateHandoffLoss(Cause.interrupt(1))).toBe(true);
expect(
isLegacyUpdateHandoffLoss(
Cause.fail(
new RpcClientError.RpcClientError({
reason: new Socket.SocketCloseError({ code: 1006 }),
}),
),
),
).toBe(true);
expect(
isLegacyUpdateHandoffLoss(
Cause.fail(
new RpcClientError.RpcClientError({
reason: new Socket.SocketOpenError({
kind: "Unknown",
cause: new Error("connection refused"),
}),
}),
),
),
).toBe(false);
expect(
isLegacyUpdateHandoffLoss(
Cause.fail(
new RpcClientError.RpcClientError({
reason: new RpcClientError.RpcClientDefect({
message: "incompatible protocol",
cause: new Error("invalid response"),
}),
}),
),
),
).toBe(false);
expect(isLegacyUpdateHandoffLoss(Cause.fail(new Error("Install failed.")))).toBe(false);
});
it.effect("resumes after the progress stream disconnects following completion", () => {
const result = {
targetVersion: "0.0.31",
method: "respawn" as const,
};
const disconnect = new RpcClientError.RpcClientError({
reason: new Socket.SocketCloseError({ code: 1006 }),
});
return Effect.gen(function* () {
const resumed = yield* resolveServerUpdateProgressResult(
result.targetVersion,
Option.some(result),
Exit.fail(disconnect),
);
expect(resumed).toEqual(result);
});
});
it("projects streamed update milestones into the shared operation state", () => {
expect(
serverUpdateStateForProgressEvent("0.0.30", "0.0.31", {
type: "progress",
stage: "installing",
}),
).toEqual({
status: "running",
stage: "installing",
fromVersion: "0.0.30",
targetVersion: "0.0.31",
});
expect(
serverUpdateStateForProgressEvent("0.0.30", "0.0.31", {
type: "complete",
result: { targetVersion: "0.0.31", method: "respawn" },
}),
).toEqual({
status: "running",
stage: "resuming",
fromVersion: "0.0.30",
targetVersion: "0.0.31",
});
expect(
serverUpdateStateForProgressEvent("0.0.30", "0.0.31", {
type: "complete",
result: { targetVersion: "0.0.31", method: "desktop-app", desktopUpdateToken: "token" },
}).stage,
).toBe("installing");
});
it("keeps active update state and hides stale failures after a version change", () => {
const running = {
status: "running" as const,
stage: "resuming" as const,
fromVersion: "0.0.30",
targetVersion: "0.0.31",
};
const failed = {
status: "failed" as const,
stage: "installing" as const,
fromVersion: "0.0.30",
targetVersion: "0.0.31",
message: "Install failed.",
};
expect(serverUpdateStateForServerVersion(running, "0.0.31")).toBe(running);
expect(serverUpdateStateForServerVersion(failed, "0.0.30")).toBe(failed);
expect(serverUpdateStateForServerVersion(failed, null)).toBe(failed);
expect(serverUpdateStateForServerVersion(failed, "0.0.31")).toEqual({ status: "idle" });
});
it.effect("correlates launcher outcomes and fails immediately after rollback", () =>
Effect.gen(function* () {
const result = {
targetVersion: "0.0.31",
method: "boot-service" as const,
updateId: "update-1",
};
const ready = (status: "committed" | "rolled-back") =>
({
version: 1 as const,
sequence: 1,
type: "ready" as const,
payload: {
at: "2026-08-01T00:00:00.000Z",
environment: { serverVersion: status === "committed" ? "0.0.31" : "0.0.30" },
updateOutcome: {
id: "update-1",
fromVersion: "0.0.30",
targetVersion: "0.0.31",
status,
...(status === "rolled-back" ? { reason: "prepared-timeout" } : {}),
},
},
}) as Parameters<typeof matchesServerUpdateReadyEvent>[1];
expect(matchesServerUpdateReadyEvent(result, ready("committed"))).toBe(true);
yield* validateServerUpdateReadyEvent(result, ready("committed"));
const rollback = yield* Effect.flip(
validateServerUpdateReadyEvent(result, ready("rolled-back")),
);
expect(rollback.message).toBe("prepared-timeout");
}),
);
it("requires tokenless desktop updates to reach the target version", () => {
const ready = (serverVersion: string) =>
({
version: 1 as const,
sequence: 1,
type: "ready" as const,
payload: {
at: "2026-09-01T00:00:00.000Z",
environment: { serverVersion },
},
}) as Parameters<typeof matchesServerUpdateResumeEvent>[1];
expect(
matchesServerUpdateResumeEvent(
{ targetVersion: "0.0.31", method: "desktop-app" },
ready("0.0.30"),
),
).toBe(false);
expect(
matchesServerUpdateResumeEvent(
{
targetVersion: "0.0.31",
method: "desktop-app",
desktopUpdateToken: "update-1",
},
ready("0.0.30"),
),
).toBe(true);
});
it("keeps published themes across a reconnect snapshot", () => {
const themes = [
{
id: "nightfall",
name: "Nightfall",
appearance: "dark",
canvas: "#1a1b26",
accent: "#7aa2f7",
},
] as const;
const withThemes = applyServerConfigProjection(
applyServerConfigProjection(Option.none(), { version: 1, type: "snapshot", config: CONFIG }),
{ version: 1, type: "environmentThemesUpdated", payload: { themes } },
);
expect(Option.getOrThrow(withThemes).config.environmentThemes).toEqual(themes);
const afterReconnect = applyServerConfigProjection(withThemes, {
version: 1,
type: "snapshot",
config: CONFIG,
});
expect(Option.getOrThrow(afterReconnect).config.environmentThemes).toEqual(themes);
});
it("keeps a current welcome on ready and rejects a buffered welcome from the old session", () => {
const firstSession = session({} as WsRpcProtocolClient);
const secondSession = session({} as WsRpcProtocolClient);
const welcome = {
environment: {} as ServerLifecycleWelcomePayload["environment"],
cwd: "/repo",
projectName: "repo",
} as ServerLifecycleWelcomePayload;
const initial = {
currentSession: firstSession,
welcomeSession: firstSession,
welcome: null,
};
const afterWelcome = applyServerWelcomeEvent(initial, firstSession, {
type: "welcome",
payload: welcome,
});
const afterReady = applyServerWelcomeEvent(afterWelcome, firstSession, {
type: "ready",
payload: {},
});
const afterSwitch = { ...afterReady, currentSession: secondSession };
const afterBufferedOldWelcome = applyServerWelcomeEvent(afterSwitch, firstSession, {
type: "welcome",
payload: { ...welcome, cwd: "/stale" },
});
expect(afterReady).toBe(afterWelcome);
expect(resolveServerWelcomeState(afterReady)).toBe(welcome);
expect(afterBufferedOldWelcome).toBe(afterSwitch);
expect(resolveServerWelcomeState(afterBufferedOldWelcome)).toBeNull();
});
it.effect("checks the authoritative session before accepting a buffered welcome", () =>
Effect.gen(function* () {
const firstEvents = yield* Queue.unbounded<{
readonly type: "welcome" | "ready";
readonly payload: unknown;
}>();
const firstSubscribed = yield* Deferred.make<void>();
const firstClient = {
[WS_METHODS.subscribeServerLifecycle]: () =>
Stream.fromEffect(Deferred.succeed(firstSubscribed, undefined)).pipe(
Stream.drain,
Stream.concat(Stream.fromQueue(firstEvents)),
),
} as unknown as WsRpcProtocolClient;
const firstSession = session(firstClient);
const secondSession = session({} as WsRpcProtocolClient);
const supervisorSession = yield* SubscriptionRef.make(Option.some(firstSession));
const supervisor = EnvironmentSupervisor.EnvironmentSupervisor.of({
target: TARGET,
state: yield* SubscriptionRef.make(AVAILABLE_CONNECTION_STATE),
session: supervisorSession,
prepared: yield* SubscriptionRef.make(Option.none<PreparedConnection>()),
connect: Effect.void,
disconnect: Effect.void,
retryNow: Effect.void,
} satisfies EnvironmentSupervisor.EnvironmentSupervisor["Service"]);
const staleWelcome = {
environment: {} as ServerLifecycleWelcomePayload["environment"],
cwd: "/stale",
projectName: "stale",
} as ServerLifecycleWelcomePayload;
yield* Effect.scoped(
Effect.gen(function* () {
const state = yield* makeEnvironmentServerWelcomeState().pipe(
Effect.provideService(EnvironmentSupervisor.EnvironmentSupervisor, supervisor),
);
yield* Deferred.await(firstSubscribed);
supervisorSession.value = Option.some(secondSession);
const handled = yield* SubscriptionRef.changes(state).pipe(
Stream.filter(
(value) => value.currentSession === secondSession || value.welcome === staleWelcome,
),
Stream.runHead,
Effect.map(Option.getOrThrow),
Effect.forkChild,
);
yield* Queue.offer(firstEvents, { type: "welcome", payload: staleWelcome });
const next = yield* Fiber.join(handled);
expect(next.currentSession).toBe(secondSession);
expect(resolveServerWelcomeState(next)).toBeNull();
}),
);
}),
);
it.effect("reads the authoritative session after waiting for the welcome state lock", () =>
Effect.gen(function* () {
const firstSubscribed = yield* Deferred.make<void>();
const firstClient = {
[WS_METHODS.subscribeServerLifecycle]: () =>
Stream.fromEffect(Deferred.succeed(firstSubscribed, undefined)).pipe(Stream.drain),
} as unknown as WsRpcProtocolClient;
const secondClient = {
[WS_METHODS.subscribeServerLifecycle]: () => Stream.never,
} as unknown as WsRpcProtocolClient;
const firstSession = session(firstClient);
const secondSession = session(secondClient);
const thirdSession = session({} as WsRpcProtocolClient);
const supervisorSession = yield* SubscriptionRef.make(Option.some(firstSession));
const supervisor = EnvironmentSupervisor.EnvironmentSupervisor.of({
target: TARGET,
state: yield* SubscriptionRef.make(AVAILABLE_CONNECTION_STATE),
session: supervisorSession,
prepared: yield* SubscriptionRef.make(Option.none<PreparedConnection>()),
connect: Effect.void,
disconnect: Effect.void,
retryNow: Effect.void,
} satisfies EnvironmentSupervisor.EnvironmentSupervisor["Service"]);
yield* Effect.scoped(
Effect.gen(function* () {
const state = yield* makeEnvironmentServerWelcomeState().pipe(
Effect.provideService(EnvironmentSupervisor.EnvironmentSupervisor, supervisor),
);
yield* Deferred.await(firstSubscribed);
const changed = yield* SubscriptionRef.changes(state).pipe(
Stream.filter((value) => value.currentSession !== firstSession),
Stream.runHead,
Effect.map(Option.getOrThrow),
Effect.forkChild,
);
yield* state.semaphore.withPermit(
Effect.gen(function* () {
yield* SubscriptionRef.set(supervisorSession, Option.some(secondSession));
yield* Effect.yieldNow;
yield* Effect.yieldNow;
yield* Effect.yieldNow;
supervisorSession.value = Option.some(thirdSession);
}),
);
expect((yield* Fiber.join(changed)).currentSession).toBe(thirdSession);
}),
);
}),
);
it.effect("clears a welcome until the reconnected session sends its own", () =>
Effect.gen(function* () {
const firstEvents = yield* Queue.unbounded<{
readonly type: "welcome" | "ready";
readonly payload: unknown;
}>();
const secondEvents = yield* Queue.unbounded<{
readonly type: "welcome" | "ready";
readonly payload: unknown;
}>();
const firstClient = {
[WS_METHODS.subscribeServerLifecycle]: () => Stream.fromQueue(firstEvents),
} as unknown as WsRpcProtocolClient;
const secondClient = {
[WS_METHODS.subscribeServerLifecycle]: () => Stream.fromQueue(secondEvents),
} as unknown as WsRpcProtocolClient;
const firstSession = session(firstClient);
const secondSession = session(secondClient);
const supervisorSession = yield* SubscriptionRef.make(Option.some(firstSession));
const supervisor = EnvironmentSupervisor.EnvironmentSupervisor.of({
target: TARGET,
state: yield* SubscriptionRef.make(AVAILABLE_CONNECTION_STATE),
session: supervisorSession,
prepared: yield* SubscriptionRef.make(Option.none<PreparedConnection>()),
connect: Effect.void,
disconnect: Effect.void,
retryNow: Effect.void,
} satisfies EnvironmentSupervisor.EnvironmentSupervisor["Service"]);
const firstWelcome = {
environment: {} as ServerLifecycleWelcomePayload["environment"],
cwd: "/first",
projectName: "first",
} as ServerLifecycleWelcomePayload;
const secondWelcome = {
environment: {} as ServerLifecycleWelcomePayload["environment"],
cwd: "/second",
projectName: "second",
} as ServerLifecycleWelcomePayload;
yield* Effect.scoped(
Effect.gen(function* () {
const state = yield* makeEnvironmentServerWelcomeState().pipe(
Effect.provideService(EnvironmentSupervisor.EnvironmentSupervisor, supervisor),
);
const nextResolved = (
predicate: (value: ServerLifecycleWelcomePayload | null) => boolean,
) =>
SubscriptionRef.changes(state).pipe(
Stream.map(resolveServerWelcomeState),
Stream.filter(predicate),
Stream.runHead,
Effect.map(Option.getOrThrow),
);
const first = yield* nextResolved((value) => value === firstWelcome).pipe(
Effect.forkChild,
);
yield* Queue.offer(firstEvents, { type: "welcome", payload: firstWelcome });
expect(yield* Fiber.join(first)).toBe(firstWelcome);
const cleared = yield* nextResolved((value) => value === null).pipe(Effect.forkChild);
yield* SubscriptionRef.set(supervisorSession, Option.some(secondSession));
expect(yield* Fiber.join(cleared)).toBeNull();
expect(resolveServerWelcomeState(yield* SubscriptionRef.get(state))).toBeNull();
const second = yield* nextResolved((value) => value === secondWelcome).pipe(
Effect.forkChild,
);
yield* Queue.offer(secondEvents, { type: "welcome", payload: secondWelcome });
expect(yield* Fiber.join(second)).toBe(secondWelcome);
}),
);
}),
);
it("prefers an active session config over cache until a live event arrives", () => {
const config = (source: string, serverVersion: string) =>
({
...CONFIG,
environment: { serverVersion },
settings: { source },
}) as unknown as ServerConfig;
const cached = config("cache", "0.0.29");
const staleLive = config("stale-live", "0.0.29");
const initial = config("session", "0.0.30");
const live = config("live", "0.0.30");
expect(
resolveServerConfigValue(
{
config: cached,
latestEvent: snapshotEvent(cached),
source: "cache",
},
initial,
),
).toBe(initial);
expect(
resolveServerConfigValue(
{
config: staleLive,
latestEvent: snapshotEvent(staleLive),
source: "live",
},
initial,
),
).toBe(initial);
expect(
resolveServerConfigValue(
{
config: live,
latestEvent: snapshotEvent(live),
source: "live",
},
initial,
),
).toBe(live);
});
it("merges fetched workspace snapshots only from servers that omit them", () => {
const claude = ProviderInstanceId.make("claudeAgent");
const codex = ProviderInstanceId.make("codex");
const snapshot = (cwd: string, command: string) => ({
cwd,
checkedAt: "2026-10-25T00:00:00.000Z",
slashCommands: [{ name: command }],
skills: [],
});
const provider = (
instanceId: ProviderInstanceId,
workspaceSnapshots?: ReadonlyArray<ReturnType<typeof snapshot>>,
slashCommands: ReadonlyArray<{ readonly name: string }> = [],
) =>
({
instanceId,
enabled: true,
slashCommands,
skills: [],
...(workspaceSnapshots ? { workspaceSnapshots } : {}),
}) as unknown as ServerConfig["providers"][number];
const configWith = (onDemand: boolean, providers: ServerConfig["providers"]) =>
({
...CONFIG,
environment: { capabilities: { providerWorkspaceSnapshotsOnDemand: onDemand } },
providers,
}) as unknown as ServerConfig;
const claudeA = snapshot("/a", "claude");
const record = (
current: Parameters<typeof recordFetchedWorkspaceSnapshot>[0],
instanceId: ProviderInstanceId,
fresh: boolean,
reply: ServerConfig["providers"],
) =>
recordFetchedWorkspaceSnapshot(
current,
{ instanceId, cwd: "/a", fresh },
reply,
provider(instanceId),
);
let fetched = record([], claude, false, [provider(claude, [claudeA])]);
fetched = record(fetched, codex, false, [provider(codex, [snapshot("/a", "codex")])]);
const merged = withFetchedWorkspaceSnapshots(
configWith(true, [provider(claude), provider(codex)]),
fetched,
);
expect(merged.providers[0]?.workspaceSnapshots).toEqual([claudeA]);
// An unchanged answer keeps the cache, so config readers do not re-render.
expect(
record(fetched, claude, false, [
provider(claude, [JSON.parse(JSON.stringify(claudeA)) as typeof claudeA]),
]),
).toBe(fetched);
// Health checks and usage updates leave the snapshot in place.
expect(
withFetchedWorkspaceSnapshots(
configWith(true, [
{ ...provider(claude), checkedAt: "2026-10-25T00:09:00.000Z", usageLimits: {} },
] as unknown as ServerConfig["providers"]),
fetched,
).providers[0]?.workspaceSnapshots,
).toEqual([claudeA]);
// New provider-wide commands, such as a live session's, retire the old snapshot.
expect(
withFetchedWorkspaceSnapshots(
configWith(true, [provider(claude, undefined, [{ name: "live" }])]),
fetched,
).providers[0]?.workspaceSnapshots,
).toBeUndefined();
// Older servers send every snapshot and every drop; their config stands.
const legacy = configWith(false, [provider(claude)]);
expect(withFetchedWorkspaceSnapshots(legacy, fetched)).toBe(legacy);
// A fresh scan drops the cwd's other provider snapshots, as the server does.
expect(record(fetched, claude, true, [])).toEqual([]);
});
it.effect("starts from cached configuration and persists the live projection", () =>
Effect.gen(function* () {
const events = yield* Queue.unbounded<ServerConfigStreamEvent>();
const client = {
[WS_METHODS.subscribeServerConfig]: () => Stream.fromQueue(events),
} as unknown as WsRpcProtocolClient;
const supervisor = EnvironmentSupervisor.EnvironmentSupervisor.of({
target: TARGET,
state: yield* SubscriptionRef.make(AVAILABLE_CONNECTION_STATE),
session: yield* SubscriptionRef.make(Option.some(session(client))),
prepared: yield* SubscriptionRef.make(Option.none<PreparedConnection>()),
connect: Effect.void,
disconnect: Effect.void,
retryNow: Effect.void,
} satisfies EnvironmentSupervisor.EnvironmentSupervisor["Service"]);
const savedConfigs = yield* Queue.unbounded<ServerConfig>();
const cache = Persistence.EnvironmentCacheStore.of({
loadShell: () => Effect.succeedNone,
saveShell: () => Effect.void,
loadThread: () => Effect.succeedNone,
saveThread: () => Effect.void,
removeThread: () => Effect.void,
loadServerConfig: () => Effect.succeedSome(CONFIG),
saveServerConfig: (_environmentId, config) => Queue.offer(savedConfigs, config),
loadVcsRefs: () => Effect.succeedNone,
saveVcsRefs: () => Effect.void,
removeVcsRefs: () => Effect.void,
clearVcsRefs: () => Effect.void,
clear: () => Effect.void,
});
yield* Effect.scoped(
Effect.gen(function* () {
const state = yield* makeEnvironmentServerConfigState({}).pipe(
Effect.provideService(EnvironmentSupervisor.EnvironmentSupervisor, supervisor),
Effect.provideService(Persistence.EnvironmentCacheStore, cache),
);
expect(Option.getOrThrow(yield* SubscriptionRef.get(state)).config).toBe(CONFIG);
const providers: ServerConfig["providers"] = [];
yield* Queue.offer(events, {
version: 1,
type: "providerStatuses",
payload: { providers },
});
const projected = yield* SubscriptionRef.changes(state).pipe(
Stream.filter((value) =>
Option.match(value, {
onNone: () => false,
onSome: (projection) => projection.latestEvent.type === "providerStatuses",
}),
),
Stream.runHead,
);
expect(Option.getOrThrow(Option.getOrThrow(projected)).config.providers).toEqual(
providers,
);
}),
);
expect((yield* Queue.take(savedConfigs)).providers).toEqual([]);
}),
);
it.effect("shows a reported stall but never caches it", () =>
Effect.gen(function* () {
const events = yield* Queue.unbounded<ServerConfigStreamEvent>();
const client = {
[WS_METHODS.subscribeServerConfig]: () => Stream.fromQueue(events),
} as unknown as WsRpcProtocolClient;
const supervisor = EnvironmentSupervisor.EnvironmentSupervisor.of({
target: TARGET,
state: yield* SubscriptionRef.make(AVAILABLE_CONNECTION_STATE),
session: yield* SubscriptionRef.make(Option.some(session(client))),
prepared: yield* SubscriptionRef.make(Option.none<PreparedConnection>()),
connect: Effect.void,
disconnect: Effect.void,
retryNow: Effect.void,
} satisfies EnvironmentSupervisor.EnvironmentSupervisor["Service"]);
const savedConfigs = yield* Queue.unbounded<ServerConfig>();
const cache = Persistence.EnvironmentCacheStore.of({
loadShell: () => Effect.succeedNone,
saveShell: () => Effect.void,
loadThread: () => Effect.succeedNone,
saveThread: () => Effect.void,
removeThread: () => Effect.void,
loadServerConfig: () => Effect.succeedSome(CONFIG),
saveServerConfig: (_environmentId, config) => Queue.offer(savedConfigs, config),
loadVcsRefs: () => Effect.succeedNone,
saveVcsRefs: () => Effect.void,
removeVcsRefs: () => Effect.void,
clearVcsRefs: () => Effect.void,
clear: () => Effect.void,
});
yield* Effect.scoped(
Effect.gen(function* () {
const state = yield* makeEnvironmentServerConfigState({}).pipe(
Effect.provideService(EnvironmentSupervisor.EnvironmentSupervisor, supervisor),
Effect.provideService(Persistence.EnvironmentCacheStore, cache),
);
expect(Option.getOrThrow(yield* SubscriptionRef.get(state)).config).toBe(CONFIG);
const lastEventLoopStall = {
detectedAt: "2026-10-20T07:50:37.633Z",
durationMs: 12_422,
loadAverage: 219.4,
cpuCount: 18,
};
yield* Queue.offer(events, {
version: 1,
type: "snapshot",
config: { ...CONFIG, lastEventLoopStall },
});
const projected = yield* SubscriptionRef.changes(state).pipe(
Stream.filter((value) =>
Option.match(value, {
onNone: () => false,
onSome: (projection) => projection.source === "live",
}),
),
Stream.runHead,
);
expect(Option.getOrThrow(Option.getOrThrow(projected)).config.lastEventLoopStall).toEqual(
lastEventLoopStall,
);
}),
);
// Cached, it would read as a fresh freeze on the next launch.
expect(yield* Queue.take(savedConfigs)).not.toHaveProperty("lastEventLoopStall");
}),
);
});
describe("provider setup commands", () => {
it.effect("starts installs for two instances in one environment separately", () =>
Effect.gen(function* () {
const requested = yield* Queue.unbounded<ProviderInstanceId>();
const release = yield* Deferred.make<void>();
const installState = (driver: string): ProviderInstallState => ({
driver: ProviderDriverKind.make(driver),
operationId: null,
phase: "downloading",
downloadedBytes: 0,
totalBytes: null,
version: null,
installedVersion: null,
canRemove: false,
message: null,
});
const client = {
[WS_METHODS.providerInstallStart]: ({ instanceId }: ProviderSetupInput) =>
Queue.offer(requested, instanceId).pipe(
Effect.andThen(Deferred.await(release)),
Effect.as(installState(instanceId)),
),
} as unknown as WsRpcProtocolClient;
const supervisor = EnvironmentSupervisor.EnvironmentSupervisor.of({
target: TARGET,
state: yield* SubscriptionRef.make(AVAILABLE_CONNECTION_STATE),
session: yield* SubscriptionRef.make(Option.some(session(client))),
prepared: yield* SubscriptionRef.make(Option.none<PreparedConnection>()),
connect: Effect.void,
disconnect: Effect.void,
retryNow: Effect.void,
} satisfies EnvironmentSupervisor.EnvironmentSupervisor["Service"]);
const runtime = Atom.runtime(
Layer.merge(
Layer.succeed(EnvironmentRegistry.EnvironmentRegistry, {
run: (_environmentId, effect) =>
Effect.provideService(
effect,
EnvironmentSupervisor.EnvironmentSupervisor,
supervisor,
),
} as EnvironmentRegistry.EnvironmentRegistry["Service"]),
Layer.succeed(
Persistence.EnvironmentCacheStore,
{} as Persistence.EnvironmentCacheStore["Service"],
),
),
);
const atoms = createServerEnvironmentAtoms(runtime, {
initialConfigValueAtom: () => Atom.make(CONFIG),
});
const registry = yield* Effect.acquireRelease(Effect.sync(AtomRegistry.make), (registry) =>
Effect.sync(() => registry.dispose()),
);
const install = (instanceId: string) =>
atoms.startProviderInstall.run(registry, {
environmentId: TARGET.environmentId,
input: { instanceId: ProviderInstanceId.make(instanceId) },
});
const codex = install("codex");
expect(yield* Queue.take(requested)).toBe("codex");
const duplicateCodex = install("codex");
const antigravity = install("antigravity");
yield* Deferred.succeed(release, undefined);
expect(yield* Effect.promise(() => codex)).toMatchObject({
_tag: "Success",
value: { driver: "codex" },
});
expect(yield* Effect.promise(() => duplicateCodex)).toEqual(
yield* Effect.promise(() => codex),
);
expect(yield* Effect.promise(() => antigravity)).toMatchObject({
_tag: "Success",
value: { driver: "antigravity" },
});
expect(yield* Queue.takeAll(requested)).toEqual(["antigravity"]);
}).pipe(Effect.scoped),
);
});
describe("resource telemetry history", () => {
it.effect("refreshes an initially empty history while mounted and stops after unmount", () =>
Effect.gen(function* () {
vi.useFakeTimers();
try {
yield* Effect.scoped(
Effect.gen(function* () {
let reads = 0;
const client = {
[WS_METHODS.serverGetResourceTelemetryHistory]: () =>
Effect.sync(() => ({
retainedSampleCount: reads++,
})),
} as unknown as WsRpcProtocolClient;
const supervisor = EnvironmentSupervisor.EnvironmentSupervisor.of({
target: TARGET,
state: yield* SubscriptionRef.make<SupervisorConnectionState>({
...AVAILABLE_CONNECTION_STATE,
phase: "connected",
}),
session: yield* SubscriptionRef.make(Option.some(session(client))),
prepared: yield* SubscriptionRef.make(Option.none<PreparedConnection>()),
connect: Effect.void,
disconnect: Effect.void,
retryNow: Effect.void,
});
const environments = EnvironmentRegistry.EnvironmentRegistry.of({
run: (_id, effect) =>
Effect.provideService(
effect,
EnvironmentSupervisor.EnvironmentSupervisor,
supervisor,
),
followStream: (_id, stream) =>
Stream.provideService(
stream,
EnvironmentSupervisor.EnvironmentSupervisor,
supervisor,
),
} as EnvironmentRegistry.EnvironmentRegistry["Service"]);
const runtime = Atom.runtime(
Layer.merge(
Layer.succeed(EnvironmentRegistry.EnvironmentRegistry, environments),
Layer.succeed(Persistence.EnvironmentCacheStore, {
loadServerConfig: () => Effect.succeedNone,
} as unknown as Persistence.EnvironmentCacheStore["Service"]),
),
);
const atoms = createServerEnvironmentAtoms(runtime, {
initialConfigValueAtom: () => Atom.make(CONFIG),
});
const registry = yield* Effect.acquireRelease(Effect.sync(AtomRegistry.make), (value) =>
Effect.sync(() => value.dispose()),
);
const history = atoms.resourceTelemetryHistory({
environmentId: TARGET.environmentId,
input: { windowMs: 900_000, bucketMs: 30_000 },
});
const unmount = registry.mount(history);
const initial = yield* AtomRegistry.getResult(registry, history, {
suspendOnWaiting: true,
});
expect(initial.retainedSampleCount).toBe(0);
yield* Effect.promise(() => vi.advanceTimersByTimeAsync(5_000));
expect(reads).toBe(2);
const updated = yield* AtomRegistry.getResult(registry, history, {
suspendOnWaiting: true,
});
expect(updated.retainedSampleCount).toBe(1);
unmount();
yield* Effect.promise(() => vi.advanceTimersByTimeAsync(10_000));
expect(reads).toBe(2);
}),
);
} finally {
vi.useRealTimers();
}
}),
);
});