veryfront 0.1.1127 → 0.1.1132

package/esm/src/server/runtime-handler/project-runtime-context.js

@@ -0,0 +1,181 @@
+import { getHostEnv } from "../../platform/compat/process.js";
+import { normalizeSourceIntegrationPolicy } from "../../integrations/source-policy.js";
+import { createRequestContext } from "../context/request-context.js";
+import { isProxyTrusted } from "../utils/proxy-trust.js";
+import { getEffectiveRequestHost } from "../utils/request-host.js";
+import { resolveAdapter } from "./adapter-factory.js";
+import { resolveEnvironment } from "./environment-resolution.js";
+import { buildHandlerContext } from "./handler-context-builder.js";
+import { extractRequestHeaders, resolveProject } from "./project-resolution.js";
+import { isLightweightPath, isWebSocketPath, shouldSkipEnrichedContext } from "./request-utils.js";
+export async function prepareProjectRequest(input) {
+    const { req, url, isProxyMode } = input;
+    const proxyTrusted = isProxyMode
+        ? await (input.trustProxy ?? isProxyTrusted)(req, {
+            publicKeyPem: input.adapterEnv?.get("CHANNEL_DISPATCH_SIGNING_PUBLIC_KEY") ??
+                getHostEnv("CHANNEL_DISPATCH_SIGNING_PUBLIC_KEY"),
+        })
+        : undefined;
+    const headers = extractRequestHeaders(req, url, proxyTrusted);
+    const requestContext = createRequestContext(req, { proxyTrusted });
+    const hostHeader = req.headers.get("host") ?? url.host;
+    const domain = hostHeader.replace(/:\d+$/, "");
+    return {
+        url,
+        headers,
+        requestContext,
+        proxyTrust: { proxyTrusted },
+        loggerFacts: {
+            domain,
+            projectSlug: headers.projectSlug,
+            projectId: headers.projectId,
+            releaseId: headers.releaseId,
+            branchId: headers.branchId,
+            branchName: headers.branchName,
+            pathname: url.pathname,
+        },
+        trackingFacts: {
+            projectSlug: headers.projectSlug,
+            pathname: url.pathname,
+            method: req.method,
+            environment: headers.environment,
+            releaseId: headers.releaseId,
+        },
+        proxyGuard: createProxyGuard(req, url, isProxyMode, headers, proxyTrusted),
+    };
+}
+export async function resolveProjectIdentity(input) {
+    if (input.operation && input.operation !== "identity") {
+        throw new Error(`Unsupported project runtime context operation: ${input.operation}`);
+    }
+    return await resolveProject(input.req, input.url, input.headers, {
+        config: input.config,
+        reqCtx: input.requestContext,
+        defaultProjectSlug: input.defaultProjectSlug,
+        defaultProjectId: input.defaultProjectId,
+        defaultReleaseId: input.defaultReleaseId,
+        wsSlugOverride: input.wsSlugOverride,
+        proxyTrusted: input.proxyTrust.proxyTrusted,
+    });
+}
+export async function resolveProjectRuntimeContext(input) {
+    const projectRes = input.projectIdentity;
+    const reqCtx = input.requestContext;
+    const profileAdapter = input.profileAdapter ?? ((operation) => operation());
+    const profileEnvVars = input.profileEnvVars ?? ((operation) => operation());
+    const adapterRes = await profileAdapter(() => resolveAdapter({
+        req: input.req,
+        projectDir: input.projectDir,
+        adapter: input.adapter,
+        config: input.config,
+        projectSlug: projectRes.projectSlug,
+        projectId: projectRes.projectId,
+        proxyToken: reqCtx.token,
+        releaseId: projectRes.releaseId,
+        proxyEnv: projectRes.proxyEnv,
+        branch: reqCtx.branch,
+        environmentName: projectRes.environmentName,
+        parsedDomain: projectRes.parsedDomain,
+        pathname: input.url.pathname,
+        isProxyMode: input.isProxyMode,
+        proxyTrusted: input.proxyTrust.proxyTrusted,
+    }));
+    const host = getEffectiveRequestHost(input.req, input.url, input.proxyTrust.proxyTrusted ?? getHostEnv("VERYFRONT_TRUST_FORWARDED_HEADERS") === "1");
+    const envRes = resolveEnvironment({
+        proxyEnv: projectRes.proxyEnv,
+        reqCtxMode: reqCtx.mode,
+        releaseId: projectRes.releaseId,
+        projectSlug: projectRes.projectSlug,
+        projectId: projectRes.projectId,
+        environmentName: projectRes.environmentName,
+        host,
+        isLocalProject: adapterRes.isLocalProject,
+        isProxyMode: input.isProxyMode,
+        pathname: input.url.pathname,
+        defaultEnvironment: input.defaultEnvironment,
+    });
+    input.onEnvironmentResolved?.(envRes);
+    if (envRes.errorResponse) {
+        return {
+            adapter: adapterRes,
+            environment: envRes,
+            handlerContext: undefined,
+            rawEnvVars: {},
+            sourceIntegrationPolicy: normalizeSourceIntegrationPolicy(undefined),
+        };
+    }
+    const handlerContext = buildHandlerContext({
+        projectDir: adapterRes.projectDir,
+        adapter: adapterRes.adapter,
+        securityConfig: input.securityConfig,
+        cspUserHeader: input.cspUserHeader,
+        debug: input.debug,
+        config: adapterRes.config,
+        parsedDomain: projectRes.parsedDomain,
+        projectSlug: projectRes.projectSlug,
+        projectId: projectRes.projectId,
+        releaseId: envRes.releaseId,
+        proxyToken: reqCtx.token,
+        environmentName: projectRes.environmentName,
+        resolvedEnvironment: envRes.resolvedEnvironment ?? "preview",
+        requestContext: reqCtx,
+        routeRegistry: input.routeRegistry,
+        isLocalProject: adapterRes.isLocalProject,
+        moduleServerUrl: input.moduleServerUrl,
+        environmentId: input.environmentId ?? input.headers.environmentId,
+        skipEnrichedContext: input.skipEnrichedContext ?? shouldSkipEnrichedContext(input.url.pathname),
+    });
+    let rawEnvVars = {};
+    const environmentId = input.environmentId ?? input.headers.environmentId;
+    if (!adapterRes.isLocalProject &&
+        environmentId &&
+        reqCtx.token &&
+        projectRes.projectSlug) {
+        const projectSlug = projectRes.projectSlug;
+        rawEnvVars = await profileEnvVars(() => input.envVarCache.get(environmentId, reqCtx.token, projectSlug));
+        input.logDebug?.("[runtime-handler] Project env vars fetched", {
+            projectSlug,
+            environmentId,
+            count: Object.keys(rawEnvVars).length,
+        });
+    }
+    const sourceIntegrationPolicy = normalizeSourceIntegrationPolicy(adapterRes.config?.integrations);
+    return {
+        adapter: adapterRes,
+        environment: envRes,
+        handlerContext,
+        rawEnvVars,
+        sourceIntegrationPolicy,
+    };
+}
+function createProxyGuard(req, url, isProxyMode, headers, proxyTrusted) {
+    if (!isProxyMode || isLightweightPath(url.pathname) || isWebSocketPath(url.pathname)) {
+        return undefined;
+    }
+    const token = req.headers.get("x-token");
+    const body = !headers.projectSlug
+        ? {
+            error: "Missing project context",
+            detail: "x-project-slug header is required in proxy mode",
+        }
+        : !token
+            ? {
+                error: "Missing authentication context",
+                detail: "x-token header is required in proxy mode",
+            }
+            : req.headers.get("x-project-path") && !proxyTrusted
+                ? {
+                    error: "Untrusted proxy context",
+                    detail: "proxy context headers require a trusted upstream proxy",
+                }
+                : undefined;
+    if (!body)
+        return undefined;
+    return {
+        detail: body.detail,
+        response: new Response(JSON.stringify(body), {
+            status: 502,
+            headers: { "Content-Type": "application/json" },
+        }),
+    };
+}

