veryfront 0.1.1047 → 0.1.1049

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

@@ -26,8 +26,48 @@ export type CacheOptions = {
     /** React version to use for esm.sh URLs (defaults to DEFAULT_REACT_VERSION) */
     reactVersion?: string;
 };
+export type HttpCacheIdentityOptions = Pick<CacheOptions, "importMap" | "reactVersion">;
+export interface HttpCacheIdentityMetadata extends HttpCacheIdentityOptions {
+    url: string;
+    /** SHA-256 key for the shared distributed-cache import-map record. */
+    importMapFingerprint?: string;
+}
+export interface EffectiveHttpCacheRequest<T extends HttpCacheIdentityOptions = HttpCacheIdentityOptions> {
+    url: string;
+    options: T;
+}
+/** Build an order-independent fingerprint covering imports and scoped imports. */
+export declare function fingerprintImportMap(importMap: ImportMapConfig): Promise<string>;
+/**
+ * Snapshot an import-map fingerprint for one top-level immutable request graph.
+ * Callers must create a fresh prepared options object for each top-level request.
+ */
+export declare function prepareHttpCacheRequestOptions<T extends CacheOptions>(options: T): T;
+/** Preserve an existing graph snapshot, or create one for an unprepared entry point. */
+export declare function ensurePreparedHttpCacheRequestOptions<T extends CacheOptions>(options: T): T;
+/** Canonical identity shared by normal caching and all recovery paths. */
+export declare function buildHttpCacheIdentity(url: string, options: HttpCacheIdentityOptions): Promise<string>;
+/** Build recoverable metadata while reusing the request graph's import-map fingerprint. */
+export declare function buildHttpCacheIdentityMetadata(url: string, options: HttpCacheIdentityOptions): Promise<HttpCacheIdentityMetadata>;
+/** Build the versioned, collision-resistant filename and distributed-cache hash. */
+export declare function hashHttpCacheIdentity(identity: string): Promise<string>;
 export declare function ensureAbsoluteDir(path: string): string;
 export declare function isHttpUrl(specifier: string): boolean;
