@qvac/sdk 0.10.2 → 0.11.0

package/dist/server/rpc/handlers/load-model/download-manager.js

@@ -1,10 +1,11 @@
 import { AbortController } from "bare-abort-controller";
-import { DownloadCancelledError } from "../../../../utils/errors-server.js";
+import { DownloadCancelledError, InferenceCancelledError, } from "../../../../utils/errors-server.js";
 import { getServerLogger } from "../../../../logging/index.js";
+import { getRequestRegistry } from "../../../bare/runtime/index.js";
 const logger = getServerLogger();
 const activeTransfers = new Map();
 let nextSubscriberId = 0;
-function createSubscriber(onProgress) {
+function createSubscriber(onProgress, requestId) {
     let resolve;
     let reject;
     const promise = new Promise((res, rej) => {
@@ -18,6 +19,7 @@ function createSubscriber(onProgress) {
         resolve,
         reject,
         promise,
+        requestId,
     };
 }
 function settleSubscriber(subscriber, result) {
@@ -45,7 +47,7 @@ function deliverProgress(transfer, subscriber, progress) {
             error,
         });
         settleSubscriber(subscriber, error);
-        transfer.subscribers.delete(subscriber.id);
+        removeSubscriber(transfer, subscriber.id);
     }
 }
 function broadcastTransferProgress(transfer, progress) {
@@ -54,12 +56,76 @@ function broadcastTransferProgress(transfer, progress) {
         deliverProgress(transfer, sub, progress);
     }
 }
-export function startOrJoinDownload(downloadKey, startDownload, onProgress) {
+/**
+ * Idempotent: remove the subscriber from the transfer's roster and tear
+ * the transfer down iff no subscribers remain. Wired from two places per
+ * subscriber:
+ *
+ *   - the `request.signal.addEventListener("abort", ...)` listener that
+ *     fires when `registry.cancel({ requestId })` aborts the request's
+ *     context — this is the "user clicked Stop" cancel path;
+ *   - `request.scope.defer(...)` which runs at request scope unwind —
+ *     the safety net catching every other unwind path (handler returns,
+ *     handler throws for a non-cancel reason, awaited promise settled
+ *     and the `await using` falls out of scope on the success path).
+ *
+ * Both ends call this helper so an already-cleaned-up subscriber is a
+ * no-op the second time around.
+ */
+function removeSubscriber(transfer, subscriberId) {
+    if (!transfer.subscribers.has(subscriberId))
+        return;
+    transfer.subscribers.delete(subscriberId);
+    maybeCancelTransfer(transfer);
+}
+/**
+ * Last-subscriber rule: when every caller has detached (cancel or
+ * progress-callback throw), abort the shared transfer so the underlying
+ * HTTP / hyperdrive download tears down. Until then the transfer keeps
+ * running for the remaining subscribers — the content-addressed dedup
+ * semantics callers rely on.
+ */
+function maybeCancelTransfer(transfer) {
+    if (transfer.subscribers.size > 0)
+        return;
+    if (transfer.abortController.signal.aborted)
+        return;
+    logger.debug(`[download-manager] last subscriber left, aborting transfer ${transfer.downloadKey}`);
+    transfer.abortController.abort();
+}
+function attachRequestBinding(transfer, subscriber, request) {
+    const onAbort = () => {
+        if (!subscriber.settled) {
+            settleSubscriber(subscriber, new InferenceCancelledError(request.requestId));
+        }
+        removeSubscriber(transfer, subscriber.id);
+    };
+    if (request.signal.aborted) {
+        onAbort();
+        return;
+    }
+    request.signal.addEventListener("abort", onAbort, { once: true });
+    // Safety net: scope unwind on any handler exit path triggers the same
+    // cleanup. If the abort listener already ran it's a no-op. Cleaning
+    // up the abort listener here keeps the parent signal from carrying a
+    // dangling reference into the next request.
+    request.scope.defer(() => {
+        request.signal.removeEventListener("abort", onAbort);
+        if (!subscriber.settled) {
+            settleSubscriber(subscriber, new InferenceCancelledError(request.requestId));
+        }
+        removeSubscriber(transfer, subscriber.id);
+    });
+}
+export function startOrJoinDownload(downloadKey, startDownload, onProgress, request) {
     const existing = activeTransfers.get(downloadKey);
     if (existing && !existing.abortController.signal.aborted) {
         logger.info(`📥 Reusing existing download for: ${downloadKey}`);
-        const subscriber = createSubscriber(onProgress);
+        const subscriber = createSubscriber(onProgress, request?.requestId);
         existing.subscribers.set(subscriber.id, subscriber);
+        if (request) {
+            attachRequestBinding(existing, subscriber, request);
+        }
         if (existing.lastProgress) {
             deliverProgress(existing, subscriber, existing.lastProgress);
         }
@@ -76,9 +142,12 @@ export function startOrJoinDownload(downloadKey, startDownload, onProgress) {
         subscribers: new Map(),
         clearCache: false,
     };
-    const initialSubscriber = createSubscriber(onProgress);
+    const initialSubscriber = createSubscriber(onProgress, request?.requestId);
     transfer.subscribers.set(initialSubscriber.id, initialSubscriber);
     activeTransfers.set(downloadKey, transfer);
+    if (request) {
+        attachRequestBinding(transfer, initialSubscriber, request);
+    }
     const downloadPromise = startDownload({
         broadcastProgress: (progress) => {
             broadcastTransferProgress(transfer, progress);
@@ -110,14 +179,78 @@ export function startOrJoinDownload(downloadKey, startDownload, onProgress) {
         getCacheHit: () => transfer.cacheHit,
     };
 }
+/**
+ * Legacy cancel entry point. Callers (`cancelHandler`'s deprecated
+ * `case "downloadAsset"` arm, the shutdown sweep, intra-resolve
+ * cleanup) call this with a `downloadKey`. The single source of cancel
+ * routing is the request registry, so this function resolves each
+ * subscriber's request via `registry.cancel({ requestId })`.
+ *
+ * Subscribers without a `requestId` (legacy callers that didn't pass a
+ * registry binding) are settled directly with `DownloadCancelledError`
+ * so we don't leak the transfer if a legacy code path holds the only
+ * reference.
+ */
+/**
+ * Set `clearCache=true` on the transfer that owns the subscriber bound
+ * to `requestId`, so when the registry's targeted cancel removes that
+ * subscriber and we reach last-subscriber teardown, the partial
+ * download file is deleted instead of preserved for automatic resume.
+ *
+ * Lookup is O(transfers * subscribers); transfers are short-lived and
+ * subscriber counts per transfer are tiny in practice, so this is
+ * fine. Returns `true` if a matching subscriber was found, `false`
+ * otherwise — the cancel handler treats both cases identically (the
+ * registry cancel still fires) and the return value is informational.
+ *
+ * Added in 0.11.0 to support `cancel({ requestId, clearCache: true })`
+ * for download requests after the wire schema collapse removed the
+ * `{ operation: "downloadAsset", downloadKey, clearCache }` arm. The
+ * subscriber is the unit of `clearCache` even though the flag lives on
+ * the shared transfer: if any subscriber on the transfer asks for
+ * clearCache, the partial file is deleted when the last subscriber
+ * leaves, matching the pre-collapse behaviour.
+ */
+export function markClearCacheForRequest(requestId) {
+    for (const transfer of activeTransfers.values()) {
+        for (const sub of transfer.subscribers.values()) {
+            if (sub.requestId === requestId) {
+                transfer.clearCache = true;
+                return true;
+            }
+        }
+    }
+    return false;
+}
 export function cancelTransfer(downloadKey, clearCache = false) {
     const transfer = activeTransfers.get(downloadKey);
     if (!transfer)
         return;
     transfer.clearCache = clearCache;
-    transfer.abortController.abort();
-    for (const sub of transfer.subscribers.values()) {
+    const registry = getRequestRegistry();
+    const orphanSubs = [];
+    for (const sub of Array.from(transfer.subscribers.values())) {
+        if (sub.requestId !== undefined) {
+            registry.cancel({
+                requestId: sub.requestId,
+                reason: "download-transfer-cancel",
+            });
+        }
+        else {
+            orphanSubs.push(sub);
+        }
+    }
+    if (orphanSubs.length === 0) {
+        return;
+    }
+    // Legacy subscribers (no registry binding): settle each with
+    // `DownloadCancelledError` and route removal through the
+    // `removeSubscriber` helper so the last-subscriber teardown rule is
+    // enforced in one place. Registry-bound subscribers are handled by
+    // their `attachRequestBinding` listener triggered above.
+    for (const sub of orphanSubs) {
         settleSubscriber(sub, new DownloadCancelledError());
+        removeSubscriber(transfer, sub.id);
     }
 }
 export function createHyperdriveDownloadKey(hyperdriveKey, modelFileName) {

package/dist/server/rpc/handlers/load-model/handler.js

@@ -1,3 +1,55 @@
+var __addDisposableResource = (this && this.__addDisposableResource) || function (env, value, async) {
+    if (value !== null && value !== void 0) {
+        if (typeof value !== "object" && typeof value !== "function") throw new TypeError("Object expected.");
+        var dispose, inner;
+        if (async) {
+            if (!Symbol.asyncDispose) throw new TypeError("Symbol.asyncDispose is not defined.");
+            dispose = value[Symbol.asyncDispose];
+        }
+        if (dispose === void 0) {
+            if (!Symbol.dispose) throw new TypeError("Symbol.dispose is not defined.");
+            dispose = value[Symbol.dispose];
+            if (async) inner = dispose;
+        }
+        if (typeof dispose !== "function") throw new TypeError("Object not disposable.");
+        if (inner) dispose = function() { try { inner.call(this); } catch (e) { return Promise.reject(e); } };
+        env.stack.push({ value: value, dispose: dispose, async: async });
+    }
+    else if (async) {
+        env.stack.push({ async: true });
+    }
+    return value;
+};
+var __disposeResources = (this && this.__disposeResources) || (function (SuppressedError) {
+    return function (env) {
+        function fail(e) {
+            env.error = env.hasError ? new SuppressedError(e, env.error, "An error was suppressed during disposal.") : e;
+            env.hasError = true;
+        }
+        var r, s = 0;
+        function next() {
+            while (r = env.stack.pop()) {
+                try {
+                    if (!r.async && s === 1) return s = 0, env.stack.push(r), Promise.resolve().then(next);
+                    if (r.dispose) {
+                        var result = r.dispose.call(r.value);
+                        if (r.async) return s |= 2, Promise.resolve(result).then(next, function(e) { fail(e); return next(); });
+                    }
+                    else s |= 1;
+                }
+                catch (e) {
+                    fail(e);
+                }
+            }
+            if (s === 1) return env.hasError ? Promise.reject(env.error) : Promise.resolve();
+            if (env.hasError) throw env.error;
+        }
+        return next();
+    };
+})(typeof SuppressedError === "function" ? SuppressedError : function (error, suppressed, message) {
+    var e = new Error(message);
+    return e.name = "SuppressedError", e.error = error, e.suppressed = suppressed, e;
+});
 import { normalizeModelType, PROFILING_KEY, OPERATION_EVENT_KEY, } from "../../../../schemas/index.js";
 import { loadModel } from "../../../bare/ops/load-model.js";
 import { createResolveSession } from "./resolve-session.js";
@@ -5,120 +57,183 @@ import { nowMs, generateProfileId } from "../../../../profiling/clock.js";
 import { getModelEntry, updateModelConfig, } from "../../../bare/registry/model-registry.js";
 import { generateShortHash, canonicalConfigString, transformConfigForReload, } from "../../../utils/index.js";
 import { buildDownloadProfilingFields } from "./types.js";
-import { ConfigReloadNotSupportedError, ModelTypeMismatchError, ModelIsDelegatedError, ModelNotFoundError, ModelLoadFailedError, PluginLoadConfigValidationFailedError, PluginNotFoundError, } from "../../../../utils/errors-server.js";
+import { ConfigReloadNotSupportedError, InferenceCancelledError, ModelTypeMismatchError, ModelIsDelegatedError, ModelNotFoundError, ModelLoadFailedError, PluginLoadConfigValidationFailedError, PluginNotFoundError, } from "../../../../utils/errors-server.js";
 import { getServerLogger } from "../../../../logging/index.js";
 import { getPlugin } from "../../../plugins/index.js";
+import { getRequestRegistry, withRequestContext, } from "../../../bare/runtime/index.js";
+import { generateServerRequestId } from "../../../bare/runtime/request-id.js";
 const logger = getServerLogger();
 // ---------------------------------------------------------------------------
 // Handler
 // ---------------------------------------------------------------------------
 export async function handleLoadModel(request, progressCallback) {
-    if (isReloadConfigRequest(request)) {
-        return handleConfigReload(request);
-    }
-    const { modelSrc, modelName, seed } = request;
-    const canonicalModelType = normalizeModelType(request.modelType);
-    const profilingMeta = request[PROFILING_KEY];
-    const profilingEnabled = profilingMeta?.enabled !== false && !!profilingMeta;
+    const env_1 = { stack: [], error: void 0, hasError: false };
     try {
-        const plugin = getPlugin(canonicalModelType);
-        if (!plugin) {
-            throw new PluginNotFoundError(canonicalModelType);
+        if (isReloadConfigRequest(request)) {
+            return handleConfigReload(request);
         }
-        let resolvedModelConfig = (request.modelConfig ?? {});
-        const parseResult = plugin.loadConfigSchema.safeParse(resolvedModelConfig);
-        if (!parseResult.success) {
-            const details = parseResult.error.issues
-                .map((i) => `${String(i.path.join("."))}: ${i.message}`)
-                .join(", ");
-            throw new PluginLoadConfigValidationFailedError(canonicalModelType, details);
-        }
-        resolvedModelConfig = parseResult.data;
-        const totalLoadStart = profilingEnabled ? nowMs() : 0;
-        const session = createResolveSession({
-            progressCallback,
-            seed,
-            profilingEnabled,
-        });
-        const primaryResolve = session.resolvePrimaryModelPath(modelSrc);
-        let resolvedModelPath;
-        let pluginResolveResult;
+        const { modelSrc, modelName, seed } = request;
+        const canonicalModelType = normalizeModelType(request.modelType);
+        const profilingMeta = request[PROFILING_KEY];
+        const profilingEnabled = profilingMeta?.enabled !== false && !!profilingMeta;
+        const requestId = request.requestId ?? generateServerRequestId();
+        // The handler `modelId` is derived from the config hash below — it
+        // isn't known until after `resolveConfig` runs. The registry context
+        // is opened with `modelId: undefined` so a cancel-by-modelId fired
+        // before the load completes is a clean no-op (rather than matching a
+        // half-built entry). Cancel-by-`requestId` works from `begin(...)` on.
+        const ctx = __addDisposableResource(env_1, getRequestRegistry().begin({
+            requestId,
+            kind: "loadModel",
+        }), true);
+        const log = withRequestContext(getServerLogger(), ctx);
+        log.debug(`loadModel start modelSrc=${String(modelSrc ?? "")}`);
         try {
-            const pluginResolve = plugin.resolveConfig
-                ? Promise.resolve().then(() => plugin.resolveConfig(resolvedModelConfig, session.createResolveContext(modelSrc, canonicalModelType, modelName)))
-                : undefined;
-            [resolvedModelPath, pluginResolveResult] = pluginResolve
-                ? await Promise.all([primaryResolve, pluginResolve])
-                : [await primaryResolve, undefined];
-        }
-        catch (error) {
-            session.cancelAll();
-            throw error;
-        }
-        const configStr = canonicalConfigString(request.modelConfig);
-        const modelHashInput = `${request.modelType}:${modelSrc}:${configStr}`;
-        const modelId = generateShortHash(modelHashInput);
-        let pluginArtifacts = {};
-        if (pluginResolveResult) {
-            resolvedModelConfig = pluginResolveResult.config;
-            if (pluginResolveResult.artifacts) {
-                pluginArtifacts = pluginResolveResult.artifacts;
+            const plugin = getPlugin(canonicalModelType);
+            if (!plugin) {
+                throw new PluginNotFoundError(canonicalModelType);
             }
-        }
-        if ("modelPath" in pluginArtifacts) {
-            throw new ModelLoadFailedError("Plugin returned reserved key \"modelPath\" in artifacts; primary model resolution is core-owned");
-        }
-        if (!resolvedModelPath) {
-            throw new ModelLoadFailedError("modelPath resolution failed");
-        }
-        const loadResult = await loadModel({
-            modelId,
-            modelPath: resolvedModelPath,
-            options: {
-                ...request,
-                modelType: canonicalModelType,
-                modelConfig: resolvedModelConfig,
-            },
-            artifacts: Object.keys(pluginArtifacts).length > 0 ? pluginArtifacts : undefined,
-            modelName,
-        }, profilingEnabled ? { collectTiming: true } : undefined);
-        const response = {
-            type: "loadModel",
-            success: true,
-            modelId,
-        };
-        if (profilingEnabled) {
-            const totalLoadTimeMs = nowMs() - totalLoadStart;
-            const profileId = profilingMeta?.id ?? generateProfileId();
-            const resolveResult = session.getAggregateResult();
-            const { gauges, tags } = buildDownloadProfilingFields(resolveResult?.downloadStats, resolveResult?.sourceType);
-            gauges["totalLoadTime"] = totalLoadTimeMs;
-            if (loadResult.timing?.modelInitializationTimeMs !== undefined) {
-                gauges["modelInitializationTime"] =
-                    loadResult.timing.modelInitializationTimeMs;
+            let resolvedModelConfig = (request.modelConfig ?? {});
+            const parseResult = plugin.loadConfigSchema.safeParse(resolvedModelConfig);
+            if (!parseResult.success) {
+                const details = parseResult.error.issues
+                    .map((i) => `${String(i.path.join("."))}: ${i.message}`)
+                    .join(", ");
+                throw new PluginLoadConfigValidationFailedError(canonicalModelType, details);
+            }
+            resolvedModelConfig = parseResult.data;
+            const totalLoadStart = profilingEnabled ? nowMs() : 0;
+            const session = createResolveSession({
+                progressCallback,
+                seed,
+                profilingEnabled,
+                signal: ctx.signal,
+                requestBinding: {
+                    signal: ctx.signal,
+                    scope: ctx.scope,
+                    requestId,
+                },
+            });
+            const primaryResolve = session.resolvePrimaryModelPath(modelSrc);
+            let resolvedModelPath;
+            let pluginResolveResult;
+            try {
+                const pluginResolve = plugin.resolveConfig
+                    ? Promise.resolve().then(() => plugin.resolveConfig(resolvedModelConfig, session.createResolveContext(modelSrc, canonicalModelType, modelName)))
+                    : undefined;
+                [resolvedModelPath, pluginResolveResult] = pluginResolve
+                    ? await Promise.all([primaryResolve, pluginResolve])
+                    : [await primaryResolve, undefined];
+            }
+            catch (error) {
+                session.cancelAll();
+                throw error;
+            }
+            // Phase boundary between download and load. The bare load path
+            // (`plugin.createModel(...)` / `model.load(false)`) does not accept
+            // an abort signal today, so the only honest cancel hook here is the
+            // pre-load gate: if cancel arrived during download / resolveConfig,
+            // surface `InferenceCancelledError` before sinking time into the
+            // addon work.
+            if (ctx.signal.aborted) {
+                throw new InferenceCancelledError(requestId);
+            }
+            const configStr = canonicalConfigString(request.modelConfig);
+            const modelHashInput = `${request.modelType}:${modelSrc}:${configStr}`;
+            const modelId = generateShortHash(modelHashInput);
+            let pluginArtifacts = {};
+            if (pluginResolveResult) {
+                resolvedModelConfig = pluginResolveResult.config;
+                if (pluginResolveResult.artifacts) {
+                    pluginArtifacts = pluginResolveResult.artifacts;
+                }
             }
-            if (canonicalModelType) {
-                tags["modelType"] = canonicalModelType;
+            if ("modelPath" in pluginArtifacts) {
+                throw new ModelLoadFailedError("Plugin returned reserved key \"modelPath\" in artifacts; primary model resolution is core-owned");
             }
-            const operationEvent = {
-                op: "loadModel",
-                kind: "handler",
-                ms: totalLoadTimeMs,
-                profileId,
-                gauges: Object.keys(gauges).length > 0 ? gauges : undefined,
-                tags: Object.keys(tags).length > 0 ? tags : undefined,
+            if (!resolvedModelPath) {
+                throw new ModelLoadFailedError("modelPath resolution failed");
+            }
+            const loadResult = await loadModel({
+                modelId,
+                modelPath: resolvedModelPath,
+                options: {
+                    ...request,
+                    modelType: canonicalModelType,
+                    modelConfig: resolvedModelConfig,
+                },
+                artifacts: Object.keys(pluginArtifacts).length > 0 ? pluginArtifacts : undefined,
+                modelName,
+            }, profilingEnabled ? { collectTiming: true } : undefined);
+            // Load phase soft-cancel limitation: `plugin.createModel(...)` and
+            // `model.load(false)` ran without a signal. A cancel that arrived
+            // during the load phase has just landed in the registry but the
+            // model is now loaded and registered. Surface
+            // `InferenceCancelledError` so the caller's promise rejects
+            // consistently — even though the model state is the "loaded"
+            // post-condition. The orphan-model edge case is a known
+            // limitation that requires a per-load cancel surface on the addon
+            // to fix end-to-end.
+            if (ctx.signal.aborted) {
+                throw new InferenceCancelledError(requestId);
+            }
+            const response = {
+                type: "loadModel",
+                success: true,
+                modelId,
+            };
+            if (profilingEnabled) {
+                const totalLoadTimeMs = nowMs() - totalLoadStart;
+                const profileId = profilingMeta?.id ?? generateProfileId();
+                const resolveResult = session.getAggregateResult();
+                const { gauges, tags } = buildDownloadProfilingFields(resolveResult?.downloadStats, resolveResult?.sourceType);
+                gauges["totalLoadTime"] = totalLoadTimeMs;
+                if (loadResult.timing?.modelInitializationTimeMs !== undefined) {
+                    gauges["modelInitializationTime"] =
+                        loadResult.timing.modelInitializationTimeMs;
+                }
+                if (canonicalModelType) {
+                    tags["modelType"] = canonicalModelType;
+                }
+                const operationEvent = {
+                    op: "loadModel",
+                    kind: "handler",
+                    ms: totalLoadTimeMs,
+                    profileId,
+                    gauges: Object.keys(gauges).length > 0 ? gauges : undefined,
+                    tags: Object.keys(tags).length > 0 ? tags : undefined,
+                };
+                response[OPERATION_EVENT_KEY] = operationEvent;
+            }
+            return response;
+        }
+        catch (error) {
+            // `InferenceCancelledError` rides the rejection path verbatim: the
+            // client side wants a typed cancel error on the promise it `await`s,
+            // not a `{ success: false, error }` envelope that surfaces as a
+            // generic `ModelLoadFailedError`. Every other error keeps the
+            // legacy `success: false` shape for backward compat with consumers
+            // that switch on the envelope.
+            if (error instanceof InferenceCancelledError) {
+                log.info(`loadModel cancelled requestId=${requestId}`);
+                throw error;
+            }
+            logger.error("Error loading model:", error);
+            return {
+                type: "loadModel",
+                success: false,
+                error: error instanceof Error ? error.message : "Unknown error",
             };
-            response[OPERATION_EVENT_KEY] = operationEvent;
         }
-        return response;
     }
-    catch (error) {
-        logger.error("Error loading model:", error);
-        return {
-            type: "loadModel",
-            success: false,
-            error: error instanceof Error ? error.message : "Unknown error",
-        };
+    catch (e_1) {
+        env_1.error = e_1;
+        env_1.hasError = true;
+    }
+    finally {
+        const result_1 = __disposeResources(env_1);
+        if (result_1)
+            await result_1;
     }
 }
 async function handleConfigReload(request) {

package/dist/server/rpc/handlers/load-model/http.js

@@ -398,7 +398,7 @@ export async function downloadModelFromHttp(url, progressCallback, hooks) {
             const errorToThrow = error instanceof Error ? error : new Error(String(error));
             throw errorToThrow;
         }
-    }, progressCallback);
+    }, progressCallback, hooks?.requestBinding);
     return applyJoinedDownloadStats(result, hooks);
 }
 async function downloadShardedModelFromHttp(shardUrl, progressCallback, hooks) {
@@ -484,7 +484,7 @@ async function downloadShardedModelFromHttp(shardUrl, progressCallback, hooks) {
             }
             throw error;
         }
-    }, progressCallback);
+    }, progressCallback, hooks?.requestBinding);
     return applyJoinedDownloadStats(result, hooks);
 }
 async function downloadShardedModelFromArchive(archiveUrl, progressCallback, hooks) {
@@ -591,7 +591,7 @@ async function downloadShardedModelFromArchive(archiveUrl, progressCallback, hoo
             }
             return firstShardPath;
         }
-    }, progressCallback);
+    }, progressCallback, hooks?.requestBinding);
     return applyJoinedDownloadStats(result, hooks);
 }
 async function downloadShardsWithConcurrency(shardsToDownload, allShards, concurrency, signal, downloadKey, overallTotal, progressCallback) {

package/dist/server/rpc/handlers/load-model/hyperdrive.js

@@ -557,6 +557,6 @@ export async function downloadModelFromHyperdrive(hyperdriveKey, modelFileName,
         const checksumToValidate = expectedChecksum || model?.sha256Checksum || "";
         await downloadSingleFileToFilesystem(modelPath, modelFileName, hyperdriveKey, corestoreDir, downloadKey, checksumToValidate, ctx.broadcastProgress, seed, ctx.signal, hooks, ctx.shouldClearCache);
         return modelPath;
-    }, progressCallback);
+    }, progressCallback, hooks?.requestBinding);
     return applyJoinedDownloadStats(result, hooks);
 }

