@shopify/hydrogen 0.25.1 → 0.26.0

package/dist/esnext/constants.d.ts

@@ -6,4 +6,4 @@ export declare const STOREFRONT_API_SECRET_TOKEN_HEADER = "Shopify-Storefront-Pr
 export declare const STOREFRONT_API_PUBLIC_TOKEN_HEADER = "X-Shopify-Storefront-Access-Token";
 export declare const STOREFRONT_API_BUYER_IP_HEADER = "Shopify-Storefront-Buyer-IP";
 export declare const SHOPIFY_STOREFRONT_ID_VARIABLE = "SHOPIFY_STOREFRONT_ID";
-export declare const SHOPIFY_STOREFRONT_ID_HEADER = "X-Shopify-Storefront-Id";
+export declare const SHOPIFY_STOREFRONT_ID_HEADER = "Shopify-Storefront-Id";

package/dist/esnext/constants.js

@@ -6,4 +6,4 @@ export const STOREFRONT_API_SECRET_TOKEN_HEADER = 'Shopify-Storefront-Private-To
 export const STOREFRONT_API_PUBLIC_TOKEN_HEADER = 'X-Shopify-Storefront-Access-Token';
 export const STOREFRONT_API_BUYER_IP_HEADER = 'Shopify-Storefront-Buyer-IP';
 export const SHOPIFY_STOREFRONT_ID_VARIABLE = 'SHOPIFY_STOREFRONT_ID';
-export const SHOPIFY_STOREFRONT_ID_HEADER = 'X-Shopify-Storefront-Id';
+export const SHOPIFY_STOREFRONT_ID_HEADER = 'Shopify-Storefront-Id';

package/dist/esnext/entry-client.js

