@dilemmagx/orchestra 1.2.1 → 1.2.2

package/README.md

@@ -1,7 +1,8 @@
 # @dilemmagx/orchestra
 
 Orchestra is a programmable, node-based image synthesis and processing toolkit.
-It focuses on deterministic, pixel-accurate workflows with simple composable nodes.
+The engine is centered around a flexible node state, so every built-in node is created through
+the same custom node API that you use in your own projects.
 
 ## Install
 
@@ -15,29 +16,150 @@ npm i @dilemmagx/orchestra
 import { Pipeline, createNoiseNode, createInvertNode, sourceFromEmpty } from '@dilemmagx/orchestra';
 
 const pipeline = new Pipeline().add(createNoiseNode({ grayscale: true })).add(createInvertNode());
-
 const image = await pipeline.run(sourceFromEmpty(256, 256, 'rgba8'), { seed: 42 });
 ```
 
-## Resize & Palette Mapping
+## Core Concepts
+
+- A pipeline runs nodes sequentially.
+- Each node receives a shared context and a mutable state object.
+- The default image key is "image", but nodes may read and write additional image keys.
+
+## Simplified Node API
+
+```ts
+import { node, pipeline, sourceFromEmpty } from '@dilemmagx/orchestra';
+
+const gradient = node({
+  name: 'gradient',
+  params: { from: '#22d3ee', to: '#0f172a' },
+  run: (pixels, { params }) => {
+    const height = pixels.length;
+    const width = pixels[0]?.length ?? 0;
+    return pixels.map((row, y) =>
+      row.map((_pixel, x) => {
+        const t = x / Math.max(1, width - 1);
+        return {
+          r: Math.round(34 + (15 - 34) * t),
+          g: Math.round(211 + (23 - 211) * t),
+          b: Math.round(238 + (42 - 238) * t),
+          a: 255,
+        };
+      })
+    );
+  },
+});
+
+const image = await pipeline(gradient).run(sourceFromEmpty(512, 256, 'rgba8'));
+```
+
+Nodes created with `node()` receive a 2D pixel matrix by default. Node names are optional;
+if omitted, Orchestra assigns incremental names like `node-1` to improve traceability.
+
+## Noise Suite
+
+```ts
+import {
+  pipeline,
+  sourceFromEmpty,
+  createValueNoiseNode,
+  createVoronoiNoiseNode,
+  createFractalNoiseNode,
+} from '@dilemmagx/orchestra';
+
+const image = await pipeline(
+  createValueNoiseNode({ scale: 32, octaves: 2, min: 20, max: 220 }),
+  createVoronoiNoiseNode({ scale: 28, jitter: 0.8, mode: 'edge' }),
+  createFractalNoiseNode({ scale: 40, octaves: 4, persistence: 0.55 })
+).run(sourceFromEmpty(512, 512, 'rgba8'), { seed: 42 });
+```
+
+```ts
+import {
+  pipeline,
+  sourceFromEmpty,
+  createPerlinNoiseNode,
+  createTurbulenceNoiseNode,
+  createRidgedNoiseNode,
+} from '@dilemmagx/orchestra';
+
+const image = await pipeline(
+  createPerlinNoiseNode({ scale: 48, octaves: 3 }),
+  createTurbulenceNoiseNode({ scale: 36, octaves: 4, persistence: 0.6 }),
+  createRidgedNoiseNode({ scale: 40, octaves: 5, persistence: 0.55 })
+).run(sourceFromEmpty(512, 512, 'rgba8'), { seed: 'detail' });
+```
+
+## Text Tool
+
+```ts
+import { createTextNode, pipeline, sourceFromEmpty } from '@dilemmagx/orchestra';
+
+const text = createTextNode({
+  text: 'HELLO ORCHESTRA',
+  font: {
+    family: 'Inter',
+    source: { filePath: './fonts/Inter-SemiBold.ttf' },
+    weight: 600,
+  },
+  layout: { x: 64, y: 64, maxWidth: 640, align: 'left' },
+  style: { fontSize: 48, bold: true, underline: true },
+});
+
+const image = await pipeline(text).run(sourceFromEmpty(800, 450, 'rgba8'));
+```
+
+Provide a font file to keep output identical across machines. If a font source is not supplied,
+the system font family is used when available.
+
+## Custom Node
+
+```ts
+import { Pipeline, createImageNode, sourceFromEmpty } from '@dilemmagx/orchestra';
+
+const posterize = createImageNode(
+  'posterize',
+  { step: 32 },
+  (_context, image, params) =>
+    image.mapPixels((pixel) => {
+      const next = Math.round(pixel.r / params.step) * params.step;
+      return { r: next, g: next, b: next, a: pixel.a };
+    })
+);
+
+const pipeline = new Pipeline().add(posterize);
+const image = await pipeline.run(sourceFromEmpty(512, 512, 'rgba8'));
+```
+
+## Advanced Node State
 
 ```ts
 import {
   Pipeline,
-  createResizeNode,
-  createPaletteMapNode,
-  saveImage,
-  sourceFromUrl,
+  defineNode,
+  getImage,
+  sourceFromEmpty,
+  DEFAULT_IMAGE_KEY,
 } from '@dilemmagx/orchestra';
 
