@ucdjs/pipelines-core 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-core
+
+[![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-core
+```
+
+## 📄 License
+
+Published under [MIT License](./LICENSE).
+
+[npm-version-src]: https://img.shields.io/npm/v/@ucdjs/pipelines-core?style=flat&colorA=18181B&colorB=4169E1
+[npm-version-href]: https://npmjs.com/package/@ucdjs/pipelines-core
+[npm-downloads-src]: https://img.shields.io/npm/dm/@ucdjs/pipelines-core?style=flat&colorA=18181B&colorB=4169E1
+[npm-downloads-href]: https://npmjs.com/package/@ucdjs/pipelines-core
+[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/index.d.mts

@@ -0,0 +1,531 @@
+import { a as ParsedRow, c as PropertyJson, d as ResolverFn, f as RouteOutput, i as ParseContext, l as ResolveContext, n as FileContext, o as ParserFn, p as RowContext, r as FilterContext, s as PipelineFilter, t as DefaultRange, u as ResolvedEntry } from "./types-t7nns1Hx.mjs";
+import { a as PipelineTransformDefinition, c as definePipelineTransform, i as InferTransformOutput, n as ChainTransforms, o as TransformContext, r as InferTransformInput, s as applyTransforms, t as AnyPipelineTransformDefinition } from "./transform-BSrhinRr.mjs";
+import { a as SourceBackend, c as definePipelineSource, i as PipelineSourceDefinition, l as resolveMultipleSourceFiles, n as InferSourceId, o as SourceFileContext, r as InferSourceIds, s as StreamOptions, t as FileMetadata, u as resolveSourceFiles } from "./source-DYH0SvDh.mjs";
+import { z } from "zod";
+
+//#region src/dependencies.d.ts
+type RouteDependency = `route:${string}`;
+type ArtifactDependency = `artifact:${string}:${string}`;
+type PipelineDependency = RouteDependency | ArtifactDependency;
+interface ParsedRouteDependency {
+  type: "route";
+  routeId: string;
+}
+interface ParsedArtifactDependency {
+  type: "artifact";
+  routeId: string;
+  artifactName: string;
+}
+type ParsedDependency = ParsedRouteDependency | ParsedArtifactDependency;
+type ParseDependencyType<T extends string> = T extends `route:${infer RouteId}` ? {
+  type: "route";
+  routeId: RouteId;
+} : T extends `artifact:${infer RouteId}:${infer ArtifactName}` ? {
+  type: "artifact";
+  routeId: RouteId;
+  artifactName: ArtifactName;
+} : never;
+type ExtractRouteDependencies<T extends readonly PipelineDependency[]> = { [K in keyof T]: T[K] extends `route:${infer RouteId}` ? RouteId : never }[number];
+type ExtractArtifactDependencies<T extends readonly PipelineDependency[]> = { [K in keyof T]: T[K] extends `artifact:${infer RouteId}:${infer ArtifactName}` ? {
+  routeId: RouteId;
+  artifactName: ArtifactName;
+} : never }[number];
+type ExtractArtifactKeys<T extends readonly PipelineDependency[]> = { [K in keyof T]: T[K] extends `artifact:${infer RouteId}:${infer ArtifactName}` ? `${RouteId}:${ArtifactName}` : never }[number];
+declare function parseDependency(dep: PipelineDependency): ParsedDependency;
+declare function isRouteDependency(dep: PipelineDependency): dep is RouteDependency;
+declare function isArtifactDependency(dep: PipelineDependency): dep is ArtifactDependency;
+declare function createRouteDependency(routeId: string): RouteDependency;
+declare function createArtifactDependency(routeId: string, artifactName: string): ArtifactDependency;
+//#endregion
+//#region src/route.d.ts
+interface ArtifactDefinition<TSchema extends z.ZodType = z.ZodType> {
+  _type: "artifact" | "global-artifact";
+  schema: TSchema;
+  scope: "version" | "global";
+}
+type InferArtifactType<T extends ArtifactDefinition> = T extends ArtifactDefinition<infer TSchema> ? z.infer<TSchema> : never;
+interface RouteResolveContext<TArtifactKeys extends string = string, TEmits extends Record<string, ArtifactDefinition> = Record<string, ArtifactDefinition>> {
+  version: string;
+  file: FileContext;
+  getArtifact: <K extends TArtifactKeys>(key: K) => unknown;
+  emitArtifact: <K extends keyof TEmits & string>(key: K, value: InferArtifactType<TEmits[K]>) => void;
+  normalizeEntries: (entries: ResolvedEntry[]) => ResolvedEntry[];
+  now: () => string;
+}
+type PipelineRouteResolver<TDepends extends readonly PipelineDependency[], TEmits extends Record<string, ArtifactDefinition>, TTransforms extends readonly AnyPipelineTransformDefinition[], TOutput> = (ctx: RouteResolveContext<ExtractArtifactKeys<TDepends>, TEmits>, rows: AsyncIterable<TTransforms extends readonly [] ? ParsedRow : ChainTransforms<ParsedRow, TTransforms>>) => Promise<TOutput>;
+interface PipelineRouteDefinition<TId extends string = string, TDepends extends readonly PipelineDependency[] = readonly PipelineDependency[], TEmits extends Record<string, ArtifactDefinition> = Record<string, ArtifactDefinition>, TTransforms extends readonly AnyPipelineTransformDefinition[] = readonly [], TOutput = PropertyJson[]> {
+  id: TId;
+  filter: PipelineFilter;
+  depends?: TDepends;
+  emits?: TEmits;
+  parser: ParserFn;
+  transforms?: TTransforms;
+  resolver: PipelineRouteResolver<TDepends, TEmits, TTransforms, TOutput>;
+  out?: RouteOutput;
+  cache?: boolean;
+}
+type AnyPipelineRouteDefinition = PipelineRouteDefinition<any, any, any, any, any>;
+declare function definePipelineRoute<const TId extends string, const TDepends extends readonly PipelineDependency[] = readonly [], const TEmits extends Record<string, ArtifactDefinition> = Record<string, never>, const TTransforms extends readonly AnyPipelineTransformDefinition[] = readonly [], TOutput = PropertyJson[]>(definition: PipelineRouteDefinition<TId, TDepends, TEmits, TTransforms, TOutput>): PipelineRouteDefinition<TId, TDepends, TEmits, TTransforms, TOutput>;
+type InferRoute<T> = T extends PipelineRouteDefinition<infer TId, infer TDepends, infer TEmits, infer TTransforms extends readonly PipelineTransformDefinition<any, any>[], infer TOutput> ? {
+  id: TId;
+  depends: TDepends;
+  emits: TEmits;
+  transforms: TTransforms;
+  output: TOutput;
+} : never;
+type InferRoutesOutput<T extends readonly AnyPipelineRouteDefinition[]> = T[number] extends PipelineRouteDefinition<any, any, any, any, infer TOutput> ? TOutput extends unknown[] ? TOutput[number] : TOutput : never;
+type InferEmittedArtifactsFromRoute<T> = T extends PipelineRouteDefinition<any, any, infer TEmits, any, any> ? { [K in keyof TEmits]: TEmits[K] extends ArtifactDefinition<infer TSchema> ? z.infer<TSchema> : never } : never;
+//#endregion
+//#region src/dag.d.ts
+interface DAGNode {
+  id: string;
+  dependencies: Set<string>;
+  dependents: Set<string>;
+  emittedArtifacts: Set<string>;
+}
+interface DAG {
+  nodes: Map<string, DAGNode>;
+  executionOrder: string[];
+}
+interface DAGValidationError {
+  type: "cycle" | "missing-route" | "missing-artifact" | "duplicate-route";
+  message: string;
+  details: {
+    routeId?: string;
+    dependencyId?: string;
+    cycle?: string[];
+  };
+}
+interface DAGValidationResult {
+  valid: boolean;
+  errors: DAGValidationError[];
+  dag?: DAG;
+}
+declare function buildDAG(routes: readonly PipelineRouteDefinition<any, any, any, any, any>[]): DAGValidationResult;
+declare function getExecutionLayers(dag: DAG): string[][];
+//#endregion
+//#region src/events.d.ts
+type PipelineEventType = "pipeline:start" | "pipeline:end" | "version:start" | "version:end" | "artifact:start" | "artifact:end" | "artifact:produced" | "artifact:consumed" | "file:matched" | "file:skipped" | "file:fallback" | "parse:start" | "parse:end" | "resolve:start" | "resolve:end" | "cache:hit" | "cache:miss" | "cache:store" | "error";
+interface PipelineStartEvent {
+  id: string;
+  type: "pipeline:start";
+  versions: string[];
+  spanId: string;
+  timestamp: number;
+}
+interface PipelineEndEvent {
+  id: string;
+  type: "pipeline:end";
+  durationMs: number;
+  spanId: string;
+  timestamp: number;
+}
+interface VersionStartEvent {
+  id: string;
+  type: "version:start";
+  version: string;
+  spanId: string;
+  timestamp: number;
+}
+interface VersionEndEvent {
+  id: string;
+  type: "version:end";
+  version: string;
+  durationMs: number;
+  spanId: string;
+  timestamp: number;
+}
+interface ArtifactStartEvent {
+  id: string;
+  type: "artifact:start";
+  artifactId: string;
+  version: string;
+  spanId: string;
+  timestamp: number;
+}
+interface ArtifactEndEvent {
+  id: string;
+  type: "artifact:end";
+  artifactId: string;
+  version: string;
+  durationMs: number;
+  spanId: string;
+  timestamp: number;
+}
+interface ArtifactProducedEvent {
+  id: string;
+  type: "artifact:produced";
+  artifactId: string;
+  routeId: string;
+  version: string;
+  spanId: string;
+  timestamp: number;
+}
+interface ArtifactConsumedEvent {
+  id: string;
+  type: "artifact:consumed";
+  artifactId: string;
+  routeId: string;
+  version: string;
+  spanId: string;
+  timestamp: number;
+}
+interface FileMatchedEvent {
+  id: string;
+  type: "file:matched";
+  file: FileContext;
+  routeId: string;
+  spanId: string;
+  timestamp: number;
+}
+interface FileSkippedEvent {
+  id: string;
+  type: "file:skipped";
+  file: FileContext;
+  reason: "no-match" | "filtered";
+  spanId: string;
+  timestamp: number;
+}
+interface FileFallbackEvent {
+  id: string;
+  type: "file:fallback";
+  file: FileContext;
+  spanId: string;
+  timestamp: number;
+}
+interface ParseStartEvent {
+  id: string;
+  type: "parse:start";
+  file: FileContext;
+  routeId: string;
+  spanId: string;
+  timestamp: number;
+}
+interface ParseEndEvent {
+  id: string;
+  type: "parse:end";
+  file: FileContext;
+  routeId: string;
+  rowCount: number;
+  durationMs: number;
+  spanId: string;
+  timestamp: number;
+}
+interface ResolveStartEvent {
+  id: string;
+  type: "resolve:start";
+  file: FileContext;
+  routeId: string;
+  spanId: string;
+  timestamp: number;
+}
+interface ResolveEndEvent {
+  id: string;
+  type: "resolve:end";
+  file: FileContext;
+  routeId: string;
+  outputCount: number;
+  durationMs: number;
+  spanId: string;
+  timestamp: number;
+}
+interface CacheHitEvent {
+  id: string;
+  type: "cache:hit";
+  routeId: string;
+  file: FileContext;
+  version: string;
+  spanId: string;
+  timestamp: number;
+}
+interface CacheMissEvent {
+  id: string;
+  type: "cache:miss";
+  routeId: string;
+  file: FileContext;
+  version: string;
+  spanId: string;
+  timestamp: number;
+}
+interface CacheStoreEvent {
+  id: string;
+  type: "cache:store";
+  routeId: string;
+  file: FileContext;
+  version: string;
+  spanId: string;
+  timestamp: number;
+}
+interface PipelineErrorEvent {
+  id: string;
+  type: "error";
+  error: PipelineError;
+  spanId: string;
+  timestamp: number;
+}
+type PipelineEvent = PipelineStartEvent | PipelineEndEvent | VersionStartEvent | VersionEndEvent | ArtifactStartEvent | ArtifactEndEvent | ArtifactProducedEvent | ArtifactConsumedEvent | FileMatchedEvent | FileSkippedEvent | FileFallbackEvent | ParseStartEvent | ParseEndEvent | ResolveStartEvent | ResolveEndEvent | CacheHitEvent | CacheMissEvent | CacheStoreEvent | PipelineErrorEvent;
+type PipelineErrorScope = "pipeline" | "version" | "file" | "route" | "artifact";
+interface PipelineError {
+  scope: PipelineErrorScope;
+  message: string;
+  error?: unknown;
+  file?: FileContext;
+  routeId?: string;
+  artifactId?: string;
+  version?: string;
+}
+type PipelineGraphNodeType = "source" | "file" | "route" | "artifact" | "output";
+type PipelineGraphNode = {
+  id: string;
+  type: "source";
+  version: string;
+} | {
+  id: string;
+  type: "file";
+  file: FileContext;
+} | {
+  id: string;
+  type: "route";
+  routeId: string;
+} | {
+  id: string;
+  type: "artifact";
+  artifactId: string;
+} | {
+  id: string;
+  type: "output";
+  outputIndex: number;
+  property?: string;
+};
+type PipelineGraphEdgeType = "provides" | "matched" | "parsed" | "resolved" | "uses-artifact";
+interface PipelineGraphEdge {
+  from: string;
+  to: string;
+  type: PipelineGraphEdgeType;
+}
+interface PipelineGraph {
+  nodes: PipelineGraphNode[];
+  edges: PipelineGraphEdge[];
+}
+type PipelineEventInput = Omit<PipelineStartEvent, "id" | "spanId"> & {
+  id?: string;
+  spanId?: string;
+} | Omit<PipelineEndEvent, "id" | "spanId"> & {
+  id?: string;
+  spanId?: string;
+} | Omit<VersionStartEvent, "id" | "spanId"> & {
+  id?: string;
+  spanId?: string;
+} | Omit<VersionEndEvent, "id" | "spanId"> & {
+  id?: string;
+  spanId?: string;
+} | Omit<ArtifactStartEvent, "id" | "spanId"> & {
+  id?: string;
+  spanId?: string;
+} | Omit<ArtifactEndEvent, "id" | "spanId"> & {
+  id?: string;
+  spanId?: string;
+} | Omit<ArtifactProducedEvent, "id" | "spanId"> & {
+  id?: string;
+  spanId?: string;
+} | Omit<ArtifactConsumedEvent, "id" | "spanId"> & {
+  id?: string;
+  spanId?: string;
+} | Omit<FileMatchedEvent, "id" | "spanId"> & {
+  id?: string;
+  spanId?: string;
+} | Omit<FileSkippedEvent, "id" | "spanId"> & {
+  id?: string;
+  spanId?: string;
+} | Omit<FileFallbackEvent, "id" | "spanId"> & {
+  id?: string;
+  spanId?: string;
+} | Omit<ParseStartEvent, "id" | "spanId"> & {
+  id?: string;
+  spanId?: string;
+} | Omit<ParseEndEvent, "id" | "spanId"> & {
+  id?: string;
+  spanId?: string;
+} | Omit<ResolveStartEvent, "id" | "spanId"> & {
+  id?: string;
+  spanId?: string;
+} | Omit<ResolveEndEvent, "id" | "spanId"> & {
+  id?: string;
+  spanId?: string;
+} | Omit<CacheHitEvent, "id" | "spanId"> & {
+  id?: string;
+  spanId?: string;
+} | Omit<CacheMissEvent, "id" | "spanId"> & {
+  id?: string;
+  spanId?: string;
+} | Omit<CacheStoreEvent, "id" | "spanId"> & {
+  id?: string;
+  spanId?: string;
+} | Omit<PipelineErrorEvent, "id" | "spanId"> & {
+  id?: string;
+  spanId?: string;
+};
+//#endregion
+//#region src/filters.d.ts
+declare function byName(name: string): PipelineFilter;
+declare function byDir(dir: FileContext["dir"]): PipelineFilter;
+declare function byExt(ext: string): PipelineFilter;
+declare function byGlob(pattern: string): PipelineFilter;
+declare function byPath(pathPattern: string | RegExp): PipelineFilter;
+declare function byProp(pattern: string | RegExp): PipelineFilter;
+declare function bySource(sourceIds: string | string[]): PipelineFilter;
+declare function and(...filters: PipelineFilter[]): PipelineFilter;
+declare function or(...filters: PipelineFilter[]): PipelineFilter;
+declare function not(filter: PipelineFilter): PipelineFilter;
+declare function always(): PipelineFilter;
+declare function never(): PipelineFilter;
+//#endregion
+//#region src/pipeline.d.ts
+interface FallbackRouteDefinition<TArtifacts extends Record<string, unknown> = Record<string, unknown>, TOutput = unknown> {
+  /**
+   * Optional filter to restrict which unmatched files the fallback handles.
+   */
+  filter?: PipelineFilter;
+  /**
+   * Parser function that yields parsed rows from file content.
+   */
+  parser: (ctx: ParseContext) => AsyncIterable<ParsedRow>;
+  /**
+   * Resolver function that transforms parsed rows into output.
+   */
+  resolver: (ctx: ResolveContext<TArtifacts>, rows: AsyncIterable<ParsedRow>) => Promise<TOutput>;
+}
+interface PipelineDefinitionSpec<TSources extends readonly PipelineSourceDefinition[] = readonly PipelineSourceDefinition[], TRoutes extends readonly AnyPipelineRouteDefinition[] = readonly AnyPipelineRouteDefinition[], TFallback extends FallbackRouteDefinition<any, unknown> | undefined = undefined> {
+  /**
+   * Unique identifier for the pipeline.
+   */
+  id: string;
+  /**
+   * Human-readable name for the pipeline.
+   */
+  name: string;
+  /**
+   * Description of what this pipeline does.
+   */
+  description?: string;
+  /**
+   * Tags associated with this pipeline.
+   */
+  tags?: string[];
+  /**
+   * Unicode versions this pipeline processes.
+   */
+  versions: string[];
+  /**
+   * Input sources that provide files to the pipeline.
+   */
+  inputs: TSources;
+  /**
+   * Routes that process matched files.
+   */
+  routes: TRoutes;
+  /**
+   * Global filter to include/exclude files before routing.
+   */
+  include?: PipelineFilter;
+  /**
+   * If true, throw error for files with no matching route (and no fallback).
+   * @default false
+   */
+  strict?: boolean;
+  /**
+   * Maximum concurrent route executions.
+   * @default 4
+   */
+  concurrency?: number;
+  /**
+   * Fallback handler for files that don't match any route.
+   */
+  fallback?: TFallback;
+  /**
+   * Event handler for pipeline events.
+   * Note: This is stored but not invoked by the definition itself.
+   * The executor is responsible for calling this.
+   */
+  onEvent?: (event: PipelineEvent) => void | Promise<void>;
+}
+type PipelineDefinitionOptions<TSources extends readonly PipelineSourceDefinition[] = readonly PipelineSourceDefinition[], TRoutes extends readonly PipelineRouteDefinition<any, any, any, any, any>[] = readonly PipelineRouteDefinition<any, any, any, any, any>[], TFallback extends FallbackRouteDefinition<any, unknown> | undefined = undefined> = PipelineDefinitionSpec<TSources, TRoutes, TFallback>;
+type PipelineDefinition<TId extends string = string, TSources extends readonly PipelineSourceDefinition[] = readonly PipelineSourceDefinition[], TRoutes extends readonly PipelineRouteDefinition<any, any, any, any, any>[] = readonly PipelineRouteDefinition<any, any, any, any, any>[], TFallback extends FallbackRouteDefinition<any, unknown> | undefined = undefined> = Readonly<PipelineDefinitionSpec<TSources, TRoutes, TFallback>> & {
+  /**
+   * Marker to identify this as a pipeline definition.
+   */
+  readonly _type: "pipeline-definition";
+  /**
+   * Unique identifier for the pipeline.
+   */
+  readonly id: TId;
+  /**
+   * If true, throw error for files with no matching route (and no fallback).
+   */
+  readonly strict: boolean;
+  /**
+   * Maximum concurrent route executions.
+   */
+  readonly concurrency: number;
+  /**
+   * Precomputed DAG (Directed Acyclic Graph) for route execution order.
+   * Built at definition time from route dependencies.
+   */
+  readonly dag: DAG;
+  /**
+   * Tags associated with this pipeline.
+   */
+  readonly tags: string[];
+};
+type AnyPipelineDefinition = PipelineDefinition<any, any, any, any>;
+type InferPipelineOutput<TRoutes extends readonly PipelineRouteDefinition<any, any, any, any, any>[], TFallback extends FallbackRouteDefinition<any, unknown> | undefined> = TFallback extends FallbackRouteDefinition<any, infer TFallbackOutput> ? InferRoutesOutput<TRoutes> | TFallbackOutput : InferRoutesOutput<TRoutes>;
+type InferPipelineSourceIds<T> = T extends PipelineDefinition<any, infer TSources, any, any> ? InferSourceIds<TSources> : never;
+type InferPipelineRouteIds<T> = T extends PipelineDefinition<any, any, infer TRoutes, any> ? TRoutes[number] extends PipelineRouteDefinition<infer TId, any, any, any, any> ? TId : never : never;
+/**
+ * Define a pipeline configuration.
+ *
+ * This returns a pure data structure describing the pipeline.
+ * To execute the pipeline, pass it to a pipeline executor.
+ *
+ * @example
+ * ```ts
+ * const pipeline = definePipeline({
+ *   id: "my-pipeline",
+ *   name: "My Pipeline",
+ *   versions: ["16.0.0"],
+ *   inputs: [mySource],
+ *   routes: [myRoute],
+ * });
+ *
+ * // Execute with an executor
+ * const executor = createPipelineExecutor({ pipelines: [pipeline] });
+ * const result = await executor.run();
+ * ```
+ */
+declare function definePipeline<const TId extends string, const TSources extends readonly PipelineSourceDefinition[], const TRoutes extends readonly PipelineRouteDefinition<any, any, any, any, any>[], const TFallback extends FallbackRouteDefinition<any, unknown> | undefined = undefined>(options: Omit<PipelineDefinitionSpec<readonly [...TSources], readonly [...TRoutes], TFallback>, "inputs" | "routes"> & {
+  id: TId;
+  inputs: readonly [...TSources];
+  routes: readonly [...TRoutes];
+}): PipelineDefinition<TId, TSources, TRoutes, TFallback>;
+declare function isPipelineDefinition(value: unknown): value is PipelineDefinition;
+declare function getPipelineRouteIds<T extends PipelineDefinition>(pipeline: T): string[];
+declare function getPipelineSourceIds<T extends PipelineDefinition>(pipeline: T): string[];
+//#endregion
+//#region src/utils/arrays.d.ts
+/**
+ * Split a line into exactly 2 fields.
+ * Returns a tuple [first, second] or null if not enough fields.
+ *
+ * After null check, TypeScript knows both elements exist and are strings.
+ */
+declare function splitTwoFields(line: string, delimiter: string): [string, string] | null;
+/**
+ * Split a line with minimum field count check.
+ * Returns the array or null if not enough fields.
+ *
+ * Use when you need more than 2 fields (e.g., UnicodeData with 14 fields).
+ * Access fields with nullish coalescing: `fields[0] ?? ""`
+ */
+declare function splitMinFields(line: string, delimiter: string, minFields: number): string[] | null;
+//#endregion
+export { type AnyPipelineDefinition, type AnyPipelineRouteDefinition, type ArtifactConsumedEvent, type ArtifactDefinition, type ArtifactEndEvent, type ArtifactProducedEvent, type ArtifactStartEvent, type CacheHitEvent, type CacheMissEvent, type CacheStoreEvent, type ChainTransforms, type DAG, type DAGNode, type DAGValidationError, type DAGValidationResult, type DefaultRange, type ExtractArtifactDependencies, type ExtractArtifactKeys, type ExtractRouteDependencies, type FallbackRouteDefinition, type FileContext, type FileFallbackEvent, type FileMatchedEvent, type FileMetadata, type FileSkippedEvent, type FilterContext, type InferArtifactType, type InferEmittedArtifactsFromRoute, type InferPipelineOutput, type InferPipelineRouteIds, type InferPipelineSourceIds, type InferRoute, type InferRoutesOutput, type InferSourceId, type InferSourceIds, type InferTransformInput, type InferTransformOutput, type ParseContext, type ParseDependencyType, type ParseEndEvent, type ParseStartEvent, type ParsedArtifactDependency, type ParsedDependency, type ParsedRouteDependency, type ParsedRow, type ParserFn, type PipelineDefinition, type PipelineDefinitionOptions, type PipelineDefinitionSpec, type PipelineDependency, type PipelineEndEvent, type PipelineError, type PipelineErrorEvent, type PipelineErrorScope, type PipelineEvent, type PipelineEventInput, type PipelineEventType, type PipelineFilter, type PipelineGraph, type PipelineGraphEdge, type PipelineGraphEdgeType, type PipelineGraphNode, type PipelineGraphNodeType, type PipelineRouteDefinition, type PipelineSourceDefinition, type PipelineStartEvent, type PipelineTransformDefinition, type PropertyJson, type ResolveContext, type ResolveEndEvent, type ResolveStartEvent, type ResolvedEntry, type ResolverFn, type RouteOutput, type RouteResolveContext, type RowContext, type SourceBackend, type SourceFileContext, type StreamOptions, type TransformContext, type VersionEndEvent, type VersionStartEvent, 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 };