+/** Return the exact version for an URL in React's canonical esm.sh graph. */
+export declare function getCanonicalReactEsmVersion(rawUrl: string): string | null;
+/**
+ * Align a canonical React URL and its cache options to one project version.
+ * The URL version is authoritative when the caller has no resolved version.
+ */
+export declare function getEffectiveHttpCacheRequest<T extends HttpCacheIdentityOptions>(rawUrl: string, options: T): EffectiveHttpCacheRequest<T>;
+/**
+ * Return whether an URL belongs to React's canonical esm.sh module graph.
+ *
+ * React must remain a process-wide singleton for a given version. Unrelated
+ * project import maps therefore must not partition these modules into
+ * separate local files.
+ */
+export declare function isCanonicalReactEsmUrl(rawUrl: string): boolean;
 export declare function isExternalScheme(specifier: string): boolean;
 export declare function isRelative(specifier: string): boolean;
 /**

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

@@ -1 +1 @@
-{"version":3,"file":"http-cache-helpers.d.ts","sourceRoot":"","sources":["../../../../src/src/transforms/esm/http-cache-helpers.ts"],"names":[],"mappings":"AAAA;;;;GAIG;AAMH,OAAO,KAAK,EAAE,eAAe,EAAE,MAAM,mCAAmC,CAAC;AAOzE;;GAEG;AACH,MAAM,WAAW,aAAa,CAAC,CAAC,EAAE,CAAC;IACjC,GAAG,CAAC,GAAG,EAAE,CAAC,GAAG,CAAC,GAAG,SAAS,CAAC;IAC3B,GAAG,CAAC,GAAG,EAAE,CAAC,EAAE,KAAK,EAAE,CAAC,GAAG,IAAI,CAAC;IAC5B,MAAM,CAAC,GAAG,EAAE,CAAC,GAAG,IAAI,CAAC;CACtB;AAED;;GAEG;AACH,MAAM,WAAW,OAAO,CAAC,CAAC;IACxB,GAAG,CAAC,KAAK,EAAE,CAAC,GAAG,OAAO,CAAC;IACvB,GAAG,CAAC,KAAK,EAAE,CAAC,GAAG,IAAI,CAAC;IACpB,MAAM,CAAC,KAAK,EAAE,CAAC,GAAG,OAAO,CAAC;CAC3B;AAED,MAAM,MAAM,YAAY,GAAG;IACzB,QAAQ,EAAE,MAAM,CAAC;IACjB,SAAS,EAAE,eAAe,CAAC;IAC3B,+EAA+E;IAC/E,YAAY,CAAC,EAAE,MAAM,CAAC;CACvB,CAAC;AAEF,wBAAgB,iBAAiB,CAAC,IAAI,EAAE,MAAM,GAAG,MAAM,CAEtD;AAED,wBAAgB,SAAS,CAAC,SAAS,EAAE,MAAM,GAAG,OAAO,CAEpD;AAED,wBAAgB,gBAAgB,CAAC,SAAS,EAAE,MAAM,GAAG,OAAO,CAM3D;AAED,wBAAgB,UAAU,CAAC,SAAS,EAAE,MAAM,GAAG,OAAO,CAErD;AAED;;;GAGG;AACH,wBAAgB,kBAAkB,CAAC,OAAO,EAAE,MAAM,GAAG,SAAS,GAAG,OAAO,CAEvE;AAED,wBAAgB,cAAc,CAAC,SAAS,EAAE,MAAM,GAAG,OAAO,CAQzD;AAED,wBAAgB,iBAAiB,CAAC,GAAG,EAAE,GAAG,GAAG,IAAI,CAqBhD;AAED,wBAAgB,gBAAgB,CAAC,GAAG,EAAE,MAAM,GAAG,MAAM,CA2BpD;AAED,wBAAgB,oBAAoB,CAClC,SAAS,EAAE,MAAM,EACjB,SAAS,EAAE,eAAe,EAC1B,YAAY,GAAE,MAA8B,GAC3C,MAAM,CA4BR;AAED;;;GAGG;AACH,wBAAgB,wBAAwB,CAAC,IAAI,EAAE,MAAM,EAAE,aAAa,EAAE,MAAM,GAAG,OAAO,CAkBrF"}
+{"version":3,"file":"http-cache-helpers.d.ts","sourceRoot":"","sources":["../../../../src/src/transforms/esm/http-cache-helpers.ts"],"names":[],"mappings":"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"}

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

@@ -10,13 +10,156 @@ import { resolveImport } from "../../modules/import-map/resolver.js";
 import { buildEsmShUrl } from "../import-rewriter/url-builder.js";
 import { parseBarePackageSpecifier } from "../shared/package-specifier.js";
 import { DEFAULT_REACT_VERSION, getReactImportMap } from "./package-registry.js";
+import { computeHash } from "../../utils/hash-utils.js";
 const logger = rendererLogger.component("http-cache");
+const HTTP_CACHE_REQUEST_IDENTITY_CONTEXT = Symbol("http-cache-request-identity-context");
+function compareImportMapKeys(left, right) {
+    return left[0] < right[0] ? -1 : left[0] > right[0] ? 1 : 0;
+}
+const HTTP_IMPORT_MAP_FINGERPRINT_NAMESPACE = "veryfront:http-import-map:v2";
+const HTTP_CACHE_IDENTITY_NAMESPACE = "veryfront:http-module:v2";
+const HTTP_CACHE_FILE_HASH_NAMESPACE = "veryfront:http-module-file:v2";
+/** Build an order-independent fingerprint covering imports and scoped imports. */
+export function fingerprintImportMap(importMap) {
+    const imports = Object.entries(importMap.imports ?? {}).sort(compareImportMapKeys);
+    const scopes = Object.entries(importMap.scopes ?? {})
+        .sort(([left], [right]) => left < right ? -1 : left > right ? 1 : 0)
+        .map(([scope, scopedImports]) => [
+        scope,
+        Object.entries(scopedImports).sort(compareImportMapKeys),
+    ]);
+    return computeHash(`${HTTP_IMPORT_MAP_FINGERPRINT_NAMESPACE}\0${JSON.stringify({ imports, scopes })}`);
+}
+function attachHttpCacheRequestIdentityContext(options, context) {
+    Object.defineProperty(options, HTTP_CACHE_REQUEST_IDENTITY_CONTEXT, {
+        configurable: false,
+        enumerable: false,
+        value: context,
+        writable: false,
+    });
+    return options;
+}
+function getHttpCacheRequestIdentityContext(options) {
+    return options[HTTP_CACHE_REQUEST_IDENTITY_CONTEXT];
+}
+/**
+ * Snapshot an import-map fingerprint for one top-level immutable request graph.
+ * Callers must create a fresh prepared options object for each top-level request.
+ */
+export function prepareHttpCacheRequestOptions(options) {
+    const prepared = { ...options };
+    return attachHttpCacheRequestIdentityContext(prepared, {});
+}
+/** Preserve an existing graph snapshot, or create one for an unprepared entry point. */
+export function ensurePreparedHttpCacheRequestOptions(options) {
+    return getHttpCacheRequestIdentityContext(options)
+        ? options
+        : prepareHttpCacheRequestOptions(options);
+}
+function getRequestImportMapFingerprint(rawUrl, effectiveOptions) {
+    const context = getHttpCacheRequestIdentityContext(effectiveOptions);
+    if (!context)
+        return fingerprintImportMap(effectiveOptions.importMap);
+    if (!isCanonicalReactEsmUrl(rawUrl)) {
+        context.importMapFingerprint ??= fingerprintImportMap(effectiveOptions.importMap);
+        return context.importMapFingerprint;
+    }
+    context.canonicalReactImportMapFingerprint ??= fingerprintImportMap(effectiveOptions.importMap);
+    return context.canonicalReactImportMapFingerprint;
+}
+/** Canonical identity shared by normal caching and all recovery paths. */
+export async function buildHttpCacheIdentity(url, options) {
+    const effective = getEffectiveHttpCacheRequest(url, options);
+    const normalizedUrl = normalizeHttpUrl(effective.url);
+    const importMapFingerprint = await getRequestImportMapFingerprint(url, effective.options);
+    const components = [
+        normalizedUrl,
+        effective.options.reactVersion ?? null,
+        importMapFingerprint,
+    ];
+    return `${HTTP_CACHE_IDENTITY_NAMESPACE}:${JSON.stringify(components)}`;
+}
+/** Build recoverable metadata while reusing the request graph's import-map fingerprint. */
+export async function buildHttpCacheIdentityMetadata(url, options) {
+    const effective = getEffectiveHttpCacheRequest(url, options);
+    return {
+        url: normalizeHttpUrl(effective.url),
+        importMap: effective.options.importMap,
+        reactVersion: effective.options.reactVersion,
+        importMapFingerprint: await getRequestImportMapFingerprint(url, effective.options),
+    };
+}
+/** Build the versioned, collision-resistant filename and distributed-cache hash. */
+export function hashHttpCacheIdentity(identity) {
+    return computeHash(`${HTTP_CACHE_FILE_HASH_NAMESPACE}\0${identity}`);
+}
 export function ensureAbsoluteDir(path) {
     return isAbsolute(path) ? path : join(cwd(), path);
 }
 export function isHttpUrl(specifier) {
     return specifier.startsWith("https://") || specifier.startsWith("http://");
 }