package/esm/src/server/services/rsc/orchestrators/handler.d.ts

@@ -16,6 +16,7 @@ export declare class RSCDevServerHandler {
     private renderer;
     private clientManifest;
     private rendererPromise;
+    private reactVersionPromise;
     private invalidationGeneration;
     private readonly manifestHandler;
     private readonly renderHandler;
@@ -25,8 +26,8 @@ export declare class RSCDevServerHandler {
     private readonly appDir;
     private readonly isLocalProject;
     private readonly mode;
-    private readonly reactVersionPromise;
     private readonly fs?;
+    private readonly config?;
     handleManifest(): Promise<Response>;
     handleRender(pathname: string, searchParams: URLSearchParams, request?: Request): Promise<Response>;
     handleStream(pathname: string, searchParams: URLSearchParams): Promise<Response>;
@@ -34,5 +35,6 @@ export declare class RSCDevServerHandler {
     invalidate(): void;
     private ensureRenderer;
     private initializeRenderer;
+    private getReactVersion;
 }
 //# sourceMappingURL=handler.d.ts.map

package/esm/src/server/services/rsc/orchestrators/handler.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"handler.d.ts","sourceRoot":"","sources":["../../../../../../src/src/server/services/rsc/orchestrators/handler.ts"],"names":[],"mappings":"AAOA,OAAO,KAAK,EAAE,eAAe,EAAE,MAAM,6BAA6B,CAAC;AAEnE,OAAO,KAAK,EAAE,cAAc,EAAE,MAAM,uCAAuC,CAAC;AAE5E,MAAM,WAAW,uBAAuB;IACtC,MAAM,CAAC,EAAE,eAAe,CAAC;IACzB,cAAc,CAAC,EAAE,OAAO,CAAC;IACzB,IAAI,CAAC,EAAE,aAAa,GAAG,YAAY,CAAC;IACpC,OAAO,CAAC,EAAE,cAAc,CAAC;IACzB,SAAS,CAAC,EAAE,MAAM,CAAC;IACnB,WAAW,CAAC,EAAE,MAAM,CAAC;IACrB,eAAe,CAAC,EAAE,MAAM,CAAC;IACzB,SAAS,CAAC,EAAE,MAAM,CAAC;CACpB;AAED,wBAAgB,4BAA4B,CAAC,MAAM,CAAC,EAAE,eAAe,GAAG,MAAM,GAAG,SAAS,CAKzF;AAED,qBAAa,mBAAmB;IAY5B,OAAO,CAAC,QAAQ,CAAC,UAAU;IAX7B,OAAO,CAAC,QAAQ,CAA4B;IAC5C,OAAO,CAAC,cAAc,CAAiD;IACvE,OAAO,CAAC,eAAe,CAA8B;IACrD,OAAO,CAAC,sBAAsB,CAAK;IAEnC,OAAO,CAAC,QAAQ,CAAC,eAAe,CAAkB;IAClD,OAAO,CAAC,QAAQ,CAAC,aAAa,CAAgB;IAC9C,OAAO,CAAC,QAAQ,CAAC,aAAa,CAAgB;IAC9C,OAAO,CAAC,WAAW,CAA4B;gBAG5B,UAAU,EAAE,MAAM,EACnC,OAAO,GAAE,uBAA4B;IAqCvC,OAAO,CAAC,QAAQ,CAAC,MAAM,CAAS;IAChC,OAAO,CAAC,QAAQ,CAAC,cAAc,CAAU;IACzC,OAAO,CAAC,QAAQ,CAAC,IAAI,CAA+B;IACpD,OAAO,CAAC,QAAQ,CAAC,mBAAmB,CAAkB;IACtD,OAAO,CAAC,QAAQ,CAAC,EAAE,CAAC,CAAuB;IAE3C,cAAc,IAAI,OAAO,CAAC,QAAQ,CAAC;IAI7B,YAAY,CAChB,QAAQ,EAAE,MAAM,EAChB,YAAY,EAAE,eAAe,EAC7B,OAAO,CAAC,EAAE,OAAO,GAChB,OAAO,CAAC,QAAQ,CAAC;IAKd,YAAY,CAAC,QAAQ,EAAE,MAAM,EAAE,YAAY,EAAE,eAAe,GAAG,OAAO,CAAC,QAAQ,CAAC;IAKhF,UAAU,CACd,QAAQ,EAAE,MAAM,EAChB,YAAY,EAAE,eAAe,EAC7B,KAAK,CAAC,EAAE,MAAM,GACb,OAAO,CAAC,QAAQ,CAAC;IAWpB,UAAU,IAAI,IAAI;YAOJ,cAAc;YAed,kBAAkB;CAejC"}
+{"version":3,"file":"handler.d.ts","sourceRoot":"","sources":["../../../../../../src/src/server/services/rsc/orchestrators/handler.ts"],"names":[],"mappings":"AAOA,OAAO,KAAK,EAAE,eAAe,EAAE,MAAM,6BAA6B,CAAC;AAEnE,OAAO,KAAK,EAAE,cAAc,EAAE,MAAM,uCAAuC,CAAC;AAE5E,MAAM,WAAW,uBAAuB;IACtC,MAAM,CAAC,EAAE,eAAe,CAAC;IACzB,cAAc,CAAC,EAAE,OAAO,CAAC;IACzB,IAAI,CAAC,EAAE,aAAa,GAAG,YAAY,CAAC;IACpC,OAAO,CAAC,EAAE,cAAc,CAAC;IACzB,SAAS,CAAC,EAAE,MAAM,CAAC;IACnB,WAAW,CAAC,EAAE,MAAM,CAAC;IACrB,eAAe,CAAC,EAAE,MAAM,CAAC;IACzB,SAAS,CAAC,EAAE,MAAM,CAAC;CACpB;AAED,wBAAgB,4BAA4B,CAAC,MAAM,CAAC,EAAE,eAAe,GAAG,MAAM,GAAG,SAAS,CAKzF;AAED,qBAAa,mBAAmB;IAa5B,OAAO,CAAC,QAAQ,CAAC,UAAU;IAZ7B,OAAO,CAAC,QAAQ,CAA4B;IAC5C,OAAO,CAAC,cAAc,CAAiD;IACvE,OAAO,CAAC,eAAe,CAA8B;IACrD,OAAO,CAAC,mBAAmB,CAAgC;IAC3D,OAAO,CAAC,sBAAsB,CAAK;IAEnC,OAAO,CAAC,QAAQ,CAAC,eAAe,CAAkB;IAClD,OAAO,CAAC,QAAQ,CAAC,aAAa,CAAgB;IAC9C,OAAO,CAAC,QAAQ,CAAC,aAAa,CAAgB;IAC9C,OAAO,CAAC,WAAW,CAA4B;gBAG5B,UAAU,EAAE,MAAM,EACnC,OAAO,GAAE,uBAA4B;IAkCvC,OAAO,CAAC,QAAQ,CAAC,MAAM,CAAS;IAChC,OAAO,CAAC,QAAQ,CAAC,cAAc,CAAU;IACzC,OAAO,CAAC,QAAQ,CAAC,IAAI,CAA+B;IACpD,OAAO,CAAC,QAAQ,CAAC,EAAE,CAAC,CAAuB;IAC3C,OAAO,CAAC,QAAQ,CAAC,MAAM,CAAC,CAAkB;IAE1C,cAAc,IAAI,OAAO,CAAC,QAAQ,CAAC;IAI7B,YAAY,CAChB,QAAQ,EAAE,MAAM,EAChB,YAAY,EAAE,eAAe,EAC7B,OAAO,CAAC,EAAE,OAAO,GAChB,OAAO,CAAC,QAAQ,CAAC;IAKd,YAAY,CAAC,QAAQ,EAAE,MAAM,EAAE,YAAY,EAAE,eAAe,GAAG,OAAO,CAAC,QAAQ,CAAC;IAKhF,UAAU,CACd,QAAQ,EAAE,MAAM,EAChB,YAAY,EAAE,eAAe,EAC7B,KAAK,CAAC,EAAE,MAAM,GACb,OAAO,CAAC,QAAQ,CAAC;IAWpB,UAAU,IAAI,IAAI;YAOJ,cAAc;YAed,kBAAkB;IAgBhC,OAAO,CAAC,eAAe;CAOxB"}

package/esm/src/server/services/rsc/orchestrators/handler.js

@@ -16,6 +16,7 @@ export class RSCDevServerHandler {
     renderer = null;
     clientManifest = null;
     rendererPromise = null;
+    reactVersionPromise = null;
     invalidationGeneration = 0;
     manifestHandler;
     renderHandler;
@@ -34,28 +35,25 @@ export class RSCDevServerHandler {
             fs: options.adapter?.fs,
             contentSourceId,
         });
-        this.reactVersionPromise = resolveProjectReactVersion({
-            projectDir,
-            config: options.config,
-        });
         this.renderHandler = new RenderHandler(projectDir, () => this.renderer, mode, appDir, {
             adapter: options.adapter,
             projectId: options.projectId,
             projectSlug: options.projectSlug,
             contentSourceId,
-            reactVersion: this.reactVersionPromise,
+            reactVersion: () => this.getReactVersion(),
         });
         this.streamHandler = new StreamHandler(this.renderHandler);
         this.appDir = appDir;
         this.isLocalProject = isLocalProject;
         this.mode = mode;
         this.fs = options.adapter?.fs;
+        this.config = options.config;
     }
     appDir;
     isLocalProject;
     mode;
