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

package/README.md

@@ -2,7 +2,6 @@
 
 [![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.
@@ -23,5 +22,3 @@ Published under [MIT License](./LICENSE).
 [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/discover-C_YruvBu.d.mts

@@ -0,0 +1,69 @@
+//#region src/errors.d.ts
+declare const PIPELINE_LOADER_ISSUE_CODES: readonly ["INVALID_LOCATOR", "CACHE_MISS", "REF_RESOLUTION_FAILED", "DOWNLOAD_FAILED", "MATERIALIZE_FAILED", "DISCOVERY_FAILED", "BUNDLE_RESOLVE_FAILED", "BUNDLE_TRANSFORM_FAILED", "IMPORT_FAILED", "INVALID_EXPORT"];
+type PipelineLoaderIssueCode = (typeof PIPELINE_LOADER_ISSUE_CODES)[number];
+type PipelineLoaderIssueScope = "locator" | "repository" | "discovery" | "file" | "bundle" | "import";
+interface PipelineLoaderIssue {
+  code: PipelineLoaderIssueCode;
+  scope: PipelineLoaderIssueScope;
+  message: string;
+  locator?: unknown;
+  repositoryPath?: string;
+  filePath?: string;
+  relativePath?: string;
+  cause?: Error;
+  meta?: Record<string, unknown>;
+}
+declare class PipelineLoaderError extends Error {
+  readonly code: PipelineLoaderIssueCode;
+  constructor(code: PipelineLoaderIssueCode, message: string, options?: ErrorOptions);
+}
+declare class CacheMissError extends PipelineLoaderError {
+  readonly provider: string;
+  readonly owner: string;
+  readonly repo: string;
+  readonly ref: string;
+  constructor(provider: string, owner: string, repo: string, ref: string);
+}
+declare class BundleError extends PipelineLoaderError {
+  readonly entryPath: string;
+  constructor(entryPath: string, message: string, options?: ErrorOptions);
+}
+declare class BundleResolveError extends PipelineLoaderError {
+  readonly entryPath: string;
+  readonly importPath: string;
+  constructor(entryPath: string, importPath: string, options?: ErrorOptions);
+}
+declare class BundleTransformError extends PipelineLoaderError {
+  readonly entryPath: string;
+  readonly line?: number;
+  readonly column?: number;
+  constructor(entryPath: string, options?: ErrorOptions & {
+    line?: number;
+    column?: number;
+  });
+}
+//#endregion
+//#region src/discover.d.ts
+interface RemoteOriginMeta {
+  provider: "github" | "gitlab";
+  owner: string;
+  repo: string;
+  ref: string;
+  path?: string;
+}
+interface DiscoverPipelineFilesOptions {
+  repositoryPath: string;
+  patterns?: string | string[];
+  origin?: RemoteOriginMeta;
+}
+interface DiscoverPipelineFilesResult {
+  files: Array<{
+    filePath: string;
+    relativePath: string;
+    origin?: RemoteOriginMeta;
+  }>;
+  issues: PipelineLoaderIssue[];
+}
+declare function discoverPipelineFiles(options: DiscoverPipelineFilesOptions): Promise<DiscoverPipelineFilesResult>;
+//#endregion
+export { BundleError as a, CacheMissError as c, discoverPipelineFiles as i, PipelineLoaderError as l, DiscoverPipelineFilesResult as n, BundleResolveError as o, RemoteOriginMeta as r, BundleTransformError as s, DiscoverPipelineFilesOptions as t, PipelineLoaderIssue as u };

package/dist/discover.d.mts

@@ -0,0 +1,2 @@
+import { i as discoverPipelineFiles, n as DiscoverPipelineFilesResult, r as RemoteOriginMeta, t as DiscoverPipelineFilesOptions } from "./discover-C_YruvBu.mjs";
+export { DiscoverPipelineFilesOptions, DiscoverPipelineFilesResult, RemoteOriginMeta, discoverPipelineFiles };

package/dist/discover.mjs

@@ -0,0 +1,53 @@
+import { relative } from "node:path";
+import { glob } from "tinyglobby";
+//#region src/discover.ts
+const TRAILING_SLASH_RE = /\/$/;
+const BACKSLASH_RE = /\\/g;
+function joinOriginPath(origin, relativePath) {
+	if (!origin) return void 0;
+	return {
+		...origin,
+		path: origin.path ? `${origin.path.replace(TRAILING_SLASH_RE, "")}/${relativePath}` : relativePath
+	};
+}
+async function discoverPipelineFiles(options) {
+	const patterns = options.patterns ? Array.isArray(options.patterns) ? options.patterns : [options.patterns] : ["**/*.ucd-pipeline.ts"];
+	try {
+		return {
+			files: (await glob(patterns, {
+				cwd: options.repositoryPath,
+				ignore: [
+					"node_modules/**",
+					"**/node_modules/**",
+					"**/dist/**",
+					"**/build/**",
+					"**/.git/**"
+				],
+				absolute: true,
+				onlyFiles: true
+			})).map((filePath) => {
+				const relativePath = relative(options.repositoryPath, filePath).replace(BACKSLASH_RE, "/");
+				return {
+					filePath,
+					relativePath,
+					origin: joinOriginPath(options.origin, relativePath)
+				};
+			}),
+			issues: []
+		};
+	} catch (err) {
+		const cause = err instanceof Error ? err : new Error(String(err));
+		return {
+			files: [],
+			issues: [{
+				code: "DISCOVERY_FAILED",
+				scope: "discovery",
+				message: cause.message,
+				repositoryPath: options.repositoryPath,
+				cause
+			}]
+		};
+	}
+}
+//#endregion
+export { discoverPipelineFiles };

package/dist/index.d.mts

@@ -1,58 +1,125 @@
-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";
+import { a as BundleError, c as CacheMissError, l as PipelineLoaderError, o as BundleResolveError, r as RemoteOriginMeta, s as BundleTransformError, u as PipelineLoaderIssue } from "./discover-C_YruvBu.mjs";
+import { PipelineDefinition } from "@ucdjs/pipelines-core";
 
-//#region src/loader.d.ts
-type FindPipelineSource = {
-  type: "local";
-  cwd: string;
-} | {
-  type: "github";
+//#region src/cache.d.ts
+type RemoteProvider = "github" | "gitlab";
+interface RemoteCacheStatus {
+  provider: RemoteProvider;
+  owner: string;
+  repo: string;
+  ref: string;
+  commitSha: string;
+  cacheDir: string;
+  markerPath: string;
+  cached: boolean;
+  syncedAt: string | null;
+}
+declare function getRemoteSourceCacheStatus(input: {
+  provider: RemoteProvider;
   owner: string;
   repo: string;
   ref?: string;
-  path?: string;
-} | {
-  type: "gitlab";
+}): Promise<RemoteCacheStatus>;
+/**
+ * Write a cache marker for a remote source.
+ * Call this after downloading and extracting the archive.
+ */
+declare function writeCacheMarker(input: {
+  provider: RemoteProvider;
+  owner: string;
+  repo: string;
+  ref: string;
+  commitSha: string;
+  cacheDir: string;
+  markerPath: string;
+}): Promise<void>;
+declare function clearRemoteSourceCache(input: {
+  provider: RemoteProvider;
   owner: string;
   repo: string;
   ref?: string;
-  path?: string;
-};
+}): Promise<boolean>;
 /**
- * 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
+ * List all cached remote sources.
  */
+declare function listCachedSources(): Promise<Array<{
+  source: string;
+  owner: string;
+  repo: string;
+  ref: string;
+  commitSha: string;
+  syncedAt: string;
+  cacheDir: string;
+}>>;
+//#endregion
+//#region src/loader.d.ts
+interface LoadedPipelineFile {
+  filePath: string;
+  pipelines: PipelineDefinition[];
+  exportNames: string[];
+}
+interface LoadPipelinesResult {
+  pipelines: PipelineDefinition[];
+  files: LoadedPipelineFile[];
+  issues: PipelineLoaderIssue[];
+}
 declare function loadPipelineFile(filePath: string): Promise<LoadedPipelineFile>;
-interface LoadPipelinesOptions {
-  throwOnError?: boolean;
+declare function loadPipelinesFromPaths(filePaths: string[]): Promise<LoadPipelinesResult>;
+//#endregion
+//#region src/materialize.d.ts
+interface LocalPipelineLocator {
+  kind: "local";
+  path: string;
 }
-declare function loadPipelinesFromPaths(filePaths: string[], options?: LoadPipelinesOptions): Promise<LoadPipelinesResult>;
-interface FindPipelineFilesOptions {
-  patterns?: string | string[];
-  source?: FindPipelineSource;
+interface RemotePipelineLocator {
+  kind: "remote";
+  provider: "github" | "gitlab";
+  owner: string;
+  repo: string;
+  ref?: string;
+  path?: string;
 }
-/**
- * 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[]>;
+type PipelineLocator = LocalPipelineLocator | RemotePipelineLocator;
+interface MaterializePipelineLocatorResult {
+  repositoryPath?: string;
+  filePath?: string;
+  relativePath?: string;
+  origin?: RemoteOriginMeta;
+  issues: PipelineLoaderIssue[];
+}
+declare function materializePipelineLocator(locator: PipelineLocator): Promise<MaterializePipelineLocatorResult>;
+//#endregion
+//#region src/locator.d.ts
+declare function parsePipelineLocator(input: string): PipelineLocator;
+declare function parseRemoteSourceUrl(url: string): RemotePipelineLocator | null;
+//#endregion
+//#region src/remote.d.ts
+interface UpdateCheckResult {
+  hasUpdate: boolean;
+  currentSha: string | null;
+  remoteSha: string;
+  error?: Error;
+}
+declare function checkRemoteLocatorUpdates(input: {
+  provider: "github" | "gitlab";
+  owner: string;
+  repo: string;
+  ref?: string;
+}): Promise<UpdateCheckResult>;
+interface SyncResult {
+  success: boolean;
+  updated: boolean;
+  previousSha: string | null;
+  newSha: string;
+  cacheDir: string;
+  error?: Error;
+}
+declare function ensureRemoteLocator(input: {
+  provider: "github" | "gitlab";
+  owner: string;
+  repo: string;
+  ref?: string;
+  force?: boolean;
+}): Promise<SyncResult>;
 //#endregion
-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 };
+export { BundleError, BundleResolveError, BundleTransformError, CacheMissError, type LoadedPipelineFile, type LocalPipelineLocator, PipelineLoaderError, type PipelineLoaderIssue, type PipelineLocator, type RemoteCacheStatus, type RemoteOriginMeta, type RemotePipelineLocator, type SyncResult, type UpdateCheckResult, checkRemoteLocatorUpdates, clearRemoteSourceCache, ensureRemoteLocator, getRemoteSourceCacheStatus, listCachedSources, loadPipelineFile, loadPipelinesFromPaths, materializePipelineLocator, parsePipelineLocator, parseRemoteSourceUrl, writeCacheMarker };

package/dist/index.mjs

@@ -1,76 +1,267 @@
-import { n as downloadGitHubRepo, t as downloadGitLabRepo } from "./gitlab-BeZb8tDi.mjs";
+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";
-
-//#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;
+import { parseTarGzip } from "nanotar";
+//#region src/cache.ts
+function getBaseRepoCacheDir() {
+	return getUcdConfigPath("cache", "repos");
 }
-function createDataUrl(code) {
-	return `data:text/javascript;base64,${Buffer.from(code, "utf-8").toString("base64")}`;
+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
+	};
 }
-
-//#endregion
-//#region src/loader.ts
 /**
-* Parse a github:// or gitlab:// URL
+* Write a cache marker for a remote source.
+* Call this after downloading and extracting the archive.
 */
-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]
-		};
+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;
 	}
-	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
+* List all cached remote sources.
 */
-async function loadPipelineFile(filePath) {
-	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
+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
 		});
-		resolvedPath = path.join(cacheDir, repoInfo.filePath);
-	} else resolvedPath = path.resolve(filePath);
-	const module = await import(createDataUrl(await bundleModule(resolvedPath)));
+	} 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 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)) {
@@ -86,90 +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
 	};
 }
