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

package/dist/index.mjs

@@ -1,7 +1,7 @@
-import { n as resolveMultipleSourceFiles, r as resolveSourceFiles, t as definePipelineSource } from "./source-EtWCktj_.mjs";
-import { n as definePipelineTransform, t as applyTransforms } from "./transform-BGOswbNk.mjs";
+import { n as normalizeRouteOutputs, t as filesystemSink } from "./types-BxE_sFho.mjs";
+import { a as resolveSourceFiles, i as resolveMultipleSourceFiles, n as isPipelineOutputSource, r as pipelineOutputSource, t as definePipelineSource } from "./source-UYQsDb7S.mjs";
+import { n as definePipelineTransform, t as applyTransforms } from "./transform-C7y-ZJKs.mjs";
 import picomatch from "picomatch";
-
 //#region src/dependencies.ts
 function parseDependency(dep) {
 	if (dep.startsWith("route:")) {
@@ -12,37 +12,19 @@ function parseDependency(dep) {
 			routeId
 		};
 	}
-	if (dep.startsWith("artifact:")) {
-		const rest = dep.slice(9);
-		const sepIndex = rest.indexOf(":");
-		if (sepIndex <= 0 || sepIndex >= rest.length - 1) throw new Error(`Invalid dependency format: ${dep}. Expected "route:<id>" or "artifact:<routeId>:<artifactName>"`);
-		return {
-			type: "artifact",
-			routeId: rest.slice(0, sepIndex),
-			artifactName: rest.slice(sepIndex + 1)
-		};
-	}
-	throw new Error(`Invalid dependency format: ${dep}. Expected "route:<id>" or "artifact:<routeId>:<artifactName>"`);
+	throw new Error(`Invalid dependency format: ${dep}. Expected "route:<id>"`);
 }
 function isRouteDependency(dep) {
 	return dep.startsWith("route:");
 }
-function isArtifactDependency(dep) {
-	return dep.startsWith("artifact:");
-}
 function createRouteDependency(routeId) {
 	return `route:${routeId}`;
 }
