@sentry/junior 0.202.0 → 0.204.0

package/dist/reporting-schema-DosTN__Q.js

@@ -0,0 +1,105 @@
+import { z } from "zod";
+//#region src/reporting-schema.ts
+const healthReportSchema = z.object({
+	status: z.literal("ok"),
+	service: z.string(),
+	timestamp: z.string()
+}).strict();
+const pluginSchema = z.object({
+	configKeys: z.array(z.string()),
+	description: z.string(),
+	displayName: z.string(),
+	name: z.string()
+}).strict();
+const pluginsSchema = z.array(pluginSchema);
+const skillReportSchema = z.object({
+	name: z.string(),
+	pluginProvider: z.string().optional()
+}).strict();
+const skillReportsSchema = z.array(skillReportSchema);
+const pluginPackageContentItemReportSchema = z.object({
+	dir: z.string(),
+	hasMigrationsDir: z.boolean(),
+	hasSkillsDir: z.boolean(),
+	packageName: z.string()
+}).strict();
+const pluginPackageContentReportSchema = z.object({
+	packageNames: z.array(z.string()),
+	packages: z.array(pluginPackageContentItemReportSchema),
+	manifestRoots: z.array(z.string()),
+	skillRoots: z.array(z.string()),
+	tracingIncludes: z.array(z.string())
+}).strict();
+const runtimeInfoReportSchema = z.object({
+	cwd: z.string(),
+	homeDir: z.string(),
+	descriptionText: z.string().optional(),
+	providers: z.array(z.string()),
+	skills: z.array(skillReportSchema),
+	packagedContent: pluginPackageContentReportSchema
+}).strict();
+const pluginOperationalToneSchema = z.enum([
+	"danger",
+	"good",
+	"neutral",
+	"warning"
+]);
+const pluginOperationalMetricSchema = z.object({
+	label: z.string(),
+	tone: pluginOperationalToneSchema.optional(),
+	value: z.string()
+}).strict();
+const pluginOperationalFieldSchema = z.object({
+	key: z.string(),
+	label: z.string()
+}).strict();
+const pluginOperationalRecordSchema = z.object({
+	id: z.string(),
+	tone: pluginOperationalToneSchema.optional(),
+	values: z.record(z.string(), z.string())
+}).strict();
+const pluginOperationalRecordSetSchema = z.object({
+	fields: z.array(pluginOperationalFieldSchema).optional(),
+	emptyText: z.string().optional(),
+	records: z.array(pluginOperationalRecordSchema).optional(),
+	title: z.string()
+}).strict();
+const pluginOperationalBarChartWidgetSchema = z.object({
+	categories: z.array(z.object({
+		id: z.string().min(1),
+		label: z.string().min(1),
+		values: z.record(z.string(), z.number().finite())
+	}).strict()).max(100),
+	description: z.string().optional(),
+	emptyText: z.string().optional(),
+	id: z.string().min(1),
+	series: z.array(z.object({
+		format: z.literal("usd").optional(),
+		key: z.string().min(1),
+		label: z.string().min(1),
+		tone: pluginOperationalToneSchema.optional()
+	}).strict()).min(1).max(8),
+	timeRangeDays: z.array(z.union([
+		z.literal(1),
+		z.literal(7),
+		z.literal(30),
+		z.literal(90)
+	])).min(1).max(4).optional(),
+	title: z.string().min(1),
+	type: z.literal("bar_chart")
+}).strict();
+const pluginOperationalReportSchema = z.object({
+	generatedAt: z.string().optional(),
+	metrics: z.array(pluginOperationalMetricSchema).optional(),
+	recordSets: z.array(pluginOperationalRecordSetSchema).optional(),
+	title: z.string().optional(),
+	pluginName: z.string(),
+	widgets: z.array(pluginOperationalBarChartWidgetSchema).max(12).optional()
+}).strict();
+const pluginOperationalReportFeedSchema = z.object({
+	generatedAt: z.string(),
+	reports: z.array(pluginOperationalReportSchema),
+	source: z.literal("plugins")
+}).strict();
+//#endregion
+export { pluginPackageContentReportSchema as a, runtimeInfoReportSchema as c, pluginPackageContentItemReportSchema as i, skillReportSchema as l, pluginOperationalReportFeedSchema as n, pluginSchema as o, pluginOperationalReportSchema as r, pluginsSchema as s, healthReportSchema as t, skillReportsSchema as u };