-/**
-* 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"];
-	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
+//#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
 		});
-		else cwd = await downloadGitLabRepo({
-			owner: source.owner,
-			repo: source.repo,
-			ref: source.ref
+		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
 		});
-	} else cwd = process.cwd();
-	return glob(patterns, {
-		cwd,
-		ignore: [
-			"node_modules/**",
-			"**/node_modules/**",
-			"**/dist/**",
-			"**/build/**",
-			"**/.git/**"
-		],
-		absolute: true,
-		onlyFiles: true
+		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, loadPipelineFile, loadPipelinesFromPaths };
+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.7",
+  "version": "0.0.1-beta.8",
   "type": "module",
   "author": {
     "name": "Lucas Nørgård",
@@ -19,7 +19,7 @@
   },
   "exports": {
     ".": "./dist/index.mjs",
-    "./internal": "./dist/internal.mjs",
+    "./discover": "./dist/discover.mjs",
     "./package.json": "./package.json"
   },
   "types": "./dist/index.d.mts",
@@ -31,18 +31,19 @@
   },
   "dependencies": {
     "nanotar": "0.3.0",
-    "rolldown": "1.0.0-rc.6",
+    "rolldown": "1.0.0-rc.11",
     "tinyglobby": "0.2.15",
-    "@ucdjs/pipelines-core": "0.0.1-beta.7",
-    "@ucdjs-internal/shared": "0.1.1-beta.7"
+    "@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.1",
-    "eslint": "10.0.2",
-    "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"
   },

package/dist/gitlab-BeZb8tDi.mjs

@@ -1,108 +0,0 @@
-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/internal.d.mts

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

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

package/dist/types-C7EhTWo6.d.mts

@@ -1,48 +0,0 @@
-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;
-interface RemoteFileList {
-  files: string[];
-  truncated: boolean;
-}
-interface RemoteRequestOptions {
-  customFetch?: typeof fetch;
-}
-//#endregion
-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 };