package/dist/server/rpc/handlers/load-model/registry.js

@@ -298,6 +298,6 @@ export async function downloadModelFromRegistry(registryPath, registrySource, pr
             throw error;
         }
         return modelPath;
-    }, progressCallback);
+    }, progressCallback, hooks?.requestBinding);
     return applyJoinedDownloadStats(result, hooks);
 }

package/dist/server/rpc/handlers/load-model/resolve-session.d.ts

@@ -1,9 +1,28 @@
+import type { AbortSignal } from "bare-abort-controller";
 import type { ModelProgressUpdate, ResolveContext } from "../../../../schemas/index";
-import type { ResolveResult } from "./types";
+import type { DownloadRequestBinding, ResolveResult } from "./types";
 export interface ResolveSessionOptions {
     progressCallback?: ((update: ModelProgressUpdate) => void) | undefined;
     seed?: boolean | undefined;
     profilingEnabled: boolean;
+    /**
+     * Optional cancel signal — typically `ctx.signal` from the surrounding
+     * `await using ctx = registry.begin(...)` block. When provided,
+     * `resolveModelPath` short-circuits with `InferenceCancelledError` if the
+     * signal is already aborted on entry; the same signal also propagates
+     * to in-progress transfers via the request binding below so cancel
+     * tears them down end-to-end.
+     */
+    signal?: AbortSignal | undefined;
+    /**
+     * Optional per-request binding threaded into every `startOrJoinDownload`
+     * call. The download manager wires a per-subscriber abort listener
+     * against `binding.signal`, registers a scope-defer cleanup, and stamps
+     * the subscriber with `binding.requestId` so the legacy
+     * `cancelTransfer(downloadKey)` path can route through
+     * `registry.cancel({ requestId })`.
+     */
+    requestBinding?: DownloadRequestBinding | undefined;
 }
 export interface ResolveSession {
     resolvePrimaryModelPath(modelSrc: unknown): Promise<string>;

package/dist/server/rpc/handlers/load-model/resolve-session.js

@@ -2,7 +2,7 @@ import { resolveModelPath, resolveModelPathWithStats, } from "./resolve.js";
 import { cancelTransfer } from "./download-manager.js";
 import { mergeDownloadStats } from "./download-stats.js";
 export function createResolveSession(options) {
-    const { progressCallback, seed, profilingEnabled } = options;
+    const { progressCallback, seed, profilingEnabled, signal, requestBinding } = options;
     let primaryResult;
     const resolveResults = [];
     const activeDownloadKeys = new Set();
@@ -10,23 +10,24 @@ export function createResolveSession(options) {
         onDownloadKey(key) {
             activeDownloadKeys.add(key);
         },
+        ...(requestBinding !== undefined && { requestBinding }),
     };
     async function resolvePrimaryModelPath(modelSrc) {
         if (profilingEnabled) {
-            const result = await resolveModelPathWithStats(modelSrc, progressCallback, seed, downloadHooks);
+            const result = await resolveModelPathWithStats(modelSrc, progressCallback, seed, signal, downloadHooks);
             primaryResult = result;
             resolveResults.push(result);
             return result.path;
         }
-        return resolveModelPath(modelSrc, progressCallback, seed, downloadHooks);
+        return resolveModelPath(modelSrc, progressCallback, seed, signal, downloadHooks);
     }
     async function resolveForPlugin(src) {
         if (profilingEnabled) {
-            const result = await resolveModelPathWithStats(src, progressCallback, seed, downloadHooks);
+            const result = await resolveModelPathWithStats(src, progressCallback, seed, signal, downloadHooks);
             resolveResults.push(result);
             return result.path;
         }
-        return resolveModelPath(src, progressCallback, seed, downloadHooks);
+        return resolveModelPath(src, progressCallback, seed, signal, downloadHooks);
     }
     function createResolveContext(modelSrc, modelType, modelName) {
         return {