@ucdjs/pipelines-loader 0.0.1-beta.6 → 0.0.1-beta.8

package/dist/index.mjs

@@ -1,17 +1,275 @@
-import "./insecure-lzOoh_sk.mjs";
-import { findRemotePipelineFiles, loadRemotePipelines } from "./remote.mjs";
-import { pathToFileURL } from "node:url";
+import { mkdir, readFile, readdir, rm, stat, writeFile } from "node:fs/promises";
+import path from "node:path";
+import { getUcdConfigPath } from "@ucdjs/env";
 import { isPipelineDefinition } from "@ucdjs/pipelines-core";
-import { glob } from "tinyglobby";
-
+import { build } from "rolldown";
+import { parseTarGzip } from "nanotar";
+//#region src/cache.ts
+function getBaseRepoCacheDir() {
+	return getUcdConfigPath("cache", "repos");
+}
+const CACHE_FILE_NAME = ".ucd-cache.json";
+async function readCache(markerPath) {
+	try {
+		const raw = await readFile(markerPath, "utf8");
+		const parsed = JSON.parse(raw);
+		if (!parsed || typeof parsed !== "object") return null;
+		const marker = parsed;
+		if (typeof marker.source === "string" && typeof marker.owner === "string" && typeof marker.repo === "string" && typeof marker.ref === "string" && typeof marker.commitSha === "string" && typeof marker.syncedAt === "string") return marker;
+		return null;
+	} catch {
+		return null;
+	}
+}
+async function getRemoteSourceCacheStatus(input) {
+	const { provider, owner, repo, ref = "HEAD" } = input;
+	const cacheDir = path.join(getBaseRepoCacheDir(), provider, owner, repo, ref);
+	const markerPath = path.join(cacheDir, CACHE_FILE_NAME);
+	const marker = await readCache(markerPath);
+	return {
+		provider,
+		owner,
+		repo,
+		ref,
+		commitSha: marker?.commitSha ?? "",
+		cacheDir,
+		markerPath,
+		cached: marker !== null,
+		syncedAt: marker?.syncedAt ?? null
+	};
+}
+/**
+* Write a cache marker for a remote source.
+* Call this after downloading and extracting the archive.
+*/
+async function writeCacheMarker(input) {
+	const marker = {
+		source: input.provider,
+		owner: input.owner,
+		repo: input.repo,
+		ref: input.ref,
+		commitSha: input.commitSha,
+		syncedAt: (/* @__PURE__ */ new Date()).toISOString()
+	};
+	await writeFile(input.markerPath, JSON.stringify(marker, null, 2), "utf8");
+}
+async function clearRemoteSourceCache(input) {
+	const { provider, owner, repo, ref } = input;
+	const status = await getRemoteSourceCacheStatus({
+		provider,
+		owner,
+		repo,
+		ref
+	});
+	if (!status.cached) return false;
+	try {
+		await rm(status.cacheDir, {
+			recursive: true,
+			force: true
+		});
+		return true;
+	} catch {
+		return false;
+	}
+}
+/**
+* List all cached remote sources.
+*/
+async function listCachedSources() {
+	const baseDir = getBaseRepoCacheDir();
+	const results = [];
+	try {
+		const sources = await readdir(baseDir, { withFileTypes: true });
+		for (const sourceEntry of sources) {
+			if (!sourceEntry.isDirectory()) continue;
+			const source = sourceEntry.name;
+			const owners = await readdir(path.join(baseDir, source), { withFileTypes: true });
+			for (const ownerEntry of owners) {
+				if (!ownerEntry.isDirectory()) continue;
+				const owner = ownerEntry.name;
+				const repos = await readdir(path.join(baseDir, source, owner), { withFileTypes: true });
+				for (const repoEntry of repos) {
+					if (!repoEntry.isDirectory()) continue;
+					const repo = repoEntry.name;
+					const refs = await readdir(path.join(baseDir, source, owner, repo), { withFileTypes: true });
+					for (const refEntry of refs) {
+						if (!refEntry.isDirectory()) continue;
+						const ref = refEntry.name;
+						const cacheDir = path.join(baseDir, source, owner, repo, ref);
+						const marker = await readCache(path.join(cacheDir, CACHE_FILE_NAME));
+						if (marker) results.push({
+							source,
+							owner,
+							repo,
+							ref,
+							commitSha: marker.commitSha,
+							syncedAt: marker.syncedAt,
+							cacheDir
+						});
+					}
+				}
+			}
+		}
+	} catch {}
+	return results;
+}
+//#endregion
+//#region src/errors.ts
+var PipelineLoaderError = class extends Error {
+	code;
+	constructor(code, message, options) {
+		super(message, options);
+		this.name = "PipelineLoaderError";
+		this.code = code;
+	}
+};
+var CacheMissError = class extends PipelineLoaderError {
+	provider;
+	owner;
+	repo;
+	ref;
+	constructor(provider, owner, repo, ref) {
+		super("CACHE_MISS", `Cache miss for ${provider}:${owner}/${repo}@${ref}. Run 'ucd pipelines cache refresh --${provider} ${owner}/${repo} --ref ${ref}' to sync.`);
+		this.name = "CacheMissError";
+		this.provider = provider;
+		this.owner = owner;
+		this.repo = repo;
+		this.ref = ref;
+	}
+};
+var BundleError = class extends PipelineLoaderError {
+	entryPath;
+	constructor(entryPath, message, options) {
+		super("IMPORT_FAILED", message, options);
+		this.name = "BundleError";
+		this.entryPath = entryPath;
+	}
+};
+var BundleResolveError = class extends PipelineLoaderError {
+	entryPath;
+	importPath;
+	constructor(entryPath, importPath, options) {
+		super("BUNDLE_RESOLVE_FAILED", `Cannot resolve import "${importPath}" in ${entryPath}`, options);
+		this.name = "BundleResolveError";
+		this.entryPath = entryPath;
+		this.importPath = importPath;
+	}
+};
+var BundleTransformError = class extends PipelineLoaderError {
+	entryPath;
+	line;
+	column;
+	constructor(entryPath, options) {
+		const { line, column, ...errorOptions } = options ?? {};
+		super("BUNDLE_TRANSFORM_FAILED", `Transform/parse error in ${entryPath}${line != null ? ` at line ${line}` : ""}`, errorOptions);
+		this.name = "BundleTransformError";
+		this.entryPath = entryPath;
+		this.line = line;
+		this.column = column;
+	}
+};
+function toPipelineLoaderIssue(error, filePath) {
+	if (error instanceof BundleResolveError) return {
+		code: "BUNDLE_RESOLVE_FAILED",
+		scope: "bundle",
+		message: error.message,
+		filePath,
+		cause: error,
+		meta: {
+			entryPath: error.entryPath,
+			importPath: error.importPath
+		}
+	};
+	if (error instanceof BundleTransformError) return {
+		code: "BUNDLE_TRANSFORM_FAILED",
+		scope: "bundle",
+		message: error.message,
+		filePath,
+		cause: error,
+		meta: {
+			entryPath: error.entryPath,
+			...error.line != null ? { line: error.line } : {},
+			...error.column != null ? { column: error.column } : {}
+		}
+	};
+	if (error instanceof BundleError) return {
+		code: error.code,
+		scope: "import",
+		message: error.message,
+		filePath,
+		cause: error,
+		meta: { entryPath: error.entryPath }
+	};
+	if (error instanceof PipelineLoaderError) return {
+		code: error.code,
+		scope: "import",
+		message: error.message,
+		filePath,
+		cause: error
+	};
+	return {
+		code: "IMPORT_FAILED",
+		scope: "import",
+		message: error.message,
+		filePath,
+		cause: error
+	};
+}
+//#endregion
+//#region src/bundle.ts
+const RESOLVE_ERROR_RE = /could not resolve|cannot find module/i;
+const QUOTED_IMPORT_RE = /"([^"]+)"/;
+const TRANSFORM_ERROR_RE = /unexpected token|syntaxerror|parse error|expected|transform/i;
+async function bundle(options) {
+	let result;
+	try {
+		result = await build({
+			input: options.entryPath,
+			write: false,
+			output: { format: "esm" },
+			cwd: options.cwd
+		});
+	} catch (err) {
+		const msg = err instanceof Error ? err.message : String(err);
+		if (RESOLVE_ERROR_RE.test(msg)) {
+			const importMatch = msg.match(QUOTED_IMPORT_RE);
+			throw new BundleResolveError(options.entryPath, importMatch?.[1] ?? "", { cause: err });
+		}
+		if (TRANSFORM_ERROR_RE.test(msg)) throw new BundleTransformError(options.entryPath, { cause: err });
+		throw new BundleTransformError(options.entryPath, { cause: err });
+	}
+	const chunk = (Array.isArray(result) ? result : [result]).flatMap((output) => output.output ?? []).find((item) => item.type === "chunk");
+	if (!chunk || chunk.type !== "chunk") throw new BundleError(options.entryPath, "Failed to bundle module");
+	return {
+		code: chunk.code,
+		dataUrl: `data:text/javascript;base64,${Buffer.from(chunk.code, "utf-8").toString("base64")}`
+	};
+}
+//#endregion
 //#region src/loader.ts
 async function loadPipelineFile(filePath) {
-	const module = await (filePath.startsWith("file://") ? import(filePath) : import(pathToFileURL(filePath).href));
+	const bundleResult = await bundle({
+		entryPath: filePath,
+		cwd: path.dirname(filePath)
+	});
+	let module;
+	try {
+		module = await import(
+			/* @vite-ignore */
+			bundleResult.dataUrl
+);
+	} catch (err) {
+		const cause = err instanceof Error ? err : new Error(String(err));
+		throw new PipelineLoaderError("IMPORT_FAILED", `Failed to import ${filePath}: ${cause.message}`, { cause });
+	}
 	const pipelines = [];
 	const exportNames = [];
-	for (const [name, value] of Object.entries(module)) if (isPipelineDefinition(value)) {
-		pipelines.push(value);
-		exportNames.push(name);
+	for (const [name, value] of Object.entries(module)) {
+		if (name === "default") continue;
+		if (isPipelineDefinition(value)) {
+			pipelines.push(value);
+			exportNames.push(name);
+		}
 	}
 	return {
 		filePath,
@@ -19,57 +277,321 @@ async function loadPipelineFile(filePath) {
 		exportNames
 	};
 }
-async function loadPipelinesFromPaths(filePaths, options = {}) {
-	const { throwOnError = false } = options;
-	if (throwOnError) {
-		const wrapped = filePaths.map((filePath) => loadPipelineFile(filePath).catch((err) => {
-			const error = err instanceof Error ? err : new Error(String(err));
-			throw new Error(`Failed to load pipeline file: ${filePath}`, { cause: error });
-		}));
-		const results = await Promise.all(wrapped);
-		return {
-			pipelines: results.flatMap((r) => r.pipelines),
-			files: results,
-			errors: []
-		};
-	}
-	const settled = await Promise.allSettled(filePaths.map((fp) => loadPipelineFile(fp)));
+async function loadPipelinesFromPaths(filePaths) {
+	const settled = await Promise.allSettled(filePaths.map((filePath) => loadPipelineFile(filePath)));
 	const files = [];
-	const errors = [];
-	for (const [i, result] of settled.entries()) {
+	const issues = [];
+	for (const [index, result] of settled.entries()) {
 		if (result.status === "fulfilled") {
 			files.push(result.value);
 			continue;
 		}
-		const error = result.reason instanceof Error ? result.reason : new Error(String(result.reason));
-		errors.push({
-			filePath: filePaths[i],
-			error
-		});
+		const cause = result.reason instanceof Error ? result.reason : new Error(String(result.reason));
+		issues.push(toPipelineLoaderIssue(cause, filePaths[index]));
 	}
 	return {
-		pipelines: files.flatMap((f) => f.pipelines),
+		pipelines: files.flatMap((file) => file.pipelines),
 		files,
-		errors
+		issues
 	};
 }
-async function findPipelineFiles(options = {}) {
-	let patterns = ["**/*.ucd-pipeline.ts"];
-	const resolvedCwd = options.cwd ?? process.cwd();
-	if (options.patterns) patterns = Array.isArray(options.patterns) ? options.patterns : [options.patterns];
-	return glob(patterns, {
-		cwd: resolvedCwd,
-		ignore: [
-			"node_modules/**",
-			"**/node_modules/**",
-			"**/dist/**",
-			"**/build/**",
-			"**/.git/**"
-		],
-		absolute: true,
-		onlyFiles: true
+//#endregion
+//#region src/locator.ts
+function parsePipelineLocator(input) {
+	if (input.startsWith("github://") || input.startsWith("gitlab://")) {
+		const provider = input.startsWith("github://") ? "github" : "gitlab";
+		const parsed = new URL(input.replace(`${provider}://`, "https://fake-host/"));
+		const [, owner, repo] = parsed.pathname.split("/");
+		if (!owner || !repo) throw new Error(`Invalid ${provider} locator: ${input}`);
+		return {
+			kind: "remote",
+			provider,
+			owner,
+			repo,
+			ref: parsed.searchParams.get("ref") ?? "HEAD",
+			path: parsed.searchParams.get("path") ?? void 0
+		};
+	}
+	return {
+		kind: "local",
+		path: input
+	};
+}
+function parseRemoteSourceUrl(url) {
+	try {
+		const locator = parsePipelineLocator(url);
+		return locator.kind === "remote" ? locator : null;
+	} catch {
+		return null;
+	}
+}
+//#endregion
+//#region src/materialize.ts
+const BACKSLASH_RE = /\\/g;
+function createRemoteOrigin(locator) {
+	return {
+		provider: locator.provider,
+		owner: locator.owner,
+		repo: locator.repo,
+		ref: locator.ref ?? "HEAD",
+		...locator.path ? { path: locator.path } : {}
+	};
+}
+async function detectPathKind(targetPath) {
+	return stat(targetPath).then((value) => value.isFile() ? "file" : value.isDirectory() ? "directory" : null).catch(() => null);
+}
+async function materializePipelineLocator(locator) {
+	if (locator.kind === "local") {
+		const absolutePath = path.resolve(locator.path);
+		const pathKind = await detectPathKind(absolutePath);
+		if (!pathKind) return { issues: [{
+			code: "MATERIALIZE_FAILED",
+			scope: "file",
+			message: `Path does not exist: ${absolutePath}`,
+			locator,
+			meta: { path: absolutePath }
+		}] };
+		if (pathKind === "directory") return {
+			repositoryPath: absolutePath,
+			issues: []
+		};
+		return {
+			repositoryPath: path.dirname(absolutePath),
+			filePath: absolutePath,
+			relativePath: path.basename(absolutePath),
+			issues: []
+		};
+	}
+	const ref = locator.ref ?? "HEAD";
+	const status = await getRemoteSourceCacheStatus({
+		provider: locator.provider,
+		owner: locator.owner,
+		repo: locator.repo,
+		ref
 	});
+	if (!status.cached) return { issues: [{
+		code: "CACHE_MISS",
+		scope: "repository",
+		message: `Remote repository ${locator.owner}/${locator.repo}@${ref} is not materialized in cache.`,
+		locator,
+		meta: {
+			provider: locator.provider,
+			owner: locator.owner,
+			repo: locator.repo,
+			ref
+		}
+	}] };
+	const origin = createRemoteOrigin(locator);
+	if (!locator.path) return {
+		repositoryPath: status.cacheDir,
+		origin,
+		issues: []
+	};
+	const targetPath = path.resolve(status.cacheDir, locator.path);
+	if (targetPath !== status.cacheDir && !targetPath.startsWith(`${status.cacheDir}${path.sep}`)) return { issues: [{
+		code: "INVALID_LOCATOR",
+		scope: "locator",
+		message: `Remote path resolves outside materialized repository: ${locator.path}`,
+		locator,
+		repositoryPath: status.cacheDir
+	}] };
+	const pathKind = await detectPathKind(targetPath);
+	if (!pathKind) return { issues: [{
+		code: "MATERIALIZE_FAILED",
+		scope: "file",
+		message: `Materialized path does not exist: ${locator.path}`,
+		locator,
+		repositoryPath: status.cacheDir,
+		meta: { path: locator.path }
+	}] };
+	if (pathKind === "directory") return {
+		repositoryPath: targetPath,
+		relativePath: locator.path.replace(BACKSLASH_RE, "/"),
+		origin,
+		issues: []
+	};
+	return {
+		repositoryPath: path.dirname(targetPath),
+		filePath: targetPath,
+		relativePath: path.basename(targetPath),
+		origin,
+		issues: []
+	};
+}
+//#endregion
+//#region src/adapters/github.ts
+const GITHUB_API_BASE = "https://api.github.com";
+const GITHUB_ACCEPT_HEADER = "application/vnd.github.v3+json";
+async function resolveGitHubRef(ref) {
+	const { owner, repo, ref: refValue = "HEAD" } = ref;
+	const response = await fetch(`${GITHUB_API_BASE}/repos/${owner}/${repo}/commits/${refValue}`, { headers: { Accept: GITHUB_ACCEPT_HEADER } });
+	if (!response.ok) throw new Error(`GitHub API error: ${response.status} ${response.statusText}`);
+	const data = await response.json();
+	if (!data || typeof data !== "object" || !("sha" in data) || typeof data.sha !== "string") throw new Error("GitHub API error: invalid response format (missing 'sha')");
+	return data.sha;
+}
+async function downloadGitHubArchive(ref) {
+	const { owner, repo, commitSha } = ref;
+	const archiveUrl = `${GITHUB_API_BASE}/repos/${owner}/${repo}/tarball/${commitSha}`;
+	const response = await fetch(archiveUrl, { headers: { Accept: "application/vnd.github.v3+json" } });
+	if (!response.ok) throw new Error(`Failed to download GitHub archive: ${response.status} ${response.statusText}`);
+	return response.arrayBuffer();
+}
+//#endregion
+//#region src/adapters/gitlab.ts
+const GITLAB_API_BASE = "https://gitlab.com/api/v4";
+async function resolveGitLabRef(ref) {
+	const { owner, repo, ref: refValue = "HEAD" } = ref;
+	const url = `${GITLAB_API_BASE}/projects/${encodeURIComponent(`${owner}/${repo}`)}/repository/commits/${refValue}`;
+	const response = await fetch(url);
+	if (!response.ok) throw new Error(`GitLab API error: ${response.status} ${response.statusText}`);
+	const data = await response.json();
+	if (!data || typeof data !== "object" || !("id" in data) || typeof data.id !== "string") throw new Error("GitLab API error: invalid response format (missing 'id')");
+	return data.id;
+}
+async function downloadGitLabArchive(ref) {
+	const { owner, repo, commitSha } = ref;
+	const archiveUrl = `${GITLAB_API_BASE}/projects/${encodeURIComponent(`${owner}/${repo}`)}/repository/archive.tar.gz?sha=${commitSha}`;
+	const response = await fetch(archiveUrl);
+	if (!response.ok) throw new Error(`Failed to download GitLab archive: ${response.status} ${response.statusText}`);
+	return response.arrayBuffer();
+}
+//#endregion
+//#region src/remote.ts
+const LEADING_PATH_SEPARATORS_RE = /^([/\\])+/;
+async function extractArchiveToDirectory(archiveBuffer, targetDir) {
+	const files = await parseTarGzip(archiveBuffer);
+	const rootPrefix = files[0]?.name.split("/")[0];
+	if (!rootPrefix) throw new Error("Invalid archive: no files found");
+	for (const file of files) {
+		if (file.type === "directory" || !file.data) continue;
+		const relativePath = file.name.slice(rootPrefix.length + 1);
+		if (!relativePath) continue;
+		let safeRelativePath = path.normalize(relativePath);
+		safeRelativePath = safeRelativePath.replace(LEADING_PATH_SEPARATORS_RE, "");
+		if (!safeRelativePath) continue;
+		const upSegment = `..${path.sep}`;
+		if (safeRelativePath === ".." || safeRelativePath.startsWith(upSegment) || safeRelativePath.includes(`${path.sep}..${path.sep}`) || safeRelativePath.endsWith(`${path.sep}..`)) throw new Error(`Invalid archive entry path (path traversal detected): ${file.name}`);
+		const outputPath = path.join(targetDir, safeRelativePath);
+		const resolvedTargetDir = path.resolve(targetDir);
+		const resolvedOutputPath = path.resolve(outputPath);
+		if (resolvedOutputPath !== resolvedTargetDir && !resolvedOutputPath.startsWith(resolvedTargetDir + path.sep)) throw new Error(`Invalid archive entry path (outside target dir): ${file.name}`);
+		await mkdir(path.dirname(resolvedOutputPath), { recursive: true });
+		await writeFile(resolvedOutputPath, file.data);
+	}
+}
+async function resolveRemoteLocatorRef(provider, ref) {
+	if (provider === "github") return resolveGitHubRef(ref);
+	return resolveGitLabRef(ref);
+}
+async function downloadRemoteLocatorArchive(provider, ref) {
+	if (provider === "github") return downloadGitHubArchive(ref);
+	return downloadGitLabArchive(ref);
+}
+async function extractArchiveToCleanDirectory(archiveBuffer, targetDir) {
+	await rm(targetDir, {
+		recursive: true,
+		force: true
+	});
+	await mkdir(targetDir, { recursive: true });
+	try {
+		await extractArchiveToDirectory(archiveBuffer, targetDir);
+	} catch (err) {
+		await rm(targetDir, {
+			recursive: true,
+			force: true
+		});
+		throw err;
+	}
+}
+async function checkRemoteLocatorUpdates(input) {
+	const { provider, owner, repo, ref = "HEAD" } = input;
+	const status = await getRemoteSourceCacheStatus({
+		provider,
+		owner,
+		repo,
+		ref
+	});
+	const currentSha = status.cached ? status.commitSha : null;
+	try {
+		const remoteSha = await resolveRemoteLocatorRef(provider, {
+			owner,
+			repo,
+			ref
+		});
+		return {
+			hasUpdate: currentSha !== remoteSha,
+			currentSha,
+			remoteSha
+		};
+	} catch (err) {
+		return {
+			hasUpdate: false,
+			currentSha,
+			remoteSha: "",
+			error: err instanceof Error ? err : new Error(String(err))
+		};
+	}
+}
+async function ensureRemoteLocator(input) {
+	const { provider, owner, repo, ref = "HEAD", force = false } = input;
+	const status = await getRemoteSourceCacheStatus({
+		provider,
+		owner,
+		repo,
+		ref
+	});
+	const previousSha = status.cached ? status.commitSha : null;
+	try {
+		const commitSha = await resolveRemoteLocatorRef(provider, {
+			owner,
+			repo,
+			ref
+		});
+		if (!force && status.cached && status.commitSha === commitSha) return {
+			success: true,
+			updated: false,
+			previousSha,
+			newSha: commitSha,
+			cacheDir: status.cacheDir
+		};
+		const archiveBuffer = await downloadRemoteLocatorArchive(provider, {
+			owner,
+			repo,
+			ref,
+			commitSha
+		});
+		await rm(status.cacheDir, {
+			recursive: true,
+			force: true
+		});
+		await extractArchiveToCleanDirectory(archiveBuffer, status.cacheDir);
+		await writeCacheMarker({
+			provider,
+			owner,
+			repo,
+			ref,
+			commitSha,
+			cacheDir: status.cacheDir,
+			markerPath: status.markerPath
+		});
+		return {
+			success: true,
+			updated: true,
+			previousSha,
+			newSha: commitSha,
+			cacheDir: status.cacheDir
+		};
+	} catch (err) {
+		return {
+			success: false,
+			updated: false,
+			previousSha,
+			newSha: "",
+			cacheDir: status.cacheDir,
+			error: err instanceof Error ? err : new Error(String(err))
+		};
+	}
 }
-
 //#endregion
-export { findPipelineFiles, findRemotePipelineFiles, loadPipelineFile, loadPipelinesFromPaths, loadRemotePipelines };
+export { BundleError, BundleResolveError, BundleTransformError, CacheMissError, PipelineLoaderError, checkRemoteLocatorUpdates, clearRemoteSourceCache, ensureRemoteLocator, getRemoteSourceCacheStatus, listCachedSources, loadPipelineFile, loadPipelinesFromPaths, materializePipelineLocator, parsePipelineLocator, parseRemoteSourceUrl, writeCacheMarker };

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@ucdjs/pipelines-loader",
-  "version": "0.0.1-beta.6",
+  "version": "0.0.1-beta.8",
   "type": "module",
   "author": {
     "name": "Lucas Nørgård",
@@ -19,8 +19,7 @@
   },
   "exports": {
     ".": "./dist/index.mjs",
-    "./insecure": "./dist/insecure.mjs",
-    "./remote": "./dist/remote.mjs",
+    "./discover": "./dist/discover.mjs",
     "./package.json": "./package.json"
   },
   "types": "./dist/index.d.mts",
@@ -31,21 +30,20 @@
     "node": ">=24.13"
   },
   "dependencies": {
-    "oxc-parser": "0.114.0",
-    "oxc-transform": "0.114.0",
-    "picomatch": "4.0.3",
-    "rolldown": "1.0.0-rc.5",
+    "nanotar": "0.3.0",
+    "rolldown": "1.0.0-rc.11",
     "tinyglobby": "0.2.15",
-    "@ucdjs/pipelines-core": "0.0.1-beta.6"
+    "@ucdjs/env": "0.1.1-beta.9",
+    "@ucdjs/pipelines-core": "0.0.1-beta.8",
+    "@ucdjs-internal/shared": "0.1.1-beta.8"
   },
   "devDependencies": {
-    "@luxass/eslint-config": "7.2.0",
-    "@types/picomatch": "4.0.2",
-    "eslint": "10.0.0",
-    "publint": "0.3.17",
-    "tsdown": "0.20.3",
-    "typescript": "5.9.3",
-    "vitest-testdirs": "4.4.2",
+    "@luxass/eslint-config": "7.4.1",
+    "eslint": "10.1.0",
+    "publint": "0.3.18",
+    "tsdown": "0.21.4",
+    "typescript": "6.0.2",
+    "vitest-testdirs": "4.4.3",
     "@ucdjs-tooling/tsconfig": "1.0.0",
     "@ucdjs-tooling/tsdown-config": "1.0.0"
   },