-    reactVersionPromise;
     fs;
+    config;
     handleManifest() {
         return this.manifestHandler.handle(this.clientManifest);
     }
@@ -69,7 +67,7 @@ export class RSCDevServerHandler {
     }
     async handlePage(pathname, searchParams, nonce) {
         if (!this.pageHandler) {
-            this.pageHandler = new PageHandler(this.mode === "development", await this.reactVersionPromise, this.isLocalProject ? "fs" : "rsc-module");
+            this.pageHandler = new PageHandler(this.mode === "development", await this.getReactVersion(), this.isLocalProject ? "fs" : "rsc-module");
         }
         return this.pageHandler.handle(pathname, searchParams, nonce);
     }
@@ -96,7 +94,7 @@ export class RSCDevServerHandler {
     }
     async initializeRenderer(generation) {
         const clientManifest = await buildClientManifest(this.projectDir, this.appDir, this.fs);
-        const reactVersion = await this.reactVersionPromise;
+        const reactVersion = await this.getReactVersion();
         if (generation !== this.invalidationGeneration)
             return;
         this.clientManifest = clientManifest;
@@ -109,4 +107,11 @@ export class RSCDevServerHandler {
             reactVersion,
         });
     }
+    getReactVersion() {
+        this.reactVersionPromise ??= resolveProjectReactVersion({
+            projectDir: this.projectDir,
+            config: this.config,
+        });
+        return this.reactVersionPromise;
+    }
 }

package/esm/src/server/services/rsc/orchestrators/render-handler.d.ts

