fundus 0.28.1 → 0.29.1

package/build/index.js

@@ -1,7 +1,7 @@
 import http from 'node:http';
 import fs__default from 'node:fs';
 import process from 'node:process';
-import { p as polka, h as handler, f as format_listening_address } from './server/chunks/handler-BAe0c9yw.js';
+import { p as polka, h as handler, f as format_listening_address } from './server/chunks/handler-Cna54zf6.js';
 import { env, timeout_env } from './env.js';
 import { rm } from 'node:fs/promises';
 import './shims.js';
@@ -11,15 +11,15 @@ import 'node:path';
 import 'node:timers';
 import 'node:querystring';
 import 'node:stream';
-import './server/chunks/chunks/shared.js-D3ZDVUlh.js';
-import './server/chunks/chunks/internal.js-CJkB_gzV.js';
+import './server/chunks/chunks/shared.js-C6qC0jnA.js';
+import './server/chunks/chunks/internal.js-DlRiYJji.js';
 import 'node:module';
-import './server/chunks/chunks/utils.js-CqWW_v-5.js';
-import './server/chunks/index.js-DUYD4JB0.js';
+import './server/chunks/chunks/utils.js-BZ32hXFI.js';
+import './server/chunks/index.js-BnpHWDec.js';
 import './server/chunks/chunks/internal2.js-BlXt2rfE.js';
-import './server/chunks/chunks/exports.js-D0dALD2Q.js';
+import './server/chunks/chunks/exports.js-CNZgoxR0.js';
 import './server/chunks/chunks/routing.js-y-tryuip.js';
-import './server/chunks/manifest.js-zwun-T7O.js';
+import './server/chunks/manifest.js-9WMEOpxH.js';
 import 'node:url';
 
 const path = env('SOCKET_PATH', false);

package/build/server/chunks/chunks/{context.js-BZSZNuAd.js → context.js-BR2IRl9z.js}

@@ -1,8 +1,8 @@
-import { c as compareCodeUnits, h as folderOfRawPath, j as rawFileNameOfPath, g as canonicalizeParameters, n as normalizeFolderPath, J as typesForFileName, k as parentFolderPath, u as portableFolderPathKey } from './core.js-BHxa3VBo.js';
-import { i as isRecord, s as serverPluginsByType, L as LibraryStore, d as descriptorsByType, m as manifestModuleFileName, l as locateGeneratedAssetDeclaration, a as serializeLibrary, b as serverPluginForType, S as SourceImportError, p as processAssets, g as generateManifestModules, r as readCurrentProxy, e as encodeRelativePathForUrl, c as invalidInput, f as parseLibrary } from './contract.js-B4JdXFgm.js';
-import { c as collectAllReferences, a as assetIdError, b as computeLibraryMembership, d as allDeliveredAssetIds, i as isValidAssetId } from './manifest-membership.js-BkrPsM_r.js';
+import { c as compareCodeUnits, h as folderOfRawPath, j as rawFileNameOfPath, g as canonicalizeParameters, n as normalizeFolderPath, J as typesForFileName, k as parentFolderPath, u as portableFolderPathKey } from './core.js-AGKlECJ0.js';
+import { i as isRecord, s as serverPluginsByType, P as ProxyInfoCache, L as LibraryStore, d as descriptorsByType, m as manifestModuleFileName, l as locateGeneratedAssetDeclaration, a as serializeLibrary, b as serverPluginForType, S as SourceImportError, p as processAssets, g as generateManifestModules, r as readCurrentProxy, e as encodeRelativePathForUrl, c as invalidInput, f as parseLibrary } from './contract.js-DHeIVVv8.js';
+import { c as collectAllReferences, d as allDeliveredAssetIds, b as computeLibraryMembership, a as assetIdError, i as isValidAssetId } from './manifest-membership.js-DkHaPk2F.js';
 import { v as validateDependencyList, f as formatRequiredBy } from './dependencies.js-pUkjICr5.js';
-import { v as verifyStableRawFile, c as classifyRawDirectory } from './raw-reconciliation2.js-DKOpJ8if.js';
+import { m as mapConcurrent, v as verifyStableRawFile, c as classifyRawDirectory } from './raw-reconciliation.js-Cco4r8lr.js';
 import { createRequire } from 'node:module';
 import { isAbsolute, resolve, basename, dirname, join, extname, relative, sep } from 'node:path';
 import { existsSync, watch, readFileSync } from 'node:fs';
