Method getArchiveForModule

valdi/src/valdi/runtime/Resources/ResourceManager.cpp:80–151

}

Result<Ref<ValdiModuleArchive>> ResourceManager::getArchiveForModule(const StringBox& modulePath,
                                                                     bool useMmap,
                                                                     const Path& mmapCacheDir,
                                                                     const Ref<Metrics>& metrics) {
    auto bundleFilePath = resolveModuleArchiveFilePath(modulePath);

    auto bundleContent = _resourceLoader->loadModuleContent(bundleFilePath);
    if (!bundleContent) {
        // Fallback on .valdimodule for backward compatibility
        auto bundleContentAlternative = _resourceLoader->loadModuleContent(modulePath.append(".valdimodule"));
        if (!bundleContentAlternative) {
            return bundleContent.error().rethrow(STRING_FORMAT("Unable to load module '{}'", modulePath));
        } else {
            bundleContent = std::move(bundleContentAlternative);
        }
    }

    const auto& data = bundleContent.value();

    // NOTE: do not acquire _mutex anywhere in this function. It is called from getBundle while the
    // BundleInitializer holds the Bundle's mutex; the cleanup path (removeUnusedResources) takes
    // _mutex and then a Bundle mutex, so taking _mutex here inverts that order and can deadlock.
    // The mmap/metrics settings are snapshotted by getBundle under _mutex and passed in.

    bool usedMmap = false;
    bool mmapPublishFailed = false;
    MetricsStopWatch decompressStopWatch;
    Result<ValdiModuleArchive> result = [&]() {
        if (useMmap) {
            // Flat filename keyed by SHA-256 of the module path. Avoids
            // nested directories under the cache dir, sidesteps any
            // path-traversal concern from manifest-supplied module paths,
            // and is deterministic across app launches (std::hash is not —
            // libc++ may seed it randomly, which would orphan every cache
            // file on every restart and slowly fill the user's disk).
            auto modulePathView = modulePath.toStringView();
            auto flatName =
                BytesUtils::sha256String(reinterpret_cast<const Byte*>(modulePathView.data()), modulePathView.size());
            auto mmapPath = mmapCacheDir.appending(std::string_view(flatName));
            return ValdiModuleArchive::decompress(data.data(), data.size(), mmapPath, &usedMmap, &mmapPublishFailed);
        }
        return ValdiModuleArchive::decompress(data.data(), data.size());
    }();
    auto decompressDuration = decompressStopWatch.elapsed();

    // A/B telemetry. Emit a single path counter and a latency timer per call.
    // Failures don't get a path counter — they wouldn't tell us anything useful
    // about realized mmap rate.
    if (result && metrics != nullptr) {
        if (useMmap) {
            if (usedMmap) {
                metrics->emitModuleArchiveMmapSuccess(modulePath);
                // Emitted alongside Mmap_Success when the rename-into-cache step
                // failed; the in-memory buffer is still valid but no file was
                // published. Expected to be ~0 in production.
                if (mmapPublishFailed) {
                    metrics->emitModuleArchiveMmapPublishFail(modulePath);
                }