fundus 0.3.0 → 0.5.0

package/build/server/chunks/chunks/{context.js-B77ZAVLi.js → context.js-bXe5hzjI.js}

@@ -1,8 +1,14 @@
-import { f as folderOfRawPath, r as rawFileNameOfPath, C as typesForFileName, D as proposeAssetId, e as parentFolderPath, m as portableFolderPathKey, b as assetIdError } from './core.js-EA_ysb1J.js';
-import { s as serverPluginsByType, i as isRecord, L as LibraryStore, a as serverPluginForType, v as verifyStableRawFile, p as processAssets, g as generateManifestModules, c as collectAllReferences, d as descriptorsByType, b as computeLibraryMembership, e as allDeliveredAssetIds, f as compareCodeUnits, r as readCurrentProxy, h as encodeRelativePathForUrl, j as classifyRawDirectory } from './library-store.js-DJ-JRE-g.js';
-import { isAbsolute, resolve, join } from 'node:path';
+import { e as folderOfRawPath, g as rawFileNameOfPath, n as normalizeFolderPath, z as typesForFileName, B as proposeAssetId, h as parentFolderPath, q as portableFolderPathKey } from './core.js-Clg1CHb6.js';
+import { s as serverPluginsByType, i as isRecord, L as LibraryStore, a as serverPluginForType, S as SourceImportError, p as processAssets, g as generateManifestModules, c as collectAllReferences, d as descriptorsByType, b as computeLibraryMembership, e as allDeliveredAssetIds, r as readCurrentProxy, f as encodeRelativePathForUrl, h as invalidInput } from './contract.js-sHny3b-s.js';
+import { a as assetIdError } from './asset-id.js-CFsW8jeL.js';
+import { v as verifyStableRawFile, c as canonicalizeParameters, a as compareCodeUnits, b as classifyRawDirectory } from './raw-reconciliation.js-DOFtjkgu.js';
+import { isAbsolute, resolve, join, extname } from 'node:path';
 import { existsSync } from 'node:fs';
 import { createJiti } from 'jiti';
+import sharp from 'sharp';
+import { lookup } from 'node:dns/promises';
+import { isIP } from 'node:net';
+import { request } from 'node:https';
 
 //#region src/lib/server/config-loader.ts
 /**
@@ -39,13 +45,26 @@ function resolveConfig(projectRoot, value, registry = serverPluginsByType) {
 		projectRoot,
 		value: plugins[definition.namespace]
 	});
+	const importConfig = value.import === void 0 ? {} : value.import;
+	if (!isRecord(importConfig)) throw new Error("fundus.config: \"import\" must be an object.");
+	const figma = importConfig.figma === void 0 ? {} : importConfig.figma;
+	if (!isRecord(figma)) throw new Error("fundus.config: \"import.figma\" must be an object.");
+	if (figma.token !== void 0 && (typeof figma.token !== "string" || figma.token.length === 0)) throw new Error("fundus.config: \"import.figma.token\" must be a non-empty string.");
+	const defaults = figma.defaults === void 0 ? {} : figma.defaults;
+	if (!isRecord(defaults)) throw new Error("fundus.config: \"import.figma.defaults\" must be an object.");
+	const scale = defaults.scale === void 0 ? 2 : defaults.scale;
+	if (scale !== 1 && scale !== 2 && scale !== 3 && scale !== 4) throw new Error("fundus.config: \"import.figma.defaults.scale\" must be 1, 2, 3, or 4.");
 	return {
 		rawDir: resolvePath(projectRoot, requiredString(value, "rawDir")),
 		proxyDir: resolvePath(projectRoot, requiredString(value, "proxyDir")),
 		library: resolvePath(projectRoot, requiredString(value, "library")),
 		manifestsDir: resolvePath(projectRoot, requiredString(value, "manifestsDir")),
 		proxyBasePath,
-		plugins: resolvedPlugins
+		plugins: resolvedPlugins,
+		import: { figma: {
+			...figma.token !== void 0 ? { token: figma.token } : {},
+			defaults: { scale }
+		} }
 	};
 }
 /** Load `fundus.config.ts` from the host project root. */