@@ -5,7 +5,7 @@ interface RenderHandlerModuleOptions {
     projectId?: string;
     projectSlug?: string;
     contentSourceId?: string;
-    reactVersion?: Promise<string>;
+    reactVersion?: () => Promise<string>;
 }
 export declare class RenderHandler {
     private projectDir;

package/esm/src/server/services/rsc/orchestrators/render-handler.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"render-handler.d.ts","sourceRoot":"","sources":["../../../../../../src/src/server/services/rsc/orchestrators/render-handler.ts"],"names":[],"mappings":"AAGA,OAAO,KAAK,EAAE,WAAW,EAAE,MAAM,oDAAoD,CAAC;AActF,OAAO,KAAK,EAAE,cAAc,EAAE,MAAM,uCAAuC,CAAC;AAM5E,UAAU,0BAA0B;IAClC,OAAO,CAAC,EAAE,cAAc,CAAC;IACzB,SAAS,CAAC,EAAE,MAAM,CAAC;IACnB,WAAW,CAAC,EAAE,MAAM,CAAC;IACrB,eAAe,CAAC,EAAE,MAAM,CAAC;IACzB,YAAY,CAAC,EAAE,OAAO,CAAC,MAAM,CAAC,CAAC;CAChC;AASD,qBAAa,aAAa;IAEtB,OAAO,CAAC,UAAU;IAClB,OAAO,CAAC,WAAW;IACnB,OAAO,CAAC,IAAI;IACZ,OAAO,CAAC,MAAM;IACd,OAAO,CAAC,aAAa;gBAJb,UAAU,EAAE,MAAM,EAClB,WAAW,EAAE,MAAM,WAAW,GAAG,IAAI,EACrC,IAAI,GAAE,aAAa,GAAG,YAA2B,EACjD,MAAM,GAAE,MAAc,EACtB,aAAa,GAAE,0BAA+B;IAGlD,MAAM,CACV,QAAQ,EAAE,MAAM,EAChB,YAAY,EAAE,eAAe,EAC7B,OAAO,CAAC,EAAE,OAAO,GAChB,OAAO,CAAC,QAAQ,CAAC;YAWN,aAAa;YA+Bb,mBAAmB;IA2CjC,OAAO,CAAC,UAAU;YAOJ,aAAa;IA2B3B,OAAO,CAAC,cAAc;IAYtB,OAAO,CAAC,eAAe;IAIvB,OAAO,CAAC,YAAY;IAmBpB,OAAO,CAAC,mBAAmB;CA6B5B"}
+{"version":3,"file":"render-handler.d.ts","sourceRoot":"","sources":["../../../../../../src/src/server/services/rsc/orchestrators/render-handler.ts"],"names":[],"mappings":"AAGA,OAAO,KAAK,EAAE,WAAW,EAAE,MAAM,oDAAoD,CAAC;AActF,OAAO,KAAK,EAAE,cAAc,EAAE,MAAM,uCAAuC,CAAC;AAM5E,UAAU,0BAA0B;IAClC,OAAO,CAAC,EAAE,cAAc,CAAC;IACzB,SAAS,CAAC,EAAE,MAAM,CAAC;IACnB,WAAW,CAAC,EAAE,MAAM,CAAC;IACrB,eAAe,CAAC,EAAE,MAAM,CAAC;IACzB,YAAY,CAAC,EAAE,MAAM,OAAO,CAAC,MAAM,CAAC,CAAC;CACtC;AASD,qBAAa,aAAa;IAEtB,OAAO,CAAC,UAAU;IAClB,OAAO,CAAC,WAAW;IACnB,OAAO,CAAC,IAAI;IACZ,OAAO,CAAC,MAAM;IACd,OAAO,CAAC,aAAa;gBAJb,UAAU,EAAE,MAAM,EAClB,WAAW,EAAE,MAAM,WAAW,GAAG,IAAI,EACrC,IAAI,GAAE,aAAa,GAAG,YAA2B,EACjD,MAAM,GAAE,MAAc,EACtB,aAAa,GAAE,0BAA+B;IAGlD,MAAM,CACV,QAAQ,EAAE,MAAM,EAChB,YAAY,EAAE,eAAe,EAC7B,OAAO,CAAC,EAAE,OAAO,GAChB,OAAO,CAAC,QAAQ,CAAC;YAWN,aAAa;YA+Bb,mBAAmB;IA2CjC,OAAO,CAAC,UAAU;YAOJ,aAAa;IA2B3B,OAAO,CAAC,cAAc;IAYtB,OAAO,CAAC,eAAe;IAIvB,OAAO,CAAC,YAAY;IAmBpB,OAAO,CAAC,mBAAmB;CA6B5B"}

package/esm/src/server/services/rsc/orchestrators/render-handler.js

