The best way to control Claude Code, Codex and more from any computer or phone
fix(client-runtime): threads with many images no longer flood a remote with URL requests (#27440)
Co-authored-by: Claude Sonnet 5.5 <noreply@anthropic.com>
voida6 committed
Nov 2, 2026 at 08:45 UTC
a4b6afe1849b12ea35f93a7897ce5b12d4c5b222
2 files changed
+210
-5
packages/client-runtime/src/state/assets.test.ts
+193
-2
@@ -1,10 +1,28 @@
1
import { describe, expect, it } from "@effect/vitest";
2
-import { type AssetCreateUrlResult, EnvironmentId } from "@t3tools/contracts";
2
+import { type AssetCreateUrlResult, EnvironmentId, WS_METHODS } from "@t3tools/contracts";
3
import * as Cause from "effect/Cause";
4
+import * as Effect from "effect/Effect";
5
+import * as Layer from "effect/Layer";
6
import * as Option from "effect/Option";
7
+import * as Queue from "effect/Queue";
8
+import * as Stream from "effect/Stream";
9
+import * as SubscriptionRef from "effect/SubscriptionRef";
10
import { AsyncResult, Atom, AtomRegistry } from "effect/reactivity";
11
7
-import { createProjectFaviconUrlAtomFamily } from "./assets.ts";
12
+import {
13
+ AVAILABLE_CONNECTION_STATE,
14
+ type PreparedConnection,
15
+ PrimaryConnectionTarget,
16
+ type SupervisorConnectionState,
17
+} from "../connection/model.ts";
18
+import * as EnvironmentRegistry from "../connection/registry.ts";
19
+import * as EnvironmentSupervisor from "../connection/supervisor.ts";
20
+import type * as RpcSession from "../rpc/session.ts";
21
+import {
22
+ ASSET_URL_MAX_IN_FLIGHT,
23
+ createAssetEnvironmentAtoms,
24
+ createProjectFaviconUrlAtomFamily,
25
+} from "./assets.ts";
26
27
describe("project favicon URL cache", () => {
28
it("does not reuse another environment, workspace, or selected icon's cached URL", () => {
@@ -38,3 +56,176 @@ describe("project favicon URL cache", () => {
56
}
57
});
58
});
59
+
60
+/**
61
+ * Environments whose `assets.createUrl` never answers until the test releases a call.
62
+ * `started` receives the environment of each call as it begins, and `inFlight` counts
63
+ * calls that have begun and not yet been released or interrupted.
64
+ */
65
+const makeAssetUrlHarness = Effect.fn("TestAssetUrl.makeHarness")(function* (
66
+ environmentIds: ReadonlyArray<EnvironmentId>,
67
+) {
68
+ const started = yield* Queue.unbounded<EnvironmentId>();
69
+ const inFlight = new Map<EnvironmentId, number>();
70
+ const maxInFlight = new Map<EnvironmentId, number>();
71
+ const releases = new Map<EnvironmentId, Queue.Queue<void>>();
72
+ const supervisors = new Map<
73
+ EnvironmentId,
74
+ EnvironmentSupervisor.EnvironmentSupervisor["Service"]
75
+ >();
76
+ const sessions = new Map<
77
+ EnvironmentId,
78
+ SubscriptionRef.SubscriptionRef<Option.Option<RpcSession.RpcSession>>
79
+ >();
80
+ const makeSession = (environmentId: EnvironmentId) =>
81
+ ({
82
+ client: {
83
+ [WS_METHODS.assetsCreateUrl]: () =>
84
+ Effect.gen(function* () {
85
+ const now = (inFlight.get(environmentId) ?? 0) + 1;
86
+ inFlight.set(environmentId, now);
87
+ maxInFlight.set(environmentId, Math.max(maxInFlight.get(environmentId) ?? 0, now));
88
+ yield* Queue.offer(started, environmentId);
89
+ yield* Queue.take(releases.get(environmentId)!);
90
+ return { relativeUrl: "/api/assets/token/image.png", expiresAt: 4_000_000_000_000 };
91
+ }).pipe(
92
+ Effect.ensuring(
93
+ Effect.sync(() =>
94
+ inFlight.set(environmentId, (inFlight.get(environmentId) ?? 1) - 1),
95
+ ),
96
+ ),
97
+ ),
98
+ },
99
+ }) as unknown as RpcSession.RpcSession;
100
+ for (const environmentId of environmentIds) {
101
+ releases.set(environmentId, yield* Queue.unbounded<void>());
102
+ const session = yield* SubscriptionRef.make(Option.some(makeSession(environmentId)));
103
+ sessions.set(environmentId, session);
104
+ supervisors.set(
105
+ environmentId,
106
+ EnvironmentSupervisor.EnvironmentSupervisor.of({
107
+ target: new PrimaryConnectionTarget({
108
+ environmentId,
109
+ label: environmentId,
110
+ httpBaseUrl: "https://assets.example.test",
111
+ wsBaseUrl: "wss://assets.example.test",
112
+ }),
113
+ state: yield* SubscriptionRef.make<SupervisorConnectionState>({
114
+ ...AVAILABLE_CONNECTION_STATE,
115
+ desired: true,
116
+ network: "online",
117
+ phase: "connected",
118
+ attempt: 1,
119
+ generation: 1,
120
+ }),
121
+ session,
122
+ prepared: yield* SubscriptionRef.make<Option.Option<PreparedConnection>>(Option.none()),
123
+ connect: Effect.void,
124
+ disconnect: Effect.void,
125
+ retryNow: Effect.void,
126
+ } satisfies EnvironmentSupervisor.EnvironmentSupervisor["Service"]),
127
+ );
128
+ }
129
+ const run: EnvironmentRegistry.EnvironmentRegistry["Service"]["run"] = (environmentId, effect) =>
130
+ Effect.provideService(
131
+ effect,
132
+ EnvironmentSupervisor.EnvironmentSupervisor,
133
+ supervisors.get(environmentId)!,
134
+ );
135
+ const followStream: EnvironmentRegistry.EnvironmentRegistry["Service"]["followStream"] = (
136
+ environmentId,
137
+ stream,
138
+ ) =>
139
+ Stream.provideService(
140
+ stream,
141
+ EnvironmentSupervisor.EnvironmentSupervisor,
142
+ supervisors.get(environmentId)!,
143
+ );
144
+ const environmentRegistry = EnvironmentRegistry.EnvironmentRegistry.of({
145
+ run,
146
+ followStream,
147
+ } as unknown as EnvironmentRegistry.EnvironmentRegistry["Service"]);
148
+ const registry = AtomRegistry.make();
149
+ yield* Effect.addFinalizer(() => Effect.sync(() => registry.dispose()));
150
+ const atoms = createAssetEnvironmentAtoms(
151
+ Atom.runtime(Layer.succeed(EnvironmentRegistry.EnvironmentRegistry, environmentRegistry)),
152
+ );
153
+ return {
154
+ started,
155
+ inFlight: (environmentId: EnvironmentId) => inFlight.get(environmentId) ?? 0,
156
+ maxInFlight: (environmentId: EnvironmentId) => maxInFlight.get(environmentId) ?? 0,
157
+ release: (environmentId: EnvironmentId) => Queue.offer(releases.get(environmentId)!, undefined),
158
+ replaceSession: (environmentId: EnvironmentId) =>
159
+ SubscriptionRef.set(sessions.get(environmentId)!, Option.some(makeSession(environmentId))),
160
+ mountImages: (environmentId: EnvironmentId, count: number) => {
161
+ for (let index = 0; index < count; index += 1) {
162
+ registry.mount(
163
+ atoms.createUrl({
164
+ environmentId,
165
+ input: { resource: { _tag: "attachment", attachmentId: `image-${index}` } },
166
+ }),
167
+ );
168
+ }
169
+ },
170
+ };
171
+});
172
+
173
+describe("asset URL requests", () => {
174
+ const remote = EnvironmentId.make("asset-remote");
175
+ const other = EnvironmentId.make("asset-other");
176
+
177
+ it.effect("keeps a thread of images from flooding one environment with requests", () =>
178
+ Effect.scoped(
179
+ Effect.gen(function* () {
180
+ const harness = yield* makeAssetUrlHarness([remote]);
181
+ const total = ASSET_URL_MAX_IN_FLIGHT * 3;
182
+ harness.mountImages(remote, total);
183
+
184
+ for (let call = 0; call < ASSET_URL_MAX_IN_FLIGHT; call += 1) {
185
+ yield* Queue.take(harness.started);
186
+ }
187
+ expect(harness.inFlight(remote)).toBe(ASSET_URL_MAX_IN_FLIGHT);
188
+
189
+ // Each answer admits the next waiting request.
190
+ for (let call = 0; call < total; call += 1) {
191
+ yield* harness.release(remote);
192
+ if (call < total - ASSET_URL_MAX_IN_FLIGHT) yield* Queue.take(harness.started);
193
+ }
194
+ expect(harness.maxInFlight(remote)).toBe(ASSET_URL_MAX_IN_FLIGHT);
195
+ }),
196
+ ),
197
+ );
198
+
199
+ it.effect("limits each environment on its own", () =>
200
+ Effect.scoped(
201
+ Effect.gen(function* () {
202
+ const harness = yield* makeAssetUrlHarness([remote, other]);
203
+ harness.mountImages(remote, ASSET_URL_MAX_IN_FLIGHT + 2);
204
+ for (let call = 0; call < ASSET_URL_MAX_IN_FLIGHT; call += 1) {
205
+ yield* Queue.take(harness.started);
206
+ }
207
+ harness.mountImages(other, 1);
208
+ expect(yield* Queue.take(harness.started)).toBe(other);
209
+ expect(harness.inFlight(remote)).toBe(ASSET_URL_MAX_IN_FLIGHT);
210
+ }),
211
+ ),
212
+ );
213
+
214
+ it.effect("frees the limit when the session behind the requests is replaced", () =>
215
+ Effect.scoped(
216
+ Effect.gen(function* () {
217
+ const harness = yield* makeAssetUrlHarness([remote]);
218
+ harness.mountImages(remote, ASSET_URL_MAX_IN_FLIGHT * 2);
219
+ for (let call = 0; call < ASSET_URL_MAX_IN_FLIGHT; call += 1) {
220
+ yield* Queue.take(harness.started);
221
+ }
222
+
223
+ yield* harness.replaceSession(remote);
224
+ for (let call = 0; call < ASSET_URL_MAX_IN_FLIGHT; call += 1) {
225
+ yield* Queue.take(harness.started);
226
+ }
227
+ expect(harness.maxInFlight(remote)).toBe(ASSET_URL_MAX_IN_FLIGHT);
228
+ }),
229
+ ),
230
+ );
231
+});
packages/client-runtime/src/state/assets.ts
+17
-3
@@ -18,6 +18,7 @@ import * as Effect from "effect/Effect";
18
import * as Option from "effect/Option";
19
import * as Result from "effect/Result";
20
import * as Schema from "effect/Schema";
21
+import * as Semaphore from "effect/Semaphore";
22
import { AsyncResult, Atom, AtomRegistry } from "effect/reactivity";
23
24
import * as EnvironmentRegistry from "../connection/registry.ts";
@@ -29,6 +30,7 @@ import { createEnvironmentQueryAtomFamily } from "./runtime.ts";
30
const ASSET_URL_REFRESH_INTERVAL_MS = 30 * 60_000;
31
const ASSET_URL_STALE_TIME_MS = 5 * 60_000;
32
const ASSET_URL_IDLE_TTL_MS = 60 * 60_000;
33
+export const ASSET_URL_MAX_IN_FLIGHT = 6;
34
35
export class InvalidAssetCollectionKeyError extends Schema.TaggedError<InvalidAssetCollectionKeyError>()(
36
"InvalidAssetCollectionKeyError",
@@ -136,15 +138,27 @@ export function createAssetEnvironmentAtoms<R, E>(
138
readonly httpBaseUrl: string;
139
} | null>,
140
) {
141
+ // A thread with hundreds of images asks for hundreds of URLs at once. Over a slow remote
142
+ // they would all wait on one socket and read as stalled, so each environment gets a few
143
+ // at a time. A query that is interrupted, such as by a new session, gives its slot back.
144
+ const mintLimits = new Map<EnvironmentId, Semaphore.Semaphore>();
145
+ const mint = (environmentId: EnvironmentId, input: AssetCreateUrlInput) => {
146
+ let limit = mintLimits.get(environmentId);
147
+ if (limit === undefined) {
148
+ limit = Semaphore.makeUnsafe(ASSET_URL_MAX_IN_FLIGHT);
149
+ mintLimits.set(environmentId, limit);
150
+ }
151
+ return request(WS_METHODS.assetsCreateUrl, input).pipe(limit.withPermit);
152
+ };
153
const execute = Effect.fn("assets.createUrl")(function* (input: AssetCreateUrlInput) {
140
- const result = yield* request(WS_METHODS.assetsCreateUrl, input).pipe(Effect.result);
154
+ const supervisor = yield* EnvironmentSupervisor.EnvironmentSupervisor;
155
+ const result = yield* mint(supervisor.target.environmentId, input).pipe(Effect.result);
156
if (Result.isSuccess(result)) return result.success;
157
const error = result.failure;
158
const resource = input.resource;
159
const local = localMediaEnvironment
160
? (yield* AtomRegistry.AtomRegistry).get(localMediaEnvironment)
161
: null;
147
- const supervisor = yield* EnvironmentSupervisor.EnvironmentSupervisor;
162
if (
163
!local ||
164
local.environmentId === supervisor.target.environmentId ||
@@ -161,7 +175,7 @@ export function createAssetEnvironmentAtoms<R, E>(
175
const registry = yield* EnvironmentRegistry.EnvironmentRegistry;
176
// Map the full cause so retry defects and interruption survive.
177
const asset = yield* registry
164
- .run(local.environmentId, request(WS_METHODS.assetsCreateUrl, input))
178
+ .run(local.environmentId, mint(local.environmentId, input))
179
.pipe(Effect.catchCause((cause) => Effect.failCause(Cause.map(cause, () => error))));
180
return { ...asset, relativeUrl: new URL(asset.relativeUrl, local.httpBaseUrl).href };
181
});