@@ -116,6 +135,429 @@ function rawSafetyIssues(library, classification, compatibleTypes) {
 	});
 }
 //#endregion
+//#region src/lib/server/importers/pinned-https.ts
+function pinnedUrl(url, address) {
+	const pinned = new URL(url);
+	pinned.hostname = address.family === 6 ? `[${address.address}]` : address.address;
+	return pinned;
+}
+function responseHeaders(source) {
+	const headers = new Headers();
+	for (const [name, value] of Object.entries(source)) if (Array.isArray(value)) for (const item of value) headers.append(name, item);
+	else if (value !== void 0) headers.set(name, value);
+	return headers;
+}
+function createPinnedHttpsTransport(requester = request) {
+	return (target, signal) => new Promise((resolve, reject) => {
+		let addressIndex = 0;
+		let lastError;
+		let settled = false;
+		const attempt = () => {
+			if (signal.aborted) {
+				reject(signal.reason);
+				return;
+			}
+			const address = target.addresses[addressIndex++];
+			if (!address) {
+				reject(lastError ?? /* @__PURE__ */ new Error(`No validated address is available for ${target.url.hostname}.`));
+				return;
+			}
+			let clientRequest;
+			try {
+				clientRequest = requester(pinnedUrl(target.url, address), {
+					method: "GET",
+					agent: false,
+					headers: { host: target.url.host },
+					servername: target.url.hostname,
+					rejectUnauthorized: true,
+					signal
+				}, (response) => {
+					settled = true;
+					resolve({
+						status: response.statusCode ?? 0,
+						headers: responseHeaders(response.headers),
+						body: response,
+						cancel: () => response.destroy()
+					});
+				});
+			} catch (cause) {
+				lastError = cause;
+				attempt();
+				return;
+			}
+			clientRequest.once("error", (cause) => {
+				if (settled) return;
+				lastError = cause;
+				attempt();
+			});
+			clientRequest.end();
+		};
+		attempt();
+	});
+}
+var requestPinnedHttps = createPinnedHttpsTransport();
+//#endregion
+//#region src/lib/server/importers/figma.ts
+var MAX_DOWNLOAD_BYTES = 50 * 1024 * 1024;
+var MAX_PIXELS = 32e6;
+var MAX_REDIRECTS = 3;
+var REQUEST_TIMEOUT_MS = 3e4;
+var PNG_SIGNATURE = Uint8Array.from([
+	137,
+	80,
+	78,
+	71,
+	13,
+	10,
+	26,
+	10
+]);
+function record(value) {
+	return typeof value === "object" && value !== null && !Array.isArray(value) ? value : null;
+}
+function parseFigmaSelectionUrl(value) {
+	let url;
+	try {
+		url = new URL(value);
+	} catch {
+		return invalidInput("Enter a valid Figma selection link.");
+	}
+	if (url.protocol !== "https:" || url.hostname !== "figma.com" && url.hostname !== "www.figma.com") return invalidInput("Figma links must use HTTPS on figma.com.");
+	const segments = url.pathname.split("/").filter(Boolean);
+	if (![
+		"design",
+		"file",
+		"proto"
+	].includes(segments[0] ?? "") || !segments[1]) return invalidInput("The Figma link must point to a design, file, or prototype.");
+	const nodeIds = url.searchParams.getAll("node-id");
+	if (nodeIds.length !== 1 || !/^\d+[-:]\d+$/.test(nodeIds[0])) return invalidInput("The Figma link must contain exactly one valid node-id.");
+	const [left, right] = nodeIds[0].split(/[-:]/);
+	return {
+		fileKey: segments[1],
+		nodeId: `${left}:${right}`
+	};
+}
+function validateScale(value) {
+	if (value !== 1 && value !== 2 && value !== 3 && value !== 4) return invalidInput("Figma export scale must be 1, 2, 3, or 4.");
+	return value;
+}
+function validateInput(value) {
+	const input = record(value);
+	if (!input || typeof input.url !== "string") return invalidInput("Figma import requires a URL.");
+	if (input.format !== void 0 && input.format !== "png") return invalidInput("Figma import currently supports PNG only.");
+	return {
+		url: input.url,
+		format: "png",
+		...input.scale !== void 0 ? { scale: validateScale(input.scale) } : {}
+	};
+}
+function validateFigmaSourceParameters(value) {
+	const source = record(value);
+	if (!source || typeof source.fileKey !== "string" || source.fileKey.length === 0 || typeof source.nodeId !== "string" || !/^\d+:\d+$/.test(source.nodeId) || source.format !== "png") return invalidInput("Stored Figma source parameters are invalid.");
+	return {
+		fileKey: source.fileKey,
+		nodeId: source.nodeId,
+		format: "png",
+		scale: validateScale(source.scale)
+	};
+}
+function retryAfter(response) {
+	const raw = response.headers.get("retry-after");
+	if (!raw || !/^\d+$/.test(raw.trim())) return void 0;
+	const seconds = Number(raw);
+	return Number.isSafeInteger(seconds) ? seconds : void 0;
+}
+function upstreamStatusError(response) {
+	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 === 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}.`);
+}
+function isForbiddenIpv4(address) {
+	const parts = address.split(".").map(Number);
+	const [a, b] = parts;
+	return a === 0 || a === 10 || a === 127 || a === 100 && b >= 64 && b <= 127 || a === 169 && b === 254 || a === 172 && b >= 16 && b <= 31 || a === 192 && b === 0 || a === 192 && b === 0 && parts[2] === 2 || a === 192 && b === 168 || a === 198 && (b === 18 || b === 19) || a === 198 && b === 51 && parts[2] === 100 || a === 203 && b === 0 && parts[2] === 113 || a >= 224;
+}
+function mappedIpv4Address(address) {
+	const normalized = address.toLowerCase().split("%")[0];
+	const dotted = /^(?:::ffff:|0:0:0:0:0:ffff:)(\d+\.\d+\.\d+\.\d+)$/.exec(normalized);
+	if (dotted && isIP(dotted[1]) === 4) return dotted[1];
+	const halves = normalized.split("::");
+	if (halves.length > 2) return null;
+	const left = halves[0] ? halves[0].split(":") : [];
+	const right = halves.length === 2 && halves[1] ? halves[1].split(":") : [];
+	const missing = 8 - left.length - right.length;
+	if (missing < 0 || halves.length === 1 && missing !== 0) return null;
+	const parts = [
+		...left,
+		...Array.from({ length: missing }, () => "0"),
+		...right
+	];
+	if (parts.length !== 8 || parts.slice(0, 5).some((part) => Number.parseInt(part || "0", 16) !== 0) || Number.parseInt(parts[5] || "0", 16) !== 65535) return null;
+	const high = Number.parseInt(parts[6], 16);
+	const low = Number.parseInt(parts[7], 16);
+	if (!Number.isInteger(high) || !Number.isInteger(low) || high < 0 || high > 65535 || low < 0 || low > 65535) return null;
+	return `${high >>> 8}.${high & 255}.${low >>> 8}.${low & 255}`;
+}
+function isForbiddenIp(address) {
+	if (isIP(address) === 4) return isForbiddenIpv4(address);
+	const normalized = address.toLowerCase().split("%")[0];
+	const mapped = mappedIpv4Address(normalized);
+	if (mapped) return isForbiddenIpv4(mapped);
+	return normalized === "::" || normalized === "::1" || normalized.startsWith("fc") || normalized.startsWith("fd") || normalized.startsWith("fe8") || normalized.startsWith("fe9") || normalized.startsWith("fea") || normalized.startsWith("feb") || normalized.startsWith("ff") || normalized.startsWith("2001:db8:");
+}
+async function resolveSafeDownloadTarget(value) {
+	let url;
+	try {
+		url = value instanceof URL ? value : new URL(value);
+	} catch {
+		throw new SourceImportError("unsafe-download-url", "Figma returned an unsafe download target.");
+	}
+	if (url.protocol !== "https:" || url.username !== "" || url.password !== "" || url.port !== "" && url.port !== "443" || url.hostname === "" || url.hostname === "localhost" || url.hostname.endsWith(".localhost") || url.hostname.endsWith(".local") || url.hostname.startsWith("[") || isIP(url.hostname) !== 0) throw new SourceImportError("unsafe-download-url", "Figma returned an unsafe download target.");
+	let resolvedAddresses;
+	try {
+		resolvedAddresses = await lookup(url.hostname, { all: true });
+	} catch {
+		throw new SourceImportError("unsafe-download-url", "Figma returned an unavailable download target.");
+	}
+	if (resolvedAddresses.length === 0 || resolvedAddresses.some(({ address }) => isIP(address) === 0 || isForbiddenIp(address))) throw new SourceImportError("unsafe-download-url", "Figma returned an unsafe download target.");
+	const addresses = resolvedAddresses.map(({ address }) => ({
+		address,
+		family: isIP(address)
+	}));
+	return {
+		url,
+		addresses
+	};
+}
+async function fetchWithDeadline(fetcher, url, init, consume) {
+	const controller = new AbortController();
+	const timeout = setTimeout(() => controller.abort(), REQUEST_TIMEOUT_MS);
+	try {
+		const response = await fetcher(url, {
+			...init,
+			signal: controller.signal
+		});
+		if (!response.ok) throw upstreamStatusError(response);
+		return await consume(response);
+	} catch (cause) {
+		if (controller.signal.aborted || cause instanceof Error && cause.name === "AbortError") throw new SourceImportError("download-timeout", "Figma export timed out.");
+		if (cause instanceof SourceImportError) throw cause;
+		throw new SourceImportError("upstream-failed", "Figma export request failed.");
+	} finally {
+		clearTimeout(timeout);
+	}
+}
+async function readLimitedBody(response, signal) {
+	let canceled = false;
+	const cancel = () => {
+		if (canceled) return;
+		canceled = true;
+		response.cancel();
+	};
+	const declared = response.headers.get("content-length");
+	if (declared && /^\d+$/.test(declared) && Number(declared) > MAX_DOWNLOAD_BYTES) {
+		cancel();
+		throw new SourceImportError("download-too-large", "Figma export exceeds the 50 MiB limit.");
+	}
+	const iterator = response.body[Symbol.asyncIterator]();
+	const chunks = [];
+	let size = 0;
+	let rejectAbort;
+	const aborted = new Promise((_, reject) => rejectAbort = reject);
+	const onAbort = () => {
+		rejectAbort(new SourceImportError("download-timeout", "Figma export download timed out."));
+		cancel();
+	};
+	signal.addEventListener("abort", onAbort, { once: true });
+	try {
+		for (;;) {
+			const { done, value } = await Promise.race([iterator.next(), aborted]);
+			if (signal.aborted) throw new SourceImportError("download-timeout", "Figma export download timed out.");
+			if (done) break;
+			size += value.byteLength;
+			if (size > MAX_DOWNLOAD_BYTES) {
+				cancel();
+				throw new SourceImportError("download-too-large", "Figma export exceeds the 50 MiB limit.");
+			}
+			chunks.push(value);
+		}
+	} catch (cause) {
+		cancel();
+		throw cause;
+	} finally {
+		signal.removeEventListener("abort", onAbort);
+	}
+	const bytes = new Uint8Array(size);
+	let offset = 0;
+	for (const chunk of chunks) {
+		bytes.set(chunk, offset);
+		offset += chunk.byteLength;
+	}
+	return bytes;
+}
+async function downloadExport(transport, initial) {
+	let target = await resolveSafeDownloadTarget(initial);
+	const controller = new AbortController();
+	const timeout = setTimeout(() => controller.abort(), REQUEST_TIMEOUT_MS);
+	try {
+		for (let redirects = 0;; redirects++) {
+			let response;
+			try {
+				response = await transport(target, controller.signal);
+			} catch (cause) {
+				if (controller.signal.aborted || cause instanceof Error && cause.name === "AbortError") throw new SourceImportError("download-timeout", "Figma export download timed out.");
+				throw new SourceImportError("upstream-failed", "Figma export download failed.");
+			}
+			if (response.status >= 300 && response.status < 400) {
+				if (redirects >= MAX_REDIRECTS) {
+					response.cancel();
+					throw new SourceImportError("unsafe-download-url", "Figma export redirected too many times.");
+				}
+				const location = response.headers.get("location");
+				if (!location) {
+					response.cancel();
+					throw new SourceImportError("invalid-response", "Figma export redirect was invalid.");
+				}
+				response.cancel();
+				target = await resolveSafeDownloadTarget(new URL(location, target.url));
+				continue;
+			}
+			if (response.status < 200 || response.status >= 300) {
+				response.cancel();
+				throw upstreamStatusError(response);
+			}
+			return await readLimitedBody(response, controller.signal);
+		}
+	} finally {
+		clearTimeout(timeout);
+	}
+}
+async function validatePng(bytes) {
+	if (bytes.byteLength < PNG_SIGNATURE.byteLength || PNG_SIGNATURE.some((value, index) => bytes[index] !== value)) throw new SourceImportError("invalid-response", "Figma export is not a valid PNG.");
+	let metadata;
+	try {
+		metadata = await sharp(bytes).metadata();
+	} catch {
+		throw new SourceImportError("invalid-response", "Figma export is not a readable PNG.");
+	}
+	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.");
+}
+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.");
+	const bytes = await downloadExport(context.httpsTransport ?? requestPinnedHttps, imageUrl);
+	await validatePng(bytes);
+	return {
+		bytes,
+		extension: "png",
+		importSource: {
+			importer: "figma",
+			parameters: source
+		}
+	};
+}
+var figmaSourceImporter = {
+	kind: "figma",
+	label: "Figma",
+	validateInput,
+	async importRaw(input, context) {
+		const parsed = parseFigmaSelectionUrl(input.url);
+		return materialize({
+			fileKey: parsed.fileKey,
+			nodeId: parsed.nodeId,
+			format: "png",
+			scale: input.scale ?? context.config.import.figma.defaults.scale
+		}, context);
+	},
+	validateSourceParameters: validateFigmaSourceParameters,
+	async reimportRaw(source, context) {
+		return materialize(source, context);
+	}
+};
+//#endregion
+//#region src/lib/server/importers/file.ts
+function validate(value) {
+	if (typeof value !== "object" || value === null || Array.isArray(value)) throw new SourceImportError("invalid-input", "File import input must be an object.");
+	const input = value;
+	if (typeof input.fileName !== "string" || input.fileName.length === 0) throw new SourceImportError("invalid-input", "File import requires a file name.");
+	if (!(input.bytes instanceof Uint8Array)) throw new SourceImportError("invalid-input", "File import requires byte data.");
+	return {
+		fileName: input.fileName,
+		bytes: input.bytes
+	};
+}
+var fileSourceImporter = {
+	kind: "file",
+	label: "File",
+	validateInput: validate,
+	async importRaw(input) {
+		const extension = extname(input.fileName).slice(1).toLowerCase();
+		if (!extension) throw new SourceImportError("invalid-input", "The file needs an extension.");
+		return {
+			bytes: input.bytes,
+			extension,
+			suggestedFileName: input.fileName
+		};
+	},
+	validateSourceParameters() {
+		throw new SourceImportError("invalid-input", "File imports cannot be re-imported.");
+	}
+};
+//#endregion
+//#region src/lib/server/importers/registry.ts
+var SourceImporterRegistry = class {
+	#byKind = /* @__PURE__ */ new Map();
+	constructor(importers) {
+		for (const importer of importers) {
+			if (!importer.kind) throw new Error("Source importer kind must not be empty.");
+			if (this.#byKind.has(importer.kind)) throw new Error(`Duplicate source importer kind "${importer.kind}".`);
+			this.#byKind.set(importer.kind, importer);
+		}
+	}
+	require(kind) {
+		const importer = this.#byKind.get(kind);
+		if (!importer) throw new SourceImportError("invalid-input", `Unknown source importer "${kind}".`);
+		return importer;
+	}
+	has(kind) {
+		return this.#byKind.has(kind);
+	}
+	requireReimport(source) {
+		const importer = this.require(source.importer);
+		if (!importer.reimportRaw) throw new SourceImportError("invalid-input", `Source importer "${source.importer}" does not support re-import.`);
+		return {
+			importer,
+			parameters: importer.validateSourceParameters(source.parameters)
+		};
+	}
+};
+//#endregion
+//#region src/lib/server/importers.ts
+var serverImporters = new SourceImporterRegistry([fileSourceImporter, figmaSourceImporter]);
+//#endregion
 //#region src/lib/server/operations.ts
 /**
 * The one operations layer: builds the state payload and runs
@@ -142,12 +584,14 @@ var FundusOperations = class {
 	#config;
 	#registry;
 	#store;
+	#importers;
 	#operationQueue = Promise.resolve();
 	#pipelineQueue = Promise.resolve();
-	constructor(config, registry = serverPluginsByType) {
+	constructor(config, registry = serverPluginsByType, importerRegistry = serverImporters) {
 		this.#config = config;
 		this.#registry = registry;
 		this.#store = new LibraryStore(config, registry);
+		this.#importers = importerRegistry;
 	}
 	get config() {
 		return this.#config;
@@ -274,6 +718,7 @@ var FundusOperations = class {
 				record.type = type;
 				record.rawHash = edited.hash;
 				record.parameters = parameters;
+				delete record.importSource;
 				return edited.assetId;
 			});
 			await this.#store.deleteProxiesOf(result.value);
@@ -290,6 +735,7 @@ var FundusOperations = class {
 				const record = current.assets[edited.assetId];
 				if (!this.#compatibleTypes(edited.path).includes(record.type)) throw new Error(`The moved file "${edited.path}" is not compatible with its current ${record.type} type; choose a compatible type and process it.`);
 				candidate.assets[edited.assetId].rawHash = edited.hash;
+				delete candidate.assets[edited.assetId].importSource;
 				return edited.assetId;
 			});
 			await this.#store.deleteProxiesOf(result.value);
@@ -306,32 +752,130 @@ var FundusOperations = class {
 	* rolls the whole ingest back, so a failed ingest leaves nothing behind.
 	*/
 	ingest(options) {
-		return this.#enqueueOperation(() => this.#ingest(options));
+		return this.#enqueueOperation(async () => {
+			const importer = this.#importers.require("file");
+			const input = importer.validateInput({
+				fileName: options.fileName,
+				bytes: options.bytes
+			});
+			const raw = await importer.importRaw(input, {
+				config: this.#config,
+				fetch: globalThis.fetch
+			});
+			return this.#createImportedAsset(raw, options);
+		});
 	}
-	async #ingest(options) {
-		let library = await this.#store.ingest(options);
-		try {
-			const plugin = serverPluginForType(options.type, this.#registry);
+	/** Materialize a source outside the operation queue, then atomically create the asset. */
+	async importAsset(options) {
+		const preflight = await this.#enqueueOperation(async () => {
+			const library = await this.#store.read();
+			this.#validateImportTarget(options, library);
+			if (Object.hasOwn(library.assets, options.id)) throw new SourceImportError("invalid-input", `An asset with id "${options.id}" already exists.`);
+			const importer = this.#importers.require(options.importer);
+			return {
+				importer,
+				input: importer.validateInput(options.input)
+			};
+		});
+		const raw = await preflight.importer.importRaw(preflight.input, {
+			config: this.#config,
+			fetch: globalThis.fetch
+		});
+		return this.#enqueueOperation(async () => {
+			this.#validateImportedRaw(raw, options.importer);
+			return this.#createImportedAsset(raw, options);
+		});
+	}
+	/** Re-materialize a persisted source with record and on-disk CAS protection. */
+	async reimportAsset(id, input) {
+		const snapshot = await this.#enqueueOperation(async () => {
+			const library = await this.#store.read();
+			this.#requireAsset(library, id);
+			const record = library.assets[id];
+			if (!record.importSource) throw new SourceImportError("invalid-input", `Asset "${id}" has no repeatable import source.`);
+			const resolved = this.#importers.requireReimport(record.importSource);
+			try {
+				await verifyStableRawFile(join(this.#config.rawDir, record.raw), record.rawHash);
+			} catch {
+				throw new SourceImportError("stale-import", "The local raw file changed. Apply or discard that edit before re-importing.");
+			}
+			return {
+				importer: resolved.importer,
+				parameters: resolved.parameters,
+				input: input === void 0 ? void 0 : resolved.importer.validateInput(input),
+				expected: {
+					raw: record.raw,
+					rawHash: record.rawHash,
+					type: record.type,
+					canonicalSource: canonicalizeParameters(record.importSource)
+				}
+			};
+		});
+		const context = {
+			config: this.#config,
+			fetch: globalThis.fetch
+		};
+		const raw = snapshot.input === void 0 ? await snapshot.importer.reimportRaw(snapshot.parameters, context) : await snapshot.importer.importRaw(snapshot.input, context);
+		if (snapshot.input !== void 0 && !raw.importSource) throw new SourceImportError("invalid-response", "The source importer did not return provenance for the updated source.");
+		return this.#enqueueOperation(async () => {
+			this.#validateImportedRaw(raw, snapshot.importer.kind);
+			if (!serverPluginForType(snapshot.expected.type, this.#registry).descriptor.accepts.includes(raw.extension)) throw new SourceImportError("invalid-response", `The ${snapshot.expected.type} type does not accept ".${raw.extension}" files.`);
+			let library;
+			try {
+				library = await this.#store.replaceRawFromImportSource(id, raw.bytes, snapshot.expected, raw.importSource);
+			} catch (cause) {
+				if (cause instanceof Error && cause.message === "stale-import") throw new SourceImportError("stale-import", "The asset or local raw file changed while Figma was exporting. Nothing was replaced.");
+				throw cause;
+			}
+			return this.#afterMutation(library);
+		});
+	}
+	async #createImportedAsset(raw, options) {
+		this.#validateImportedRaw(raw);
+		const fileName = raw.suggestedFileName ?? `${options.id}.${raw.extension}`;
+		const plugin = serverPluginForType(options.type, this.#registry);
+		const library = await this.#store.createAsset({
+			fileName,
+			bytes: raw.bytes,
+			type: options.type,
+			id: options.id,
+			folder: options.folder,
+			manifests: options.manifests,
+			importSource: raw.importSource
+		}, async ({ rawPath, rawFileName, parameters }) => {
+			let next = parameters;
 			if (plugin.seedIngestParameters) {
-				const record = library.assets[options.id];
 				const seeded = await plugin.seedIngestParameters({
-					rawPath: join(this.#config.rawDir, record.raw),
-					rawFileName: rawFileNameOfPath(record.raw),
-					parameters: plugin.descriptor.validateParameters(record.parameters),
+					rawPath,
+					rawFileName,
+					parameters: next,
 					config: this.#config
 				});
-				if (seeded !== void 0) library = await this.#store.updateParameters(options.id, seeded);
+				if (seeded !== void 0) next = seeded;
 			}
-			if (options.parametersPatch !== void 0 || options.manifests !== void 0) library = await this.#applyAssetChanges(library, options.id, {
-				parametersPatch: options.parametersPatch,
-				manifests: options.manifests
-			});
-		} catch (cause) {
-			await this.#store.deleteAsset(options.id);
-			throw cause;
-		}
+			if (options.parametersPatch !== void 0) next = mergeParameterPatch(next, options.parametersPatch);
+			return plugin.descriptor.validateParameters(next);
+		});
 		return this.#afterMutation(library);
 	}
+	#validateImportTarget(options, library) {
+		if (typeof options.importer !== "string" || typeof options.id !== "string" || typeof options.type !== "string") throw new SourceImportError("invalid-input", "Import requires importer, type, and id strings.");
+		const problem = assetIdError(options.id);
+		if (problem) throw new SourceImportError("invalid-input", problem);
+		serverPluginForType(options.type, this.#registry);
+		if (options.folder !== void 0 && typeof options.folder !== "string") throw new SourceImportError("invalid-input", "Import folder must be a string.");
+		const folder = normalizeFolderPath(options.folder ?? "");
+		if (folder !== "" && !library.folders.includes(folder)) throw new SourceImportError("invalid-input", `Unknown folder "${folder}".`);
+		if (options.manifests !== void 0 && (!Array.isArray(options.manifests) || options.manifests.some((value) => typeof value !== "string"))) throw new SourceImportError("invalid-input", "Import manifests must be an array of strings.");
+		for (const manifest of new Set(options.manifests ?? [])) if (!Object.hasOwn(library.manifests, manifest)) throw new SourceImportError("invalid-input", `Unknown manifest "${manifest}".`);
+	}
+	#validateImportedRaw(raw, importerKind) {
+		if (!(raw.bytes instanceof Uint8Array) || !/^[a-z0-9]+$/.test(raw.extension)) throw new SourceImportError("invalid-response", "The source importer returned invalid raw data.");
+		if (raw.importSource) {
+			if (importerKind && raw.importSource.importer !== importerKind) throw new SourceImportError("invalid-response", "The source importer returned mismatched provenance.");
+			this.#importers.require(raw.importSource.importer).validateSourceParameters(raw.importSource.parameters);
+		}
+	}
 	/** Apply a PATCH body: parameters and/or manifests and/or a rename — in that order. */
 	patchAsset(id, body) {
 		return this.#enqueueOperation(() => this.#patchAsset(id, body));
@@ -583,6 +1127,7 @@ var FundusOperations = class {
 			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);
@@ -602,6 +1147,7 @@ var FundusOperations = class {
 				folder: folderOfRawPath(record.raw),
 				rawUrl: `/files/raw/${encodeRelativePathForUrl(record.raw)}?v=${record.rawHash.slice(0, 12)}`,
 				rawHash: record.rawHash,
+				importSource: record.importSource,
 				parameters: record.parameters,
 				manifests: record.manifests,
 				passiveManifests: passiveManifestsByAsset.get(assetId) ?? [],
@@ -631,14 +1177,16 @@ var FundusOperations = class {
 		}
 		const presetNames = {};
 		for (const [type, plugin] of Object.entries(this.#registry)) presetNames[type] = Object.keys(plugin.presets(this.#config)).sort();
+		const rawIngestionQueue = this.#buildRawIngestionQueue(library, classification);
 		return {
 			library,
 			assets,
+			importDefaults: { figma: { scale: this.#config.import.figma.defaults.scale } },
 			issues,
 			presetNames,
 			manifestMemberships,
 			manifestDeliveredBytes,
-			rawIngestionQueue: this.#buildRawIngestionQueue(library, classification)
+			rawIngestionQueue
 		};
 	}
 	#compatibleTypes(path) {
@@ -800,4 +1348,4 @@ async function createFundusContext() {
 }
 
 export { getFundusContext as g, initializeFundusContext as i };
-//# sourceMappingURL=context.js-B77ZAVLi.js.map
+//# sourceMappingURL=context.js-bXe5hzjI.js.map