@ucdjs/pipelines-loader 0.0.1-beta.5 → 0.0.1-beta.7

package/dist/gitlab-BeZb8tDi.mjs

@@ -0,0 +1,108 @@
+import path from "node:path";
+import { mkdir, writeFile } from "node:fs/promises";
+import { getRepositoryCacheDir } from "@ucdjs-internal/shared/config";
+import { parseTarGzip } from "nanotar";
+
+//#region src/cache/github.ts
+const GITHUB_API_BASE = "https://api.github.com";
+const GITHUB_ACCEPT_HEADER = "application/vnd.github.v3+json";
+/**
+* Resolve a ref (branch/tag) to a commit SHA
+*/
+async function resolveGitHubRef(repoRef, options = {}) {
+	const { owner, repo, ref = "HEAD" } = repoRef;
+	const { customFetch = fetch } = options;
+	const response = await customFetch(`${GITHUB_API_BASE}/repos/${owner}/${repo}/commits/${ref}`, { headers: { Accept: GITHUB_ACCEPT_HEADER } });
+	if (!response.ok) throw new Error(`GitHub API error: ${response.status} ${response.statusText}`);
+	return (await response.json()).sha;
+}
+/**
+* Download and extract a GitHub repository archive
+*/
+async function downloadGitHubRepo(repoRef, options = {}) {
+	const { owner, repo } = repoRef;
+	const { customFetch = fetch } = options;
+	const commitSha = await resolveGitHubRef(repoRef, options);
+	const cacheDir = getRepositoryCacheDir("github", owner, repo, commitSha);
+	try {
+		if ((await import("node:fs")).existsSync(cacheDir)) return cacheDir;
+	} catch {}
+	const response = await customFetch(`${GITHUB_API_BASE}/repos/${owner}/${repo}/tarball/${commitSha}`, { headers: { Accept: "application/vnd.github.v3+json" } });
+	if (!response.ok) throw new Error(`Failed to download GitHub archive: ${response.status} ${response.statusText}`);
+	await mkdir(cacheDir, { recursive: true });
+	const files = await parseTarGzip(await response.arrayBuffer());
+	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(/^([/\\])+/, "");
+		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(cacheDir, safeRelativePath);
+		const resolvedCacheDir = path.resolve(cacheDir);
+		const resolvedOutputPath = path.resolve(outputPath);
+		if (resolvedOutputPath !== resolvedCacheDir && !resolvedOutputPath.startsWith(resolvedCacheDir + path.sep)) throw new Error(`Invalid archive entry path (outside cache dir): ${file.name}`);
+		await mkdir(path.dirname(resolvedOutputPath), { recursive: true });
+		await writeFile(resolvedOutputPath, file.data);
+	}
+	return cacheDir;
+}
+
+//#endregion
+//#region src/cache/gitlab.ts
+const GITLAB_API_BASE = "https://gitlab.com/api/v4";
+function encodeProjectPath(owner, repo) {
+	return encodeURIComponent(`${owner}/${repo}`);
+}
+/**
+* Resolve a ref (branch/tag) to a commit SHA
+*/
+async function resolveGitLabRef(repoRef, options = {}) {
+	const { owner, repo, ref = "HEAD" } = repoRef;
+	const { customFetch = fetch } = options;
+	const response = await customFetch(`${GITLAB_API_BASE}/projects/${encodeProjectPath(owner, repo)}/repository/commits/${ref === "HEAD" ? "HEAD" : ref}`);
+	if (!response.ok) throw new Error(`GitLab API error: ${response.status} ${response.statusText}`);
+	return (await response.json()).id;
+}
+/**
+* Download and extract a GitLab repository archive
+*/
+async function downloadGitLabRepo(repoRef, options = {}) {
+	const { owner, repo } = repoRef;
+	const { customFetch = fetch } = options;
+	const commitSha = await resolveGitLabRef(repoRef, options);
+	const cacheDir = getRepositoryCacheDir("gitlab", owner, repo, commitSha);
+	try {
+		if ((await import("node:fs")).existsSync(cacheDir)) return cacheDir;
+	} catch {}
+	const response = await customFetch(`${GITLAB_API_BASE}/projects/${encodeProjectPath(owner, repo)}/repository/archive.tar.gz?sha=${commitSha}`);
+	if (!response.ok) throw new Error(`Failed to download GitLab archive: ${response.status} ${response.statusText}`);
+	await mkdir(cacheDir, { recursive: true });
+	const files = await parseTarGzip(await response.arrayBuffer());
+	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(/^([/\\])+/, "");
+		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(cacheDir, safeRelativePath);
+		const resolvedCacheDir = path.resolve(cacheDir);
+		const resolvedOutputPath = path.resolve(outputPath);
+		if (resolvedOutputPath !== resolvedCacheDir && !resolvedOutputPath.startsWith(resolvedCacheDir + path.sep)) throw new Error(`Invalid archive entry path (outside cache dir): ${file.name}`);
+		await mkdir(path.dirname(resolvedOutputPath), { recursive: true });
+		await writeFile(resolvedOutputPath, file.data);
+	}
+	return cacheDir;
+}
+
+//#endregion
+export { downloadGitHubRepo as n, downloadGitLabRepo as t };