@@ -61,7 +61,7 @@ export class RenderHandler {
                 : await fs.readTextFile(componentPath);
             const { body, frontmatter } = extractFrontmatter(source);
             const compiled = await compileContent(this.mode, this.projectDir, body, frontmatter, componentPath, "server");
-            return await mdxRenderer.loadModuleESM(compiled.compiledCode, adapter, this.moduleOptions.projectId ?? this.projectDir, this.projectDir, this.moduleOptions.projectSlug, this.moduleOptions.contentSourceId, await this.moduleOptions.reactVersion);
+            return await mdxRenderer.loadModuleESM(compiled.compiledCode, adapter, this.moduleOptions.projectId ?? this.projectDir, this.projectDir, this.moduleOptions.projectSlug, this.moduleOptions.contentSourceId, await this.moduleOptions.reactVersion?.());
         }
         if (!adapter) {
             return (await import(componentPath));
@@ -73,7 +73,7 @@ export class RenderHandler {
             contentSourceId: this.moduleOptions.contentSourceId,
             dev: this.mode === "development",
             mode: this.mode === "development" ? "preview" : "production",
-            reactVersion: await this.moduleOptions.reactVersion,
+            reactVersion: await this.moduleOptions.reactVersion?.(),
         });
     }
     buildProps(pathname, searchParams) {

package/esm/src/transforms/esm/http-cache.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"http-cache.d.ts","sourceRoot":"","sources":["../../../../src/src/transforms/esm/http-cache.ts"],"names":[],"mappings":"AAAA;;;;;;;GAOG;AAeH,OAAO,EACL,eAAe,EACf,uBAAuB,EACvB,oBAAoB,EACpB,qBAAqB,EACrB,kBAAkB,EACnB,MAAM,sBAAsB,CAAC;AAI9B,OAAO,EAAE,cAAc,EAAE,gBAAgB,EAAE,MAAM,uBAAuB,CAAC;AAEzE,OAAO,EAGL,KAAK,YAAY,EAKjB,wBAAwB,EACxB,KAAK,wBAAwB,EAC7B,KAAK,aAAa,EAElB,gBAAgB,EAEhB,KAAK,OAAO,EACb,MAAM,yBAAyB,CAAC;AACjC,OAAO,EAAE,iBAAiB,EAA2B,MAAM,4BAA4B,CAAC;AACxF,OAAO,EACL,0BAA0B,EAO3B,MAAM,wBAAwB,CAAC;AAChC,OAAO,EACL,sBAAsB,EAKvB,MAAM,uBAAuB,CAAC;AAe/B,OAAO,EACL,eAAe,EACf,uBAAuB,EACvB,oBAAoB,EACpB,qBAAqB,EACrB,kBAAkB,GACnB,CAAC;AAGF,YAAY,EAAE,YAAY,EAAE,aAAa,EAAE,OAAO,EAAE,CAAC;AACrD,OAAO,EAAE,iBAAiB,EAAE,wBAAwB,EAAE,gBAAgB,EAAE,CAAC;AACzE,OAAO,EAAE,0BAA0B,EAAE,CAAC;AACtC,OAAO,EAAE,cAAc,EAAE,gBAAgB,EAAE,CAAC;AAC5C,OAAO,EAAE,sBAAsB,EAAE,CAAC;AAwTlC,wEAAwE;AACxE,UAAU,sBAAsB;IAC9B,IAAI,EAAE,MAAM,CAAC;IACb,gBAAgB,CAAC,EAAE,MAAM,CAAC;CAC3B;AAED;;;GAGG;AACH,wBAAgB,uBAAuB,CACrC,IAAI,EAAE,MAAM,EACZ,OAAO,EAAE,YAAY,GACpB,OAAO,CAAC,sBAAsB,CAAC,CAkCjC;AAED;;GAEG;AACH,wBAAsB,kBAAkB,CACtC,GAAG,EAAE,MAAM,EACX,QAAQ,EAAE,MAAM,EAChB,YAAY,CAAC,EAAE,MAAM,GACpB,OAAO,CAAC,MAAM,CAAC,CAOjB;AAED;;;GAGG;AACH,wBAAgB,uBAAuB,CACrC,IAAI,EAAE,MAAM,EACZ,QAAQ,EAAE,MAAM,EAChB,UAAU,CAAC,EAAE,MAAM,EACnB,QAAQ,CAAC,EAAE,wBAAwB,GAClC,OAAO,CAAC,OAAO,CAAC,CAElB;AAED;;;GAGG;AACH,wBAAgB,sBAAsB,CACpC,WAAW,EAAE,KAAK,CAAC;IAAE,IAAI,EAAE,MAAM,CAAC;IAAC,IAAI,EAAE,MAAM,CAAA;CAAE,CAAC,EAClD,QAAQ,EAAE,MAAM,EAChB,QAAQ,CAAC,EAAE,wBAAwB,GAClC,OAAO,CAAC,MAAM,EAAE,CAAC,CAEnB;AAED;;GAEG;AACH,wBAAgB,oBAAoB,CAAC,IAAI,EAAE,MAAM,EAAE,QAAQ,EAAE,MAAM,GAAG,OAAO,CAAC,OAAO,CAAC,CAErF;AAGD,eAAO,MAAM,wBAAwB,0BAAoB,CAAC"}
+{"version":3,"file":"http-cache.d.ts","sourceRoot":"","sources":["../../../../src/src/transforms/esm/http-cache.ts"],"names":[],"mappings":"AAAA;;;;;;;GAOG;AAgBH,OAAO,EACL,eAAe,EACf,uBAAuB,EACvB,oBAAoB,EACpB,qBAAqB,EACrB,kBAAkB,EACnB,MAAM,sBAAsB,CAAC;AAI9B,OAAO,EAAE,cAAc,EAAE,gBAAgB,EAAE,MAAM,uBAAuB,CAAC;AAEzE,OAAO,EAGL,KAAK,YAAY,EAKjB,wBAAwB,EACxB,KAAK,wBAAwB,EAC7B,KAAK,aAAa,EAElB,gBAAgB,EAEhB,KAAK,OAAO,EACb,MAAM,yBAAyB,CAAC;AACjC,OAAO,EAAE,iBAAiB,EAA2B,MAAM,4BAA4B,CAAC;AACxF,OAAO,EACL,0BAA0B,EAO3B,MAAM,wBAAwB,CAAC;AAChC,OAAO,EACL,sBAAsB,EAKvB,MAAM,uBAAuB,CAAC;AAqJ/B,OAAO,EACL,eAAe,EACf,uBAAuB,EACvB,oBAAoB,EACpB,qBAAqB,EACrB,kBAAkB,GACnB,CAAC;AAGF,YAAY,EAAE,YAAY,EAAE,aAAa,EAAE,OAAO,EAAE,CAAC;AACrD,OAAO,EAAE,iBAAiB,EAAE,wBAAwB,EAAE,gBAAgB,EAAE,CAAC;AACzE,OAAO,EAAE,0BAA0B,EAAE,CAAC;AACtC,OAAO,EAAE,cAAc,EAAE,gBAAgB,EAAE,CAAC;AAC5C,OAAO,EAAE,sBAAsB,EAAE,CAAC;AAmRlC,wEAAwE;AACxE,UAAU,sBAAsB;IAC9B,IAAI,EAAE,MAAM,CAAC;IACb,gBAAgB,CAAC,EAAE,MAAM,CAAC;CAC3B;AAED;;;GAGG;AACH,wBAAgB,uBAAuB,CACrC,IAAI,EAAE,MAAM,EACZ,OAAO,EAAE,YAAY,GACpB,OAAO,CAAC,sBAAsB,CAAC,CAkCjC;AAED;;GAEG;AACH,wBAAsB,kBAAkB,CACtC,GAAG,EAAE,MAAM,EACX,QAAQ,EAAE,MAAM,EAChB,YAAY,CAAC,EAAE,MAAM,GACpB,OAAO,CAAC,MAAM,CAAC,CAOjB;AAED;;;GAGG;AACH,wBAAgB,uBAAuB,CACrC,IAAI,EAAE,MAAM,EACZ,QAAQ,EAAE,MAAM,EAChB,UAAU,CAAC,EAAE,MAAM,EACnB,QAAQ,CAAC,EAAE,wBAAwB,GAClC,OAAO,CAAC,OAAO,CAAC,CAElB;AAED;;;GAGG;AACH,wBAAgB,sBAAsB,CACpC,WAAW,EAAE,KAAK,CAAC;IAAE,IAAI,EAAE,MAAM,CAAC;IAAC,IAAI,EAAE,MAAM,CAAA;CAAE,CAAC,EAClD,QAAQ,EAAE,MAAM,EAChB,QAAQ,CAAC,EAAE,wBAAwB,GAClC,OAAO,CAAC,MAAM,EAAE,CAAC,CAEnB;AAED;;GAEG;AACH,wBAAgB,oBAAoB,CAAC,IAAI,EAAE,MAAM,EAAE,QAAQ,EAAE,MAAM,GAAG,OAAO,CAAC,OAAO,CAAC,CAErF;AAGD,eAAO,MAAM,wBAAwB,0BAAoB,CAAC"}