package/dist/resolve-CZHnfxaS.js

@@ -0,0 +1,546 @@
+import { C as withSpan, _ as setSpanAttributes } from "./logging-BzAk1S_s.js";
+import { A as sleep, P as SANDBOX_WORKSPACE_ROOT, r as isStale, t as create, u as isSandboxUnavailableError, v as getVercelSandboxCredentials, w as getStateAdapter, x as runNonInteractiveCommand } from "./profile-CrT5nXbw.js";
+import { z } from "zod";
+import { FileSystem, Sandbox } from "@vercel/sandbox";
+//#region src/chat/sandbox/resources.ts
+let configuredResources;
+function resourcesFromEnv() {
+	const value = process.env.SANDBOX_VCPUS?.trim();
+	if (!value || !/^\d+$/.test(value)) return;
+	const vcpus = Number(value);
+	if (!Number.isSafeInteger(vcpus) || vcpus <= 0) return;
+	return { vcpus };
+}
+/** Return the app-level sandbox sizing override. */
+function getSandboxResourceConfig() {
+	return configuredResources;
+}
+/** Replace app-level sandbox sizing and return the previous setting. */
+function setSandboxResourceConfig(config) {
+	const previous = configuredResources;
+	if (config?.vcpus === void 0) {
+		configuredResources = void 0;
+		return previous;
+	}
+	if (!Number.isSafeInteger(config.vcpus) || config.vcpus <= 0) throw new Error("sandbox.vcpus must be a positive integer");
+	configuredResources = { vcpus: config.vcpus };
+	return previous;
+}
+/** Resolve app-level sandbox sizing, falling back to the legacy environment setting. */
+function getSandboxResources() {
+	return configuredResources ?? resourcesFromEnv();
+}
+//#endregion
+//#region src/chat/sandbox/snapshot/span.ts
+/** Record the reusable snapshot selected for a new Sandbox. */
+function setSnapshotSpanAttributes(snapshot) {
+	setSpanAttributes({
+		"app.sandbox.source": snapshot.snapshotId ? "snapshot" : "created",
+		"app.sandbox.snapshot.cache_hit": snapshot.cacheHit,
+		"app.sandbox.snapshot.resolve_outcome": snapshot.resolveOutcome,
+		...snapshot.profileHash ? { "app.sandbox.snapshot.profile_hash": snapshot.profileHash } : void 0,
+		"app.sandbox.snapshot.dependency_count": snapshot.dependencyCount,
+		...snapshot.rebuildReason ? { "app.sandbox.snapshot.rebuild_reason": snapshot.rebuildReason } : void 0
+	});
+}
+/** Record one stage of dependency snapshot resolution or creation. */
+async function trace(name, op, attributes, callback) {
+	return await withSpan(name, op, {}, callback, attributes);
+}
+//#endregion
+//#region src/chat/sandbox/snapshot/install.ts
+async function runOrThrow(sandbox, params, label) {
+	const result = await runNonInteractiveCommand(sandbox, params);
+	if (result.exitCode === 0) return;
+	const detail = result.stderr.trim() || result.stdout.trim() || "command failed";
+	throw new Error(`${label} failed: ${detail}`);
+}
+async function tryRun(sandbox, params) {
+	return (await runNonInteractiveCommand(sandbox, params)).exitCode === 0;
+}
+async function installGh(sandbox, signal, timeoutMs) {
+	if (await tryRun(sandbox, {
+		cmd: "dnf",
+		args: [
+			"install",
+			"-y",
+			"gh"
+		],
+		signal,
+		sudo: true,
+		timeoutMs
+	})) return;
+	if (!await tryRun(sandbox, {
+		cmd: "dnf",
+		args: [
+			"config-manager",
+			"addrepo",
+			"--from-repofile=https://cli.github.com/packages/rpm/gh-cli.repo"
+		],
+		signal,
+		sudo: true,
+		timeoutMs
+	})) {
+		await runOrThrow(sandbox, {
+			cmd: "dnf",
+			args: [
+				"install",
+				"-y",
+				"dnf-command(config-manager)"
+			],
+			signal,
+			sudo: true,
+			timeoutMs
+		}, "dnf install dnf-command(config-manager)");
+		await runOrThrow(sandbox, {
+			cmd: "dnf",
+			args: [
+				"config-manager",
+				"--add-repo",
+				"https://cli.github.com/packages/rpm/gh-cli.repo"
+			],
+			signal,
+			sudo: true,
+			timeoutMs
+		}, "dnf config-manager --add-repo gh-cli.repo");
+	}
+	await runOrThrow(sandbox, {
+		cmd: "dnf",
+		args: [
+			"install",
+			"-y",
+			"gh",
+			"--repo",
+			"gh-cli"
+		],
+		signal,
+		sudo: true,
+		timeoutMs
+	}, "dnf install gh --repo gh-cli");
+}
+function filePath(url, sha256) {
+	let basename = "package.rpm";
+	try {
+		const candidate = new URL(url).pathname.split("/").filter(Boolean).at(-1);
+		if (candidate) basename = candidate;
+	} catch {}
+	const sanitized = basename.replace(/[^a-zA-Z0-9._-]/g, "_");
+	return `/tmp/junior-runtime-${sha256.slice(0, 12)}-${sanitized}`;
+}
+async function installUrl(sandbox, dependency, signal, timeoutMs) {
+	const rpmPath = filePath(dependency.url, dependency.sha256);
+	await runOrThrow(sandbox, {
+		cmd: "curl",
+		args: [
+			"-fsSL",
+			dependency.url,
+			"-o",
+			rpmPath
+		],
+		signal,
+		timeoutMs
+	}, `curl download ${dependency.url}`);
+	const checksum = await runNonInteractiveCommand(sandbox, {
+		cmd: "sha256sum",
+		args: [rpmPath],
+		signal,
+		timeoutMs
+	});
+	const expected = dependency.sha256;
+	const actual = checksum.stdout.trim().split(/\s+/)[0]?.toLowerCase();
+	if (checksum.exitCode !== 0) {
+		const detail = checksum.stderr.trim() || checksum.stdout.trim() || "command failed";
+		throw new Error(`sha256sum failed: ${detail}`);
+	}
+	if (!actual) throw new Error("sha256sum produced empty output");
+	if (actual !== expected) throw new Error(`checksum mismatch for ${dependency.url}: expected ${expected}, got ${actual}`);
+	await runOrThrow(sandbox, {
+		cmd: "dnf",
+		args: [
+			"install",
+			"-y",
+			rpmPath
+		],
+		signal,
+		sudo: true,
+		timeoutMs
+	}, `dnf install ${dependency.url}`);
+}
+/** Install declared system and npm dependencies into a snapshot sandbox. */
+async function dependencies(sandbox, values, signal, timeoutMs) {
+	const system = values.filter((dependency) => dependency.type === "system");
+	const npm = values.filter((dependency) => dependency.type === "npm").map((dependency) => `${dependency.package}@${dependency.version}`);
+	if (system.length > 0) await trace("sandbox.snapshot.install_system", "sandbox.snapshot.install.system", { "app.sandbox.snapshot.install.system_count": system.length }, async () => {
+		for (const dependency of system) {
+			signal?.throwIfAborted();
+			if ("url" in dependency) await installUrl(sandbox, dependency, signal, timeoutMs);
+			else if (dependency.package === "gh") await installGh(sandbox, signal, timeoutMs);
+			else await runOrThrow(sandbox, {
+				cmd: "dnf",
+				args: [
+					"install",
+					"-y",
+					dependency.package
+				],
+				signal,
+				sudo: true,
+				timeoutMs
+			}, `dnf install ${dependency.package}`);
+		}
+	});
+	if (npm.length > 0) await trace("sandbox.snapshot.install_npm", "sandbox.snapshot.install.npm", { "app.sandbox.snapshot.install.npm_count": npm.length }, async () => {
+		await runOrThrow(sandbox, {
+			cmd: "npm",
+			args: [
+				"install",
+				"--global",
+				"--prefix",
+				`${SANDBOX_WORKSPACE_ROOT}/.junior`,
+				...npm
+			],
+			signal,
+			timeoutMs
+		}, "npm install");
+	});
+}
+/** Run declared postinstall commands after dependency binaries are available. */
+async function postinstall(sandbox, commands, signal, timeoutMs) {
+	if (commands.length === 0) return;
+	await trace("sandbox.snapshot.runtime_postinstall", "sandbox.snapshot.runtime_postinstall", { "app.sandbox.snapshot.runtime_postinstall.count": commands.length }, async () => {
+		for (const command of commands) {
+			signal?.throwIfAborted();
+			const result = await runNonInteractiveCommand(sandbox, {
+				cmd: command.cmd,
+				args: command.args,
+				login: true,
+				pathPrefix: `${SANDBOX_WORKSPACE_ROOT}/.junior/bin:$PATH`,
+				signal,
+				timeoutMs,
+				...command.sudo !== void 0 ? { sudo: command.sudo } : void 0
+			});
+			if (result.exitCode !== 0) {
+				const detail = result.stderr.trim() || result.stdout.trim() || "command failed";
+				throw new Error(`runtime-postinstall ${command.cmd} failed: ${detail}`);
+			}
+		}
+	});
+}
+//#endregion
+//#region src/chat/sandbox/workspace.ts
+/** Bind one tool call's cancellation to every sandbox filesystem operation. */
+function bindSandboxFileSystem(fs, signal) {
+	if (!signal) return fs;
+	return {
+		readFile(filePath, options) {
+			signal.throwIfAborted();
+			return fs.readFile(filePath, {
+				...options,
+				signal
+			});
+		},
+		writeFile(filePath, content, options) {
+			signal.throwIfAborted();
+			return fs.writeFile(filePath, content, {
+				...options,
+				signal
+			});
+		},
+		readdir(filePath) {
+			signal.throwIfAborted();
+			return fs.readdir(filePath, { signal });
+		},
+		stat(filePath) {
+			signal.throwIfAborted();
+			return fs.stat(filePath, { signal });
+		}
+	};
+}
+/** Pin Junior's sandbox contract to one Vercel session without SDK replay. */
+function createSandboxSession(sandbox, options) {
+	const session = sandbox.currentSession();
+	const fileSystem = new FileSystem(session);
+	const run = async (operation) => {
+		try {
+			return await operation();
+		} catch (error) {
+			if (isSandboxUnavailableError(error)) options?.onUnavailable?.(session.sessionId);
+			throw error;
+		}
+	};
+	return {
+		sandboxId: sandbox.name,
+		sessionId: session.sessionId,
+		fs: {
+			readFile: async (filePath, readOptions) => await run(async () => await fileSystem.readFile(filePath, readOptions)),
+			writeFile: async (filePath, content, writeOptions) => await run(async () => await fileSystem.writeFile(filePath, content, writeOptions)),
+			readdir: async (filePath, readOptions) => await run(async () => await fileSystem.readdir(filePath, readOptions)),
+			stat: async (filePath, statOptions) => await run(async () => await fileSystem.stat(filePath, statOptions))
+		},
+		extendTimeout(duration) {
+			return run(async () => await session.extendTimeout(duration));
+		},
+		mkDir(path) {
+			return run(async () => await session.mkDir(path));
+		},
+		readFileToBuffer(input) {
+			return run(async () => await session.readFileToBuffer(input));
+		},
+		async runCommand(input) {
+			const result = await run(async () => await session.runCommand(input));
+			const [stdout, stderr] = await Promise.all([run(async () => await result.stdout()), run(async () => await result.stderr())]);
+			return {
+				exitCode: result.exitCode,
+				stdout,
+				stderr
+			};
+		},
+		snapshot(options) {
+			return run(async () => {
+				return { snapshotId: (await session.snapshot(options)).snapshotId };
+			});
+		},
+		stop() {
+			return run(async () => await session.stop());
+		},
+		update(params) {
+			return run(async () => await session.update(params));
+		},
+		writeFiles(files) {
+			return run(async () => await session.writeFiles(files));
+		}
+	};
+}
+/** Best-effort stop; ignore secondary stop failures during cleanup. */
+async function stopSession(session) {
+	if (!session) return;
+	try {
+		await session.stop();
+	} catch {}
+}
+//#endregion
+//#region src/chat/sandbox/snapshot/resolve.ts
+const SNAPSHOT_CACHE_PREFIX = "junior:sandbox_snapshot_profile:v2";
+const SNAPSHOT_LOCK_PREFIX = "junior:sandbox_snapshot_lock";
+const SNAPSHOT_CACHE_TTL_MS = 2592e6;
+const SNAPSHOT_BUILD_LOCK_BUFFER_MS = 3e4;
+const SNAPSHOT_WAIT_FOR_LOCK_BUFFER_MS = 3e4;
+const cachedSnapshotSchema = z.object({
+	profileHash: z.string(),
+	snapshotId: z.string(),
+	runtime: z.string(),
+	createdAtMs: z.number(),
+	dependencyCount: z.number(),
+	buildDurationMs: z.number().int().nonnegative()
+}).strict();
+function profileCacheKey(profileHash) {
+	return `${SNAPSHOT_CACHE_PREFIX}:${profileHash}`;
+}
+function profileLockKey(profileHash) {
+	return `${SNAPSHOT_LOCK_PREFIX}:${profileHash}`;
+}
+/** Read one cached snapshot pointer; only a missing key is a cache miss. */
+async function getCachedSnapshot(profileHash) {
+	const state = getStateAdapter();
+	await state.connect();
+	const raw = await state.get(profileCacheKey(profileHash));
+	if (typeof raw !== "string") return null;
+	let value;
+	try {
+		value = JSON.parse(raw);
+	} catch {
+		throw new Error(`Invalid cached sandbox snapshot for ${profileHash}`);
+	}
+	const parsed = cachedSnapshotSchema.safeParse(value);
+	if (!parsed.success || parsed.data.profileHash !== profileHash) throw new Error(`Invalid cached sandbox snapshot for ${profileHash}`);
+	return parsed.data;
+}
+/** Persist one dependency profile's reusable snapshot pointer. */
+async function setCachedSnapshot(entry) {
+	const state = getStateAdapter();
+	await state.connect();
+	await state.set(profileCacheKey(entry.profileHash), JSON.stringify(entry), SNAPSHOT_CACHE_TTL_MS);
+}
+async function build(value, runtime, timeoutMs, signal, prepare) {
+	return await trace("sandbox.snapshot.build", "sandbox.snapshot.build", {
+		"app.sandbox.runtime": runtime,
+		"app.sandbox.snapshot.dependency_count": value.dependencyCount
+	}, async () => {
+		const startedAtMs = Date.now();
+		const sandboxCredentials = getVercelSandboxCredentials();
+		const resources = getSandboxResources();
+		const sandbox = createSandboxSession(await Sandbox.create({
+			timeout: timeoutMs,
+			runtime,
+			signal,
+			...sandboxCredentials ?? {},
+			...resources ? { resources } : void 0
+		}));
+		try {
+			await dependencies(sandbox, value.dependencies, signal);
+			await postinstall(sandbox, value.postinstall, signal);
+			await prepare?.(sandbox);
+			return {
+				snapshotId: await trace("sandbox.snapshot.capture", "sandbox.snapshot.capture", { "app.sandbox.snapshot.dependency_count": value.dependencyCount }, async () => {
+					return (await sandbox.snapshot({ signal })).snapshotId;
+				}),
+				buildDurationMs: Math.max(0, Date.now() - startedAtMs)
+			};
+		} finally {
+			try {
+				await sandbox.stop();
+			} catch {}
+		}
+	});
+}
+/** Run one profile build under a timeout-buffered lock or reuse its result. */
+async function withBuildLock(profileHash, timeoutMs, callback, canUseCachedSnapshot, onWaitingForLock, signal) {
+	signal?.throwIfAborted();
+	const state = getStateAdapter();
+	await state.connect();
+	const lockKey = profileLockKey(profileHash);
+	const lockTtlMs = timeoutMs + SNAPSHOT_BUILD_LOCK_BUFFER_MS;
+	const tryAcquireLock = async () => await state.acquireLock(lockKey, lockTtlMs);
+	let lock = await tryAcquireLock();
+	if (lock) try {
+		return await callback();
+	} finally {
+		await state.releaseLock(lock);
+	}
+	return await trace("sandbox.snapshot.lock_wait", "sandbox.snapshot.lock_wait", { "app.sandbox.snapshot.profile_hash": profileHash }, async () => {
+		await onWaitingForLock?.();
+		const waitUntil = Date.now() + lockTtlMs + SNAPSHOT_WAIT_FOR_LOCK_BUFFER_MS;
+		while (Date.now() < waitUntil) {
+			signal?.throwIfAborted();
+			const cached = await getCachedSnapshot(profileHash);
+			if (cached?.snapshotId && canUseCachedSnapshot(cached)) return {
+				snapshotId: cached.snapshotId,
+				source: "cache_hit_after_lock_wait",
+				createdAtMs: cached.createdAtMs,
+				buildDurationMs: cached.buildDurationMs
+			};
+			lock = await tryAcquireLock();
+			if (lock) try {
+				const result = await callback();
+				return {
+					snapshotId: result.snapshotId,
+					source: result.source === "built" ? "built" : "cache_hit_after_lock_wait",
+					createdAtMs: result.createdAtMs,
+					buildDurationMs: result.buildDurationMs
+				};
+			} finally {
+				await state.releaseLock(lock);
+			}
+			await sleep(500, signal);
+		}
+		signal?.throwIfAborted();
+		const cached = await getCachedSnapshot(profileHash);
+		if (cached?.snapshotId && canUseCachedSnapshot(cached)) return {
+			snapshotId: cached.snapshotId,
+			source: "cache_hit_after_lock_wait",
+			createdAtMs: cached.createdAtMs,
+			buildDurationMs: cached.buildDurationMs
+		};
+		throw new Error("Timed out waiting for snapshot build lock");
+	});
+}
+function toResolveOutcome(forceRebuild, source) {
+	if (source === "built") return forceRebuild ? "forced_rebuild" : "rebuilt";
+	return source;
+}
+function getRebuildReason(params) {
+	if (params.forceRebuild) return params.staleSnapshotId ? "snapshot_missing" : "force_rebuild";
+	if (params.cached?.snapshotId && params.shouldRebuildCached) return "floating_stale";
+	if (!params.cached?.snapshotId) return "cache_miss";
+}
+/** Resolve or build the reusable snapshot for the current dependency profile. */
+async function resolve(params) {
+	return await trace("sandbox.snapshot.resolve", "sandbox.snapshot.resolve", {
+		"app.sandbox.runtime": params.runtime,
+		"app.sandbox.snapshot.force_rebuild": Boolean(params.forceRebuild)
+	}, async () => {
+		params.signal?.throwIfAborted();
+		await params.onProgress?.("resolve_start");
+		const currentProfile = create(params.runtime, params.workspace);
+		if (!currentProfile) return {
+			dependencyCount: 0,
+			cacheHit: false,
+			resolveOutcome: "no_profile"
+		};
+		const cached = await getCachedSnapshot(currentProfile.hash);
+		const cachedNeedsRebuild = Boolean(cached?.snapshotId && isStale(currentProfile, cached.createdAtMs));
+		if (!params.forceRebuild && cached?.snapshotId && !cachedNeedsRebuild) {
+			await params.onProgress?.("cache_hit");
+			return {
+				snapshotId: cached.snapshotId,
+				profileHash: currentProfile.hash,
+				dependencyCount: currentProfile.dependencyCount,
+				cacheHit: true,
+				resolveOutcome: "cache_hit",
+				createdAtMs: cached.createdAtMs,
+				buildDurationMs: cached.buildDurationMs
+			};
+		}
+		const rebuildReason = getRebuildReason({
+			forceRebuild: params.forceRebuild,
+			staleSnapshotId: params.staleSnapshotId,
+			cached,
+			shouldRebuildCached: cachedNeedsRebuild
+		});
+		const canUseCachedSnapshot = (candidate) => {
+			if (params.forceRebuild) {
+				if (params.staleSnapshotId) return candidate.snapshotId !== params.staleSnapshotId;
+				return candidate.snapshotId !== cached?.snapshotId;
+			}
+			return !isStale(currentProfile, candidate.createdAtMs);
+		};
+		const lockResult = await withBuildLock(currentProfile.hash, params.timeoutMs, async () => {
+			const latest = await getCachedSnapshot(currentProfile.hash);
+			if (latest?.snapshotId && canUseCachedSnapshot(latest)) {
+				await params.onProgress?.("cache_hit");
+				return {
+					snapshotId: latest.snapshotId,
+					source: "cache_hit",
+					createdAtMs: latest.createdAtMs,
+					buildDurationMs: latest.buildDurationMs
+				};
+			}
+			await params.onProgress?.("building_snapshot");
+			const built = await build(currentProfile, params.runtime, params.timeoutMs, params.signal, params.prepareWorkspace);
+			const createdAtMs = Date.now();
+			await setCachedSnapshot({
+				profileHash: currentProfile.hash,
+				snapshotId: built.snapshotId,
+				runtime: params.runtime,
+				createdAtMs,
+				dependencyCount: currentProfile.dependencyCount,
+				buildDurationMs: built.buildDurationMs
+			});
+			await params.onProgress?.("build_complete");
+			return {
+				snapshotId: built.snapshotId,
+				source: "built",
+				createdAtMs,
+				buildDurationMs: built.buildDurationMs
+			};
+		}, canUseCachedSnapshot, async () => {
+			await params.onProgress?.("waiting_for_lock");
+		}, params.signal);
+		return {
+			snapshotId: lockResult.snapshotId,
+			profileHash: currentProfile.hash,
+			dependencyCount: currentProfile.dependencyCount,
+			cacheHit: lockResult.source !== "built",
+			resolveOutcome: toResolveOutcome(Boolean(params.forceRebuild), lockResult.source),
+			createdAtMs: lockResult.createdAtMs,
+			buildDurationMs: lockResult.buildDurationMs,
+			...rebuildReason ? { rebuildReason } : void 0
+		};
+	});
+}
+/** Identify provider errors that mean a referenced snapshot no longer exists. */
+function isMissingError(error) {
+	const searchable = error instanceof Error ? error.message.toLowerCase() : String(error).toLowerCase();
+	return searchable.includes("snapshot") && (searchable.includes("not found") || searchable.includes("unknown") || searchable.includes("404"));
+}
+//#endregion
+export { createSandboxSession as a, postinstall as c, getSandboxResources as d, setSandboxResourceConfig as f, bindSandboxFileSystem as i, setSnapshotSpanAttributes as l, isMissingError as n, stopSession as o, resolve as r, dependencies as s, getCachedSnapshot as t, getSandboxResourceConfig as u };

package/dist/rolldown-runtime-B4FMCO8f.js

@@ -0,0 +1,28 @@
+import "node:module";
+//#region \0rolldown/runtime.js
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __exportAll = (all, no_symbols) => {
+	let target = {};
+	for (var name in all) __defProp(target, name, {
+		get: all[name],
+		enumerable: true
+	});
+	if (!no_symbols) __defProp(target, Symbol.toStringTag, { value: "Module" });
+	return target;
+};
+var __copyProps = (to, from, except, desc) => {
+	if (from && typeof from === "object" || typeof from === "function") for (var keys = __getOwnPropNames(from), i = 0, n = keys.length, key; i < n; i++) {
+		key = keys[i];
+		if (!__hasOwnProp.call(to, key) && key !== except) __defProp(to, key, {
+			get: ((k) => from[k]).bind(null, key),
+			enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable
+		});
+	}
+	return to;
+};
+var __reExport = (target, mod, secondTarget) => (__copyProps(target, mod, "default"), secondTarget && __copyProps(secondTarget, mod, "default"));
+//#endregion
+export { __reExport as n, __exportAll as t };