package/dist/index.d.mts

@@ -1,7 +1,30 @@
-import { a as LocalSource, i as LoadedPipelineFile, n as GitLabSource, o as PipelineLoadError, r as LoadPipelinesResult, s as PipelineSource, t as GitHubSource } from "./types-Br8gGmsN.mjs";
-import { FindRemotePipelineFilesOptions, LoadRemotePipelinesOptions, findRemotePipelineFiles, loadRemotePipelines } from "./remote.mjs";
+import { a as LocalSource, c as RemoteFileList, i as LoadedPipelineFile, l as RemoteRequestOptions, n as GitLabSource, o as PipelineLoadError, r as LoadPipelinesResult, s as PipelineSource, t as GitHubSource } from "./types-C7EhTWo6.mjs";
 
 //#region src/loader.d.ts
+type FindPipelineSource = {
+  type: "local";
+  cwd: string;
+} | {
+  type: "github";
+  owner: string;
+  repo: string;
+  ref?: string;
+  path?: string;
+} | {
+  type: "gitlab";
+  owner: string;
+  repo: string;
+  ref?: string;
+  path?: string;
+};
+/**
+ * Load a pipeline file from a local path or remote URL.
+ *
+ * Supports:
+ * - Local file paths
+ * - github://owner/repo?ref=branch&path=file.ts
+ * - gitlab://owner/repo?ref=branch&path=file.ts
+ */
 declare function loadPipelineFile(filePath: string): Promise<LoadedPipelineFile>;
 interface LoadPipelinesOptions {
   throwOnError?: boolean;
@@ -9,8 +32,27 @@ interface LoadPipelinesOptions {
 declare function loadPipelinesFromPaths(filePaths: string[], options?: LoadPipelinesOptions): Promise<LoadPipelinesResult>;
 interface FindPipelineFilesOptions {
   patterns?: string | string[];
-  cwd?: string;
+  source?: FindPipelineSource;
 }
+/**
+ * Find pipeline files in a local directory or remote repository.
+ *
+ * Examples:
+ * ```typescript
+ * // Local directory
+ * findPipelineFiles({ source: { type: "local", cwd: "./pipelines" } })
+ *
+ * // GitHub repository
+ * findPipelineFiles({
+ *   source: { type: "github", owner: "ucdjs", repo: "demo-pipelines", ref: "main" }
+ * })
+ *
+ * // GitLab repository
+ * findPipelineFiles({
+ *   source: { type: "gitlab", owner: "mygroup", repo: "demo", ref: "main" }
+ * })
+ * ```
+ */
 declare function findPipelineFiles(options?: FindPipelineFilesOptions): Promise<string[]>;
 //#endregion
-export { type FindPipelineFilesOptions, type FindRemotePipelineFilesOptions, type GitHubSource, type GitLabSource, type LoadPipelinesOptions, type LoadPipelinesResult, type LoadRemotePipelinesOptions, type LoadedPipelineFile, type LocalSource, type PipelineLoadError, type PipelineSource, findPipelineFiles, findRemotePipelineFiles, loadPipelineFile, loadPipelinesFromPaths, loadRemotePipelines };
+export { type FindPipelineFilesOptions, type FindPipelineSource, type GitHubSource, type GitLabSource, type LoadPipelinesOptions, type LoadPipelinesResult, type LoadedPipelineFile, type LocalSource, type PipelineLoadError, type PipelineSource, type RemoteFileList, type RemoteRequestOptions, findPipelineFiles, loadPipelineFile, loadPipelinesFromPaths };

package/dist/index.mjs

@@ -1,17 +1,84 @@
-import "./bundle-dlu7M3TU.mjs";
-import { findRemotePipelineFiles, loadRemotePipelines } from "./remote.mjs";
-import { pathToFileURL } from "node:url";
+import { n as downloadGitHubRepo, t as downloadGitLabRepo } from "./gitlab-BeZb8tDi.mjs";
+import path from "node:path";
 import { isPipelineDefinition } from "@ucdjs/pipelines-core";
 import { glob } from "tinyglobby";
+import { build } from "rolldown";
 
+//#region src/bundle.ts
+async function bundleModule(entryPath) {
+	const result = await build({
+		input: entryPath,
+		write: false,
+		output: { format: "esm" }
+	});
+	const chunk = (Array.isArray(result) ? result : [result]).flatMap((output) => output.output ?? []).find((item) => item.type === "chunk");
+	if (!chunk || chunk.type !== "chunk") throw new Error("Failed to bundle module");
+	return chunk.code;
+}
+function createDataUrl(code) {
+	return `data:text/javascript;base64,${Buffer.from(code, "utf-8").toString("base64")}`;
+}
+
+//#endregion
 //#region src/loader.ts
+/**
+* Parse a github:// or gitlab:// URL
+*/
+function parseRepoUrl(url) {
+	if (url.startsWith("github://")) {
+		const match = url.match(/^github:\/\/([^/]+)\/([^?]+)\?ref=([^&]+)&path=(.+)$/);
+		if (match && match[1] && match[2] && match[3] && match[4]) return {
+			type: "github",
+			owner: match[1],
+			repo: match[2],
+			ref: match[3],
+			filePath: match[4]
+		};
+	}
+	if (url.startsWith("gitlab://")) {
+		const match = url.match(/^gitlab:\/\/([^/]+)\/([^?]+)\?ref=([^&]+)&path=(.+)$/);
+		if (match && match[1] && match[2] && match[3] && match[4]) return {
+			type: "gitlab",
+			owner: match[1],
+			repo: match[2],
+			ref: match[3],
+			filePath: match[4]
+		};
+	}
+	return null;
+}
+/**
+* Load a pipeline file from a local path or remote URL.
+*
+* Supports:
+* - Local file paths
+* - github://owner/repo?ref=branch&path=file.ts
+* - gitlab://owner/repo?ref=branch&path=file.ts
+*/
 async function loadPipelineFile(filePath) {
-	const module = await (filePath.startsWith("file://") ? import(filePath) : import(pathToFileURL(filePath).href));
+	let resolvedPath;
+	const repoInfo = parseRepoUrl(filePath);
+	if (repoInfo) {
+		const cacheDir = repoInfo.type === "github" ? await downloadGitHubRepo({
+			owner: repoInfo.owner,
+			repo: repoInfo.repo,
+			ref: repoInfo.ref
+		}) : await downloadGitLabRepo({
+			owner: repoInfo.owner,
+			repo: repoInfo.repo,
+			ref: repoInfo.ref
+		});
+		resolvedPath = path.join(cacheDir, repoInfo.filePath);
+	} else resolvedPath = path.resolve(filePath);
+	const module = await import(createDataUrl(await bundleModule(resolvedPath)));
 	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,
@@ -53,12 +120,45 @@ async function loadPipelinesFromPaths(filePaths, options = {}) {
 		errors
 	};
 }
+/**
+* Find pipeline files in a local directory or remote repository.
+*
+* Examples:
+* ```typescript
+* // Local directory
+* findPipelineFiles({ source: { type: "local", cwd: "./pipelines" } })
+*
+* // GitHub repository
+* findPipelineFiles({
+*   source: { type: "github", owner: "ucdjs", repo: "demo-pipelines", ref: "main" }
+* })
+*
+* // GitLab repository
+* findPipelineFiles({
+*   source: { type: "gitlab", owner: "mygroup", repo: "demo", ref: "main" }
+* })
+* ```
+*/
 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];
+	let cwd;
+	if (options.source) {
+		const source = options.source;
+		if (source.type === "local") cwd = source.cwd;
+		else if (source.type === "github") cwd = await downloadGitHubRepo({
+			owner: source.owner,
+			repo: source.repo,
+			ref: source.ref
+		});
+		else cwd = await downloadGitLabRepo({
+			owner: source.owner,
+			repo: source.repo,
+			ref: source.ref
+		});
+	} else cwd = process.cwd();
 	return glob(patterns, {
-		cwd: resolvedCwd,
+		cwd,
 		ignore: [
 			"node_modules/**",
 			"**/node_modules/**",
@@ -72,4 +172,4 @@ async function findPipelineFiles(options = {}) {
 }
 
 //#endregion
-export { findPipelineFiles, findRemotePipelineFiles, loadPipelineFile, loadPipelinesFromPaths, loadRemotePipelines };
+export { findPipelineFiles, loadPipelineFile, loadPipelinesFromPaths };

package/dist/internal.d.mts

@@ -0,0 +1,31 @@
+import { l as RemoteRequestOptions } from "./types-C7EhTWo6.mjs";
+
+//#region src/cache/github.d.ts
+interface GitHubRepoRef {
+  owner: string;
+  repo: string;
+  ref?: string;
+}
+/**
+ * Resolve a ref (branch/tag) to a commit SHA
+ */
+/**
+ * Download and extract a GitHub repository archive
+ */
+declare function downloadGitHubRepo(repoRef: GitHubRepoRef, options?: RemoteRequestOptions): Promise<string>;
+//#endregion
+//#region src/cache/gitlab.d.ts
+interface GitLabRepoRef {
+  owner: string;
+  repo: string;
+  ref?: string;
+}
+/**
+ * Resolve a ref (branch/tag) to a commit SHA
+ */
+/**
+ * Download and extract a GitLab repository archive
+ */
+declare function downloadGitLabRepo(repoRef: GitLabRepoRef, options?: RemoteRequestOptions): Promise<string>;
+//#endregion
+export { downloadGitHubRepo, downloadGitLabRepo };

package/dist/internal.mjs

@@ -0,0 +1,3 @@
+import { n as downloadGitHubRepo, t as downloadGitLabRepo } from "./gitlab-BeZb8tDi.mjs";
+
+export { downloadGitHubRepo, downloadGitLabRepo };

package/dist/{types-Br8gGmsN.d.mts → types-C7EhTWo6.d.mts}

@@ -37,5 +37,12 @@ interface LocalSource {
   cwd: string;
 }
 type PipelineSource = LocalSource | GitHubSource | GitLabSource;
+interface RemoteFileList {
+  files: string[];
+  truncated: boolean;
+}
+interface RemoteRequestOptions {
+  customFetch?: typeof fetch;
+}
 //#endregion
-export { LocalSource as a, LoadedPipelineFile as i, GitLabSource as n, PipelineLoadError as o, LoadPipelinesResult as r, PipelineSource as s, GitHubSource as t };
+export { LocalSource as a, RemoteFileList as c, LoadedPipelineFile as i, RemoteRequestOptions as l, GitLabSource as n, PipelineLoadError as o, LoadPipelinesResult as r, PipelineSource as s, GitHubSource as t };

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@ucdjs/pipelines-loader",
-  "version": "0.0.1-beta.5",
+  "version": "0.0.1-beta.7",
   "type": "module",
   "author": {
     "name": "Lucas Nørgård",
@@ -19,8 +19,7 @@
   },
   "exports": {
     ".": "./dist/index.mjs",
-    "./insecure": "./dist/insecure.mjs",
-    "./remote": "./dist/remote.mjs",
+    "./internal": "./dist/internal.mjs",
     "./package.json": "./package.json"
   },
   "types": "./dist/index.d.mts",
@@ -28,20 +27,18 @@
     "dist"
   ],
   "engines": {
-    "node": ">=22.18"
+    "node": ">=24.13"
   },
   "dependencies": {
-    "oxc-parser": "0.112.0",
-    "oxc-transform": "0.112.0",
-    "picomatch": "4.0.3",
-    "rolldown": "1.0.0-rc.4",
+    "nanotar": "0.3.0",
+    "rolldown": "1.0.0-rc.6",
     "tinyglobby": "0.2.15",
-    "@ucdjs/pipelines-core": "0.0.1-beta.5"
+    "@ucdjs/pipelines-core": "0.0.1-beta.7",
+    "@ucdjs-internal/shared": "0.1.1-beta.7"
   },
   "devDependencies": {
-    "@luxass/eslint-config": "7.2.0",
-    "@types/picomatch": "4.0.2",
-    "eslint": "10.0.0",
+    "@luxass/eslint-config": "7.2.1",
+    "eslint": "10.0.2",
     "publint": "0.3.17",
     "tsdown": "0.20.3",
     "typescript": "5.9.3",

package/dist/bundle-dlu7M3TU.mjs

@@ -1,320 +0,0 @@
-import { t as __exportAll } from "./chunk-DQk6qfdC.mjs";
-import path from "node:path";
-import { build } from "rolldown";
-import { parseSync } from "oxc-parser";
-import { readFile } from "node:fs/promises";
-import { transform } from "oxc-transform";
-
-//#region src/bundler/identifiers.ts
-function isUrlLike(value) {
-	return /^[a-z][a-z+.-]*:/i.test(value);
-}
-function parseRemoteIdentifier(identifier) {
-	if (!identifier.startsWith("github://") && !identifier.startsWith("gitlab://")) return null;
-	const url = new URL(identifier);
-	const provider = url.protocol.replace(":", "");
-	const owner = url.hostname;
-	const repo = url.pathname.replace(/^\/+/, "");
-	if (!owner || !repo) throw new Error(`Invalid remote identifier: ${identifier}`);
-	return {
-		provider,
-		owner,
-		repo,
-		ref: url.searchParams.get("ref") ?? "HEAD",
-		path: url.searchParams.get("path") ?? ""
-	};
-}
-function formatRemoteIdentifier(remote) {
-	const url = new URL(`${remote.provider}://${remote.owner}/${remote.repo}`);
-	url.searchParams.set("ref", remote.ref);
-	url.searchParams.set("path", remote.path);
-	return url.toString();
-}
-function formatRemoteIdentifierFromParts(provider, owner, repo, ref, filePath) {
-	return formatRemoteIdentifier({
-		provider,
-		owner,
-		repo,
-		ref: ref ?? "HEAD",
-		path: filePath
-	});
-}
-
-//#endregion
-//#region src/bundler/errors.ts
-var RemoteNotFoundError = class extends Error {
-	name = "RemoteNotFoundError";
-	constructor(message) {
-		super(message);
-	}
-};
-
-//#endregion
-//#region src/bundler/parse.ts
-function getStaticImportSpecifiers(source, identifier) {
-	let parsed;
-	try {
-		parsed = parseSync(identifier ?? "<inline>", source, { sourceType: "module" });
-	} catch (error) {
-		const message = error instanceof Error ? error.message : String(error);
-		throw new Error(`Failed to parse module ${identifier ?? "<inline>"}: ${message}`);
-	}
-	const specifiers = /* @__PURE__ */ new Set();
-	const visit = (value) => {
-		if (!value) return;
-		if (Array.isArray(value)) {
-			for (const item of value) visit(item);
-			return;
-		}
-		if (typeof value !== "object") return;
-		const node = value;
-		if (node.type === "ImportDeclaration") {
-			const sourceNode = node.source;
-			if (sourceNode?.value) specifiers.add(sourceNode.value);
-		} else if (node.type === "ExportAllDeclaration" || node.type === "ExportNamedDeclaration") {
-			const sourceNode = node.source;
-			if (sourceNode?.value) specifiers.add(sourceNode.value);
-		} else if (node.type === "ImportExpression") {
-			const sourceNode = node.source ?? node.argument;
-			if (sourceNode?.type === "StringLiteral" && sourceNode.value) specifiers.add(sourceNode.value);
-		}
-		for (const [key, child] of Object.entries(node)) {
-			if (key === "parent") continue;
-			visit(child);
-		}
-	};
-	visit(parsed.program);
-	return Array.from(specifiers);
-}
-
-//#endregion
-//#region src/bundler/resolve.ts
-const EXTENSIONS = [
-	".ts",
-	".mts",
-	".js",
-	".mjs"
-];
-function assertRelativeSpecifier(specifier) {
-	if (isUrlLike(specifier)) throw new Error(`Unsupported import specifier: ${specifier}`);
-	if (!specifier.startsWith("./") && !specifier.startsWith("../")) throw new Error(`Unsupported import specifier: ${specifier}`);
-}
-function stripTrailingSlash(value) {
-	return value.endsWith("/") ? value.slice(0, -1) : value;
-}
-function appendSuffix(identifier, suffix) {
-	const remote = parseRemoteIdentifier(identifier);
-	if (remote) return formatRemoteIdentifier({
-		...remote,
-		path: `${remote.path}${suffix}`
-	});
-	if (isUrlLike(identifier)) {
-		const url = new URL(identifier);
-		url.pathname = `${url.pathname}${suffix}`;
-		return url.toString();
-	}
-	return `${identifier}${suffix}`;
-}
-function resolveRelativeSpecifier(specifier, parentIdentifier) {
-	const remote = parseRemoteIdentifier(parentIdentifier);
-	if (remote) {
-		const parentDir = remote.path ? path.posix.dirname(remote.path) : "";
-		const cleanPath = path.posix.normalize(path.posix.join(parentDir, specifier)).replace(/^\/+/, "");
-		return formatRemoteIdentifier({
-			...remote,
-			path: cleanPath
-		});
-	}
-	if (isUrlLike(parentIdentifier)) {
-		const base = new URL(parentIdentifier);
-		return new URL(specifier, base).toString();
-	}
-	const parentDir = path.dirname(parentIdentifier);
-	return path.resolve(parentDir, specifier);
-}
-function getSpecifierExtension(specifier) {
-	return path.posix.extname(specifier);
-}
-function buildCandidateIdentifiers(specifier, parentIdentifier) {
-	const resolvedBase = resolveRelativeSpecifier(specifier, parentIdentifier);
-	if (getSpecifierExtension(specifier) !== "") return [resolvedBase];
-	const normalizedBase = stripTrailingSlash(resolvedBase);
-	const candidates = [];
-	for (const ext of EXTENSIONS) candidates.push(appendSuffix(normalizedBase, ext));
-	for (const ext of EXTENSIONS) candidates.push(appendSuffix(`${normalizedBase}/index`, ext));
-	return candidates;
-}
-
-//#endregion
-//#region src/remote/github.ts
-var github_exports = /* @__PURE__ */ __exportAll({
-	fetchFile: () => fetchFile$1,
-	listFiles: () => listFiles$1
-});
-const GITHUB_API_BASE = "https://api.github.com";
-const GITHUB_ACCEPT_HEADER = "application/vnd.github.v3+json";
-async function listFiles$1(repoRef, options = {}) {
-	const { owner, repo, ref = "HEAD", path = "" } = repoRef;
-	const { customFetch = fetch } = options;
-	const response = await customFetch(`${GITHUB_API_BASE}/repos/${owner}/${repo}/git/trees/${ref}?recursive=1`, { headers: { Accept: GITHUB_ACCEPT_HEADER } });
-	if (!response.ok) throw new Error(`GitHub API error: ${response.status} ${response.statusText}`);
-	const data = await response.json();
-	const prefix = path ? `${path}/` : "";
-	return {
-		files: data.tree.filter((item) => item.type === "blob" && item.path.startsWith(prefix)).map((item) => item.path),
-		truncated: data.truncated
-	};
-}
-async function fetchFile$1(repoRef, filePath, options = {}) {
-	const { owner, repo, ref = "HEAD" } = repoRef;
-	const { customFetch = fetch } = options;
-	const response = await customFetch(`${GITHUB_API_BASE}/repos/${owner}/${repo}/contents/${encodeURIComponent(filePath)}?ref=${ref}`, { headers: { Accept: GITHUB_ACCEPT_HEADER } });
-	if (!response.ok) {
-		if (response.status === 404) throw new RemoteNotFoundError(`GitHub file not found: ${filePath}`);
-		throw new Error(`GitHub API error: ${response.status} ${response.statusText}`);
-	}
-	const data = await response.json();
-	if (data.encoding !== "base64") throw new Error(`Unexpected encoding: ${data.encoding}`);
-	return Buffer.from(data.content, "base64").toString("utf-8");
-}
-
-//#endregion
-//#region src/remote/gitlab.ts
-var gitlab_exports = /* @__PURE__ */ __exportAll({
-	fetchFile: () => fetchFile,
-	listFiles: () => listFiles
-});
-const GITLAB_API_BASE = "https://gitlab.com/api/v4";
-function encodeProjectPath(owner, repo) {
-	return encodeURIComponent(`${owner}/${repo}`);
-}
-async function listFiles(repoRef, options = {}) {
-	const { owner, repo, ref, path } = repoRef;
-	const refValue = ref ?? "HEAD";
-	const pathValue = path ?? "";
-	const { customFetch = fetch } = options;
-	const projectId = encodeProjectPath(owner, repo);
-	const encodedPath = encodeURIComponent(pathValue);
-	const files = [];
-	let truncated = false;
-	async function fetchPage(page) {
-		const response = await customFetch(`${GITLAB_API_BASE}/projects/${projectId}/repository/tree?recursive=true&ref=${refValue}&path=${encodedPath}&per_page=100&page=${page}`);
-		if (!response.ok) throw new Error(`GitLab API error: ${response.status} ${response.statusText}`);
-		const data = await response.json();
-		files.push(...data.filter((item) => item.type === "blob").map((item) => item.path));
-		const nextPage = response.headers.get("x-next-page");
-		if (!nextPage) return;
-		const nextPageNumber = Number(nextPage);
-		if (!Number.isFinite(nextPageNumber) || nextPageNumber <= page) {
-			truncated = true;
-			return;
-		}
-		await fetchPage(nextPageNumber);
-	}
-	await fetchPage(1);
-	return {
-		files,
-		truncated
-	};
-}
-async function fetchFile(repoRef, filePath, options = {}) {
-	const { owner, repo, ref } = repoRef;
-	const refValue = ref ?? "HEAD";
-	const { customFetch = fetch } = options;
-	const response = await customFetch(`${GITLAB_API_BASE}/projects/${encodeProjectPath(owner, repo)}/repository/files/${encodeURIComponent(filePath)}/raw?ref=${refValue}`);
-	if (!response.ok) {
-		if (response.status === 404) throw new RemoteNotFoundError(`GitLab file not found: ${filePath}`);
-		throw new Error(`GitLab API error: ${response.status} ${response.statusText}`);
-	}
-	return response.text();
-}
-
-//#endregion
-//#region src/bundler/source.ts
-async function loadRemoteSource(identifier, customFetch) {
-	const remote = parseRemoteIdentifier(identifier);
-	if (!remote) {
-		if (isUrlLike(identifier)) throw new Error(`Unsupported import specifier: ${identifier}`);
-		try {
-			return await readFile(identifier, "utf-8");
-		} catch (error) {
-			if (error instanceof Error && "code" in error && error.code === "ENOENT") throw new RemoteNotFoundError(`Module not found: ${identifier}`);
-			throw error;
-		}
-	}
-	const repoRef = {
-		owner: remote.owner,
-		repo: remote.repo,
-		ref: remote.ref
-	};
-	if (remote.provider === "github") return fetchFile$1(repoRef, remote.path, { customFetch });
-	return fetchFile(repoRef, remote.path, { customFetch });
-}
-async function compileModuleSource(identifier, source) {
-	let filename;
-	try {
-		const url = new URL(identifier);
-		filename = url.searchParams.get("path") ?? (url.pathname || identifier);
-	} catch {
-		filename = identifier;
-	}
-	const result = await transform(filename, source, { sourceType: "module" });
-	if (result.errors && result.errors.length > 0) {
-		const message = result.errors.map((error) => error.message).join("\n");
-		throw new Error(`Failed to parse module ${identifier}: ${message}`);
-	}
-	return result.code;
-}
-
-//#endregion
-//#region src/bundler/bundle.ts
-function createRemotePlugin(input) {
-	const customFetch = input.customFetch ?? fetch;
-	const moduleCache = /* @__PURE__ */ new Map();
-	return {
-		name: "pipeline-remote-loader",
-		resolveId: async (specifier, importer) => {
-			if (!importer) return input.identifier;
-			assertRelativeSpecifier(specifier);
-			const candidates = buildCandidateIdentifiers(specifier, importer);
-			for (const candidate of candidates) try {
-				const source = await loadRemoteSource(candidate, customFetch);
-				moduleCache.set(candidate, source);
-				return candidate;
-			} catch (err) {
-				if (err instanceof RemoteNotFoundError) continue;
-				throw err;
-			}
-			throw new Error(`Module not found: ${specifier}`);
-		},
-		load: async (id) => {
-			if (id === input.identifier) return compileModuleSource(id, input.content);
-			const source = moduleCache.get(id) ?? await loadRemoteSource(id, customFetch);
-			const code = await compileModuleSource(id, source);
-			moduleCache.set(id, source);
-			return code;
-		}
-	};
-}
-async function bundleRemoteModule(input) {
-	const specifiers = getStaticImportSpecifiers(input.content, input.identifier);
-	for (const specifier of specifiers) assertRelativeSpecifier(specifier);
-	const result = await build({
-		input: input.identifier,
-		plugins: [createRemotePlugin(input)],
-		write: false,
-		output: { format: "esm" }
-	});
-	const chunk = (Array.isArray(result) ? result : [result]).flatMap((output) => output.output ?? []).find((item) => item.type === "chunk");
-	if (!chunk || chunk.type !== "chunk") throw new Error("Failed to bundle remote module");
-	return chunk.code;
-}
-function createDataUrl(code) {
-	return `data:text/javascript;base64,${Buffer.from(code, "utf-8").toString("base64")}`;
-}
-function identifierForLocalFile(filePath) {
-	return path.resolve(filePath);
-}
-
-//#endregion
-export { gitlab_exports as a, github_exports as c, fetchFile as i, listFiles$1 as l, createDataUrl as n, listFiles as o, identifierForLocalFile as r, fetchFile$1 as s, bundleRemoteModule as t, formatRemoteIdentifierFromParts as u };

package/dist/chunk-DQk6qfdC.mjs

@@ -1,18 +0,0 @@
-//#region \0rolldown/runtime.js
-var __defProp = Object.defineProperty;
-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;
-};
-
-//#endregion
-export { __exportAll as t };

package/dist/gitlab-C8zDC1_j.d.mts

@@ -1,32 +0,0 @@
-//#region src/remote/types.d.ts
-interface RemoteFileList {
-  files: string[];
-  truncated: boolean;
-}
-interface RemoteRequestOptions {
-  customFetch?: typeof fetch;
-}
-declare namespace github_d_exports {
-  export { fetchFile$1 as fetchFile, listFiles$1 as listFiles };
-}
-interface GitHubRepoRef {
-  owner: string;
-  repo: string;
-  ref?: string;
-  path?: string;
-}
-declare function listFiles$1(repoRef: GitHubRepoRef, options?: RemoteRequestOptions): Promise<RemoteFileList>;
-declare function fetchFile$1(repoRef: GitHubRepoRef, filePath: string, options?: RemoteRequestOptions): Promise<string>;
-declare namespace gitlab_d_exports {
-  export { GitLabRepoRef, fetchFile, listFiles };
-}
-interface GitLabRepoRef {
-  owner: string;
-  repo: string;
-  ref?: string;
-  path?: string;
-}
-declare function listFiles(repoRef: GitLabRepoRef, options?: RemoteRequestOptions): Promise<RemoteFileList>;
-declare function fetchFile(repoRef: GitLabRepoRef, filePath: string, options?: RemoteRequestOptions): Promise<string>;
-//#endregion
-export { github_d_exports as n, RemoteFileList as r, gitlab_d_exports as t };

package/dist/insecure.d.mts

@@ -1,10 +0,0 @@
-import { i as LoadedPipelineFile } from "./types-Br8gGmsN.mjs";
-
-//#region src/insecure.d.ts
-interface LoadPipelineFromContentOptions {
-  identifier?: string;
-  customFetch?: typeof fetch;
-}
-declare function loadPipelineFromContent(content: string, filename: string, options?: LoadPipelineFromContentOptions): Promise<LoadedPipelineFile>;
-//#endregion
-export { LoadPipelineFromContentOptions, loadPipelineFromContent };

package/dist/insecure.mjs

@@ -1,30 +0,0 @@
-import { n as createDataUrl, r as identifierForLocalFile, t as bundleRemoteModule } from "./bundle-dlu7M3TU.mjs";
-import { isPipelineDefinition } from "@ucdjs/pipelines-core";
-import path from "node:path";
-
-//#region src/insecure.ts
-async function loadPipelineFromContent(content, filename, options = {}) {
-	const module = await import(createDataUrl(await bundleRemoteModule({
-		content,
-		identifier: options.identifier ?? identifierForLocalFile(path.resolve(filename)),
-		customFetch: options.customFetch
-	})));
-	const pipelines = [];
-	const exportNames = [];
-	const exportedModule = module;
-	for (const [name, value] of Object.entries(exportedModule)) {
-		if (name === "default") continue;
-		if (isPipelineDefinition(value)) {
-			pipelines.push(value);
-			exportNames.push(name);
-		}
-	}
-	return {
-		filePath: filename,
-		pipelines,
-		exportNames
-	};
-}
-
-//#endregion
-export { loadPipelineFromContent };

package/dist/remote.d.mts

@@ -1,16 +0,0 @@
-import { n as GitLabSource, r as LoadPipelinesResult, t as GitHubSource } from "./types-Br8gGmsN.mjs";
-import { n as github_d_exports, r as RemoteFileList, t as gitlab_d_exports } from "./gitlab-C8zDC1_j.mjs";
-
-//#region src/remote.d.ts
-interface FindRemotePipelineFilesOptions {
-  pattern?: string;
-  customFetch?: typeof fetch;
-}
-declare function findRemotePipelineFiles(source: GitHubSource | GitLabSource, options?: FindRemotePipelineFilesOptions): Promise<RemoteFileList>;
-interface LoadRemotePipelinesOptions {
-  throwOnError?: boolean;
-  customFetch?: typeof fetch;
-}
-declare function loadRemotePipelines(source: GitHubSource | GitLabSource, filePaths: string[], options?: LoadRemotePipelinesOptions): Promise<LoadPipelinesResult>;
-//#endregion
-export { FindRemotePipelineFilesOptions, LoadRemotePipelinesOptions, findRemotePipelineFiles, github_d_exports as github, gitlab_d_exports as gitlab, loadRemotePipelines };

package/dist/remote.mjs

@@ -1,77 +0,0 @@
-import { a as gitlab_exports, c as github_exports, i as fetchFile$1, l as listFiles, o as listFiles$1, s as fetchFile, u as formatRemoteIdentifierFromParts } from "./bundle-dlu7M3TU.mjs";
-import { loadPipelineFromContent } from "./insecure.mjs";
-import picomatch from "picomatch";
-
-//#region src/remote.ts
-async function findRemotePipelineFiles(source, options = {}) {
-	const { pattern = "**/*.ucd-pipeline.ts", customFetch = fetch } = options;
-	const { owner, repo, ref, path } = source;
-	const repoRef = {
-		owner,
-		repo,
-		ref,
-		path
-	};
-	let fileList;
-	if (source.type === "github") fileList = await listFiles(repoRef, { customFetch });
-	else fileList = await listFiles$1(repoRef, { customFetch });
-	const isMatch = picomatch(pattern, { dot: true });
-	return {
-		files: fileList.files.filter((file) => isMatch(file)),
-		truncated: fileList.truncated
-	};
-}
-function buildRemoteIdentifier(provider, owner, repo, ref, filePath) {
-	return formatRemoteIdentifierFromParts(provider, owner, repo, ref, filePath);
-}
-async function loadRemotePipelines(source, filePaths, options = {}) {
-	const { throwOnError = false, customFetch = fetch } = options;
-	const { owner, repo, ref, type } = source;
-	const repoRef = {
-		owner,
-		repo,
-		ref
-	};
-	if (throwOnError) {
-		const wrapped = filePaths.map((filePath) => (type === "github" ? fetchFile(repoRef, filePath, { customFetch }) : fetchFile$1(repoRef, filePath, { customFetch })).then((content) => loadPipelineFromContent(content, filePath, {
-			identifier: buildRemoteIdentifier(type, owner, repo, ref, filePath),
-			customFetch
-		})).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(async (filePath) => {
-		return loadPipelineFromContent(type === "github" ? await fetchFile(repoRef, filePath, { customFetch }) : await fetchFile$1(repoRef, filePath, { customFetch }), filePath, {
-			identifier: buildRemoteIdentifier(type, owner, repo, ref, filePath),
-			customFetch
-		});
-	}));
-	const files = [];
-	const errors = [];
-	for (const [i, 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
-		});
-	}
-	return {
-		pipelines: files.flatMap((f) => f.pipelines),
-		files,
-		errors
-	};
-}
-
-//#endregion
-export { findRemotePipelineFiles, github_exports as github, gitlab_exports as gitlab, loadRemotePipelines };