package/esm/src/transforms/esm/http-cache.js

@@ -9,9 +9,10 @@
 import { createFileSystem, exists } from "../../platform/compat/fs.js";
 import { join } from "../../platform/compat/path/index.js";
 import { rendererLogger as logger } from "../../utils/index.js";
-import { BUILD_FAILED, BUNDLE_ERROR, FILE_NOT_FOUND } from "../../errors/index.js";
+import { BUILD_FAILED, BUNDLE_ERROR, FILE_NOT_FOUND, retryWithBackoff } from "../../errors/index.js";
 import { SpanNames } from "../../observability/index.js";
 import { withSpan } from "../../observability/tracing/otlp-setup.js";
+import { sanitizeUrlForSpan } from "../../utils/logger/redact.js";
 import { replaceSpecifiers } from "./lexer.js";
 import { createBundleManifest, storeBundleManifest } from "./bundle-manifest.js";
 import { HTTP_MODULE_DISTRIBUTED_TTL_SEC } from "../../utils/constants/cache.js";
@@ -32,8 +33,119 @@ import { buildReplacements, rewriteModuleImports } from "./specifier-resolver.js
 import { ensureHttpBundlesExist as ensureHttpBundlesExistImpl, invalidateHttpBundle as invalidateHttpBundleImpl, recoverHttpBundleByHash as recoverHttpBundleByHashImpl, } from "./bundle-recovery.js";
 /** Threshold in ms above which an HTTP module fetch is considered slow */
 const SLOW_HTTP_FETCH_THRESHOLD_MS = 500;
+const HTTP_MODULE_FETCH_MAX_ATTEMPTS = 3;
+const HTTP_MODULE_FETCH_RETRY_DELAY_MS = 100;
+const HTTP_MODULE_FETCH_WAIT_GRACE_MS = 5_000;
+const HTTP_MODULE_FETCH_MAX_WAIT_MS = HTTP_FETCH_TIMEOUT_MS * HTTP_MODULE_FETCH_MAX_ATTEMPTS +
+    HTTP_MODULE_FETCH_RETRY_DELAY_MS *
+        ((HTTP_MODULE_FETCH_MAX_ATTEMPTS - 1) * HTTP_MODULE_FETCH_MAX_ATTEMPTS / 2) +
+    HTTP_MODULE_FETCH_WAIT_GRACE_MS;
 const httpCacheLog = logger.component("http-cache");
 const contentMetricsLog = logger.component("content-metrics");
+class HttpModuleResponseError extends Error {
+    status;
+    constructor(status) {
+        super(`HTTP module response returned status ${status}`);
+        this.status = status;
+        this.name = "HttpModuleResponseError";
+    }
+}
+class HttpModuleRequestError extends Error {
+    requestErrorType;
+    constructor(requestErrorType) {
+        super(`HTTP module request failed (${requestErrorType})`);
+        this.requestErrorType = requestErrorType;
+        this.name = "HttpModuleRequestError";
+    }
+}
+function shouldRetryHttpModuleFetch(status) {
+    return status === 408 || status === 425 || status === 429 || status >= 500;
+}
+async function discardResponseBody(response) {
+    try {
+        await response.body?.cancel();
+    }
+    catch (_) {
+        // The response is already being discarded.
+    }
+}
+async function fetchHttpModuleAttempt(url, safeUrl, urlObj, signal, attempt) {
+    let response;
+    try {
+        const startedAt = performance.now();
+        response = await fetch(url, {
+            headers: { "user-agent": "Mozilla/5.0 Veryfront/1.0" },
+            signal,
+            redirect: "follow",
+        });
+        const duration = Math.round(performance.now() - startedAt);
+        contentMetricsLog.debug("HTTP_MODULE_FETCH", {
+            url: safeUrl,
+            host: urlObj.host,
+            duration_ms: duration,
+            status: response.status,
+            slow: duration > SLOW_HTTP_FETCH_THRESHOLD_MS,
+            attempt: attempt + 1,
+        });
+        if (!response.ok) {
+            const status = response.status;
+            await discardResponseBody(response);
+            throw new HttpModuleResponseError(status);
+        }
+        return {
+            code: await response.text(),
+            contentType: response.headers.get("content-type") ?? "",
+        };
+    }
+    catch (error) {
+        if (error instanceof HttpModuleResponseError)
+            throw error;
+        if (response)
+            await discardResponseBody(response);
+        const requestErrorType = error instanceof Error ? error.name : typeof error;
+        throw new HttpModuleRequestError(requestErrorType);
+    }
+}
+async function fetchHttpModule(url) {
+    const urlObj = new URL(url);
+    const safeUrl = sanitizeUrlForSpan(url);
+    try {
+        return await retryWithBackoff((signal, attempt) => withSpan(SpanNames.HTTP_CLIENT_FETCH, () => fetchHttpModuleAttempt(url, safeUrl, urlObj, signal, attempt), {
+            "http.method": "GET",
+            "http.url": safeUrl,
+            "http.host": urlObj.host,
+            "http.scheme": urlObj.protocol.replace(":", ""),
+            "esm.package_fetch": true,
+        }), {
+            maxAttempts: HTTP_MODULE_FETCH_MAX_ATTEMPTS,
+            timeoutMs: HTTP_FETCH_TIMEOUT_MS,
+            shouldRetry: (error) => !(error instanceof HttpModuleResponseError) ||
+                shouldRetryHttpModuleFetch(error.status),
+            computeDelay: (attempt) => HTTP_MODULE_FETCH_RETRY_DELAY_MS * (attempt + 1),
+            onRetry: ({ error, attempt }) => {
+                httpCacheLog.warn("HTTP module fetch failed, retrying", {
+                    url: safeUrl,
+                    status: error instanceof HttpModuleResponseError ? error.status : undefined,
+                    errorType: error instanceof HttpModuleRequestError
+                        ? error.requestErrorType
+                        : error.name,
+                    attempt: attempt + 1,
+                });
+            },
+        });
+    }
+    catch (error) {
+        if (error instanceof HttpModuleResponseError) {
+            throw BUILD_FAILED.create({ detail: `Failed to fetch ${safeUrl}: ${error.status}` });
+        }
+        if (error instanceof HttpModuleRequestError) {
+            throw BUILD_FAILED.create({
+                detail: `Failed to fetch ${safeUrl}: ${error.requestErrorType}`,
+            });
+        }
+        throw error;
+    }
+}
 // Re-export for backwards compatibility
 export { CACHE_DIR_TOKEN, detokenizeAllCachePaths, detokenizeCachePaths, tokenizeAllCachePaths, tokenizeCachePaths, };
 export { extractBundleDeps, hasIncompatibleFilePaths, normalizeHttpUrl };