-function createArtifactDependency(routeId, artifactName) {
-	return `artifact:${routeId}:${artifactName}`;
-}
-
 //#endregion
 //#region src/dag.ts
 function buildDAG(routes) {
 	const errors = [];
 	const nodes = /* @__PURE__ */ new Map();
-	const artifactsByRoute = /* @__PURE__ */ new Map();
 	const seenIds = /* @__PURE__ */ new Map();
 	for (let i = 0; i < routes.length; i++) {
 		const route = routes[i];
@@ -60,65 +42,29 @@ function buildDAG(routes) {
 		errors
 	};
 	const routeIds = new Set(routes.map((r) => r.id));
-	for (const route of routes) {
-		const emittedArtifacts = /* @__PURE__ */ new Set();
-		if (route.emits) for (const artifactName of Object.keys(route.emits)) emittedArtifacts.add(`${route.id}:${artifactName}`);
-		artifactsByRoute.set(route.id, emittedArtifacts);
-		nodes.set(route.id, {
-			id: route.id,
-			dependencies: /* @__PURE__ */ new Set(),
-			dependents: /* @__PURE__ */ new Set(),
-			emittedArtifacts
-		});
-	}
+	for (const route of routes) nodes.set(route.id, {
+		id: route.id,
+		dependencies: /* @__PURE__ */ new Set(),
+		dependents: /* @__PURE__ */ new Set()
+	});
 	for (const route of routes) {
 		const node = nodes.get(route.id);
 		if (!route.depends) continue;
 		for (const dep of route.depends) {
 			const parsed = parseDependency(dep);
-			if (isRouteDependency(dep)) {
-				if (!routeIds.has(parsed.routeId)) {
-					errors.push({
-						type: "missing-route",
-						message: `Route "${route.id}" depends on non-existent route "${parsed.routeId}"`,
-						details: {
-							routeId: route.id,
-							dependencyId: parsed.routeId
-						}
-					});
-					continue;
-				}
-				node.dependencies.add(parsed.routeId);
-				nodes.get(parsed.routeId).dependents.add(route.id);
-			} else if (isArtifactDependency(dep)) {
-				if (parsed.type !== "artifact") continue;
-				if (!routeIds.has(parsed.routeId)) {
-					errors.push({
-						type: "missing-route",
-						message: `Route "${route.id}" depends on artifact from non-existent route "${parsed.routeId}"`,
-						details: {
-							routeId: route.id,
-							dependencyId: parsed.routeId
-						}
-					});
-					continue;
-				}
-				const routeArtifacts = artifactsByRoute.get(parsed.routeId);
-				const artifactKey = `${parsed.routeId}:${parsed.artifactName}`;
-				if (!routeArtifacts?.has(artifactKey)) {
-					errors.push({
-						type: "missing-artifact",
-						message: `Route "${route.id}" depends on non-existent artifact "${parsed.artifactName}" from route "${parsed.routeId}"`,
-						details: {
-							routeId: route.id,
-							dependencyId: artifactKey
-						}
-					});
-					continue;
-				}
-				node.dependencies.add(parsed.routeId);
-				nodes.get(parsed.routeId).dependents.add(route.id);
+			if (!routeIds.has(parsed.routeId)) {
+				errors.push({
+					type: "missing-route",
+					message: `Route "${route.id}" depends on non-existent route "${parsed.routeId}"`,
+					details: {
+						routeId: route.id,
+						dependencyId: parsed.routeId
+					}
+				});
+				continue;
 			}
+			node.dependencies.add(parsed.routeId);
+			nodes.get(parsed.routeId).dependents.add(route.id);
 		}
 	}
 	const cycleResult = detectCycle(nodes);
@@ -201,52 +147,110 @@ function getExecutionLayers(dag) {
 	}
 	return layers;
 }
-
 //#endregion
 //#region src/filters.ts
+const FILTER_NODE = Symbol.for("ucdjs.filter-node");
+function setFilterNode(filter, node) {
+	Object.defineProperty(filter, FILTER_NODE, {
+		value: node,
+		enumerable: false,
+		configurable: false,
+		writable: false
+	});
+	return filter;
+}
+function getFilterNode(filter) {
+	return filter[FILTER_NODE];
+}
+function createPipelineFilter(caller, args, filter) {
+	return setFilterNode(filter, {
+		type: "filter",
+		name: caller.name,
+		args
+	});
+}
+function serializeNode(filter, insideCombinator = false) {
+	const node = getFilterNode(filter);
+	if (!node) return "<custom>";
+	switch (node.type) {
+		case "filter": {
+			const args = node.args.map(formatArg).join(", ");
+			return `${node.name}(${args})`;
+		}
+		case "and": {
+			const description = node.filters.map((filter) => serializeNode(filter, true)).join(" AND ");
+			return insideCombinator ? `(${description})` : description;
+		}
+		case "or": {
+			const description = node.filters.map((filter) => serializeNode(filter, true)).join(" OR ");
+			return insideCombinator ? `(${description})` : description;
+		}
+		case "not": return `NOT ${serializeNode(node.filter, true)}`;
+	}
+}
+function formatArg(arg) {
+	if (typeof arg === "string") return JSON.stringify(arg);
+	if (arg instanceof RegExp) return String(arg);
+	if (Array.isArray(arg)) return JSON.stringify(arg);
+	return String(arg);
+}
+function getFilterDescription(filter) {
+	if (!getFilterNode(filter)) return;
+	return serializeNode(filter);
+}
 function byName(name) {
-	return (ctx) => ctx.file.name === name;
+	return createPipelineFilter(byName, [name], (context) => context.file.name === name);
 }
 function byDir(dir) {
-	return (ctx) => ctx.file.dir === dir;
+	return createPipelineFilter(byDir, [dir], (context) => context.file.dir === dir);
 }
 function byExt(ext) {
-	if (ext === "") return (ctx) => ctx.file.ext === "";
-	const normalizedExt = ext.startsWith(".") ? ext : `.${ext}`;
-	return (ctx) => ctx.file.ext === normalizedExt;
+	const normalizedExt = ext === "" ? "" : ext.startsWith(".") ? ext : `.${ext}`;
+	return createPipelineFilter(byExt, [normalizedExt], (context) => context.file.ext === normalizedExt);
 }
 function byGlob(pattern) {
-	const matcher = picomatch(pattern);
-	return (ctx) => matcher(ctx.file.path);
+	const matches = picomatch(pattern);
+	return createPipelineFilter(byGlob, [pattern], (context) => matches(context.file.path));
 }
 function byPath(pathPattern) {
-	if (typeof pathPattern === "string") return (ctx) => ctx.file.path === pathPattern;
-	return (ctx) => pathPattern.test(ctx.file.path);
+	if (typeof pathPattern === "string") return createPipelineFilter(byPath, [pathPattern], (context) => context.file.path === pathPattern);
+	return createPipelineFilter(byPath, [pathPattern], (context) => pathPattern.test(context.file.path));
 }
 function byProp(pattern) {
-	if (typeof pattern === "string") return (ctx) => ctx.row?.property === pattern;
-	return (ctx) => !!ctx.row?.property && pattern.test(ctx.row.property);
+	if (typeof pattern === "string") return createPipelineFilter(byProp, [pattern], (context) => context.row?.property === pattern);
+	return createPipelineFilter(byProp, [pattern], (context) => {
+		const property = context.row?.property;
+		return property != null && pattern.test(property);
+	});
 }
 function bySource(sourceIds) {
 	const ids = Array.isArray(sourceIds) ? sourceIds : [sourceIds];
-	return (ctx) => ctx.source != null && ids.includes(ctx.source.id);
+	return createPipelineFilter(bySource, [ids.length === 1 ? ids[0] : ids], (context) => context.source != null && ids.includes(context.source.id));
 }
 function and(...filters) {
-	return (ctx) => filters.every((f) => f(ctx));
+	return setFilterNode((context) => filters.every((filter) => filter(context)), {
+		type: "and",
+		filters
+	});
 }
 function or(...filters) {
-	return (ctx) => filters.some((f) => f(ctx));
+	return setFilterNode((context) => filters.some((filter) => filter(context)), {
+		type: "or",
+		filters
+	});
 }
 function not(filter) {
-	return (ctx) => !filter(ctx);
+	return setFilterNode((context) => !filter(context), {
+		type: "not",
+		filter
+	});
 }
 function always() {
-	return () => true;
+	return createPipelineFilter(always, [], () => true);
 }
 function never() {
-	return () => false;
+	return createPipelineFilter(never, [], () => false);
 }
-
 //#endregion
 //#region src/pipeline.ts
 /**
@@ -288,7 +292,6 @@ function definePipeline(options) {
 		strict: options.strict ?? false,
 		concurrency: options.concurrency ?? 4,
 		fallback: options.fallback,
-		onEvent: options.onEvent,
 		dag: dagResult.dag,
 		tags: options.tags ?? []
 	};
@@ -302,13 +305,11 @@ function getPipelineRouteIds(pipeline) {
 function getPipelineSourceIds(pipeline) {
 	return pipeline.inputs.map((source) => source.id);
 }
-
 //#endregion
 //#region src/route.ts
 function definePipelineRoute(definition) {
 	return definition;
 }
-
 //#endregion
 //#region src/utils/arrays.ts
 /**
@@ -333,6 +334,5 @@ function splitMinFields(line, delimiter, minFields) {
 	const parts = line.split(delimiter);
 	return parts.length >= minFields ? parts : null;
 }
-
 //#endregion
-export { always, and, applyTransforms, buildDAG, byDir, byExt, byGlob, byName, byPath, byProp, bySource, createArtifactDependency, createRouteDependency, definePipeline, definePipelineRoute, definePipelineSource, definePipelineTransform, getExecutionLayers, getPipelineRouteIds, getPipelineSourceIds, isArtifactDependency, isPipelineDefinition, isRouteDependency, never, not, or, parseDependency, resolveMultipleSourceFiles, resolveSourceFiles, splitMinFields, splitTwoFields };
+export { FILTER_NODE, always, and, applyTransforms, buildDAG, byDir, byExt, byGlob, byName, byPath, byProp, bySource, createPipelineFilter, createRouteDependency, definePipeline, definePipelineRoute, definePipelineSource, definePipelineTransform, filesystemSink, getExecutionLayers, getFilterDescription, getPipelineRouteIds, getPipelineSourceIds, isPipelineDefinition, isPipelineOutputSource, isRouteDependency, never, normalizeRouteOutputs, not, or, parseDependency, pipelineOutputSource, resolveMultipleSourceFiles, resolveSourceFiles, splitMinFields, splitTwoFields };

package/dist/outputs/index.d.mts

@@ -0,0 +1,17 @@
+import { c as FilesystemOutputSinkDefinition, d as RouteOutputDefinition, f as RouteOutputPathContext, h as normalizeRouteOutputs, l as NormalizedRouteOutputDefinition, m as filesystemSink, p as RouteOutputPathResolver, u as OutputSinkDefinition } from "../route-BT-OXkF-.mjs";
+
+//#region src/outputs/resolve.d.ts
+interface ResolvedOutputDestination {
+  locator: string;
+  displayLocator: string;
+}
+declare const DEFAULT_FALLBACK_OUTPUTS: readonly NormalizedRouteOutputDefinition[];
+declare function getOutputProperty(output: unknown): string | undefined;
+declare function resolveOutputDestination(definition: NormalizedRouteOutputDefinition, ctx: RouteOutputPathContext, resolvePath?: (base: string, relative: string) => string): ResolvedOutputDestination;
+declare function renderOutputPathTemplate(template: string, ctx: RouteOutputPathContext): string;
+declare function propertyToKebab(value: string): string;
+//#endregion
+//#region src/outputs/serialize.d.ts
+declare function serializeOutputValue(value: unknown, format: "json" | "text"): string;
+//#endregion
+export { DEFAULT_FALLBACK_OUTPUTS, type FilesystemOutputSinkDefinition, type NormalizedRouteOutputDefinition, type OutputSinkDefinition, type ResolvedOutputDestination, type RouteOutputDefinition, type RouteOutputPathContext, type RouteOutputPathResolver, filesystemSink, getOutputProperty, normalizeRouteOutputs, propertyToKebab, renderOutputPathTemplate, resolveOutputDestination, serializeOutputValue };

package/dist/outputs/index.mjs

@@ -0,0 +1,73 @@
+import { n as normalizeRouteOutputs, t as filesystemSink } from "../types-BxE_sFho.mjs";
+//#region src/outputs/resolve.ts
+const DEFAULT_FALLBACK_OUTPUTS = [{
+	id: "fallback-output",
+	format: "json"
+}];
+const KEBAB_WORD_RE = /[a-z0-9]+/g;
+const LEADING_SLASHES_RE = /^\/+/;
+const TEMPLATE_TOKEN_RE = /\{([^{}]+)\}/g;
+function getOutputProperty(output) {
+	if (typeof output !== "object" || output == null) return;
+	if ("property" in output && typeof output.property === "string") return output.property;
+}
+function resolveOutputDestination(definition, ctx, resolvePath) {
+	if (definition.path) {
+		const relativeLocator = typeof definition.path === "function" ? definition.path(ctx) : renderOutputPathTemplate(definition.path, ctx);
+		return createDestination(definition.sink, relativeLocator, resolvePath);
+	}
+	const property = ctx.property ?? "output";
+	const defaultRelative = `${ctx.routeId}/${propertyToKebab(property)}-${ctx.outputIndex}.${definition.format === "text" ? "txt" : "json"}`;
+	return createDestination(definition.sink, defaultRelative, resolvePath);
+}
+function createDestination(sink, relativeLocator, resolvePath) {
+	const normalizedRelative = relativeLocator.replaceAll("\\", "/");
+	if (normalizedRelative.startsWith("/") || normalizedRelative.split("/").includes("..")) throw new Error(`Output path must stay within the configured sink: "${relativeLocator}"`);
+	if (sink?.type === "filesystem") {
+		const resolved = sink.baseDir ? resolvePath?.(sink.baseDir, normalizedRelative) ?? `${sink.baseDir}/${normalizedRelative}` : resolvePath?.("", normalizedRelative) ?? normalizedRelative;
+		return {
+			locator: resolved,
+			displayLocator: resolved
+		};
+	}
+	const stripped = normalizedRelative.replace(LEADING_SLASHES_RE, "");
+	return {
+		locator: `memory://${stripped}`,
+		displayLocator: `memory://${stripped}`
+	};
+}
+function renderOutputPathTemplate(template, ctx) {
+	return template.replaceAll(TEMPLATE_TOKEN_RE, (_match, token) => {
+		const [rawKey = "", transform] = String(token).split(":");
+		const value = resolveTemplateValue(rawKey, ctx);
+		if (value == null) return "";
+		const stringValue = String(value);
+		switch (transform) {
+			case "lower": return stringValue.toLowerCase();
+			case "kebab": return propertyToKebab(stringValue);
+			default: return stringValue;
+		}
+	});
+}
+function resolveTemplateValue(key, ctx) {
+	switch (key) {
+		case "version": return ctx.version;
+		case "routeId": return ctx.routeId;
+		case "property": return ctx.property;
+		case "outputIndex": return ctx.outputIndex;
+		case "file.name": return ctx.file.name;
+		case "file.path": return ctx.file.path;
+		default: return;
+	}
+}
+function propertyToKebab(value) {
+	return (value.toLowerCase().match(KEBAB_WORD_RE) ?? []).join("-");
+}
+//#endregion
+//#region src/outputs/serialize.ts
+function serializeOutputValue(value, format) {
+	if (format === "text") return typeof value === "string" ? value : JSON.stringify(value, null, 2) ?? "null";
+	return JSON.stringify(value, null, 2) ?? "null";
+}
+//#endregion
+export { DEFAULT_FALLBACK_OUTPUTS, filesystemSink, getOutputProperty, normalizeRouteOutputs, propertyToKebab, renderOutputPathTemplate, resolveOutputDestination, serializeOutputValue };

package/dist/route-BT-OXkF-.d.mts

@@ -0,0 +1,96 @@
+import { a as ParsedRow, d as ResolvedEntry, l as PipelineLogger, n as FileContext, o as ParserFn, s as PipelineFilter, u as PropertyJson } from "./types-B_R0NiDI.mjs";
+import { a as PipelineTransformDefinition, n as ChainTransforms, t as AnyPipelineTransformDefinition } from "./transform-BkBLzZAP.mjs";
+
+//#region src/dependencies.d.ts
+type RouteDependency = `route:${string}`;
+type PipelineDependency = RouteDependency;
+interface ParsedRouteDependency {
+  type: "route";
+  routeId: string;
+}
+type ParsedDependency = ParsedRouteDependency;
+type ParseDependencyType<T extends string> = T extends `route:${infer RouteId}` ? {
+  type: "route";
+  routeId: RouteId;
+} : never;
+type ExtractRouteDependencies<T extends readonly PipelineDependency[]> = { [K in keyof T]: T[K] extends `route:${infer RouteId}` ? RouteId : never }[number];
+declare function parseDependency(dep: PipelineDependency): ParsedDependency;
+declare function isRouteDependency(dep: PipelineDependency): dep is RouteDependency;
+declare function createRouteDependency(routeId: string): RouteDependency;
+//#endregion
+//#region src/outputs/types.d.ts
+interface FilesystemOutputSinkDefinition {
+  type: "filesystem";
+  baseDir?: string;
+}
+type OutputSinkDefinition = FilesystemOutputSinkDefinition;
+interface RouteOutputPathContext {
+  version: string;
+  routeId: string;
+  file: FileContext;
+  output: unknown;
+  property?: string;
+  outputIndex: number;
+}
+type RouteOutputPathResolver = (ctx: RouteOutputPathContext) => string;
+interface RouteOutputDefinition {
+  /**
+   * Stable identifier for this output destination within the route.
+   */
+  id?: string;
+  /**
+   * Destination sink to use when the output should be persisted.
+   * When omitted, the output remains available for the run only.
+   */
+  sink?: OutputSinkDefinition;
+  /**
+   * Output format used by built-in sinks.
+   * @default "json"
+   */
+  format?: "json" | "text";
+  /**
+   * Preferred explicit path for the output.
+   */
+  path?: string | RouteOutputPathResolver;
+}
+declare function filesystemSink(options?: Omit<FilesystemOutputSinkDefinition, "type">): FilesystemOutputSinkDefinition;
+interface NormalizedRouteOutputDefinition {
+  id: string;
+  sink?: OutputSinkDefinition;
+  format: "json" | "text";
+  path?: RouteOutputDefinition["path"];
+}
+declare function normalizeRouteOutputs(route: PipelineRouteDefinition): NormalizedRouteOutputDefinition[];
+//#endregion
+//#region src/route.d.ts
+interface ResolveContext<TDepends extends readonly PipelineDependency[] = readonly PipelineDependency[]> {
+  version: string;
+  file: FileContext;
+  logger: PipelineLogger;
+  getRouteData: <T = unknown>(routeId: ExtractRouteDependencies<TDepends>) => readonly T[];
+  normalizeEntries: (entries: ResolvedEntry[]) => ResolvedEntry[];
+  now: () => string;
+}
+type ResolverFn<TOutput = PropertyJson[], TDepends extends readonly PipelineDependency[] = readonly PipelineDependency[]> = (ctx: ResolveContext<TDepends>, rows: AsyncIterable<ParsedRow>) => Promise<TOutput>;
+type PipelineRouteResolver<TDepends extends readonly PipelineDependency[], TTransforms extends readonly AnyPipelineTransformDefinition[], TOutput> = (ctx: ResolveContext<TDepends>, rows: AsyncIterable<TTransforms extends readonly [] ? ParsedRow : ChainTransforms<ParsedRow, TTransforms>>) => Promise<TOutput>;
+interface PipelineRouteDefinition<TId extends string = string, TDepends extends readonly PipelineDependency[] = readonly PipelineDependency[], TTransforms extends readonly AnyPipelineTransformDefinition[] = readonly [], TOutput = PropertyJson[]> {
+  id: TId;
+  filter: PipelineFilter;
+  depends?: TDepends;
+  parser: ParserFn;
+  transforms?: TTransforms;
+  resolver: PipelineRouteResolver<TDepends, TTransforms, TOutput>;
+  outputs?: RouteOutputDefinition[];
+  cache?: boolean;
+}
+type AnyPipelineRouteDefinition = PipelineRouteDefinition<any, any, any, any>;
+declare function definePipelineRoute<const TId extends string, const TDepends extends readonly PipelineDependency[] = readonly [], const TTransforms extends readonly AnyPipelineTransformDefinition[] = readonly [], TOutput = PropertyJson[]>(definition: PipelineRouteDefinition<TId, TDepends, TTransforms, TOutput>): PipelineRouteDefinition<TId, TDepends, TTransforms, TOutput>;
+type InferRoute<T> = T extends PipelineRouteDefinition<infer TId, infer TDepends, infer TTransforms extends readonly PipelineTransformDefinition<any, any>[], infer TOutput> ? {
+  id: TId;
+  depends: TDepends;
+  transforms: TTransforms;
+  output: TOutput;
+} : never;
+type InferRoutesOutput<T extends readonly AnyPipelineRouteDefinition[]> = T[number] extends PipelineRouteDefinition<any, any, any, infer TOutput> ? TOutput extends unknown[] ? TOutput[number] : TOutput : never;
+//#endregion
+export { parseDependency as C, isRouteDependency as S, ParseDependencyType as _, ResolveContext as a, PipelineDependency as b, FilesystemOutputSinkDefinition as c, RouteOutputDefinition as d, RouteOutputPathContext as f, ExtractRouteDependencies as g, normalizeRouteOutputs as h, PipelineRouteDefinition as i, NormalizedRouteOutputDefinition as l, filesystemSink as m, InferRoute as n, ResolverFn as o, RouteOutputPathResolver as p, InferRoutesOutput as r, definePipelineRoute as s, AnyPipelineRouteDefinition as t, OutputSinkDefinition as u, ParsedDependency as v, createRouteDependency as x, ParsedRouteDependency as y };

package/dist/{source-Bnjgl99T.d.mts → source-Bw_42mA2.d.mts}

@@ -1,4 +1,4 @@
-import { n as FileContext, s as PipelineFilter } from "./types-T24cxilU.mjs";
+import { l as PipelineLogger, n as FileContext, s as PipelineFilter } from "./types-B_R0NiDI.mjs";
 
 //#region src/source.d.ts
 interface StreamOptions {
@@ -22,16 +22,33 @@ interface PipelineSourceDefinition<TId extends string = string> {
   backend: SourceBackend;
   includes?: PipelineFilter;
   excludes?: PipelineFilter;
+  kind?: "standard" | "pipeline-output";
+}
+interface PipelineOutputSourceDefinition<TId extends string = string> extends PipelineSourceDefinition<TId> {
+  kind: "pipeline-output";
+  pipelineId: string;
+  outputId?: string;
 }
 interface SourceFileContext extends FileContext {
   source: {
     id: string;
   };
 }
+interface ResolveSourceContext {
+  logger: PipelineLogger;
+}
 declare function definePipelineSource<const TId extends string>(definition: PipelineSourceDefinition<TId>): PipelineSourceDefinition<TId>;
-declare function resolveSourceFiles(source: PipelineSourceDefinition, version: string): Promise<SourceFileContext[]>;
-declare function resolveMultipleSourceFiles(sources: PipelineSourceDefinition[] | readonly PipelineSourceDefinition[], version: string): Promise<SourceFileContext[]>;
+declare function pipelineOutputSource<const TId extends string = string>(options: {
+  id?: TId;
+  pipelineId: string;
+  outputId?: string;
+}): PipelineOutputSourceDefinition<TId>;
+declare function isPipelineOutputSource(source: PipelineSourceDefinition): source is PipelineOutputSourceDefinition;
+declare function resolveSourceFiles(source: PipelineSourceDefinition, version: string, {
+  logger
+}: ResolveSourceContext): Promise<SourceFileContext[]>;
+declare function resolveMultipleSourceFiles(sources: PipelineSourceDefinition[] | readonly PipelineSourceDefinition[], version: string, context: ResolveSourceContext): Promise<SourceFileContext[]>;
 type InferSourceId<T> = T extends PipelineSourceDefinition<infer TId> ? TId : never;
 type InferSourceIds<T extends readonly PipelineSourceDefinition[]> = { [K in keyof T]: InferSourceId<T[K]> }[number];
 //#endregion
-export { SourceBackend as a, definePipelineSource as c, PipelineSourceDefinition as i, resolveMultipleSourceFiles as l, InferSourceId as n, SourceFileContext as o, InferSourceIds as r, StreamOptions as s, FileMetadata as t, resolveSourceFiles as u };
+export { PipelineSourceDefinition as a, SourceFileContext as c, isPipelineOutputSource as d, pipelineOutputSource as f, PipelineOutputSourceDefinition as i, StreamOptions as l, resolveSourceFiles as m, InferSourceId as n, ResolveSourceContext as o, resolveMultipleSourceFiles as p, InferSourceIds as r, SourceBackend as s, FileMetadata as t, definePipelineSource as u };

package/dist/source-UYQsDb7S.mjs

@@ -0,0 +1,49 @@
+//#region src/source.ts
+function definePipelineSource(definition) {
+	return definition;
+}
+const unsupportedPipelineOutputBackend = {
+	listFiles: async () => {
+		throw new Error("Pipeline output sources are resolved by the executor and cannot be listed directly.");
+	},
+	readFile: async () => {
+		throw new Error("Pipeline output sources are resolved by the executor and cannot be read directly.");
+	}
+};
+function pipelineOutputSource(options) {
+	return {
+		id: options.id ?? `pipeline:${options.pipelineId}${options.outputId ? `:${options.outputId}` : ""}`,
+		kind: "pipeline-output",
+		pipelineId: options.pipelineId,
+		outputId: options.outputId,
+		backend: unsupportedPipelineOutputBackend
+	};
+}
+function isPipelineOutputSource(source) {
+	return source.kind === "pipeline-output";
+}
+async function resolveSourceFiles(source, version, { logger }) {
+	if (isPipelineOutputSource(source)) return [];
+	return (await source.backend.listFiles(version)).filter((file) => {
+		const ctx = {
+			file,
+			logger
+		};
+		if (source.includes && !source.includes(ctx)) return false;
+		if (source.excludes && source.excludes(ctx)) return false;
+		return true;
+	}).map((file) => ({
+		...file,
+		source: { id: source.id }
+	}));
+}
+async function resolveMultipleSourceFiles(sources, version, context) {
+	const filesByPath = /* @__PURE__ */ new Map();
+	for (const source of sources) {
+		const files = await resolveSourceFiles(source, version, context);
+		for (const file of files) filesByPath.set(file.path, file);
+	}
+	return [...filesByPath.values()];
+}
+//#endregion
+export { resolveSourceFiles as a, resolveMultipleSourceFiles as i, isPipelineOutputSource as n, pipelineOutputSource as r, definePipelineSource as t };

package/dist/sources/index.d.mts

@@ -1,5 +1,5 @@
-import { n as FileContext } from "../types-T24cxilU.mjs";
-import { a as SourceBackend, i as PipelineSourceDefinition } from "../source-Bnjgl99T.mjs";
+import { n as FileContext } from "../types-B_R0NiDI.mjs";
+import { a as PipelineSourceDefinition, s as SourceBackend } from "../source-Bw_42mA2.mjs";
 
 //#region src/sources/http.d.ts
 interface HttpBackendOptions {

package/dist/sources/index.mjs

@@ -1,5 +1,4 @@
-import { t as definePipelineSource } from "../source-EtWCktj_.mjs";
-
+import { t as definePipelineSource } from "../source-UYQsDb7S.mjs";
 //#region src/sources/http.ts
 const UNICODE_ORG_BASE_URL = "https://www.unicode.org/Public/";
 function createHttpBackend(options) {
@@ -60,13 +59,12 @@ function createUnicodeOrgSource(id) {
 	});
 }
 const unicodeOrgSource = createUnicodeOrgSource();
-
 //#endregion
 //#region src/sources/memory.ts
 function getFileContext(version, file) {
 	const path = file.path;
 	const parts = path.split("/");
-	const name = parts[parts.length - 1];
+	const name = parts.at(-1);
 	if (!name) throw new Error(`Invalid file path: ${file.path}`);
 	const extIndex = name.lastIndexOf(".");
 	const ext = extIndex >= 0 ? name.slice(extIndex) : "";
@@ -108,6 +106,5 @@ function createMemorySource(options) {
 		backend: createMemoryBackend({ files: options?.files ?? {} })
 	});
 }
-
 //#endregion
-export { UNICODE_ORG_BASE_URL, createHttpBackend, createHttpSource, createMemoryBackend, createMemorySource, createUnicodeOrgSource, unicodeOrgSource };
+export { UNICODE_ORG_BASE_URL, createHttpBackend, createHttpSource, createMemoryBackend, createMemorySource, createUnicodeOrgSource, unicodeOrgSource };