perf(browser-transfer): run image-cdn abort wiring on the kernel operation (R3-2)

The capability-verification deadline, the probe wait and runtime close now
use createAbortableOperation/snapshotAbortTimers instead of three local
helpers and a default scheduler wrapper. Results, error codes and the
scheduler TypeError message are unchanged. Hand-rolled abort ratchet 17 -> 16.

file-transfer gzip: 54562 -> 54406

Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>
This commit is contained in:
DongHyeonka
2026-09-24 15:22:22 +09:00
co-authored by Claude Opus 5.5
parent 108ac6a606
commit 874f4012ee
2 changed files with 53 additions and 150 deletions
+3 -1
View File
@@ -205,7 +205,9 @@ async function main(): Promise<void> {
// `browser-files/browser-file-vault.ts`가 커널 race로 옮겨갔다(Q-6.2-7).
// 19 → 18: `browser-file-storage/storage-manager-adapter.ts`의 inspection
// 대기가 커널 race로 옮겨갔다(Q-B).
const HAND_ROLLED_ABORT_CEILING = 17;
// 17 → 16: `browser-transfer/image-cdn/image-cdn-runtime.ts`의 검증 deadline과
// probe 대기가 커널 operation으로 옮겨갔다(R3-2).
const HAND_ROLLED_ABORT_CEILING = 16;
const handRolledScan = spawnSync(
"git",
["grep", "-l", 'addEventListener("abort"', "--", "src/adapters"],
@@ -20,6 +20,11 @@ import {
browserDataSuccess,
observeBrowserData,
} from "../../browser-file-storage/result.ts";
import {
createAbortableOperation,
snapshotAbortTimers,
type AbortableOperation,
} from "../../platform/abortable-operation.ts";
import {
IMAGE_FORMAT_MEDIA_TYPE,
type ImageCandidateGeometry,
@@ -176,17 +181,34 @@ export function createImageCdnRuntime(
"Image capability verification timeout is invalid.",
);
}
const capabilityVerificationScheduler =
const capabilityVerificationTimers =
snapshotCapabilityVerificationScheduler(
dependencies.capabilityVerificationScheduler ??
defaultCapabilityVerificationScheduler(),
dependencies.capabilityVerificationScheduler ?? globalThis,
);
const probe =
dependencies.probe?.probe.bind(dependencies.probe);
const observer = snapshotObserver(dependencies.observer);
let acceptedAssets =
new WeakMap<ImageAssetReference, AssetSnapshot>();
const lifetime = new AbortController();
// Every in-flight operation, so `close()` ends the physical work too.
const lifetime = new Set<AbortableOperation>();
const openOperation = (
signal: AbortSignal | undefined,
timeoutMs?: number,
): AbortableOperation => {
const operation = createAbortableOperation({
...(signal ? { signal } : {}),
...(timeoutMs === undefined ? {} : { timeoutMs }),
...capabilityVerificationTimers,
});
if (closed) operation.close();
else lifetime.add(operation);
return operation;
};
const closeOperation = (operation: AbortableOperation): void => {
lifetime.delete(operation);
operation.close();
};
let activeCapabilityVerifications = 0;
let closed = false;
@@ -333,12 +355,11 @@ export function createImageCdnRuntime(
canonicalImageCapabilityPayload(snapshot);
let bindingDigest: string;
let verified: boolean;
let deadline: ImageCapabilityVerificationDeadline;
let deadline: AbortableOperation;
try {
deadline = createCapabilityVerificationDeadline(
[options.signal, lifetime.signal],
deadline = openOperation(
options.signal,
capabilityVerificationTimeoutMs,
capabilityVerificationScheduler,
);
} catch {
return browserDataFailure("UNAVAILABLE", "IMAGE_RESOLVE", {
@@ -352,10 +373,7 @@ export function createImageCdnRuntime(
}
const digestTask = sha256Hex(digest, canonicalPayload);
rawVerificationTasks.push(digestTask);
bindingDigest = await awaitImageRuntimeAbort(
digestTask,
deadline.signal,
);
bindingDigest = await raceImageRuntime(deadline, digestTask);
if (
!constantTimeHexEqual(
bindingDigest,
@@ -377,15 +395,12 @@ export function createImageCdnRuntime(
signatureBase64Url: snapshot.signature.valueBase64Url,
});
rawVerificationTasks.push(verifyTask);
verified = await awaitImageRuntimeAbort(
verifyTask,
deadline.signal,
);
verified = await raceImageRuntime(deadline, verifyTask);
} catch {
if (closed) return imageRuntimeClosedFailure();
return capabilityVerificationFailure(options.signal);
} finally {
deadline.release();
closeOperation(deadline);
}
if (closed) return imageRuntimeClosedFailure();
if (options.signal?.aborted) {
@@ -532,12 +547,10 @@ export function createImageCdnRuntime(
}
const primary = primaryCandidate(preset);
let probeResult: BrowserDataResult<ImageProbeReceipt>;
const probeScope = combineImageRuntimeAbortSignals([
request.signal,
lifetime.signal,
]);
const probeScope = openOperation(request.signal);
try {
probeResult = await awaitImageRuntimeAbort(
probeResult = await raceImageRuntime(
probeScope,
probe({
absoluteUrl: descriptor.src,
expectedMediaType: descriptor.fallbackMediaType,
@@ -552,7 +565,6 @@ export function createImageCdnRuntime(
referrerPolicy: descriptor.referrerPolicy,
signal: probeScope.signal,
}),
probeScope.signal,
);
} catch {
probeResult = closed
@@ -564,7 +576,7 @@ export function createImageCdnRuntime(
recovery: "RETRY",
});
} finally {
probeScope.release();
closeOperation(probeScope);
}
if (closed) probeResult = imageRuntimeClosedFailure();
observeImageTerminal(
@@ -629,7 +641,8 @@ export function createImageCdnRuntime(
close(): void {
if (closed) return;
closed = true;
lifetime.abort();
for (const operation of lifetime) operation.close();
lifetime.clear();
acceptedAssets =
new WeakMap<ImageAssetReference, AssetSnapshot>();
},
@@ -1046,107 +1059,16 @@ function safeNow(now: () => number): number | null {
}
}
type ImageCapabilityVerificationDeadline = Readonly<{
signal: AbortSignal;
release(): void;
}>;
function createCapabilityVerificationDeadline(
signals: readonly (AbortSignal | undefined)[],
timeoutMs: number,
scheduler: ImageCapabilityVerificationScheduler,
): ImageCapabilityVerificationDeadline {
const scope = combineImageRuntimeAbortSignals(
signals.filter(
(signal): signal is AbortSignal => signal !== undefined,
),
);
let released = false;
let timeoutHandle: unknown;
try {
timeoutHandle = scheduler.setTimeout(() => {
if (released) return;
scope.abort(capabilityVerificationAbortException());
}, timeoutMs);
} catch (error) {
scope.release();
throw error;
}
return Object.freeze({
signal: scope.signal,
release() {
if (released) return;
released = true;
try {
scheduler.clearTimeout(timeoutHandle);
} catch {
// Scheduler cleanup cannot alter an already closed adapter result.
}
scope.release();
},
});
}
function awaitImageRuntimeAbort<Value>(
/** Settles with the task's own outcome, or rejects once the operation ends. */
async function raceImageRuntime<Value>(
operation: AbortableOperation,
task: Promise<Value>,
signal: AbortSignal,
): Promise<Value> {
return new Promise<Value>((resolve, reject) => {
let settled = false;
const onAbort = () => {
if (settled) return;
settled = true;
signal.removeEventListener("abort", onAbort);
reject(capabilityVerificationAbortException());
};
signal.addEventListener("abort", onAbort, { once: true });
if (signal.aborted) onAbort();
void task.then(
(value) => {
if (settled) return;
settled = true;
signal.removeEventListener("abort", onAbort);
resolve(value);
},
(error: unknown) => {
if (settled) return;
settled = true;
signal.removeEventListener("abort", onAbort);
reject(error);
},
);
});
}
function combineImageRuntimeAbortSignals(
signals: readonly AbortSignal[],
): Readonly<{
signal: AbortSignal;
abort(reason: unknown): void;
release(): void;
}> {
const controller = new AbortController();
const abortListeners = new Map<AbortSignal, () => void>();
for (const signal of new Set(signals)) {
const onAbort = () => controller.abort(signal.reason);
abortListeners.set(signal, onAbort);
signal.addEventListener("abort", onAbort, { once: true });
if (signal.aborted) onAbort();
}
let released = false;
return Object.freeze({
signal: controller.signal,
abort: (reason: unknown) => controller.abort(reason),
release() {
if (released) return;
released = true;
for (const [signal, onAbort] of abortListeners) {
signal.removeEventListener("abort", onAbort);
}
abortListeners.clear();
},
});
const outcome = await operation.race(task);
if (outcome.kind === "VALUE") return outcome.value;
throw outcome.kind === "REJECTED"
? outcome.reason
: capabilityVerificationAbortException();
}
function capabilityVerificationFailure(
@@ -1174,35 +1096,14 @@ function capabilityVerificationAbortException(): DOMException {
function snapshotCapabilityVerificationScheduler(
scheduler: ImageCapabilityVerificationScheduler,
): ImageCapabilityVerificationScheduler {
if (
!scheduler ||
typeof scheduler.setTimeout !== "function" ||
typeof scheduler.clearTimeout !== "function"
) {
) {
try {
return snapshotAbortTimers(scheduler);
} catch {
throw new TypeError(
"Image capability verification scheduler is invalid.",
);
}
return Object.freeze({
setTimeout: scheduler.setTimeout.bind(scheduler),
clearTimeout: scheduler.clearTimeout.bind(scheduler),
});
}
function defaultCapabilityVerificationScheduler(): ImageCapabilityVerificationScheduler {
const schedule = globalThis.setTimeout.bind(globalThis);
const clear = globalThis.clearTimeout.bind(globalThis);
return Object.freeze({
setTimeout(callback: () => void, milliseconds: number) {
return schedule(callback, milliseconds);
},
clearTimeout(handle: unknown) {
clear(
handle as ReturnType<typeof globalThis.setTimeout>,
);
},
});
}
function createAssetReference(): ImageAssetReference {