@@ -42,6 +154,7 @@ export { embedSourceUrl, extractSourceUrl };
 export { __injectCachesForTests };
 async function cacheHttpModuleInternal(url, options) {
     const normalizedUrl = normalizeHttpUrl(url);
+    const safeUrl = sanitizeUrlForSpan(normalizedUrl);
     const cacheDir = ensureAbsoluteDir(options.cacheDir);
     const cacheIdentity = await buildHttpCacheIdentity(normalizedUrl, options);
     const identityMetadata = await buildHttpCacheIdentityMetadata(normalizedUrl, options);
@@ -62,7 +175,7 @@ async function cacheHttpModuleInternal(url, options) {
             // dependency could not be prefetched. Retry the prefetch instead of
             // handing the degradation on.
             httpCacheLog.debug("Local cache holds a degraded artifact, will re-fetch", {
-                url: normalizedUrl,
+                url: safeUrl,
                 hash,
             });
         }
@@ -72,7 +185,7 @@ async function cacheHttpModuleInternal(url, options) {
                 const depsValid = await validateBundleDepsExist(deps, cacheDir);
                 if (!depsValid) {
                     httpCacheLog.debug("Local cache has missing deps, will re-fetch", {
-                        url: normalizedUrl,
+                        url: safeUrl,
                         hash,
                         missingDeps: deps.length,
                     });
@@ -96,12 +209,12 @@ async function cacheHttpModuleInternal(url, options) {
     if (processingStack.has(cacheIdentity)) {
         if (await exists(cachePath)) {
             httpCacheLog.debug("Circular dependency detected, file exists", {
-                url: normalizedUrl,
+                url: safeUrl,
             });
         }
         else {
             httpCacheLog.debug("Circular dependency detected, file pending write", {
-                url: normalizedUrl,
+                url: safeUrl,
                 cachePath,
             });
         }
@@ -109,7 +222,7 @@ async function cacheHttpModuleInternal(url, options) {
     }
     let inFlight = inFlightHttpFetches.get(cacheKey);
     while (inFlight) {
-        const result = await waitForInFlightFetch(inFlight, cacheKey);
+        const result = await waitForInFlightFetch(inFlight, HTTP_MODULE_FETCH_MAX_WAIT_MS);
         if (result !== undefined)
             return result;
         if (inFlightHttpFetches.get(cacheKey) === inFlight) {
@@ -127,7 +240,7 @@ async function cacheHttpModuleInternal(url, options) {
                 const depsExist = await validateBundleDepsExist(deps, cacheDir);
                 if (!depsExist) {
                     httpCacheLog.debug("Cached code has missing bundle deps, will re-fetch", {
-                        url: normalizedUrl,
+                        url: safeUrl,
                         hash,
                         missingDeps: deps.length,
                     });
@@ -135,7 +248,7 @@ async function cacheHttpModuleInternal(url, options) {
                 else {
                     logger.debug(cacheResult.wasGzipped
                         ? "[HTTP-CACHE] Distributed cache hit (gzip decoded)"
-                        : "[HTTP-CACHE] Distributed cache hit", { url: normalizedUrl, hash });
+                        : "[HTTP-CACHE] Distributed cache hit", { url: safeUrl, hash });
                     await fs.mkdir(cacheDir, { recursive: true });
                     await fs.writeTextFile(cachePath, cachedCode);
                     if (!(await exists(cachePath))) {
@@ -150,7 +263,7 @@ async function cacheHttpModuleInternal(url, options) {
             else {
                 logger.debug(cacheResult.wasGzipped
                     ? "[HTTP-CACHE] Distributed cache hit (gzip decoded, no deps)"
-                    : "[HTTP-CACHE] Distributed cache hit", { url: normalizedUrl, hash });
+                    : "[HTTP-CACHE] Distributed cache hit", { url: safeUrl, hash });
                 await fs.mkdir(cacheDir, { recursive: true });
                 await fs.writeTextFile(cachePath, cachedCode);
                 if (!(await exists(cachePath))) {
@@ -164,49 +277,22 @@ async function cacheHttpModuleInternal(url, options) {
         }
         else if (cacheResult.failReason && cacheResult.failReason !== "not_found") {
             httpCacheLog.debug("Distributed cache get failed", {
-                url: normalizedUrl,
+                url: safeUrl,
                 reason: cacheResult.failReason,
             });
         }
-        httpCacheLog.debug("Fetching from network", { url: normalizedUrl });
-        const urlObj = new URL(normalizedUrl);
-        const controller = new AbortController();
-        const timeout = setTimeout(() => controller.abort(), HTTP_FETCH_TIMEOUT_MS);
-        const httpFetchStartTime = performance.now();
-        const response = await withSpan(SpanNames.HTTP_CLIENT_FETCH, () => fetch(normalizedUrl, {
-            headers: { "user-agent": "Mozilla/5.0 Veryfront/1.0" },
-            signal: controller.signal,
-            redirect: "follow",
-        }), {
-            "http.method": "GET",
-            "http.url": normalizedUrl,
-            "http.host": urlObj.host,
-            "http.scheme": urlObj.protocol.replace(":", ""),
-            "esm.package_fetch": true,
-        });
-        clearTimeout(timeout);
-        const httpFetchDuration = Math.round(performance.now() - httpFetchStartTime);
-        contentMetricsLog.debug("HTTP_MODULE_FETCH", {
-            url: normalizedUrl.substring(0, 120),
-            host: urlObj.host,
-            duration_ms: httpFetchDuration,
-            status: response.status,
-            slow: httpFetchDuration > SLOW_HTTP_FETCH_THRESHOLD_MS,
-        });
-        if (!response.ok) {
-            throw BUILD_FAILED.create({ detail: `Failed to fetch ${normalizedUrl}: ${response.status}` });
-        }
-        let code = await response.text();
-        const contentType = response.headers.get("content-type") ?? "";
+        httpCacheLog.debug("Fetching from network", { url: safeUrl });
+        const fetchedModule = await fetchHttpModule(normalizedUrl);
+        let code = fetchedModule.code;
+        const contentType = fetchedModule.contentType;
         const isHtmlContent = contentType.includes("text/html") || looksLikeHtmlNotJs(code);
         if (isHtmlContent) {
             logger.error("[HTTP-CACHE] Received HTML instead of JavaScript, likely an esm.sh error page", {
-                url: normalizedUrl,
+                url: safeUrl,
                 contentType,
-                preview: code.slice(0, 200),
             });
             throw BUNDLE_ERROR.create({
-                detail: `Received HTML instead of JavaScript from ${normalizedUrl}. The package may not exist or failed to build on esm.sh.`,
+                detail: `Received HTML instead of JavaScript from ${safeUrl}. The package may not exist or failed to build on esm.sh.`,
             });
         }
         processingStack.add(cacheIdentity);
@@ -236,9 +322,9 @@ async function cacheHttpModuleInternal(url, options) {
             // retries the prefetch instead of inheriting one upstream blip for the
             // lifetime of the distributed entry.
             httpCacheLog.warn("Not caching a module with unresolved dynamic imports", {
-                url: normalizedUrl,
+                url: safeUrl,
                 hash,
-                degraded,
+                degraded: degraded.map(sanitizeUrlForSpan),
             });
             return cachePath;
         }
@@ -249,7 +335,7 @@ async function cacheHttpModuleInternal(url, options) {
             if (error instanceof VeryfrontError && error.slug === "cache-invariant-violation") {
                 throw error;
             }
-            httpCacheLog.debug("Distributed cache set failed", { url: normalizedUrl, error });
+            httpCacheLog.debug("Distributed cache set failed", { url: safeUrl, error });
         }
         getCachedPaths().set(cacheKey, cachePath);
         const accumulator = bundleAccumulatorStorage.getStore();

package/esm/src/transforms/esm/import-attributes.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"import-attributes.d.ts","sourceRoot":"","sources":["../../../../src/src/transforms/esm/import-attributes.ts"],"names":[],"mappings":"AAAA;;;;;;;;;GASG;AAgEH;;;;;;;;;;GAUG;AACH,wBAAsB,uBAAuB,CAAC,IAAI,EAAE,MAAM,GAAG,OAAO,CAAC,MAAM,CAAC,CAiB3E;AAED;;;;;;;GAOG;AACH,wBAAsB,yBAAyB,CAC7C,IAAI,EAAE,MAAM,EACZ,WAAW,EAAE,CAAC,SAAS,EAAE,MAAM,KAAK,OAAO,GAC1C,OAAO,CAAC,MAAM,CAAC,CAmBjB"}
+{"version":3,"file":"import-attributes.d.ts","sourceRoot":"","sources":["../../../../src/src/transforms/esm/import-attributes.ts"],"names":[],"mappings":"AAAA;;;;;;;;;GASG;AAyDH;;;;;;;;;;GAUG;AACH,wBAAsB,uBAAuB,CAAC,IAAI,EAAE,MAAM,GAAG,OAAO,CAAC,MAAM,CAAC,CAiB3E;AAED;;;;;;;GAOG;AACH,wBAAsB,yBAAyB,CAC7C,IAAI,EAAE,MAAM,EACZ,WAAW,EAAE,CAAC,SAAS,EAAE,MAAM,KAAK,OAAO,GAC1C,OAAO,CAAC,MAAM,CAAC,CAmBjB"}

package/esm/src/transforms/esm/import-attributes.js

@@ -9,6 +9,7 @@
  * @module transforms/esm/import-attributes
  */
 import { parseMaskedImports } from "./lexer.js";
+import { importAttributeRange } from "../import-rewriter/import-edit.js";
 const ASSERT_KEYWORD = "assert";
 /**
  * The legacy `assert` keyword following a static import specifier.
@@ -32,15 +33,7 @@ const JSON_TYPE_ATTRIBUTE = /^\{\s*(["']?)type\1\s*:\s*(["'])json\2\s*,?\s*\}$/;
  *
  * The range is empty when the import declares no attributes.
  */
-function attributeRange(imp) {
-    // Static: `e` indexes the closing quote and `se` ends the statement before
-    // any semicolon, so the clause and its keyword lie between them.
-    if (imp.d === -1)
-        return { start: imp.e + 1, end: imp.se };
-    // Dynamic: `e` is already past the closing quote and `se` is past the
-    // closing paren, so the comma and the options argument lie between them.
-    return { start: imp.e, end: imp.se - 1 };
-}
+const attributeRange = importAttributeRange;
 /** Whether the declared attributes are exactly a JSON module type. */
 function declaresJsonTypeOnly(clause, isDynamic) {
     const attributes = (isDynamic ? DYNAMIC_WITH_ARGUMENT : STATIC_WITH_CLAUSE).exec(clause)?.[1];

package/esm/src/transforms/esm/in-flight-manager.d.ts

@@ -21,10 +21,11 @@ export declare const inFlightHttpFetches: Map<string, Promise<string | null>>;
  */
 export declare function __clearInFlightHttpFetches(): void;
 /**
- * Wait for an in-flight fetch with timeout + jitter.
+ * Wait for an in-flight fetch. The default timeout includes jitter; callers
+ * with a bounded owner operation can supply its complete wait window.
  * Returns undefined on timeout so caller can retry.
  */
-export declare function waitForInFlightFetch(promise: Promise<string | null>, cacheKey: string): Promise<string | null | undefined>;
+export declare function waitForInFlightFetch(promise: Promise<string | null>, waitTimeoutMs?: number): Promise<string | null | undefined>;
 /**
  * Asynchronously refresh the distributed cache entry for a local bundle.
  * This is fire-and-forget to avoid blocking the hot path.