+function parseCanonicalReactEsmPackage(rawUrl) {
+    try {
+        const url = new URL(rawUrl);
+        if (url.hostname !== "esm.sh")
+            return null;
+        const pathSegments = url.pathname.split("/").filter(Boolean);
+        const prefix = pathSegments[0] ?? "";
+        const packageIndex = prefix === "stable" || /^v\d+$/.test(prefix) ? 1 : 0;
+        const match = /^(react|react-dom)@(\d+\.\d+\.\d+(?:[-+][A-Za-z0-9.-]+)?)$/.exec(pathSegments[packageIndex] ?? "");
+        if (!match?.[1] || !match[2])
+            return null;
+        return {
+            packageName: match[1],
+            version: match[2],
+            packageIndex,
+            url,
+            pathSegments,
+        };
+    }
+    catch (_) {
+        /* expected: malformed URLs are not canonical React modules */
+        return null;
+    }
+}
+/** Return the exact version for an URL in React's canonical esm.sh graph. */
+export function getCanonicalReactEsmVersion(rawUrl) {
+    return parseCanonicalReactEsmPackage(rawUrl)?.version ?? null;
+}
+/**
+ * Align a canonical React URL and its cache options to one project version.
+ * The URL version is authoritative when the caller has no resolved version.
+ */
+export function getEffectiveHttpCacheRequest(rawUrl, options) {
+    const parsed = parseCanonicalReactEsmPackage(rawUrl);
+    if (!parsed)
+        return { url: rawUrl, options };
+    const version = options.reactVersion ?? parsed.version;
+    if (version !== parsed.version) {
+        parsed.pathSegments[parsed.packageIndex] = `${parsed.packageName}@${version}`;
+        parsed.url.pathname = `/${parsed.pathSegments.join("/")}`;
+    }
+    const effectiveOptions = {
+        ...options,
+        importMap: { imports: {}, scopes: {} },
+        reactVersion: version,
+    };
+    const context = getHttpCacheRequestIdentityContext(options);
+    if (context)
+        attachHttpCacheRequestIdentityContext(effectiveOptions, context);
+    return { url: parsed.url.toString(), options: effectiveOptions };
+}
+/**
+ * Return whether an URL belongs to React's canonical esm.sh module graph.
+ *
+ * React must remain a process-wide singleton for a given version. Unrelated
+ * project import maps therefore must not partition these modules into
+ * separate local files.
+ */
+export function isCanonicalReactEsmUrl(rawUrl) {
+    return getCanonicalReactEsmVersion(rawUrl) !== null;
+}
 export function isExternalScheme(specifier) {
     return specifier.startsWith("node:") ||
         specifier.startsWith("data:") ||

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

@@ -1 +1 @@
-{"version":3,"file":"http-cache-invariants.d.ts","sourceRoot":"","sources":["../../../../src/src/transforms/esm/http-cache-invariants.ts"],"names":[],"mappings":"AAAA;;;;;;;GAOG;AAGH,OAAO,EAEL,KAAK,UAAU,EACf,KAAK,eAAe,EACpB,KAAK,kBAAkB,EAExB,MAAM,uBAAuB,CAAC;AAC/B,OAAO,EACL,eAAe,EACf,yBAAyB,EACzB,sBAAsB,IAAI,0BAA0B,EACrD,MAAM,sBAAsB,CAAC;AAC9B,OAAO,EAAE,cAAc,EAAE,MAAM,uBAAuB,CAAC;AAIvD;;;GAGG;AACH,OAAO,EAAE,eAAe,EAAE,CAAC;AAE3B,OAAO,EAAE,yBAAyB,EAAE,cAAc,EAAE,CAAC;AAErD;;;;;;GAMG;AACH,eAAO,MAAM,sBAAsB,mCAA6B,CAAC;AAYjE;;;;;;GAMG;AACH,wBAAgB,cAAc,CAAC,IAAI,EAAE,kBAAkB,GAAG,IAAI,CAa7D;AAED;;;;;;GAMG;AACH,wBAAgB,WAAW,CAAC,IAAI,EAAE,eAAe,GAAG,IAAI,CAcvD;AAED;;;;;;;GAOG;AACH,wBAAgB,YAAY,CAAC,IAAI,EAAE,MAAM,GAAG,UAAU,CASrD;AAED;;;;;;;GAOG;AACH,wBAAgB,iBAAiB,CAAC,IAAI,EAAE,MAAM,GAAG,eAAe,CAQ/D"}
+{"version":3,"file":"http-cache-invariants.d.ts","sourceRoot":"","sources":["../../../../src/src/transforms/esm/http-cache-invariants.ts"],"names":[],"mappings":"AAAA;;;;;;;GAOG;AAGH,OAAO,EAEL,KAAK,UAAU,EACf,KAAK,eAAe,EACpB,KAAK,kBAAkB,EAExB,MAAM,uBAAuB,CAAC;AAC/B,OAAO,EACL,eAAe,EACf,yBAAyB,EACzB,sBAAsB,IAAI,0BAA0B,EACrD,MAAM,sBAAsB,CAAC;AAC9B,OAAO,EAAE,cAAc,EAAE,MAAM,uBAAuB,CAAC;AAIvD;;;GAGG;AACH,OAAO,EAAE,eAAe,EAAE,CAAC;AAE3B,OAAO,EAAE,yBAAyB,EAAE,cAAc,EAAE,CAAC;AAErD;;;;;;GAMG;AACH,eAAO,MAAM,sBAAsB,mCAA6B,CAAC;AAYjE;;;;;;GAMG;AACH,wBAAgB,cAAc,CAAC,IAAI,EAAE,kBAAkB,GAAG,IAAI,CAa7D;AAED;;;;;;GAMG;AACH,wBAAgB,WAAW,CAAC,IAAI,EAAE,eAAe,GAAG,IAAI,CAcvD;AAED;;;;;;;GAOG;AACH,wBAAgB,YAAY,CAAC,IAAI,EAAE,MAAM,GAAG,UAAU,CAUrD;AAED;;;;;;;GAOG;AACH,wBAAgB,iBAAiB,CAAC,IAAI,EAAE,MAAM,GAAG,eAAe,CAQ/D"}

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

@@ -80,10 +80,11 @@ export function assertLocal(code) {
  * @throws VeryfrontError (cache-invariant-violation) if hash format is invalid
  */
 export function asBundleHash(hash) {
-    // Bundle hashes should be numeric (from simpleHash)
-    if (!/^\d+$/.test(hash)) {
+    const isLegacyDecimal = /^\d+$/.test(hash);
+    const isSha256 = /^[a-f0-9]{64}$/.test(hash);
+    if (!isLegacyDecimal && !isSha256) {
         throw CACHE_INVARIANT_VIOLATION.create({
-            detail: `[CACHE INVARIANT VIOLATION] Invalid bundle hash format: "${hash}" (expected numeric)`,
+            detail: `[CACHE INVARIANT VIOLATION] Invalid bundle hash format: "${hash}" (expected legacy decimal or lowercase SHA-256)`,
         });
     }
     return brand(hash);

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

@@ -13,6 +13,7 @@
 import type { CacheBackend } from "../../cache/types.js";
 import { type BundleHash, type LocalModuleCode, type NormalizedUrl, type PortableModuleCode } from "./http-cache-types.js";
 import { asBundleHash } from "./http-cache-invariants.js";
+import { type HttpCacheIdentityMetadata } from "./http-cache-helpers.js";
 export declare function __setDistributedCacheAccessorForTests(accessor: (() => Promise<CacheBackend | null>) | null): void;
 export declare function initializeHttpModuleDistributedCache(): Promise<boolean>;
 /**
@@ -75,7 +76,7 @@ declare class HttpBundleCache {
      * @param url - Original URL for reverse lookup
      * @param ttl - TTL in seconds (defaults to HTTP_MODULE_DISTRIBUTED_TTL_SEC)
      */
-    setCode(hash: BundleHash | string, code: LocalModuleCode, url: NormalizedUrl | string, ttl?: number): Promise<void>;
+    setCode(hash: BundleHash | string, code: LocalModuleCode, url: NormalizedUrl | string, ttl?: number, identityMetadata?: HttpCacheIdentityMetadata): Promise<void>;
     /**
      * Batch get multiple bundle codes from distributed cache.
      * ALWAYS returns LocalModuleCode (detokenized) for each successful fetch.
@@ -91,6 +92,8 @@ declare class HttpBundleCache {
      * @returns Original URL or null
      */
     getOriginalUrl(hash: BundleHash | string): Promise<string | null>;
+    /** Return the full rewrite identity needed to reproduce a bundle by URL. */
+    getIdentityMetadata(hash: BundleHash | string): Promise<HttpCacheIdentityMetadata | null>;
     /**
      * Delete a bundle from distributed cache.
      * Removes all keys associated with the hash (code, url, hash mapping).

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

@@ -1 +1 @@
-{"version":3,"file":"http-cache-wrapper.d.ts","sourceRoot":"","sources":["../../../../src/src/transforms/esm/http-cache-wrapper.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;GAWG;AAOH,OAAO,KAAK,EAAE,YAAY,EAAE,MAAM,sBAAsB,CAAC;AAEzD,OAAO,EAEL,KAAK,UAAU,EAEf,KAAK,eAAe,EACpB,KAAK,aAAa,EAClB,KAAK,kBAAkB,EAExB,MAAM,uBAAuB,CAAC;AAC/B,OAAO,EACL,YAAY,EAKb,MAAM,4BAA4B,CAAC;AAoBpC,wBAAgB,qCAAqC,CACnD,QAAQ,EAAE,CAAC,MAAM,OAAO,CAAC,YAAY,GAAG,IAAI,CAAC,CAAC,GAAG,IAAI,GACpD,IAAI,CAEN;AAED,wBAAsB,oCAAoC,IAAI,OAAO,CAAC,OAAO,CAAC,CAM7E;AAWD;;;;;;GAMG;AACH,iBAAS,QAAQ,CAAC,IAAI,EAAE,eAAe,GAAG,kBAAkB,CAoB3D;AAED;;;GAGG;AACH,iBAAS,UAAU,CAAC,IAAI,EAAE,kBAAkB,GAAG,MAAM,GAAG,eAAe,CAMtE;AAmCD;;GAEG;AACH,UAAU,aAAa;IACrB,wEAAwE;IACxE,IAAI,EAAE,eAAe,GAAG,IAAI,CAAC;IAC7B,uDAAuD;IACvD,UAAU,EAAE,OAAO,CAAC;IACpB,4CAA4C;IAC5C,UAAU,CAAC,EAAE,WAAW,GAAG,oBAAoB,GAAG,cAAc,GAAG,OAAO,CAAC;CAC5E;AAED;;;;;;;;;GASG;AACH,cAAM,eAAe;IACnB;;;;;;OAMG;IACG,aAAa,CAAC,IAAI,EAAE,UAAU,GAAG,MAAM,GAAG,OAAO,CAAC,aAAa,CAAC;IAiDtE;;;;;;OAMG;IACG,YAAY,CAAC,IAAI,EAAE,UAAU,GAAG,MAAM,GAAG,OAAO,CAAC,aAAa,CAAC;IAqCrE;;;;;;;;OAQG;IACG,OAAO,CACX,IAAI,EAAE,UAAU,GAAG,MAAM,EACzB,IAAI,EAAE,eAAe,EACrB,GAAG,EAAE,aAAa,GAAG,MAAM,EAC3B,GAAG,GAAE,MAAwC,GAC5C,OAAO,CAAC,IAAI,CAAC;IA+BhB;;;;;;OAMG;IACG,aAAa,CACjB,MAAM,EAAE,KAAK,CAAC,UAAU,GAAG,MAAM,CAAC,GACjC,OAAO,CAAC,GAAG,CAAC,MAAM,EAAE,eAAe,CAAC,CAAC;IA8CxC;;;;;OAKG;IACG,cAAc,CAAC,IAAI,EAAE,UAAU,GAAG,MAAM,GAAG,OAAO,CAAC,MAAM,GAAG,IAAI,CAAC;IAcvE;;;;;;OAMG;IACG,UAAU,CAAC,IAAI,EAAE,UAAU,GAAG,MAAM,GAAG,OAAO,CAAC,OAAO,CAAC;IAsB7D;;OAEG;IACG,WAAW,IAAI,OAAO,CAAC,OAAO,CAAC;CAItC;AAED;;;GAGG;AACH,eAAO,MAAM,eAAe,iBAAwB,CAAC;AAErD;;;GAGG;AACH,OAAO,EAAE,YAAY,EAAE,UAAU,EAAE,QAAQ,EAAE,CAAC"}
+{"version":3,"file":"http-cache-wrapper.d.ts","sourceRoot":"","sources":["../../../../src/src/transforms/esm/http-cache-wrapper.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;GAWG;AAOH,OAAO,KAAK,EAAE,YAAY,EAAE,MAAM,sBAAsB,CAAC;AAEzD,OAAO,EAEL,KAAK,UAAU,EAEf,KAAK,eAAe,EACpB,KAAK,aAAa,EAClB,KAAK,kBAAkB,EAExB,MAAM,uBAAuB,CAAC;AAC/B,OAAO,EACL,YAAY,EAKb,MAAM,4BAA4B,CAAC;AAEpC,OAAO,EAAwB,KAAK,yBAAyB,EAAE,MAAM,yBAAyB,CAAC;AAwF/F,wBAAgB,qCAAqC,CACnD,QAAQ,EAAE,CAAC,MAAM,OAAO,CAAC,YAAY,GAAG,IAAI,CAAC,CAAC,GAAG,IAAI,GACpD,IAAI,CAEN;AAED,wBAAsB,oCAAoC,IAAI,OAAO,CAAC,OAAO,CAAC,CAM7E;AAWD;;;;;;GAMG;AACH,iBAAS,QAAQ,CAAC,IAAI,EAAE,eAAe,GAAG,kBAAkB,CAoB3D;AAED;;;GAGG;AACH,iBAAS,UAAU,CAAC,IAAI,EAAE,kBAAkB,GAAG,MAAM,GAAG,eAAe,CAMtE;AAmCD;;GAEG;AACH,UAAU,aAAa;IACrB,wEAAwE;IACxE,IAAI,EAAE,eAAe,GAAG,IAAI,CAAC;IAC7B,uDAAuD;IACvD,UAAU,EAAE,OAAO,CAAC;IACpB,4CAA4C;IAC5C,UAAU,CAAC,EAAE,WAAW,GAAG,oBAAoB,GAAG,cAAc,GAAG,OAAO,CAAC;CAC5E;AAED;;;;;;;;;GASG;AACH,cAAM,eAAe;IACnB;;;;;;OAMG;IACG,aAAa,CAAC,IAAI,EAAE,UAAU,GAAG,MAAM,GAAG,OAAO,CAAC,aAAa,CAAC;IAiDtE;;;;;;OAMG;IACG,YAAY,CAAC,IAAI,EAAE,UAAU,GAAG,MAAM,GAAG,OAAO,CAAC,aAAa,CAAC;IAqCrE;;;;;;;;OAQG;IACG,OAAO,CACX,IAAI,EAAE,UAAU,GAAG,MAAM,EACzB,IAAI,EAAE,eAAe,EACrB,GAAG,EAAE,aAAa,GAAG,MAAM,EAC3B,GAAG,GAAE,MAAwC,EAC7C,gBAAgB,CAAC,EAAE,yBAAyB,GAC3C,OAAO,CAAC,IAAI,CAAC;IAoDhB;;;;;;OAMG;IACG,aAAa,CACjB,MAAM,EAAE,KAAK,CAAC,UAAU,GAAG,MAAM,CAAC,GACjC,OAAO,CAAC,GAAG,CAAC,MAAM,EAAE,eAAe,CAAC,CAAC;IA8CxC;;;;;OAKG;IACG,cAAc,CAAC,IAAI,EAAE,UAAU,GAAG,MAAM,GAAG,OAAO,CAAC,MAAM,GAAG,IAAI,CAAC;IAcvE,4EAA4E;IACtE,mBAAmB,CACvB,IAAI,EAAE,UAAU,GAAG,MAAM,GACxB,OAAO,CAAC,yBAAyB,GAAG,IAAI,CAAC;IA+B5C;;;;;;OAMG;IACG,UAAU,CAAC,IAAI,EAAE,UAAU,GAAG,MAAM,GAAG,OAAO,CAAC,OAAO,CAAC;IAuB7D;;OAEG;IACG,WAAW,IAAI,OAAO,CAAC,OAAO,CAAC;CAItC;AAED;;;GAGG;AACH,eAAO,MAAM,eAAe,iBAAwB,CAAC;AAErD;;;GAGG;AACH,OAAO,EAAE,YAAY,EAAE,UAAU,EAAE,QAAQ,EAAE,CAAC"}

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

@@ -19,6 +19,7 @@ import { HTTP_MODULE_DISTRIBUTED_TTL_SEC } from "../../utils/constants/cache.js"
 import { brand, unbrand, } from "./http-cache-types.js";
 import { asBundleHash, assertLocal, assertPortable, CACHE_DIR_TOKEN, VeryfrontError, } from "./http-cache-invariants.js";
 import { looksLikeHtmlContent as looksLikeHtml } from "./html-content.js";
+import { fingerprintImportMap } from "./http-cache-helpers.js";
 const logger = rendererLogger.component("http-cache-wrapper");
 /** Maximum number of keys per batch request to distributed cache API */
 const BATCH_FETCH_CHUNK_SIZE = 100;
@@ -28,6 +29,68 @@ let testDistributedCacheAccessor = null;
 function resolveDistributedCache() {
     return testDistributedCacheAccessor ? testDistributedCacheAccessor() : getDistributedCache();
 }
+function parseStringRecord(value) {
+    if (value === undefined)
+        return undefined;
+    if (!value || typeof value !== "object" || Array.isArray(value))
+        return undefined;
+    const entries = Object.entries(value);
+    if (entries.some(([, entry]) => typeof entry !== "string"))
+        return undefined;
+    return Object.fromEntries(entries);
+}
+function parseImportMap(value) {
+    if (!value || typeof value !== "object" || Array.isArray(value))
+        return null;
+    const rawImportMap = value;
+    const imports = parseStringRecord(rawImportMap.imports);
+    if (rawImportMap.imports !== undefined && imports === undefined)
+        return null;
+    let scopes;
+    if (rawImportMap.scopes !== undefined) {
+        if (!rawImportMap.scopes || typeof rawImportMap.scopes !== "object" ||
+            Array.isArray(rawImportMap.scopes))
+            return null;
+        scopes = {};
+        for (const [scope, rawScopedImports] of Object.entries(rawImportMap.scopes)) {
+            const scopedImports = parseStringRecord(rawScopedImports);
+            if (!scopedImports)
+                return null;
+            scopes[scope] = scopedImports;
+        }
+    }
+    return { imports, scopes };
+}
+function parseIdentityMetadata(value) {
+    try {
+        const parsed = JSON.parse(value);
+        if (!parsed || typeof parsed !== "object" || typeof parsed.url !== "string")
+            return null;
+        if (parsed.reactVersion !== undefined && typeof parsed.reactVersion !== "string")
+            return null;
+        // Backward compatibility for v2 records written before import maps were shared.
+        if (parsed.importMap !== undefined) {
+            const importMap = parseImportMap(parsed.importMap);
+            return importMap
+                ? {
+                    url: parsed.url,
+                    reactVersion: parsed.reactVersion,
+                    importMap,
+                }
+                : null;
+        }
+        if (typeof parsed.importMapFingerprint !== "string")
+            return null;
+        return {
+            url: parsed.url,
+            reactVersion: parsed.reactVersion,
+            importMapFingerprint: parsed.importMapFingerprint,
+        };
+    }
+    catch {
+        return null;
+    }
+}
 export function __setDistributedCacheAccessorForTests(accessor) {
     testDistributedCacheAccessor = accessor;
 }
@@ -214,7 +277,7 @@ class HttpBundleCache {
      * @param url - Original URL for reverse lookup
      * @param ttl - TTL in seconds (defaults to HTTP_MODULE_DISTRIBUTED_TTL_SEC)
      */
-    async setCode(hash, code, url, ttl = HTTP_MODULE_DISTRIBUTED_TTL_SEC) {
+    async setCode(hash, code, url, ttl = HTTP_MODULE_DISTRIBUTED_TTL_SEC, identityMetadata) {
         const distributed = await resolveDistributedCache();
         if (!distributed)
             return;
@@ -226,11 +289,21 @@ class HttpBundleCache {
             // Validate invariant
             assertPortable(portableCode);
             const portableStr = unbrand(portableCode);
-            await Promise.all([
+            const writes = [
                 distributed.set(distributedKey("url", hashStr), portableStr, ttl),
                 distributed.set(distributedKey("code", hashStr), portableStr, ttl),
                 distributed.set(distributedKey("hash", hashStr), urlStr, ttl),
-            ]);
+            ];
+            if (identityMetadata) {
+                const importMapFingerprint = identityMetadata.importMapFingerprint ??
+                    await fingerprintImportMap(identityMetadata.importMap);
+                writes.push(distributed.set(distributedKey("import-map", importMapFingerprint), JSON.stringify(identityMetadata.importMap), ttl), distributed.set(distributedKey("identity", hashStr), JSON.stringify({
+                    url: identityMetadata.url,
+                    reactVersion: identityMetadata.reactVersion,
+                    importMapFingerprint,
+                }), ttl));
+            }
+            await Promise.all(writes);
             logger.debug("Stored code in distributed cache", { hash: hashStr });
         }
         catch (error) {
@@ -305,6 +378,40 @@ class HttpBundleCache {
             return null;
         }
     }
+    /** Return the full rewrite identity needed to reproduce a bundle by URL. */
+    async getIdentityMetadata(hash) {
+        const distributed = await resolveDistributedCache();
+        if (!distributed)
+            return null;
+        const hashStr = typeof hash === "string" ? hash : unbrand(hash);
+        try {
+            const raw = await distributed.get(distributedKey("identity", hashStr));
+            if (!raw)
+                return null;
+            const parsed = parseIdentityMetadata(raw);
+            if (!parsed || "importMap" in parsed)
+                return parsed;
+            const rawImportMap = await distributed.get(distributedKey("import-map", parsed.importMapFingerprint));
+            if (!rawImportMap)
+                return null;
+            let importMapValue;
+            try {
+                importMapValue = JSON.parse(rawImportMap);
+            }
+            catch {
+                return null;
+            }
+            const importMap = parseImportMap(importMapValue);
+            if (!importMap)
+                return null;
+            if (await fingerprintImportMap(importMap) !== parsed.importMapFingerprint)
+                return null;
+            return { ...parsed, importMap };
+        }
+        catch {
+            return null;
+        }
+    }
     /**
      * Delete a bundle from distributed cache.
      * Removes all keys associated with the hash (code, url, hash mapping).
@@ -323,6 +430,7 @@ class HttpBundleCache {
                 distributed.del(distributedKey("url", hashStr)),
                 distributed.del(distributedKey("code", hashStr)),
                 distributed.del(distributedKey("hash", hashStr)),
+                distributed.del(distributedKey("identity", hashStr)),
             ]);
             logger.info("Deleted bundle from distributed cache", { hash: hashStr });
             return true;

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

@@ -1,6 +1,6 @@
 import { CACHE_DIR_TOKEN, detokenizeAllCachePaths, detokenizeCachePaths, tokenizeAllCachePaths, tokenizeCachePaths } from "../../cache/paths.js";
 import { embedSourceUrl, extractSourceUrl } from "./source-url-embed.js";
-import { type CacheOptions, hasIncompatibleFilePaths, type HttpCacheLike, normalizeHttpUrl, type SetLike } from "./http-cache-helpers.js";
+import { type CacheOptions, hasIncompatibleFilePaths, type HttpCacheIdentityOptions, type HttpCacheLike, normalizeHttpUrl, type SetLike } from "./http-cache-helpers.js";
 import { extractBundleDeps } from "./bundle-deps-validator.js";
 import { __clearInFlightHttpFetches } from "./in-flight-manager.js";
 import { __injectCachesForTests } from "./http-cache-state.js";
@@ -23,12 +23,12 @@ export declare function cacheHttpImportsToLocal(code: string, options: CacheOpti
 /**
  * Cache a specific HTTP module URL and return its local file:// path.
  */
-export declare function cacheModuleToLocal(url: string, cacheDir: string): Promise<string>;
+export declare function cacheModuleToLocal(url: string, cacheDir: string, reactVersion?: string): Promise<string>;
 /**
  * Recover a missing HTTP bundle by looking up the code directly from the hash.
  * Delegates to bundle-recovery module with cacheHttpModule wired in.
  */
-export declare function recoverHttpBundleByHash(hash: string, cacheDir: string, parentCode?: string): Promise<boolean>;
+export declare function recoverHttpBundleByHash(hash: string, cacheDir: string, parentCode?: string, identity?: HttpCacheIdentityOptions): Promise<boolean>;
 /**
  * Ensure all HTTP bundles exist locally before import.
  * Delegates to bundle-recovery module with cacheHttpModule wired in.
@@ -36,7 +36,7 @@ export declare function recoverHttpBundleByHash(hash: string, cacheDir: string,
 export declare function ensureHttpBundlesExist(bundlePaths: Array<{
     path: string;
     hash: string;
-}>, cacheDir: string): Promise<string[]>;
+}>, cacheDir: string, identity?: HttpCacheIdentityOptions): Promise<string[]>;
 /**
  * Invalidate a corrupted bundle from both local and distributed cache.
  */

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":"AAyBA,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;AACzE,OAAO,EACL,KAAK,YAAY,EAEjB,wBAAwB,EACxB,KAAK,aAAa,EAElB,gBAAgB,EAChB,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;AAoQlC,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,CA4BjC;AAED;;GAEG;AACH,wBAAsB,kBAAkB,CAAC,GAAG,EAAE,MAAM,EAAE,QAAQ,EAAE,MAAM,GAAG,OAAO,CAAC,MAAM,CAAC,CAOvF;AAED;;;GAGG;AACH,wBAAgB,uBAAuB,CACrC,IAAI,EAAE,MAAM,EACZ,QAAQ,EAAE,MAAM,EAChB,UAAU,CAAC,EAAE,MAAM,GAClB,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,GACf,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":"AAwBA,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;AACzE,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;AAsRlC,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

@@ -11,7 +11,6 @@ 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 { simpleHash } from "../../utils/hash-utils.js";
 import { withSpan } from "../../observability/tracing/otlp-setup.js";
 import { SpanNames } from "../../observability/tracing/span-names.js";
 import { replaceSpecifiers } from "./lexer.js";
@@ -25,7 +24,7 @@ import { CACHE_DIR_TOKEN, detokenizeAllCachePaths, detokenizeCachePaths, tokeniz
 import { looksLikeHtmlContent as looksLikeHtmlNotJs } from "./html-content.js";
 // Extracted modules
 import { embedSourceUrl, extractSourceUrl } from "./source-url-embed.js";
-import { ensureAbsoluteDir, hasIncompatibleFilePaths, isHttpUrl, normalizeHttpUrl, } from "./http-cache-helpers.js";
+import { buildHttpCacheIdentity, buildHttpCacheIdentityMetadata, ensureAbsoluteDir, ensurePreparedHttpCacheRequestOptions, getEffectiveHttpCacheRequest, hashHttpCacheIdentity, hasIncompatibleFilePaths, isHttpUrl, normalizeHttpUrl, prepareHttpCacheRequestOptions, } from "./http-cache-helpers.js";
 import { extractBundleDeps, validateBundleDepsExist } from "./bundle-deps-validator.js";
 import { __clearInFlightHttpFetches, bundleAccumulatorStorage, inFlightHttpFetches, processingStackStorage, refreshDistributedCacheAsync, trackBundleAccumulator, waitForInFlightFetch, } from "./in-flight-manager.js";
 import { __injectCachesForTests, getCachedPaths, getLastDistributedRefresh, getProcessingStack, hasInjectedProcessingStack, } from "./http-cache-state.js";
@@ -44,14 +43,16 @@ export { __injectCachesForTests };
 async function cacheHttpModuleInternal(url, options) {
     const normalizedUrl = normalizeHttpUrl(url);
     const cacheDir = ensureAbsoluteDir(options.cacheDir);
-    const cacheKey = `${cacheDir}:${normalizedUrl}`;
+    const cacheIdentity = await buildHttpCacheIdentity(normalizedUrl, options);
+    const identityMetadata = await buildHttpCacheIdentityMetadata(normalizedUrl, options);
+    const cacheKey = `${cacheDir}:${cacheIdentity}`;
     const existing = getCachedPaths().get(cacheKey);
     if (existing) {
         if (await exists(existing))
             return existing;
         getCachedPaths().delete(cacheKey);
     }
-    const hash = simpleHash(normalizedUrl);
+    const hash = await hashHttpCacheIdentity(cacheIdentity);
     const cachePath = join(cacheDir, `http-${hash}.mjs`);
     const fs = createFileSystem();
     if (await exists(cachePath)) {
@@ -68,20 +69,20 @@ async function cacheHttpModuleInternal(url, options) {
             }
             else {
                 getCachedPaths().set(cacheKey, cachePath);
-                refreshDistributedCacheAsync(hash, code, cacheDir, normalizedUrl, getLastDistributedRefresh);
+                refreshDistributedCacheAsync(hash, code, cacheDir, normalizedUrl, identityMetadata, getLastDistributedRefresh);
                 trackBundleAccumulator(hash, normalizedUrl, cachePath);
                 return cachePath;
             }
         }
         else {
             getCachedPaths().set(cacheKey, cachePath);
-            refreshDistributedCacheAsync(hash, code, cacheDir, normalizedUrl, getLastDistributedRefresh);
+            refreshDistributedCacheAsync(hash, code, cacheDir, normalizedUrl, identityMetadata, getLastDistributedRefresh);
             trackBundleAccumulator(hash, normalizedUrl, cachePath);
             return cachePath;
         }
     }
     const processingStack = getProcessingStack();
-    if (processingStack.has(normalizedUrl)) {
+    if (processingStack.has(cacheIdentity)) {
         if (await exists(cachePath)) {
             httpCacheLog.debug("Circular dependency detected, file exists", {
                 url: normalizedUrl,
@@ -197,12 +198,12 @@ async function cacheHttpModuleInternal(url, options) {
                 detail: `Received HTML instead of JavaScript from ${normalizedUrl}. The package may not exist or failed to build on esm.sh.`,
             });
         }
-        processingStack.add(normalizedUrl);
+        processingStack.add(cacheIdentity);
         try {
             code = await rewriteModuleImports(code, normalizedUrl, options, cacheHttpModule);
         }
         finally {
-            processingStack.delete(normalizedUrl);
+            processingStack.delete(cacheIdentity);
         }
         code = embedSourceUrl(code, normalizedUrl);
         await fs.mkdir(cacheDir, { recursive: true });
@@ -213,7 +214,7 @@ async function cacheHttpModuleInternal(url, options) {
             });
         }
         try {
-            await httpBundleCache.setCode(String(hash), asLocalModuleCode(code), normalizedUrl, HTTP_MODULE_DISTRIBUTED_TTL_SEC);
+            await httpBundleCache.setCode(String(hash), asLocalModuleCode(code), normalizedUrl, HTTP_MODULE_DISTRIBUTED_TTL_SEC, identityMetadata);
         }
         catch (error) {
             if (error instanceof VeryfrontError && error.slug === "cache-invariant-violation") {
@@ -241,18 +242,22 @@ async function cacheHttpModuleInternal(url, options) {
     }
 }
 async function cacheHttpModule(url, options) {
+    const preparedOptions = ensurePreparedHttpCacheRequestOptions(options);
+    const effective = getEffectiveHttpCacheRequest(url, preparedOptions);
+    const effectiveOptions = effective.options;
     if (hasInjectedProcessingStack() || processingStackStorage.getStore()) {
-        return cacheHttpModuleInternal(url, options);
+        return cacheHttpModuleInternal(effective.url, effectiveOptions);
     }
-    return processingStackStorage.run(new Set(), () => cacheHttpModuleInternal(url, options));
+    return processingStackStorage.run(new Set(), () => cacheHttpModuleInternal(effective.url, effectiveOptions));
 }
 /**
  * Rewrite HTTP imports in the provided code to cached local file:// paths.
  * Returns the rewritten code and an optional bundle manifest ID for atomic validation.
  */
 export function cacheHttpImportsToLocal(code, options) {
+    const requestOptions = prepareHttpCacheRequestOptions(options);
     return bundleAccumulatorStorage.run([], async () => {
-        const replacements = await buildReplacements(code, undefined, options, cacheHttpModule);
+        const replacements = await buildReplacements(code, undefined, requestOptions, cacheHttpModule);
         if (replacements.size === 0)
             return { code };
         httpCacheLog.debug("Cached HTTP imports", { count: replacements.size });
@@ -278,26 +283,26 @@ export function cacheHttpImportsToLocal(code, options) {
 /**
  * Cache a specific HTTP module URL and return its local file:// path.
  */
-export async function cacheModuleToLocal(url, cacheDir) {
+export async function cacheModuleToLocal(url, cacheDir, reactVersion) {
     if (!isHttpUrl(url))
         return url;
     const importMap = { imports: {}, scopes: {} };
-    const cached = await cacheHttpModule(url, { cacheDir, importMap });
+    const cached = await cacheHttpModule(url, { cacheDir, importMap, reactVersion });
     return cached ? `file://${cached}` : url;
 }
 /**
  * Recover a missing HTTP bundle by looking up the code directly from the hash.
  * Delegates to bundle-recovery module with cacheHttpModule wired in.
  */
-export function recoverHttpBundleByHash(hash, cacheDir, parentCode) {
-    return recoverHttpBundleByHashImpl(hash, cacheDir, cacheHttpModule, parentCode);
+export function recoverHttpBundleByHash(hash, cacheDir, parentCode, identity) {
+    return recoverHttpBundleByHashImpl(hash, cacheDir, cacheHttpModule, parentCode, identity);
 }
 /**
  * Ensure all HTTP bundles exist locally before import.
  * Delegates to bundle-recovery module with cacheHttpModule wired in.
  */
-export function ensureHttpBundlesExist(bundlePaths, cacheDir) {
-    return ensureHttpBundlesExistImpl(bundlePaths, cacheDir, cacheHttpModule);
+export function ensureHttpBundlesExist(bundlePaths, cacheDir, identity) {
+    return ensureHttpBundlesExistImpl(bundlePaths, cacheDir, cacheHttpModule, identity);
 }
 /**
  * Invalidate a corrupted bundle from both local and distributed cache.

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

@@ -1,6 +1,6 @@
 import { AsyncLocalStorage } from "node:async_hooks";
 import type { BundleEntry } from "./bundle-manifest-types.js";
-import type { HttpCacheLike } from "./http-cache-helpers.js";
+import type { HttpCacheIdentityMetadata, HttpCacheLike } from "./http-cache-helpers.js";
 /** Per-request accumulator for bundle metadata during cacheHttpImportsToLocal. */
 export declare const bundleAccumulatorStorage: AsyncLocalStorage<BundleEntry[]>;
 /** Per-request stack used to detect circular HTTP module dependencies. */
@@ -21,9 +21,9 @@ export declare function waitForInFlightFetch(promise: Promise<string | null>, ca
  * Asynchronously refresh the distributed cache entry for a local bundle.
  * This is fire-and-forget to avoid blocking the hot path.
  */
-export declare function refreshDistributedCacheAsync(hash: number, code: string, _cacheDir: string, normalizedUrl: string, getLastDistributedRefresh: () => HttpCacheLike<string, number>): void;
+export declare function refreshDistributedCacheAsync(hash: string, code: string, _cacheDir: string, normalizedUrl: string, identityMetadata: HttpCacheIdentityMetadata, getLastDistributedRefresh: () => HttpCacheLike<string, number>): void;
 /**
  * Track bundle for manifest accumulation if in accumulation context.
  */
-export declare function trackBundleAccumulator(hash: number, normalizedUrl: string, cachePath: string): void;
+export declare function trackBundleAccumulator(hash: string, normalizedUrl: string, cachePath: string): void;
 //# sourceMappingURL=in-flight-manager.d.ts.map