@ucdjs/pipelines-loader 0.0.1-beta.1

package/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2025-PRESENT Lucas Nørgård
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

package/README.md

@@ -0,0 +1,27 @@
+# @ucdjs/pipelines-loader
+
+[![npm version][npm-version-src]][npm-version-href]
+[![npm downloads][npm-downloads-src]][npm-downloads-href]
+[![codecov][codecov-src]][codecov-href]
+
+> [!IMPORTANT]
+> This is an internal package. It may change without warning and is not subject to semantic versioning. Use at your own risk.
+
+A collection of core pipeline functionalities for the UCD project.
+
+## Installation
+
+```bash
+npm install @ucdjs/pipelines-loader
+```
+
+## 📄 License
+
+Published under [MIT License](./LICENSE).
+
+[npm-version-src]: https://img.shields.io/npm/v/@ucdjs/pipelines-loader?style=flat&colorA=18181B&colorB=4169E1
+[npm-version-href]: https://npmjs.com/package/@ucdjs/pipelines-loader
+[npm-downloads-src]: https://img.shields.io/npm/dm/@ucdjs/pipelines-loader?style=flat&colorA=18181B&colorB=4169E1
+[npm-downloads-href]: https://npmjs.com/package/@ucdjs/pipelines-loader
+[codecov-src]: https://img.shields.io/codecov/c/gh/ucdjs/ucd?style=flat&colorA=18181B&colorB=4169E1
+[codecov-href]: https://codecov.io/gh/ucdjs/ucd

package/dist/bundle-dlu7M3TU.mjs

@@ -0,0 +1,320 @@
+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

@@ -0,0 +1,18 @@
+//#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

@@ -0,0 +1,32 @@
+//#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/index.d.mts

@@ -0,0 +1,16 @@
+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";
+
+//#region src/loader.d.ts
+declare function loadPipelineFile(filePath: string): Promise<LoadedPipelineFile>;
+interface LoadPipelinesOptions {
+  throwOnError?: boolean;
+}
+declare function loadPipelinesFromPaths(filePaths: string[], options?: LoadPipelinesOptions): Promise<LoadPipelinesResult>;
+interface FindPipelineFilesOptions {
+  patterns?: string | string[];
+  cwd?: string;
+}
+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 };

package/dist/index.mjs

@@ -0,0 +1,75 @@
+import "./bundle-dlu7M3TU.mjs";
+import { findRemotePipelineFiles, loadRemotePipelines } from "./remote.mjs";
+import { pathToFileURL } from "node:url";
+import { isPipelineDefinition } from "@ucdjs/pipelines-core";
+import { glob } from "tinyglobby";
+
+//#region src/loader.ts
+async function loadPipelineFile(filePath) {
+	const module = await (filePath.startsWith("file://") ? import(filePath) : import(pathToFileURL(filePath).href));
+	const pipelines = [];
+	const exportNames = [];
+	for (const [name, value] of Object.entries(module)) if (isPipelineDefinition(value)) {
+		pipelines.push(value);
+		exportNames.push(name);
+	}
+	return {
+		filePath,
+		pipelines,
+		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)));
+	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
+	};
+}
+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
+export { findPipelineFiles, findRemotePipelineFiles, loadPipelineFile, loadPipelinesFromPaths, loadRemotePipelines };

package/dist/insecure.d.mts

@@ -0,0 +1,10 @@
+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

@@ -0,0 +1,30 @@
+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

@@ -0,0 +1,16 @@
+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

@@ -0,0 +1,77 @@
+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 };

package/dist/types-Br8gGmsN.d.mts

@@ -0,0 +1,41 @@
+import { PipelineDefinition } from "@ucdjs/pipelines-core";
+
+//#region src/types.d.ts
+interface LoadedPipelineFile {
+  filePath: string;
+  pipelines: PipelineDefinition[];
+  exportNames: string[];
+}
+interface LoadPipelinesResult {
+  pipelines: PipelineDefinition[];
+  files: LoadedPipelineFile[];
+  errors: PipelineLoadError[];
+}
+interface PipelineLoadError {
+  filePath: string;
+  error: Error;
+}
+interface GitHubSource {
+  type: "github";
+  id: string;
+  owner: string;
+  repo: string;
+  ref?: string;
+  path?: string;
+}
+interface GitLabSource {
+  type: "gitlab";
+  id: string;
+  owner: string;
+  repo: string;
+  ref?: string;
+  path?: string;
+}
+interface LocalSource {
+  type: "local";
+  id: string;
+  cwd: string;
+}
+type PipelineSource = LocalSource | GitHubSource | GitLabSource;
+//#endregion
+export { LocalSource as a, LoadedPipelineFile as i, GitLabSource as n, PipelineLoadError as o, LoadPipelinesResult as r, PipelineSource as s, GitHubSource as t };

package/package.json

@@ -0,0 +1,62 @@
+{
+  "name": "@ucdjs/pipelines-loader",
+  "version": "0.0.1-beta.1",
+  "type": "module",
+  "author": {
+    "name": "Lucas Nørgård",
+    "email": "lucasnrgaard@gmail.com",
+    "url": "https://luxass.dev"
+  },
+  "license": "MIT",
+  "homepage": "https://github.com/ucdjs/ucd",
+  "repository": {
+    "type": "git",
+    "url": "git+https://github.com/ucdjs/ucd.git",
+    "directory": "packages/pipelines/pipeline-loader"
+  },
+  "bugs": {
+    "url": "https://github.com/ucdjs/ucd/issues"
+  },
+  "exports": {
+    ".": "./dist/index.mjs",
+    "./insecure": "./dist/insecure.mjs",
+    "./remote": "./dist/remote.mjs",
+    "./package.json": "./package.json"
+  },
+  "types": "./dist/index.d.mts",
+  "files": [
+    "dist"
+  ],
+  "engines": {
+    "node": ">=22.18"
+  },
+  "dependencies": {
+    "oxc-parser": "0.112.0",
+    "oxc-transform": "0.112.0",
+    "picomatch": "4.0.3",
+    "rolldown": "1.0.0-rc.4",
+    "tinyglobby": "0.2.15",
+    "@ucdjs/pipelines-core": "0.0.1-beta.1"
+  },
+  "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",
+    "@ucdjs-tooling/tsconfig": "1.0.0",
+    "@ucdjs-tooling/tsdown-config": "1.0.0"
+  },
+  "publishConfig": {
+    "access": "public"
+  },
+  "scripts": {
+    "build": "tsdown --tsconfig=./tsconfig.build.json",
+    "dev": "tsdown --watch",
+    "clean": "git clean -xdf dist node_modules",
+    "lint": "eslint .",
+    "typecheck": "tsc --noEmit -p tsconfig.build.json"
+  }
+}