@@ -16,14 +16,59 @@ import { lookup } from 'node:dns/promises';
 import { isIP } from 'node:net';
 import { request } from 'node:https';
 
-//#region src/lib/core/figma-tag-script.ts
 /**
-* Whether the id names a node inside an instance (`I<instance>;<source>`).
-* Such nodes inherit the shared plugin data of the main component's node, so
-* they report its tag without being a separate taggable node.
+* The tag a link URL names, or `null`. An exact string match (no URL parsing)
+* makes any path segment, query, fragment or percent-escape fail the tag grammar.
 */
-function isInstanceSublayerId(id) {
-	return id.startsWith("I");
+function parseFundusTagLink(url) {
+	if (!url.startsWith("https://fundus.invalid/asset/")) return null;
+	const tag = url.slice(29);
+	return isValidAssetId(tag) ? tag : null;
+}
+var TAGGABLE_NODE_ID = /^\d+:\d+$/;
+/**
+* The Fundus tags carried by own links on plain scene-node ids; inherited,
+* sublayer, foreign and unparsable links are dropped. One entry per link, so
+* several tags on one node stay several entries. Sorted by tag, then node id.
+*/
+function figmaTagEntries(links) {
+	const entries = [];
+	for (const link of links) {
+		if (link.inherited || !TAGGABLE_NODE_ID.test(link.nodeId)) continue;
+		const tag = parseFundusTagLink(link.url);
+		if (tag === null) continue;
+		entries.push(link.linkId === void 0 ? {
+			tag,
+			nodeId: link.nodeId
+		} : {
+			tag,
+			nodeId: link.nodeId,
+			linkId: link.linkId
+		});
+	}
+	return entries.sort((left, right) => compareCodeUnits(left.tag, right.tag) || compareCodeUnits(left.nodeId, right.nodeId));
+}
+/**
+* The links in a REST `GET /v1/files/:key/dev_resources` body, or `null` when
+* `dev_resources` is not an array. Entries without string `id`/`url`/`node_id`
+* are skipped.
+*/
+function figmaLinksFromRest(body) {
+	const resources = typeof body === "object" && body !== null ? body.dev_resources : void 0;
+	if (!Array.isArray(resources)) return null;
+	const links = [];
+	for (const resource of resources) {
+		if (typeof resource !== "object" || resource === null) continue;
+		const { id, url, node_id: nodeId } = resource;
+		if (typeof id !== "string" || typeof url !== "string" || typeof nodeId !== "string") continue;
+		links.push({
+			nodeId,
+			url,
+			inherited: false,
+			linkId: id
+		});
+	}
+	return links;
 }
 //#endregion
 //#region src/lib/core/propose-asset-id.ts
@@ -427,6 +472,9 @@ var PNG_SIGNATURE = Uint8Array.from([
 	26,
 	10
 ]);
+/** Worst case per API call: 3 attempts × 30 s timeout + 2 waits × 10 s = 110 s. */
+var FIGMA_RATE_LIMIT_ATTEMPTS = 3;
+var FIGMA_RATE_LIMIT_MAX_WAIT_SECONDS = 10;
 function record(value) {
 	return typeof value === "object" && value !== null && !Array.isArray(value) ? value : null;
 }
@@ -506,12 +554,12 @@ function retryAfter(response) {
 	const seconds = Number(raw);
 	return Number.isSafeInteger(seconds) ? seconds : void 0;
 }
-function upstreamStatusError(response) {
+function upstreamStatusError(response, scope) {
 	if (response.status === 401) return new SourceImportError("unauthorized", "Figma authentication failed.");
-	if (response.status === 403) return new SourceImportError("forbidden", "Figma authentication or access failed. The token may be invalid or expired, or it may not have access to this file.");
+	if (response.status === 403) return new SourceImportError("forbidden", scope ? `Figma authentication or access failed. The token may be invalid or expired, may lack the ${scope} scope, or may not have access to this file.` : "Figma authentication or access failed. The token may be invalid or expired, or it may not have access to this file.");
 	if (response.status === 404) return new SourceImportError("not-found", "The Figma file or node was not found.");
 	if (response.status === 429) return new SourceImportError("rate-limited", "Figma rate-limited this request.", retryAfter(response));
-	return new SourceImportError("upstream-failed", `Figma export failed with status ${response.status}.`);
+	return new SourceImportError("upstream-failed", `Figma request failed with status ${response.status}.`);
 }
 function isForbiddenIpv4(address) {
 	const parts = address.split(".").map(Number);
@@ -570,7 +618,7 @@ async function resolveSafeDownloadTarget(value) {
 		addresses
 	};
 }
-async function fetchWithDeadline(fetcher, url, init, consume) {
+async function fetchWithDeadline(fetcher, url, init, scope) {
 	const controller = new AbortController();
 	const timeout = setTimeout(() => controller.abort(), REQUEST_TIMEOUT_MS);
 	try {
@@ -578,12 +626,12 @@ async function fetchWithDeadline(fetcher, url, init, consume) {
 			...init,
 			signal: controller.signal
 		});
-		if (!response.ok) throw upstreamStatusError(response);
-		return await consume(response);
+		if (!response.ok) throw upstreamStatusError(response, scope);
+		return new Uint8Array(await response.arrayBuffer());
 	} catch (cause) {
-		if (controller.signal.aborted || cause instanceof Error && cause.name === "AbortError") throw new SourceImportError("download-timeout", "Figma export timed out.");
+		if (controller.signal.aborted || cause instanceof Error && cause.name === "AbortError") throw new SourceImportError("download-timeout", "Figma request timed out.");
 		if (cause instanceof SourceImportError) throw cause;
-		throw new SourceImportError("upstream-failed", "Figma export request failed.");
+		throw new SourceImportError("upstream-failed", "Figma request failed.");
 	} finally {
 		clearTimeout(timeout);
 	}
@@ -684,44 +732,28 @@ async function validatePng(bytes) {
 	if (!metadata.width || !metadata.height) throw new SourceImportError("invalid-response", "Figma export has invalid dimensions.");
 	if (metadata.width * metadata.height > MAX_PIXELS) throw new SourceImportError("image-too-large", "Figma export exceeds the 32 megapixel limit.");
 }
-/**
-* Every taggable node in a REST document tree (`plugin_data=shared`), in
-* document order. Nodes inside instances are skipped: they echo the main
-* component node's tag, and Fundus imports only plain `12:34` node ids.
-*/
-function figmaDocumentNodes(document) {
-	const nodes = [];
-	const visit = (value, page) => {
-		const current = record(value);
-		if (!current) return;
-		const name = typeof current.name === "string" ? current.name : "";
-		const pageName = current.type === "CANVAS" ? name : page;
-		if (typeof current.id === "string" && current.type !== "DOCUMENT" && current.type !== "CANVAS" && !isInstanceSublayerId(current.id)) {
-			const shared = record(current.sharedPluginData);
-			const fundus = shared ? record(shared.fundus) : null;
-			const tag = fundus && typeof fundus.assetId === "string" ? fundus.assetId : "";
-			nodes.push({
-				nodeId: current.id,
-				nodeName: name,
-				page: pageName,
-				tag: tag === "" ? null : tag
-			});
-		}
-		if (Array.isArray(current.children)) for (const child of current.children) visit(child, pageName);
-	};
-	visit(record(document), "");
-	return nodes;
+async function fetchFigmaApiBytes(endpoint, init, scope, context) {
+	for (let attempt = 1;; attempt++) try {
+		return await fetchWithDeadline(context.fetch, endpoint, init, scope);
+	} catch (cause) {
+		const wait = cause instanceof SourceImportError && cause.code === "rate-limited" ? cause.retryAfterSeconds : void 0;
+		if (wait === void 0 || wait > FIGMA_RATE_LIMIT_MAX_WAIT_SECONDS || attempt >= FIGMA_RATE_LIMIT_ATTEMPTS) throw cause;
+		await new Promise((resolve) => setTimeout(resolve, wait * 1e3));
+	}
 }
-/** The whole document tree of a Figma file, including every node's shared plugin data. */
-async function fetchFigmaDocument(fileKey, context) {
+async function requestFigmaApi(endpoint, context, request) {
 	const token = context.config.import.figma.token;
 	if (!token) throw new SourceImportError("not-configured", "Figma access is not configured.");
-	const endpoint = new URL(`https://api.figma.com/v1/files/${encodeURIComponent(fileKey)}`);
-	endpoint.searchParams.set("plugin_data", "shared");
-	const jsonBytes = await fetchWithDeadline(context.fetch, endpoint, {
+	const jsonBytes = await fetchFigmaApiBytes(endpoint, {
+		method: request.method ?? "GET",
 		redirect: "error",
-		headers: { "X-Figma-Token": token }
-	}, async (response) => new Uint8Array(await response.arrayBuffer()));
+		headers: {
+			"X-Figma-Token": token,
+			...request.body !== void 0 ? { "Content-Type": "application/json" } : {}
+		},
+		...request.body !== void 0 ? { body: JSON.stringify(request.body) } : {}
+	}, request.scope, context);
+	if (jsonBytes.byteLength === 0) return {};
 	let payload;
 	try {
 		payload = JSON.parse(new TextDecoder().decode(jsonBytes));
@@ -729,38 +761,64 @@ async function fetchFigmaDocument(fileKey, context) {
 		throw new SourceImportError("invalid-response", "Figma returned an invalid response.");
 	}
 	const body = record(payload);
-	if (!body || body.err || typeof body.status === "number" && body.status >= 400) throw new SourceImportError("invalid-response", "Figma returned an invalid response.");
-	return body.document;
+	if (!body || body.err || body.error === true || typeof body.status === "number" && body.status >= 400) throw new SourceImportError("invalid-response", request.errorMessage);
+	if (Array.isArray(body.errors) && body.errors.length > 0) throw new SourceImportError("upstream-failed", `Figma rejected the request: ${body.errors.map((entry) => {
+		const reason = record(entry)?.error;
+		return typeof reason === "string" ? reason : "unknown error";
+	}).join("; ")}`);
+	return body;
+}
+function figmaFileEndpoint(fileKey, path) {
+	return new URL(`https://api.figma.com/v1/files/${encodeURIComponent(fileKey)}${path}`);
+}
+/** Every Fundus tag link in the file (orphaned ones included); each entry has its `linkId`. */
+async function listFigmaTagEntries(fileKey, context) {
+	const links = figmaLinksFromRest(await requestFigmaApi(figmaFileEndpoint(fileKey, "/dev_resources"), context, {
+		scope: "file_dev_resources:read",
+		errorMessage: "Figma returned an invalid response."
+	}));
+	if (!links) throw new SourceImportError("invalid-response", "Figma returned an invalid Dev Resources list.");
+	return figmaTagEntries(links).filter((entry) => entry.linkId !== void 0);
+}
+/** Export URLs for the nodes in one `/images` call; `null` for a node Figma cannot render. */
+async function exportImageUrls(fileKey, nodeIds, scale, context) {
+	const endpoint = new URL(`https://api.figma.com/v1/images/${encodeURIComponent(fileKey)}`);
+	endpoint.searchParams.set("ids", nodeIds.join(","));
+	endpoint.searchParams.set("format", "png");
+	endpoint.searchParams.set("scale", String(scale));
+	const images = record((await requestFigmaApi(endpoint, context, {
+		scope: "file_content:read",
+		errorMessage: "Figma could not render this node."
+	})).images);
+	const urls = {};
+	for (const nodeId of nodeIds) {
+		if (!images || !Object.hasOwn(images, nodeId)) throw new SourceImportError("invalid-response", "Figma did not return the requested node.");
+		const imageUrl = images[nodeId];
+		urls[nodeId] = typeof imageUrl === "string" && imageUrl.length > 0 ? imageUrl : null;
+	}
+	return urls;
 }
-async function resolveTagToNode(fileKey, tag, context) {
-	const matches = figmaDocumentNodes(await fetchFigmaDocument(fileKey, context)).filter((node) => node.tag === tag);
-	if (matches.length === 0) throw new SourceImportError("not-found", `No Figma node is tagged "${tag}" in this file.`);
-	if (matches.length > 1) throw new SourceImportError("ambiguous-tag", `More than one Figma node is tagged "${tag}" in this file.`);
-	return matches[0].nodeId;
+/**
+* The one renderable node carrying `tag`. All candidates go into a single
+* `/images` call, which answers deleted nodes with `null`; a live but
+* unrenderable second candidate therefore goes unnoticed.
+*/
+async function resolveTaggedNode(fileKey, tag, scale, context) {
+	const candidates = [...new Set((await listFigmaTagEntries(fileKey, context)).filter((entry) => entry.tag === tag).map((entry) => entry.nodeId))];
+	if (candidates.length === 0) throw new SourceImportError("not-found", `No Figma node is tagged "${tag}" in this file.`);
+	const urls = await exportImageUrls(fileKey, candidates, scale, context);
+	const live = candidates.flatMap((nodeId) => {
+		const imageUrl = urls[nodeId];
+		return imageUrl ? [{
+			nodeId,
+			imageUrl
+		}] : [];
+	});
+	if (live.length === 0) throw new SourceImportError("not-found", `Every Figma node tagged "${tag}" (${candidates.join(", ")}) is deleted or cannot be rendered.`);
+	if (live.length > 1) throw new SourceImportError("ambiguous-tag", `More than one Figma node is tagged "${tag}" in this file (${live.map((node) => node.nodeId).join(", ")}).`);
+	return live[0];
 }
-async function materialize(source, context) {
-	const token = context.config.import.figma.token;
-	if (!token) throw new SourceImportError("not-configured", "Figma access is not configured.");
-	const endpoint = new URL(`https://api.figma.com/v1/images/${encodeURIComponent(source.fileKey)}`);
-	endpoint.searchParams.set("ids", source.nodeId);
-	endpoint.searchParams.set("format", source.format);
-	endpoint.searchParams.set("scale", String(source.scale));
-	const jsonBytes = await fetchWithDeadline(context.fetch, endpoint, {
-		redirect: "error",
-		headers: { "X-Figma-Token": token }
-	}, async (response) => new Uint8Array(await response.arrayBuffer()));
-	let payload;
-	try {
-		payload = JSON.parse(new TextDecoder().decode(jsonBytes));
-	} catch {
-		throw new SourceImportError("invalid-response", "Figma returned an invalid response.");
-	}
-	const body = record(payload);
-	if (!body || body.err || typeof body.status === "number" && body.status >= 400) throw new SourceImportError("invalid-response", "Figma could not render this node.");
-	const images = record(body.images);
-	if (!images || !Object.hasOwn(images, source.nodeId)) throw new SourceImportError("invalid-response", "Figma did not return the requested node.");
-	const imageUrl = images[source.nodeId];
-	if (typeof imageUrl !== "string" || imageUrl.length === 0) throw new SourceImportError("invalid-response", "Figma could not render the requested node.");
+async function downloadRaw(source, imageUrl, context) {
 	const bytes = await downloadExport(context.httpsTransport ?? requestPinnedHttps, imageUrl);
 	await validatePng(bytes);
 	return {
@@ -772,6 +830,18 @@ async function materialize(source, context) {
 		}
 	};
 }
+async function importNode(source, context) {
+	const imageUrl = (await exportImageUrls(source.fileKey, [source.nodeId], source.scale, context))[source.nodeId];
+	if (!imageUrl) throw new SourceImportError("invalid-response", "Figma could not render the requested node.");
+	return downloadRaw(source, imageUrl, context);
+}
+async function importTag(source, context) {
+	const { nodeId, imageUrl } = await resolveTaggedNode(source.fileKey, source.fundusTag, source.scale, context);
+	return downloadRaw({
+		...source,
+		nodeId
+	}, imageUrl, context);
+}
 var figmaSourceImporter = {
 	kind: "figma",
 	label: "Figma",
@@ -780,18 +850,16 @@ var figmaSourceImporter = {
 		if (input.mode === "tag") {
 			const fileKey = input.fileKey ?? context.config.import.figma.defaultFileKey;
 			if (!fileKey) throw new SourceImportError("not-configured", "Figma tag import needs a fileKey or import.figma.defaultFileKey in fundus.config.");
-			const nodeId = await resolveTagToNode(fileKey, input.tag, context);
-			return materialize({
+			return importTag({
 				mode: "tag",
 				fileKey,
 				fundusTag: input.tag,
-				nodeId,
 				format: "png",
 				scale: input.scale ?? context.config.import.figma.defaults.scale
 			}, context);
 		}
 		const parsed = parseFigmaSelectionUrl(input.url);
-		return materialize({
+		return importNode({
 			fileKey: parsed.fileKey,
 			nodeId: parsed.nodeId,
 			format: "png",
@@ -800,14 +868,8 @@ var figmaSourceImporter = {
 	},
 	validateSourceParameters: validateFigmaSourceParameters,
 	async reimportRaw(source, context) {
-		if (source.mode === "tag") {
-			const nodeId = await resolveTagToNode(source.fileKey, source.fundusTag, context);
-			return materialize({
-				...source,
-				nodeId
-			}, context);
-		}
-		return materialize(source, context);
+		if (source.mode === "tag") return importTag(source, context);
+		return importNode(source, context);
 	}
 };
 //#endregion
@@ -1451,22 +1513,22 @@ var ImageDuplicateDetector = class {
 		const images = Object.entries(library.assets).filter(([, record]) => record.type === "image").sort(([left], [right]) => compareCodeUnits(left, right));
 		const activeHashes = new Set(images.map(([, record]) => record.rawHash));
 		for (const hash of this.#fingerprints.keys()) if (!activeHashes.has(hash)) this.#fingerprints.delete(hash);
-		const readable = [];
-		for (const [id, record] of images) {
+		const readable = (await mapConcurrent(images, 8, async ([id, record]) => {
 			let fingerprint = this.#fingerprints.get(record.rawHash);
 			if (!fingerprint) {
 				fingerprint = imageFingerprint(join(rawDir, record.raw), 8);
 				this.#fingerprints.set(record.rawHash, fingerprint);
 			}
 			try {
-				readable.push({
+				return {
 					id,
 					fingerprint: await fingerprint
-				});
+				};
 			} catch {
 				this.#fingerprints.delete(record.rawHash);
+				return null;
 			}
-		}
+		})).filter((entry) => entry !== null);
 		const duplicates = /* @__PURE__ */ new Map();
 		for (let leftIndex = 0; leftIndex < readable.length; leftIndex++) for (let rightIndex = leftIndex + 1; rightIndex < readable.length; rightIndex++) {
 			const left = readable[leftIndex];
@@ -1527,6 +1589,7 @@ var FundusOperations = class {
 	#importers;
 	#usageAnalyzer;
 	#duplicateDetector = new ImageDuplicateDetector();
+	#proxyInfoCache = new ProxyInfoCache();
 	#operationQueue = Promise.resolve();
 	#pipelineQueue = Promise.resolve();
 	constructor(config, registry = serverPluginsByType, importerRegistry = serverImporters) {
@@ -1622,6 +1685,17 @@ var FundusOperations = class {
 		const classification = await this.#classifyRawDirectory(library);
 		return this.#snapshotState(library, classification);
 	}
+	/**
+	* Fill the image-fingerprint and proxy-probe caches without scanning raws or
+	* joining the operation queue, so an early editor reconcile shares this
+	* in-flight work instead of waiting behind it. Both caches are keyed by
+	* content, so a concurrent mutation can only make an entry unused.
+	*/
+	async warmCaches() {
+		const library = await this.#store.read();
+		const delivered = allDeliveredAssetIds(computeLibraryMembership(library, collectAllReferences(library, descriptorsByType(this.#registry))));
+		await Promise.all([this.#duplicateDetector.find(library, this.#config.rawDir), mapConcurrent([...delivered].sort(compareCodeUnits), 8, (assetId) => this.#proxyState(assetId, library.assets[assetId], delivered))]);
+	}
 	/** Reconcile only changes that are safe without a user decision: unique moves and deletions. */
 	reconcileRawState() {
 		return this.#enqueueOperation(async () => {
@@ -2245,12 +2319,38 @@ var FundusOperations = class {
 			state: await this.#snapshotState(latestLibrary, latestClassification, pipelineIssues)
 		};
 	}
+	async #proxyState(assetId, record, delivered) {
+		if (!delivered.has(assetId)) return { proxy: null };
+		try {
+			const currentProxy = await readCurrentProxy(assetId, record, this.#config, this.#registry, this.#proxyInfoCache);
+			if (!currentProxy) return {
+				proxy: null,
+				warning: "Proxy is stale or missing — it will be (re)processed on the next save."
+			};
+			return { proxy: {
+				url: `/files/proxy/${encodeRelativePathForUrl(currentProxy.relativePath)}`,
+				upToDate: true,
+				...currentProxy
+			} };
+		} catch (cause) {
+			return {
+				proxy: null,
+				warning: cause instanceof Error ? cause.message : String(cause)
+			};
+		}
+	}
 	async #buildState(library, issues, classification) {
-		const [gitBranch, changedGitAssets] = await Promise.all([currentGitBranch(this.#config.projectRoot), gitAssetChanges(this.#config.projectRoot, this.#config.library, library)]);
 		const referencesByAsset = collectAllReferences(library, descriptorsByType(this.#registry));
-		const duplicatesByAsset = await this.#duplicateDetector.find(library, this.#config.rawDir);
 		const membershipByManifest = computeLibraryMembership(library, referencesByAsset);
 		const delivered = allDeliveredAssetIds(membershipByManifest);
+		const assetIds = Object.keys(library.assets).sort(compareCodeUnits);
+		const [gitBranch, changedGitAssets, duplicatesByAsset, proxies] = await Promise.all([
+			currentGitBranch(this.#config.projectRoot),
+			gitAssetChanges(this.#config.projectRoot, this.#config.library, library),
+			this.#duplicateDetector.find(library, this.#config.rawDir),
+			mapConcurrent(assetIds, 8, (assetId) => this.#proxyState(assetId, library.assets[assetId], delivered))
+		]);
+		this.#proxyInfoCache.retain(delivered);
 		const passiveManifestsByAsset = /* @__PURE__ */ new Map();
 		for (const manifestName of Object.keys(library.manifests).sort(compareCodeUnits)) for (const passiveMember of membershipByManifest[manifestName].passiveMembers) {
 			const passiveManifests = passiveManifestsByAsset.get(passiveMember.assetId) ?? [];
@@ -2272,24 +2372,14 @@ var FundusOperations = class {
 		const requiredByAsset = /* @__PURE__ */ new Map();
 		for (const dependency of this.#config.dependencies) requiredByAsset.set(dependency.id, [...dependency.sources]);
 		const assets = [];
-		for (const assetId of Object.keys(library.assets).sort(compareCodeUnits)) {
+		for (const [index, assetId] of assetIds.entries()) {
 			const record = library.assets[assetId];
 			const warnings = [];
 			for (const issue of issues) if (issue.assetId === assetId) warnings.push(issue.message);
 			if (record.manifests.length === 0 && !delivered.has(assetId)) warnings.push("In no manifest and not referenced by any delivered asset — nothing is processed or generated for it.");
 			if (record.importSource && !this.#importers.has(record.importSource.importer)) warnings.push(`Importer "${record.importSource.importer}" is unavailable; the local raw file remains usable.`);
-			let proxy = null;
-			if (delivered.has(assetId)) try {
-				const currentProxy = await readCurrentProxy(assetId, record, this.#config, this.#registry);
-				if (currentProxy) proxy = {
-					url: `/files/proxy/${encodeRelativePathForUrl(currentProxy.relativePath)}`,
-					upToDate: true,
-					...currentProxy
-				};
-				else warnings.push("Proxy is stale or missing — it will be (re)processed on the next save.");
-			} catch (cause) {
-				warnings.push(cause instanceof Error ? cause.message : String(cause));
-			}
+			const { proxy, warning: proxyWarning } = proxies[index];
+			if (proxyWarning) warnings.push(proxyWarning);
 			assets.push({
 				id: assetId,
 				type: record.type,
@@ -2514,4 +2604,4 @@ async function createFundusContext() {
 }
 
 export { getFundusContext as g, initializeFundusContext as i };
-//# sourceMappingURL=context.js-BZSZNuAd.js.map
+//# sourceMappingURL=context.js-BR2IRl9z.js.map