everything-dev/dist/version-manifest-resolve.cjs

A consolidated product package for building Module Federation apps with oRPC APIs.

Object.defineProperty(exports, Symbol.toStringTag, { value: 'Module' });
const require_runtime = require('./_virtual/_rolldown/runtime.cjs');
const require_bundle_path = require('./bundle-path.cjs');
let node_fs = require("node:fs");
let node_path = require("node:path");
node_path = require_runtime.__toESM(node_path, 1);
let node_crypto = require("node:crypto");
let every_plugin_version_manifest = require("every-plugin/version-manifest");

//#region src/version-manifest-resolve.ts
const cache = /* @__PURE__ */ new Map();
function clearSlotVersionCache() {
	cache.clear();
}
function fetchText(url, fetchImpl) {
	return fetchImpl(url).then((response) => {
		if (!response.ok) throw new Error(`version manifest fetch failed: ${response.status}`);
		return response.text();
	});
}
function slotVersionFromManifest(base, manifest) {
	const trimmedBase = base.replace(/\/$/, "");
	return {
		entryUrl: `${trimmedBase}/${manifest.entry}`,
		entryIntegrity: manifest.entryIntegrity,
		...manifest.browserManifest ? { browserManifestUrl: `${trimmedBase}/${manifest.browserManifest.file}` } : {},
		...manifest.ssr ? {
			ssrEntryUrl: `${trimmedBase}/${manifest.ssr.entry}`,
			ssrIntegrity: manifest.ssr.integrity
		} : {},
		...manifest.files ? { files: manifest.files } : {}
	};
}
/**
* Staged-slot preference (ADR 0020/0021 self-contained tier): when a runtime
* stages its own namespace under `BOS_BUNDLE_DIR`, a slot resolves from the
* staged dist's own version manifest instead of the config's pin — pinned
* manifest bytes that predate the image (deploy lag after a release bump)
* cannot exist in the staged namespace, so their hashed files would 404 the
* disk and fall through to the network, where the stale immutable bytes
* still answer 200 and boot a foreign build. The staged manifest is trusted
* (staged by the image build itself) and skipped entirely when the slot is
* absent from the staged namespace or the pinned manifest is present (the
* normal healthy case, which keeps the pin's SRI check).
*/
function readStagedSlotVersion(base, pin) {
	const bundleDir = process.env.BOS_BUNDLE_DIR;
	if (!bundleDir) return null;
	const slotDir = require_bundle_path.bundleUrlToStagedPath(base, bundleDir);
	if (!slotDir || !(0, node_fs.existsSync)(slotDir)) return null;
	const pinnedManifestPath = require_bundle_path.resolveContained(slotDir, pin.manifest);
	if (!pinnedManifestPath || (0, node_fs.existsSync)(pinnedManifestPath)) return null;
	const versionsDir = node_path.default.join(slotDir, "versions");
	if (!(0, node_fs.existsSync)(versionsDir)) return null;
	const manifests = (0, node_fs.readdirSync)(versionsDir).filter((name) => name.endsWith(".json")).map((name) => node_path.default.join(versionsDir, name)).filter((file) => (0, node_fs.statSync)(file).isFile()).sort((a, b) => (0, node_fs.statSync)(b).mtimeMs - (0, node_fs.statSync)(a).mtimeMs || (a < b ? -1 : 1));
	if (manifests.length === 0) return null;
	const manifestPath = manifests[0];
	if (!manifestPath) return null;
	try {
		return slotVersionFromManifest(base, every_plugin_version_manifest.WorkspaceVersionManifestSchema.parse(JSON.parse((0, node_fs.readFileSync)(manifestPath, "utf8"))));
	} catch {
		return null;
	}
}
async function resolveSlotVersion(input) {
	const key = `${input.base}::${input.pin.manifest}::${input.pin.integrity}`;
	const cached = cache.get(key);
	if (cached) return cached;
	const staged = readStagedSlotVersion(input.base, input.pin);
	if (staged) {
		cache.set(key, staged);
		return staged;
	}
	const manifestUrl = `${input.base.replace(/\/$/, "")}/${input.pin.manifest.replace(/^\//, "")}`;
	const body = await fetchText(manifestUrl, input.fetchImpl ?? fetch);
	const computed = `sha384-${(0, node_crypto.createHash)("sha384").update(body).digest("base64")}`;
	if (computed !== input.pin.integrity) throw new Error(`[SRI] version manifest integrity mismatch for ${manifestUrl}\n  Expected: ${input.pin.integrity}\n  Computed: ${computed}`);
	const manifest = every_plugin_version_manifest.WorkspaceVersionManifestSchema.parse(JSON.parse(body));
	const resolved = slotVersionFromManifest(input.base, manifest);
	cache.set(key, resolved);
	return resolved;
}

//#endregion
exports.clearSlotVersionCache = clearSlotVersionCache;
exports.resolveSlotVersion = resolveSlotVersion;
//# sourceMappingURL=version-manifest-resolve.cjs.map