-const palette = ['#9bbc0f', '#8bac0f', '#306230', '#0f380f'];
-const pipeline = new Pipeline().add(createResizeNode(128, 85)).add(createPaletteMapNode(palette));
+const stashStats = defineNode({
+  name: 'stash-stats',
+  run: (_context, state) => {
+    const image = getImage(state, DEFAULT_IMAGE_KEY);
+    return {
+      data: {
+        pixelCount: image.width * image.height,
+      },
+    };
+  },
+});
 
-const image = await pipeline.run(sourceFromUrl('https://example.com/image.jpg'));
-await saveImage(image, './gameboy.png');
+const pipeline = new Pipeline().add(stashStats);
+const state = await pipeline.runState(sourceFromEmpty(256, 256, 'rgba8'));
+console.log(state.data.pixelCount);
 ```
 
-## Color Mask Mapping
+## Mask Mapping
 
 ```ts
 import {
@@ -46,13 +168,14 @@ import {
   createGaussianBlurNode,
   createMapNode,
   sourceFromUrl,
+  toRgba,
 } from '@dilemmagx/orchestra';
 
 const mask = createMapNode('mask', (_pixel, x, y) => {
   const dx = x - 128;
   const dy = y - 128;
   const inside = dx * dx + dy * dy <= 96 * 96;
-  return inside ? '#ffffff' : '#000000';
+  return inside ? toRgba('#ffffff') : toRgba('#000000');
 });
 
 const mapped = createMaskMapNode(mask, [
@@ -63,35 +186,7 @@ const pipeline = new Pipeline().add(mapped);
 const image = await pipeline.run(sourceFromUrl('https://example.com/image.jpg'));
 ```
 
-Mask mapping uses color keys to stitch multiple image results. Each entry maps a mask
-color to a source image or node output, with optional tolerance.
-
-You can also use a dedicated crop node:
-
-```ts
-import { createSelectionCropNode } from '@dilemmagx/orchestra';
-
-const crop = createSelectionCropNode(selector, { outsideColor: '#00000000' });
-```
-
-## Color Formats
-
-```ts
-import { toRgba, hsvaToRgba } from '@dilemmagx/orchestra';
-
-const rgba = toRgba('#ffcc00');
-const other = hsvaToRgba({ h: 120, s: 50, v: 90, a: 1 });
-```
-
-## Common Nodes
-
-```ts
-import { Pipeline, createGrayscaleNode, createGammaNode } from '@dilemmagx/orchestra';
-
-const pipeline = new Pipeline().add(createGrayscaleNode()).add(createGammaNode(1.2));
-```
-
-Built-in nodes:
+## Built-in Nodes
 
 - createBrightnessNode
 - createCheckerboardNode
@@ -106,6 +201,12 @@ Built-in nodes:
 - createGrayscaleNode
 - createInvertNode
 - createNoiseNode
+- createFractalNoiseNode
+- createPerlinNoiseNode
+- createRidgedNoiseNode
+- createTurbulenceNoiseNode
+- createValueNoiseNode
+- createVoronoiNoiseNode
 - createPaletteMapNode
 - createRandomFillNode
 - createRectNode
@@ -113,8 +214,9 @@ Built-in nodes:
 - createSaltPepperNoiseNode
 - createSharpenNode
 - createThresholdNode
+- createTextNode
 
-Selectors and masking:
+Selectors and masking helpers:
 
 - createAlphaSelector
 - createCircleSelector
@@ -124,23 +226,6 @@ Selectors and masking:
 - createRectSelector
 - createSelectionCropNode
 
-## Custom Node
-
-```ts
-import { Pipeline, createParamNode, sourceFromEmpty } from '@dilemmagx/orchestra';
-
-const posterize = createParamNode('posterize', { step: 32 }, (_context, image, params) =>
-  image.mapPixels((pixel) => {
-    const next = Math.round(pixel.r / params.step) * params.step;
-    return { r: next, g: next, b: next, a: pixel.a };
-  })
-);
-
-const pipeline = new Pipeline().add(posterize);
-const image = await pipeline.run(sourceFromEmpty(512, 512, 'rgba8'));
-```
-
 ## License
 
 GPL-3.0
-

package/dist/core/image.d.ts

@@ -17,6 +17,10 @@ export declare class ImageBuffer {
      * Creates a new ImageBuffer and optionally fills it with a color.
      */
     static create(width: number, height: number, format: PixelFormat, fill?: PixelLike): ImageBuffer;
+    /**
+     * Creates an ImageBuffer from a 2D pixel matrix.
+     */
+    static fromMatrix(matrix: Pixel[][], format?: PixelFormat): ImageBuffer;
     /**
      * Clones the buffer and its pixel data.
      */

package/dist/core/nodes.d.ts

@@ -2,21 +2,120 @@ import { ImageBuffer } from './image';
 import { ColorInput } from './color';
 import { ImageSource, Pixel, PixelLike } from './types';
 import { SeededRandom } from './random';
-import { ResizeOptions } from './sources';
+import { ResizeOptions, type TextOptions } from './sources';
+export declare const DEFAULT_IMAGE_KEY = "image";
 /**
  * Runtime context shared across nodes in a pipeline run.
  */
 export type NodeContext = {
     random: SeededRandom;
+    stash: Map<string, unknown>;
 };
+/**
+ * State passed between nodes in a pipeline run.
+ */
+export type NodeState = {
+    images: Record<string, ImageBuffer>;
+    data: Record<string, unknown>;
+};
+/**
+ * Result returned by a node execution.
+ */
+export type NodeResult = {
+    images?: Record<string, ImageBuffer>;
+    data?: Record<string, unknown>;
+};
+type NodeRunner<TParams> = {
+    bivarianceHack(context: NodeContext, state: NodeState, params: TParams): Promise<NodeResult> | NodeResult;
+}['bivarianceHack'];
 /**
  * Pipeline node definition.
  */
-export type ImageNode = {
+export type NodeDefinition<TParams = unknown> = {
     name: string;
-    params?: unknown;
-    run: (context: NodeContext, image: ImageBuffer) => Promise<ImageBuffer> | ImageBuffer;
+    params?: TParams;
+    inputs?: string[];
+    outputs?: string[];
+    run: NodeRunner<TParams>;
+};
+/**
+ * Alias for image-focused nodes.
+ */
+export type ImageNode<TParams = unknown> = NodeDefinition<TParams>;
+/**
+ * Image node with typed parameters metadata.
+ */
+export type ParametricNode<TParams> = ImageNode<TParams> & {
+    params: TParams;
+};
+/**
+ * Definition for a reusable node.
+ */
+export declare function defineNode<TParams>(definition: NodeDefinition<TParams>): NodeDefinition<TParams>;
+/**
+ * Image node input definition.
+ */
+export type ImageNodeOptions = {
+    input?: string;
+    output?: string;
+};
+/**
+ * 2D pixel matrix representation.
+ */
+export type PixelMatrix = Pixel[][];
+/**
+ * Context provided to pixel-based node handlers.
+ */
+export type PixelNodeInfo<TParams> = {
+    context: NodeContext;
+    image: ImageBuffer;
+    state: NodeState;
+    params: TParams;
+    width: number;
+    height: number;
 };
+/**
+ * Handler signature for pixel-based nodes.
+ */
+export type PixelNodeRunner<TParams> = (pixels: PixelMatrix, info: PixelNodeInfo<TParams>) => PixelMatrix | ImageBuffer | Promise<PixelMatrix | ImageBuffer>;
+/**
+ * Simplified node definition.
+ */
+export type SimpleNodeDefinition<TParams> = {
+    name?: string;
+    params?: TParams;
+    input?: string;
+    output?: string;
+    run: PixelNodeRunner<TParams>;
+};
+/**
+ * Creates a node that reads a single image key and writes a single image key.
+ */
+export declare function createImageNode<TParams>(name: string, params: TParams, run: (context: NodeContext, image: ImageBuffer, params: TParams, state: NodeState) => Promise<ImageBuffer> | ImageBuffer, options?: ImageNodeOptions): ImageNode<TParams>;
+/**
+ * Creates a node that operates on a 2D pixel matrix.
+ */
+export declare function createPixelNode<TParams>(name: string, params: TParams, run: PixelNodeRunner<TParams>, options?: ImageNodeOptions): ImageNode<TParams>;
+/**
+ * Creates a simplified pixel-based node with optional name and parameters.
+ */
+export declare function node<TParams>(definition: SimpleNodeDefinition<TParams>): ImageNode<TParams>;
+/**
+ * Returns the image associated with the given key.
+ */
+export declare function getImage(state: NodeState, key?: string): ImageBuffer;
+/**
+ * Merges a node result into a state snapshot.
+ */
+export declare function mergeNodeState(state: NodeState, result: NodeResult): NodeState;
+/**
+ * Runs a node and returns its raw result.
+ */
+export declare function runNode(node: ImageNode, context: NodeContext, state: NodeState): Promise<NodeResult>;
+/**
+ * Runs a node and returns a single image output.
+ */
+export declare function runNodeImage(node: ImageNode, context: NodeContext, state: NodeState, outputKey?: string): Promise<ImageBuffer>;
 /**
  * Selector used to choose pixels for masked execution.
  */
@@ -25,24 +124,21 @@ export type PixelSelector = (pixel: Pixel, x: number, y: number, context: NodeCo
  * Masking options for nodes.
  */
 export type SelectionOptions = {
-    /**
-     * preserve: keep non-selected pixels from the original image.
-     * clip: replace non-selected pixels with outsideColor.
-     */
     mode?: SelectionMode;
-    /**
-     * Color used for clip mode. Defaults to transparent black.
-     */
     outsideColor?: ColorInput;
 };
 /**
  * Masking mode for selection.
  */
 export type SelectionMode = 'preserve' | 'clip';
+/**
+ * Image source input accepted by nodes.
+ */
+export type ImageInput = ImageSource | ImageBuffer | ImageNode;
 /**
  * Mask source for color mapping.
  */
-export type MaskMapSource = ImageSource | ImageBuffer | ImageNode;
+export type MaskMapSource = ImageInput;
 /**
  * Color-to-source mapping entry.
  */
@@ -91,12 +187,6 @@ export declare function createLumaSelector(threshold: number): PixelSelector;
  * Creates an alpha-based selector.
  */
 export declare function createAlphaSelector(threshold: number): PixelSelector;
-/**
- * Image node with typed parameters metadata.
- */
-export type ParametricNode<TParams> = ImageNode & {
-    params: TParams;
-};
 /**
  * Creates a node with typed parameters stored in the node metadata.
  */
@@ -104,7 +194,7 @@ export declare function createParamNode<TParams>(name: string, params: TParams,
 /**
  * Creates a masked node that only processes selected pixels.
  */
-export declare function createMaskedNode(node: ImageNode, selector: PixelSelector, options?: SelectionOptions): ImageNode;
+export declare function createMaskedNode(node: ImageNode, selector: PixelSelector, options?: SelectionOptions, io?: ImageNodeOptions): ImageNode;
 /**
  * Creates a node that composites sources based on a color mask.
  */
@@ -130,10 +220,105 @@ export type NoiseOptions = {
     alpha?: number;
     grayscale?: boolean;
 };
+/**
+ * Options for creating a value noise node.
+ */
+export type ValueNoiseOptions = {
+    scale?: number;
+    octaves?: number;
+    persistence?: number;
+    lacunarity?: number;
+    min?: number;
+    max?: number;
+    alpha?: number;
+};
+/**
+ * Options for creating a Voronoi noise node.
+ */
+export type VoronoiNoiseOptions = {
+    scale?: number;
+    jitter?: number;
+    min?: number;
+    max?: number;
+    alpha?: number;
+    mode?: 'distance' | 'edge';
+};
+/**
+ * Options for creating a fractal noise node.
+ */
+export type FractalNoiseOptions = {
+    scale?: number;
+    octaves?: number;
+    persistence?: number;
+    lacunarity?: number;
+    min?: number;
+    max?: number;
+    alpha?: number;
+};
+/**
+ * Options for creating a Perlin noise node.
+ */
+export type PerlinNoiseOptions = {
+    scale?: number;
+    octaves?: number;
+    persistence?: number;
+    lacunarity?: number;
+    min?: number;
+    max?: number;
+    alpha?: number;
+};
+/**
+ * Options for creating a turbulence noise node.
+ */
+export type TurbulenceNoiseOptions = {
+    scale?: number;
+    octaves?: number;
+    persistence?: number;
+    lacunarity?: number;
+    min?: number;
+    max?: number;
+    alpha?: number;
+};
+/**
+ * Options for creating a ridged noise node.
+ */
+export type RidgedNoiseOptions = {
+    scale?: number;
+    octaves?: number;
+    persistence?: number;
+    lacunarity?: number;
+    min?: number;
+    max?: number;
+    alpha?: number;
+};
 /**
  * Creates a node that applies seeded noise to every pixel.
  */
 export declare function createNoiseNode(options?: NoiseOptions): ImageNode;
+/**
+ * Creates a node that generates value noise.
+ */
+export declare function createValueNoiseNode(options?: ValueNoiseOptions): ImageNode;
+/**
+ * Creates a node that generates Voronoi noise.
+ */
+export declare function createVoronoiNoiseNode(options?: VoronoiNoiseOptions): ImageNode;
+/**
+ * Creates a node that generates fractal value noise.
+ */
+export declare function createFractalNoiseNode(options?: FractalNoiseOptions): ImageNode;
+/**
+ * Creates a node that generates Perlin noise.
+ */
+export declare function createPerlinNoiseNode(options?: PerlinNoiseOptions): ImageNode;
+/**
+ * Creates a node that generates turbulence noise.
+ */
+export declare function createTurbulenceNoiseNode(options?: TurbulenceNoiseOptions): ImageNode;
+/**
+ * Creates a node that generates ridged noise.
+ */
+export declare function createRidgedNoiseNode(options?: RidgedNoiseOptions): ImageNode;
 /**
  * Options for convolution nodes.
  */
@@ -239,3 +424,8 @@ export declare function createEdgeDetectNode(): ImageNode;
  * Creates a node that resizes the image to the target dimensions.
  */
 export declare function createResizeNode(width: number, height: number, options?: ResizeOptions): ImageNode;
+/**
+ * Creates a node that renders text onto an image.
+ */
+export declare function createTextNode(options: TextOptions): ImageNode<TextOptions>;
+export {};

package/dist/core/pipeline.d.ts

@@ -1,14 +1,19 @@
 import { ImageBuffer } from './image';
 import { ImageSource } from './types';
 import { SeededRandom } from './random';
-import { ImageNode } from './nodes';
+import { ImageNode, NodeState } from './nodes';
 /**
  * Options for running a pipeline.
  */
 export type PipelineOptions = {
     seed?: number | string;
     random?: SeededRandom;
+    data?: Record<string, unknown>;
 };
+/**
+ * Supported inputs for running a pipeline.
+ */
+export type PipelineInput = ImageSource | ImageBuffer | NodeState;
 /**
  * Sequential pipeline that runs image nodes in order.
  */
@@ -25,9 +30,17 @@ export declare class Pipeline {
     /**
      * Executes the pipeline against an input source or buffer.
      */
-    run(input: ImageSource | ImageBuffer, options?: PipelineOptions): Promise<ImageBuffer>;
+    run(input: PipelineInput, options?: PipelineOptions): Promise<ImageBuffer>;
+    /**
+     * Executes the pipeline and returns the full node state.
+     */
+    runState(input: PipelineInput, options?: PipelineOptions): Promise<NodeState>;
 }
 /**
  * Creates a small example pipeline for quick sanity checks.
  */
 export declare function createExamplePipeline(): Pipeline;
+/**
+ * Creates a pipeline with the provided nodes.
+ */
+export declare function pipeline(...nodes: ImageNode[]): Pipeline;

package/dist/core/sources.d.ts

@@ -1,4 +1,5 @@
 import { ImageBuffer } from './image';
+import { ColorInput } from './color';
 import { ImageSource, PixelLike, PixelFormat } from './types';
 /**
  * Creates an ImageSource from a local file path.
@@ -38,6 +39,56 @@ export type ResizeOptions = {
     fit?: 'contain' | 'cover' | 'fill' | 'inside' | 'outside';
     withoutEnlargement?: boolean;
 };
+/**
+ * Text font source configuration.
+ */
+export type TextFontSource = {
+    filePath?: string;
+    data?: Buffer;
+    mime?: string;
+};
+/**
+ * Text font configuration.
+ */
+export type TextFont = {
+    family: string;
+    source?: TextFontSource;
+    weight?: number | string;
+    style?: 'normal' | 'italic' | 'oblique';
+};
+/**
+ * Text layout options.
+ */
+export type TextLayout = {
+    x: number;
+    y: number;
+    maxWidth?: number;
+    maxLines?: number;
+    align?: 'left' | 'center' | 'right';
+    lineHeight?: number;
+    letterSpacing?: number;
+};
+/**
+ * Text style options.
+ */
+export type TextStyle = {
+    fontSize?: number;
+    color?: ColorInput;
+    bold?: boolean;
+    italic?: boolean;
+    underline?: boolean;
+    strikethrough?: boolean;
+    opacity?: number;
+};
+/**
+ * Text rendering options.
+ */
+export type TextOptions = {
+    text: string;
+    font: TextFont;
+    layout: TextLayout;
+    style?: TextStyle;
+};
 /**
  * Serializes an ImageBuffer to an encoded image buffer.
  */
@@ -50,3 +101,7 @@ export declare function saveImage(image: ImageBuffer, outputPath: string, option
  * Resizes an ImageBuffer and returns a new buffer.
  */
 export declare function resizeImage(image: ImageBuffer, width: number, height: number, options?: ResizeOptions): Promise<ImageBuffer>;
+/**
+ * Renders text onto an ImageBuffer.
+ */
+export declare function renderText(image: ImageBuffer, options: TextOptions): Promise<ImageBuffer>;

package/dist/index.d.ts

@@ -3,8 +3,9 @@ export { colorDistance, hexToRgba, hslaToRgba, hsvaToRgba, rgbaToHex, rgbaToHsla
 export type { Pixel, PixelFormat, PixelLike, ImageSource } from './core/types';
 export { ImageBuffer } from './core/image';
 export { SeededRandom, createRandom } from './core/random';
-export type { ResizeOptions, SaveImageOptions } from './core/sources';
-export { imageToBuffer, loadImage, resizeImage, saveImage, sourceFromBuffer, sourceFromDataUri, sourceFromEmpty, sourceFromPath, sourceFromUrl, } from './core/sources';
-export type { CircleSelectorOptions, ImageNode, MaskMapEntry, MaskMapOptions, MaskMapSource, NodeContext, ParametricNode, PixelSelector, RectSelectorOptions, SelectionMode, SelectionOptions, } from './core/nodes';
-export { createBrightnessNode, createCircleSelector, createCheckerboardNode, createCircleNode, createConvolutionNode, createContrastNode, createAlphaSelector, createEdgeDetectNode, createFillNode, createGammaNode, createGaussianBlurNode, createGaussianNoiseNode, createGrayscaleNode, createInvertNode, createLumaSelector, createMapNode, createMaskMapNode, createMaskedNode, createNoiseNode, createPaletteMapNode, createParamNode, createRandomFillNode, createRectSelector, createResizeNode, createSelectionCropNode, createRectNode, createSaltPepperNoiseNode, createSharpenNode, createThresholdNode, buildBoxKernel, buildGaussianKernel, } from './core/nodes';
-export { Pipeline, createExamplePipeline } from './core/pipeline';
+export type { ResizeOptions, SaveImageOptions, TextFont, TextFontSource, TextLayout, TextOptions, TextStyle, } from './core/sources';
+export { imageToBuffer, loadImage, renderText, resizeImage, saveImage, sourceFromBuffer, sourceFromDataUri, sourceFromEmpty, sourceFromPath, sourceFromUrl, } from './core/sources';
+export type { CircleSelectorOptions, ImageInput, ImageNode, ImageNodeOptions, MaskMapEntry, MaskMapOptions, MaskMapSource, NodeDefinition, NodeContext, NodeResult, NodeState, ParametricNode, PixelMatrix, PixelNodeInfo, PixelNodeRunner, PixelSelector, FractalNoiseOptions, PerlinNoiseOptions, RectSelectorOptions, SelectionMode, SelectionOptions, SimpleNodeDefinition, ValueNoiseOptions, RidgedNoiseOptions, TurbulenceNoiseOptions, VoronoiNoiseOptions, } from './core/nodes';
+export { DEFAULT_IMAGE_KEY, createBrightnessNode, createCircleSelector, createCheckerboardNode, createCircleNode, createConvolutionNode, createContrastNode, createAlphaSelector, createEdgeDetectNode, createFillNode, createGammaNode, createGaussianBlurNode, createGaussianNoiseNode, createGrayscaleNode, createInvertNode, createImageNode, createPixelNode, createLumaSelector, createMapNode, createMaskMapNode, createMaskedNode, createNoiseNode, createFractalNoiseNode, createPerlinNoiseNode, createRidgedNoiseNode, createTurbulenceNoiseNode, createValueNoiseNode, createVoronoiNoiseNode, createPaletteMapNode, createParamNode, createRandomFillNode, createRectSelector, createResizeNode, createSelectionCropNode, createRectNode, createSaltPepperNoiseNode, createSharpenNode, createThresholdNode, createTextNode, defineNode, getImage, mergeNodeState, node, runNode, runNodeImage, buildBoxKernel, buildGaussianKernel, } from './core/nodes';
+export type { PipelineInput, PipelineOptions } from './core/pipeline';
+export { Pipeline, createExamplePipeline, pipeline } from './core/pipeline';