@@ -89,11 +89,13 @@ const renderHydrogen = async (ClientWrapper) => {
     const RootComponent = 
     // Default to StrictMode on, unless explicitly turned off
     config.strictMode !== false ? StrictMode : Fragment;
-    hydrateRoot(root, React.createElement(React.Fragment, null,
-        React.createElement(RootComponent, null,
-            React.createElement(ErrorBoundary, { FallbackComponent: Error },
-                React.createElement(Suspense, { fallback: null },
-                    React.createElement(Content, { clientWrapper: ClientWrapper }))))));
+    // Fixes hydration in `useId`: https://github.com/Shopify/hydrogen/issues/1589
+    const ServerRequestProviderMock = () => null;
+    hydrateRoot(root, React.createElement(RootComponent, null,
+        React.createElement(ServerRequestProviderMock, null),
+        React.createElement(ErrorBoundary, { FallbackComponent: Error },
+            React.createElement(Suspense, { fallback: null },
+                React.createElement(Content, { clientWrapper: ClientWrapper })))));
 };
 export default renderHydrogen;
 function Content({ clientWrapper: ClientWrapper = ({ children }) => children, }) {

package/dist/esnext/entry-server.js

@@ -47,6 +47,10 @@ export const renderHydrogen = (App) => {
         setLogger(hydrogenConfig.logger);
         const log = getLoggerWithContext(request);
         const response = new HydrogenResponse();
+        if (hydrogenConfig.poweredByHeader ?? true) {
+            // If not defined in the config, always show the header
+            response.headers.set('powered-by', 'Shopify-Hydrogen');
+        }
         const sessionApi = hydrogenConfig.session
             ? hydrogenConfig.session(log)
             : undefined;
@@ -55,14 +59,6 @@ export const renderHydrogen = (App) => {
          * Inject the cache & context into the module loader so we can pull it out for subrequests.
          */
         request.ctx.runtime = context;
-        if (!context?.waitUntil) {
-            const runtimeContext = {
-                waitUntil: (fn) => {
-                    setTimeout(() => fn, 0);
-                },
-            };
-            request.ctx.runtime = runtimeContext;
-        }
         setCache(cache);
         const builtInRouteResource = getBuiltInRoute(url);
         if (builtInRouteResource) {
@@ -84,7 +80,7 @@ export const renderHydrogen = (App) => {
             if (cachedResponse) {
                 if (isStale(request, cachedResponse)) {
                     const lockCacheKey = request.cacheKey(true);
-                    const staleWhileRevalidate = async (lockExists) => {
+                    const staleWhileRevalidatePromise = getItemFromCache(lockCacheKey).then(async (lockExists) => {
                         if (lockExists)
                             return;
                         try {
@@ -98,13 +94,9 @@ export const renderHydrogen = (App) => {
                         catch (e) {
                             log.error('Cache revalidate error', e);
                         }
-                        finally {
-                            await deleteItemFromCache(lockCacheKey);
-                        }
-                    };
-                    const revalidatingPromise = getItemFromCache(lockCacheKey).then(staleWhileRevalidate);
+                    });
                     // Asynchronously wait for it in workers
-                    request.ctx.runtime?.waitUntil(revalidatingPromise);
+                    request.ctx.runtime?.waitUntil(staleWhileRevalidatePromise);
                 }
                 return cachedResponse;
             }
@@ -195,11 +187,8 @@ async function runSSR({ rsc, state, request, response, nodeResponse, template, n
     const AppSSR = (React.createElement(Html, { template: response.canStream() ? noScriptTemplate : template, hydrogenConfig: request.ctx.hydrogenConfig },
         React.createElement(ServerRequestProvider, { request: request },
             React.createElement(ServerPropsProvider, { initialServerProps: state, setServerPropsForRsc: () => { } },
-                React.createElement(PreloadQueries, { request: request },
-                    React.createElement(Suspense, { fallback: null },
-                        React.createElement(RscConsumer, null)),
-                    React.createElement(Suspense, { fallback: null },
-                        React.createElement(Analytics, null)))))));
+                React.createElement(Suspense, { fallback: null },
+                    React.createElement(RscConsumer, null))))));
     log.trace('start ssr');
     const rscReadable = response.canStream()
         ? new ReadableStream({
@@ -324,6 +313,9 @@ async function runSSR({ rsc, state, request, response, nodeResponse, template, n
     }
     else if (nodeResponse) {
         const savedChunks = tagOnWrite(nodeResponse);
+        nodeResponse.on('finish', () => {
+            cacheResponse(response, request, savedChunks, revalidate);
+        });
         const { pipe } = ssrRenderToPipeableStream(AppSSR, {
             nonce,
             bootstrapScripts,
@@ -357,7 +349,6 @@ async function runSSR({ rsc, state, request, response, nodeResponse, template, n
                 if (!revalidate &&
                     (response.canStream() || nodeResponse.writableEnded)) {
                     postRequestTasks('str', nodeResponse.statusCode, request, response);
-                    cacheResponse(response, request, savedChunks, revalidate);
                     return;
                 }
                 writeHeadToNodeResponse(nodeResponse, response, log, didError());
@@ -378,7 +369,6 @@ async function runSSR({ rsc, state, request, response, nodeResponse, template, n
                     if (!error) {
                         html = assembleHtml({ ssrHtml, rscPayload, request, template });
                         postRequestTasks('ssr', nodeResponse.statusCode, request, response);
-                        cacheResponse(response, request, [html], revalidate);
                     }
                     nodeResponse.write(html);
                     nodeResponse.end();
@@ -412,13 +402,13 @@ async function runSSR({ rsc, state, request, response, nodeResponse, template, n
 function runRSC({ App, state, log, request, response }) {
     const serverProps = { ...state, request, response, log };
     request.ctx.router.serverProps = serverProps;
+    preloadRequestCacheData(request);
     const AppRSC = (React.createElement(ServerRequestProvider, { request: request },
-        React.createElement(PreloadQueries, { request: request },
-            React.createElement(App, { ...serverProps }),
-            React.createElement(Suspense, { fallback: null },
-                React.createElement(Analytics, null)),
-            request.ctx.hydrogenConfig?.__EXPERIMENTAL__devTools && (React.createElement(Suspense, { fallback: null },
-                React.createElement(DevTools, null))))));
+        React.createElement(App, { ...serverProps }),
+        React.createElement(Suspense, { fallback: null },
+            React.createElement(Analytics, null)),
+        request.ctx.hydrogenConfig?.__EXPERIMENTAL__devTools && (React.createElement(Suspense, { fallback: null },
+            React.createElement(DevTools, null)))));
     let rscDidError;
     const rscReadable = rscRenderToReadableStream(AppRSC, {
         onError(e) {
@@ -428,11 +418,6 @@ function runRSC({ App, state, log, request, response }) {
     });
     return { readable: rscReadable, didError: () => rscDidError };
 }
-function PreloadQueries({ request, children, }) {
-    const preloadQueries = request.getPreloadQueries();
-    preloadRequestCacheData(request, preloadQueries);
-    return React.createElement(React.Fragment, null, children);
-}
 export default renderHydrogen;
 function startWritingToNodeResponse(nodeResponse, error) {
     if (!nodeResponse.headersSent) {
@@ -574,7 +559,8 @@ async function cacheResponse(response, request, chunks, revalidate) {
             await saveCacheResponse(response, request, chunks);
         }
         else {
-            request.ctx.runtime?.waitUntil(Promise.resolve(true).then(() => saveCacheResponse(response, request, chunks)));
+            const cachePutPromise = Promise.resolve(true).then(() => saveCacheResponse(response, request, chunks));
+            request.ctx.runtime?.waitUntil(cachePutPromise);
         }
     }
 }
@@ -605,5 +591,6 @@ async function saveCacheResponse(response, request, chunks) {
             statusText,
             headers,
         }), response.cache());
+        deleteItemFromCache(request.cacheKey(true));
     }
 }

package/dist/esnext/foundation/Analytics/connectors/PerformanceMetrics/PerformanceMetricsDebug.client.js

@@ -1,5 +1,5 @@
 import { useEffect } from 'react';
-import { ClientAnalytics } from '../../index';
+import { ClientAnalytics } from '../../ClientAnalytics';
 const PAD = 10;
 let isInit = false;
 export function PerformanceMetricsDebug() {

package/dist/esnext/foundation/Analytics/connectors/Shopify/ShopifyAnalytics.client.js

@@ -1,6 +1,6 @@
 import { useEffect } from 'react';
 import { parse, stringify } from 'worktop/cookie';
-import { ClientAnalytics } from '../../index';
+import { ClientAnalytics } from '../../ClientAnalytics';
 import { buildUUID, addDataIf } from './utils';
 import { SHOPIFY_S, SHOPIFY_Y } from './const';
 const longTermLength = 60 * 60 * 24 * 360 * 2; // ~2 year expiry

package/dist/esnext/foundation/FileRoutes/FileRoutes.server.js

@@ -33,7 +33,7 @@ export function FileRoutes({ routes, basePath, dirPrefix }) {
     if (foundRoute) {
         request.ctx.router.routeRendered = true;
         request.ctx.router.routeParams = foundRouteDetails.params;
-        return (React.createElement(RouteParamsProvider, { routeParams: foundRouteDetails.params },
+        return (React.createElement(RouteParamsProvider, { routeParams: foundRouteDetails.params, basePath: basePath },
             React.createElement(foundRoute.component, { params: foundRouteDetails.params, ...serverProps })));
     }
     return null;

package/dist/esnext/foundation/HydrogenRequest/HydrogenRequest.server.d.ts

@@ -4,9 +4,10 @@ import type { QueryTiming } from '../../utilities/log/log-query-timeline';
 import type { ResolvedHydrogenConfig, PreloadOptions, QueryKey, RuntimeContext } from '../../types';
 import { HelmetData as HeadData } from 'react-helmet-async';
 import { SessionSyncApi } from '../session/session';
+import { LocalizationContextValue } from '../../components/LocalizationProvider/LocalizationContext.client';
 export declare type PreloadQueryEntry = {
     key: QueryKey;
-    fetcher: () => Promise<unknown>;
+    fetcher: (request: HydrogenRequest) => Promise<unknown>;
     preload?: PreloadOptions;
 };
 export declare type PreloadQueriesByURL = Map<string, PreloadQueryEntry>;
@@ -24,9 +25,15 @@ export declare type RouterContextData = {
  * - Adds a static constructor to convert a Node.js `IncomingMessage` to a Request.
  */
 export declare class HydrogenRequest extends Request {
+    /**
+     * A Map of cookies for easy access.
+     */
     cookies: Map<string, string>;
     id: string;
     time: number;
+    /**
+     * Get the canonical URL for the current page, across SSR and RSC requests.
+     */
     normalizedUrl: string;
     ctx: {
         cache: Map<string, any>;
@@ -42,6 +49,7 @@ export declare class HydrogenRequest extends Request {
         session?: SessionSyncApi;
         runtime?: RuntimeContext;
         scopes: Map<string, Record<string, any>>;
+        localization?: LocalizationContextValue;
         [key: string]: any;
     };
     constructor(input: any);

package/dist/esnext/foundation/HydrogenRequest/HydrogenRequest.server.js

@@ -22,9 +22,15 @@ const PRELOAD_ALL = '*';
  * - Adds a static constructor to convert a Node.js `IncomingMessage` to a Request.
  */
 export class HydrogenRequest extends Request {
+    /**
+     * A Map of cookies for easy access.
+     */
     cookies;
     id;
     time;
+    /**
+     * Get the canonical URL for the current page, across SSR and RSC requests.
+     */
     normalizedUrl;
     // CFW Request has a reserved 'context' property, use 'ctx' instead.
     ctx;

package/dist/esnext/foundation/Route/Route.server.js

@@ -22,7 +22,7 @@ export function Route({ path, page }) {
     if (match) {
         request.ctx.router.routeRendered = true;
         request.ctx.router.routeParams = match.params;
-        return (React.createElement(RouteParamsProvider, { routeParams: match.params }, cloneElement(page, { params: match.params || {}, ...serverProps })));
+        return (React.createElement(RouteParamsProvider, { routeParams: match.params, basePath: '/' }, cloneElement(page, { params: match.params || {}, ...serverProps })));
     }
     return null;
 }

package/dist/esnext/foundation/ServerRequestProvider/ServerRequestProvider.d.ts

@@ -1,8 +1,9 @@
-import type { PreloadQueriesByURL, HydrogenRequest } from '../HydrogenRequest/HydrogenRequest.server';
+import React from 'react';
+import type { HydrogenRequest } from '../HydrogenRequest/HydrogenRequest.server';
 import type { QueryKey } from '../../types';
 declare type ServerRequestProviderProps = {
     request: HydrogenRequest;
-    children: JSX.Element;
+    children: React.ReactNode;
 };
 export declare function ServerRequestProvider({ request, children, }: ServerRequestProviderProps): JSX.Element;
 export declare function useServerRequest(): HydrogenRequest;
@@ -17,6 +18,6 @@ declare type RequestCacheResult<T> = {
  * Returns data stored in the request cache.
  * It will throw the promise if data is not ready.
  */
-export declare function useRequestCacheData<T>(key: QueryKey, fetcher: () => T | Promise<T>): RequestCacheResult<T>;
-export declare function preloadRequestCacheData(request: HydrogenRequest, preloadQueries?: PreloadQueriesByURL): void;
+export declare function useRequestCacheData<T>(key: QueryKey, fetcher: (request: HydrogenRequest) => T | Promise<T>): RequestCacheResult<T>;
+export declare function preloadRequestCacheData(request: HydrogenRequest): void;
 export {};

package/dist/esnext/foundation/ServerRequestProvider/ServerRequestProvider.js

@@ -10,9 +10,10 @@ function requestCacheRSC() {
 }
 requestCacheRSC.key = Symbol.for('HYDROGEN_REQUEST');
 function getInternalReactDispatcher() {
+    return (
     // @ts-ignore
-    return React.__SECRET_INTERNALS_DO_NOT_USE_OR_YOU_WILL_BE_FIRED
-        .ReactCurrentDispatcher.current;
+    React.__SECRET_INTERNALS_DO_NOT_USE_OR_YOU_WILL_BE_FIRED
+        .ReactCurrentDispatcher.current || {});
 }
 function isRsc() {
     // This flag is added by RSC Vite plugin
@@ -36,7 +37,7 @@ export function ServerRequestProvider({ request, children, }) {
         // scoped to this current rendering.
         const requestCache = getCacheForType(requestCacheRSC);
         requestCache.set(requestCacheRSC.key, request);
-        return children;
+        return React.createElement(React.Fragment, null, children);
     }
     // Use a normal provider in SSR to make the request object
     // available in the current rendering.
@@ -74,7 +75,7 @@ export function useRequestCacheData(key, fetcher) {
             }
             if (!promise) {
                 const startApiTime = getTime();
-                const maybePromise = fetcher();
+                const maybePromise = fetcher(request);
                 if (!(maybePromise instanceof Promise)) {
                     result = { data: maybePromise };
                     return result;
@@ -94,8 +95,9 @@ export function useRequestCacheData(key, fetcher) {
         throw result;
     return result;
 }
-export function preloadRequestCacheData(request, preloadQueries) {
-    const cache = request.ctx.cache;
+export function preloadRequestCacheData(request) {
+    const preloadQueries = request.getPreloadQueries();
+    const { cache } = request.ctx;
     preloadQueries?.forEach((preloadQuery, cacheKey) => {
         collectQueryTimings(request, preloadQuery.key, 'preload');
         if (!cache.has(cacheKey)) {
@@ -108,7 +110,7 @@ export function preloadRequestCacheData(request, preloadQueries) {
                 }
                 if (!promise) {
                     const startApiTime = getTime();
-                    promise = preloadQuery.fetcher().then((data) => {
+                    promise = preloadQuery.fetcher(request).then((data) => {
                         result = { data };
                         collectQueryTimings(request, preloadQuery.key, 'resolved', getTime() - startApiTime);
                     }, (error) => {

package/dist/esnext/foundation/ShopifyProvider/ShopifyProvider.server.js

@@ -2,9 +2,12 @@ import React, { useMemo } from 'react';
 import { ShopifyProviderClient } from './ShopifyProvider.client';
 import { DEFAULT_LOCALE } from '../constants';
 import { useRequestCacheData, useServerRequest } from '../ServerRequestProvider';
+import { getOxygenVariable } from '../../utilities/storefrontApi';
+import { SHOPIFY_STOREFRONT_ID_VARIABLE } from '../../constants';
 function makeShopifyContext(shopifyConfig) {
     const locale = shopifyConfig.defaultLocale ?? DEFAULT_LOCALE;
     const languageCode = locale.split(/[-_]/)[0];
+    const storefrontId = getOxygenVariable(SHOPIFY_STOREFRONT_ID_VARIABLE);
     return {
         locale: locale.toUpperCase(),
         languageCode: languageCode.toUpperCase(),
@@ -12,6 +15,7 @@ function makeShopifyContext(shopifyConfig) {
         storefrontToken: shopifyConfig.storefrontToken,
         storefrontApiVersion: shopifyConfig.storefrontApiVersion,
         multipassSecret: shopifyConfig.multipassSecret,
+        storefrontId,
     };
 }
 export const SHOPIFY_PROVIDER_CONTEXT_KEY = Symbol.for('SHOPIFY_PROVIDER_RSC');

package/dist/esnext/foundation/ShopifyProvider/types.d.ts

@@ -4,6 +4,7 @@ import type { ShopifyConfigFetcher, ShopifyConfig } from '../../types';
 export interface ShopifyContextValue extends Omit<ShopifyConfig, 'defaultLocale'> {
     locale: `${LanguageCode}-${CountryCode}`;
     languageCode: `${LanguageCode}`;
+    storefrontId: string | null;
 }
 export declare type ShopifyProviderProps = {
     /** Shopify connection information. Defaults to the `shopify` property in the `hydrogen.config.js` file. */

package/dist/esnext/foundation/useNavigate/useNavigate.d.ts

@@ -7,9 +7,11 @@ declare type NavigationOptions = {
     clientState?: any;
     /** Whether to emulate natural browser behavior and restore scroll position on navigation. Defaults to true. */
     scroll?: any;
+    basePath?: string;
 };
 /**
  * The useNavigate hook imperatively navigates between routes.
  */
 export declare function useNavigate(): (path: string, options?: NavigationOptions) => void;
+export declare function buildPath(basePath: string, path: string): string;
 export {};

package/dist/esnext/foundation/useNavigate/useNavigate.js

@@ -1,10 +1,13 @@
 import { useRouter } from '../Router/BrowserRouter.client';
+import { useBasePath } from '../useRouteParams/RouteParamsProvider.client';
 /**
  * The useNavigate hook imperatively navigates between routes.
  */
 export function useNavigate() {
     const router = useRouter();
+    const routeBasePath = useBasePath();
     return (path, options = { replace: false, reloadDocument: false }) => {
+        path = buildPath(options.basePath ?? routeBasePath, path);
         const state = {
             ...options?.clientState,
             scroll: options?.scroll ?? true,
@@ -18,3 +21,13 @@ export function useNavigate() {
         }
     };
 }
+export function buildPath(basePath, path) {
+    let builtPath = path;
+    if (basePath !== '/') {
+        builtPath =
+            path.charAt(0) === '/' && basePath.charAt(0) === '/'
+                ? basePath + path.substring(1)
+                : basePath + path;
+    }
+    return builtPath;
+}

package/dist/esnext/foundation/useQuery/hooks.js

@@ -54,10 +54,7 @@ function cachedQueryFnBuilder(key, generateNewOutput, queryOptions) {
     /**
      * Attempt to read the query from cache. If it doesn't exist or if it's stale, regenerate it.
      */
-    async function useCachedQueryFn() {
-        // Call this hook before running any async stuff
-        // to prevent losing the current React cycle.
-        const request = useServerRequest();
+    async function useCachedQueryFn(request) {
         const log = getLoggerWithContext(request);
         const cacheResponse = await getItemFromCache(key);
         if (cacheResponse) {

package/dist/esnext/foundation/useRouteParams/RouteParamsProvider.client.d.ts

@@ -1,10 +1,13 @@
 import React, { FC, ReactNode } from 'react';
 declare type RouteParamsContextValue = {
     routeParams: Record<string, string>;
+    basePath: string;
 };
 export declare const RouteParamsContext: React.Context<RouteParamsContextValue>;
 export declare const RouteParamsProvider: FC<{
     routeParams: Record<string, string>;
+    basePath: string;
     children: ReactNode;
 }>;
+export declare function useBasePath(): string;
 export {};

package/dist/esnext/foundation/useRouteParams/RouteParamsProvider.client.js

@@ -1,7 +1,12 @@
-import React, { createContext } from 'react';
+import React, { useContext, createContext } from 'react';
 export const RouteParamsContext = createContext({
     routeParams: {},
+    basePath: '/',
 });
-export const RouteParamsProvider = ({ children, routeParams }) => {
-    return (React.createElement(RouteParamsContext.Provider, { value: { routeParams } }, children));
+export const RouteParamsProvider = ({ children, routeParams, basePath }) => {
+    return (React.createElement(RouteParamsContext.Provider, { value: { routeParams, basePath } }, children));
 };
+export function useBasePath() {
+    const router = useContext(RouteParamsContext);
+    return router.basePath;
+}

package/dist/esnext/framework/cache/in-memory.d.ts

@@ -1,12 +1,17 @@
 /**
- * This is an in-memory implementation of `Cache` that *barely*
- * works and is only meant to be used during development.
+ * This is a limited implementation of an in-memory cache.
+ * It only supports the `cache-control` header.
+ * It does NOT support `age` or `expires` headers.
+ * @see https://developer.mozilla.org/en-US/docs/Web/API/Cache
  */
-export declare class InMemoryCache {
-    private store;
+export declare class InMemoryCache implements Cache {
+    #private;
     constructor();
-    put(request: Request, response: Response): void;
-    match(request: Request): Response | undefined;
-    delete(request: Request): void;
+    add(request: RequestInfo): Promise<void>;
+    addAll(requests: RequestInfo[]): Promise<void>;
+    matchAll(request?: RequestInfo, options?: CacheQueryOptions): Promise<readonly Response[]>;
+    put(request: Request, response: Response): Promise<void>;
+    match(request: Request): Promise<Response | undefined>;
+    delete(request: Request): Promise<boolean>;
     keys(request?: Request): Promise<Request[]>;
 }

package/dist/esnext/framework/cache/in-memory.js

@@ -1,48 +1,76 @@
 /**
- * This is an in-memory implementation of `Cache` that *barely*
- * works and is only meant to be used during development.
+ * This is a limited implementation of an in-memory cache.
+ * It only supports the `cache-control` header.
+ * It does NOT support `age` or `expires` headers.
+ * @see https://developer.mozilla.org/en-US/docs/Web/API/Cache
  */
 export class InMemoryCache {
-    store;
+    #store;
     constructor() {
-        this.store = new Map();
+        this.#store = new Map();
     }
-    put(request, response) {
-        this.store.set(request.url, {
-            value: response,
-            date: new Date(),
+    add(request) {
+        throw new Error('Method not implemented. Use `put` instead.');
+    }
+    addAll(requests) {
+        throw new Error('Method not implemented. Use `put` instead.');
+    }
+    matchAll(request, options) {
+        throw new Error('Method not implemented. Use `match` instead.');
+    }
+    async put(request, response) {
+        if (request.method !== 'GET') {
+            throw new TypeError('Cannot cache response to non-GET request.');
+        }
+        if (response.status === 206) {
+            throw new TypeError('Cannot cache response to a range request (206 Partial Content).');
+        }
+        if (response.headers.get('vary')?.includes('*')) {
+            throw new TypeError("Cannot cache response with 'Vary: *' header.");
+        }
+        this.#store.set(request.url, {
+            body: new Uint8Array(await response.arrayBuffer()),
+            status: response.status,
+            headers: [...response.headers],
+            timestamp: Date.now(),
         });
     }
-    match(request) {
-        const match = this.store.get(request.url);
+    async match(request) {
+        if (request.method !== 'GET')
+            return;
+        const match = this.#store.get(request.url);
         if (!match) {
             return;
         }
-        const { value, date } = match;
-        const cacheControl = value.headers.get('cache-control') || '';
+        const { body, timestamp, ...metadata } = match;
+        const headers = new Headers(metadata.headers);
+        const cacheControl = headers.get('cache-control') || '';
         const maxAge = parseInt(cacheControl.match(/max-age=(\d+)/)?.[1] || '0', 10);
         const swr = parseInt(cacheControl.match(/stale-while-revalidate=(\d+)/)?.[1] || '0', 10);
-        const age = (new Date().valueOf() - date.valueOf()) / 1000;
+        const age = (Date.now() - timestamp) / 1000;
         const isMiss = age > maxAge + swr;
         if (isMiss) {
-            this.store.delete(request.url);
+            this.#store.delete(request.url);
             return;
         }
         const isStale = age > maxAge;
-        const headers = new Headers(value.headers);
         headers.set('cache', isStale ? 'STALE' : 'HIT');
-        headers.set('date', date.toUTCString());
-        const response = new Response(value.body, {
+        headers.set('date', new Date(timestamp).toUTCString());
+        return new Response(body, {
+            status: metadata.status ?? 200,
             headers,
         });
-        return response;
     }
-    delete(request) {
-        this.store.delete(request.url);
+    async delete(request) {
+        if (this.#store.has(request.url)) {
+            this.#store.delete(request.url);
+            return true;
+        }
+        return false;
     }
     keys(request) {
         const cacheKeys = [];
-        for (const url of this.store.keys()) {
+        for (const url of this.#store.keys()) {
             if (!request || request.url === url) {
                 cacheKeys.push(new Request(url));
             }

package/dist/esnext/framework/load-config.d.ts

@@ -0,0 +1,6 @@
+export declare function loadConfig(options?: {
+    root: string;
+}): Promise<{
+    configuration: any;
+    configurationPath: any;
+}>;

package/dist/esnext/framework/load-config.js

@@ -0,0 +1,10 @@
+// Provide Hydrogen config loader to external tools like the CLI
+import { VIRTUAL_PROXY_HYDROGEN_CONFIG_ID } from './plugins/vite-plugin-hydrogen-virtual-files';
+import { viteception } from './viteception';
+export async function loadConfig(options = { root: process.cwd() }) {
+    const { loaded } = await viteception([VIRTUAL_PROXY_HYDROGEN_CONFIG_ID], options);
+    return {
+        configuration: loaded[0].default,
+        configurationPath: loaded[0].configPath,
+    };
+}

package/dist/esnext/framework/plugins/vite-plugin-hydrogen-client-middleware.js

@@ -13,9 +13,8 @@ export default () => {
             server.middlewares.use(async (req, res, next) => {
                 const url = req.url;
                 try {
-                    if (url.includes('.client.js') &&
-                        url.includes('?v=') &&
-                        !url.includes('node_modules')) {
+                    if (/\.client\.[jt]sx?\?v=/.test(url) &&
+                        !/\/node_modules\//.test(url)) {
                         const result = await server.transformRequest(url, { html: false });
                         if (result) {
                             return send(req, res, result.code, 'js', {