@miliastry/quasar 1.0.6 → 1.1.0

package/dist/types/Analysis/Passes/Decision/PaletteRemapDecision.d.ts

@@ -0,0 +1,169 @@
+/**
+ * Quasar Analysis Framework — Palette Remap Decision
+ *
+ * Turns an AnalysisReport into a plan for restyling a document with a
+ * different palette: recolour its colour tags, swap its decorative glyphs,
+ * replace its divider lines.
+ *
+ * ## The plan is applied by range, not by rebuilding the tree
+ *
+ * Every other DecisionPass in this framework feeds a TransformPass that
+ * returns a new Green Tree, which is then serialized. That is the wrong shape
+ * for restyling a document someone already wrote: `BBCodeExporter` rebuilds
+ * BBCode from node kinds and metadata rather than replaying source bytes, so
+ * re-exporting a whole document also rewrites the parts nobody asked to
+ * change — `[B]` becomes `[b]`, `[color = #F00]` loses its spacing, CRLF
+ * becomes LF.
+ *
+ * So the actions here carry a `range` and a literal `replacement` string, and
+ * are meant to be applied directly to the source text. Everything outside
+ * those ranges is never re-serialized and therefore cannot drift. The Decision
+ * stage is still the right home — it consumes a report and describes intended
+ * mutations without touching the tree — but no TransformPass consumes it.
+ *
+ * Apply the actions **last range first**. They are emitted in source order,
+ * and rewriting front to back invalidates every offset that follows.
+ *
+ * ## What each kind of thing becomes
+ *
+ * **Colours inside a gradient** keep the gradient's shape. Each member tag is
+ * recoloured by sampling the new palette at the member's own position along
+ * the ramp, passed through the easing the original gradient was detected with.
+ * The result reads as the same gradient wearing a different palette, rather
+ * than as a new gradient.
+ *
+ * **Standalone colours** map to their nearest palette entry by perceptual
+ * distance in OKLab, so a pink stays the palette's pink rather than becoming
+ * whichever colour happens to be first.
+ *
+ * **Symbols** are substituted glyph for glyph, and **separators** wholesale.
+ * Both substitutions are stable across the document: a given source glyph
+ * always maps to the same palette glyph, so a document that used `✧` as its
+ * motif comes out using one motif rather than a scatter.
+ *
+ * @see ColorUsageAnalyzer — supplies the per-tag offsets this pass edits
+ * @see GradientAnalyzer — supplies the ramp shape those tags belong to
+ * @see SymbolAnalyzer — supplies the glyph runs
+ */
+import type { DecisionPass, TransformationPlan, TransformAction } from '../../Contracts/Pass';
+import type { AnalysisReport } from '../../Contracts/AnalysisReport';
+import type { PipelineContext } from '../../Contracts/PipelineContext';
+/**
+ * The palette to restyle towards.
+ *
+ * Structural, not imported: Quasar has no dependency on the application's
+ * theme catalogue, and any object with these three lists satisfies it.
+ */
+export interface Palette {
+    /** Hex colours, ordered as a ramp from first to last. */
+    readonly colors: readonly string[];
+    /** Decorative glyphs, in preference order. */
+    readonly symbols: readonly string[];
+    /** Whole divider lines. */
+    readonly separators: readonly string[];
+}
+export interface PaletteRemapOptions {
+    /**
+     * Below this confidence an action is still emitted, but marked
+     * `recommended: false`.
+     *
+     * Nothing is dropped. A caller that hides low-confidence findings can never
+     * offer them, and the glyphs that land down here — `≈` in a sum, `→` in a
+     * sentence — are exactly the ones a person should get to look at before
+     * they are rewritten. Filtering is the caller's decision; this pass only
+     * says which side of the line each action falls on.
+     */
+    readonly minConfidence?: number;
+}
+/** Every action this pass emits shares one shape. */
+export interface RemapAction extends TransformAction {
+    readonly kind: 'recolor' | 'resymbol' | 'reseparator';
+    readonly payload: {
+        /** Source span to overwrite. */
+        readonly range: {
+            readonly start: number;
+            readonly end: number;
+        };
+        /** Literal text to write in its place. */
+        readonly replacement: string;
+        /** What is there now, for previewing the change. */
+        readonly from: string;
+        /** What it becomes. */
+        readonly to: string;
+        readonly confidence: number;
+        readonly recommended: boolean;
+        /** Only on `recolor`: whether the tag belonged to a detected gradient. */
+        readonly gradient?: boolean;
+    };
+}
+export declare class PaletteRemapDecision implements DecisionPass {
+    readonly id = "palette-remap";
+    private readonly palette;
+    private readonly minConfidence;
+    /**
+     * Substitution tables, rebuilt per `run` so the pass stays reusable and
+     * every run over the same report produces the same plan.
+     */
+    private symbolMap;
+    private separatorMap;
+    constructor(palette: Palette, options?: PaletteRemapOptions);
+    run(report: AnalysisReport, _context: PipelineContext): TransformationPlan;
+    private planColors;
+    /**
+     * Where this tag sits along its gradient, resampled onto the new palette.
+     *
+     * Position comes from the tag's ordinal among the gradient's members rather
+     * than from its offset, because the members are evenly spaced *as tags* — a
+     * gradient over `Hello` has five of them regardless of how wide each tag's
+     * text is.
+     */
+    private gradientColorFor;
+    /**
+     * Sample the palette as a continuous ramp, interpolating in OKLab.
+     *
+     * `ColorMath.mixMultiple` does the same walk in RGB, which darkens and
+     * desaturates through the middle of a blend — the reason the gradient
+     * analyzers work in OKLab in the first place. Sampling rather than mapping
+     * palette entries one-to-one is what preserves the original stop count: a
+     * three-stop gradient stays three stops when restyled with a five-colour
+     * palette, instead of gaining two.
+     */
+    private samplePalette;
+    /**
+     * The palette entry that looks most like the colour already there.
+     *
+     * Perceptual distance rather than index order: a document's pink should come
+     * back as the palette's pink, not as whichever colour the palette happens to
+     * list first.
+     */
+    private nearestPaletteColor;
+    private planSymbols;
+    private planSeparators;
+    /**
+     * Assign a replacement for `source`, remembering it.
+     *
+     * Distinct sources are handed palette entries in first-seen order.
+     * Recording the choice is what keeps the document coherent: every later `✧`
+     * gets the same replacement as the first one, so a motif stays a motif.
+     *
+     * Entries already spoken for are skipped — including the identities
+     * `reserveIdentities` claimed before this ran — so distinct sources keep
+     * distinct replacements for as long as the palette has them. Once it runs
+     * out the assignment wraps, and glyphs begin to share.
+     */
+    private substitute;
+    /**
+     * Let everything the palette already contains keep its own place, before
+     * anything else is handed out.
+     *
+     * This has to happen up front rather than as each source is reached.
+     * Assignment follows document order, so in `✧ then ✿` the unowned `✧` would
+     * otherwise claim `✿` first and the real `✿` would arrive to find its own
+     * identity taken — displacing it onto a glyph the document never used.
+     *
+     * Holding identities fixed is what makes restyling idempotent: a second pass
+     * with the same theme finds every glyph already in place and changes
+     * nothing.
+     */
+    private reserveIdentities;
+}

package/dist/types/Analysis/Passes/Decision/__tests__/DefaultDecision.test.d.ts

@@ -0,0 +1,4 @@
+/**
+ * Tests for DefaultDecision
+ */
+export {};

package/dist/types/Analysis/Passes/Transform/CollapseGradientTransform.d.ts

@@ -0,0 +1,37 @@
+/**
+ * Quasar Analysis Framework — Collapse Gradient Transform
+ *
+ * Applies `collapse-gradient` actions from a TransformationPlan.
+ * Each action targets a sequence of adjacent [color] nodes and replaces
+ * them with a single [gradient] node containing all text children.
+ *
+ * The transform operates on the Green Tree and returns a new tree —
+ * it NEVER mutates the original.
+ *
+ * @example
+ * Before:
+ *   [color=#FF0000]H[/color][color=#EE1100]e[/color][color=#DD2200]l[/color]
+ * After:
+ *   [gradient=#FF0000,#EE1100,#DD2200]Hello[/gradient]
+ *
+ * @see TransformPass
+ */
+import type { TransformPass, TransformationPlan } from '../../Contracts/Pass';
+import type { PipelineContext } from '../../Contracts/PipelineContext';
+import type { GreenNode } from '../../../Syntax/GreenNode';
+export declare class CollapseGradientTransform implements TransformPass {
+    readonly id = "collapse-gradient";
+    run(tree: GreenNode, plan: TransformationPlan, _context: PipelineContext): GreenNode;
+    /**
+     * Walk the tree and collapse any sequences that fall within our ranges.
+     */
+    private transformNode;
+    /**
+     * Rebuild a node with the same kind/text/range but new children.
+     */
+    private rebuildNode;
+    /**
+     * Extract hex colour from a color node's text.
+     */
+    private extractHex;
+}

package/dist/types/Analysis/Passes/Transform/MergeColorsTransform.d.ts

@@ -0,0 +1,28 @@
+/**
+ * Quasar Analysis Framework — Merge Colors Transform
+ *
+ * Applies `merge-colors` actions from a TransformationPlan.
+ * Each action targets a sequence of identical consecutive [color=#HEX]
+ * nodes and merges them into a single `[color]` wrapper with combined text.
+ *
+ * The transform operates on the Green Tree and returns a new tree —
+ * it NEVER mutates the original.
+ *
+ * @example
+ * Before:
+ *   [color=#FF0000]H[/color][color=#FF0000]e[/color][color=#FF0000]l[/color]
+ * After:
+ *   [color=#FF0000]Hel[/color]
+ *
+ * @see TransformPass
+ */
+import type { TransformPass, TransformationPlan } from '../../Contracts/Pass';
+import type { PipelineContext } from '../../Contracts/PipelineContext';
+import type { GreenNode } from '../../../Syntax/GreenNode';
+export declare class MergeColorsTransform implements TransformPass {
+    readonly id = "merge-colors";
+    run(tree: GreenNode, plan: TransformationPlan, _context: PipelineContext): GreenNode;
+    private transformNode;
+    private rebuildNode;
+    private extractHex;
+}

package/dist/types/Analysis/Passes/Transform/RainbowCollapseTransform.d.ts

@@ -0,0 +1,19 @@
+/**
+ * Quasar Analysis Framework — Rainbow Collapse Transform
+ *
+ * Applies `collapse-rainbow` actions from a TransformationPlan.
+ * Replaces sequences of [color] nodes forming a hue-rotation pattern
+ * with a single [rainbow] node containing all text children.
+ *
+ * @example
+ * Before: [color=#FF0000]R[/color][color=#FFFF00]O[/color][color=#00FF00]Y[/color]
+ * After:  [rainbow]ROY[/rainbow]
+ */
+import type { TransformPass, TransformationPlan } from '../../Contracts/Pass';
+import type { PipelineContext } from '../../Contracts/PipelineContext';
+import type { GreenNode } from '../../../Syntax/GreenNode';
+export declare class RainbowCollapseTransform implements TransformPass {
+    readonly id = "rainbow-collapse";
+    run(tree: GreenNode, plan: TransformationPlan, _context: PipelineContext): GreenNode;
+    private transformNode;
+}

package/dist/types/Analysis/Passes/Transform/WaveCollapseTransform.d.ts

@@ -0,0 +1,20 @@
+/**
+ * Quasar Analysis Framework — Wave Collapse Transform
+ *
+ * Applies `collapse-wave` actions from a TransformationPlan.
+ * Replaces sequences of [size=N] nodes forming a sinusoidal pattern
+ * with a single [grow] node containing all text children and the
+ * detected size range in metadata.
+ *
+ * @example
+ * Before: [size=90]A[/size][size=150]B[/size][size=90]C[/size]
+ * After:  [grow]ABC[/grow]  (with metadata: min=90, max=150)
+ */
+import type { TransformPass, TransformationPlan } from '../../Contracts/Pass';
+import type { PipelineContext } from '../../Contracts/PipelineContext';
+import type { GreenNode } from '../../../Syntax/GreenNode';
+export declare class WaveCollapseTransform implements TransformPass {
+    readonly id = "wave-collapse";
+    run(tree: GreenNode, plan: TransformationPlan, _context: PipelineContext): GreenNode;
+    private transformNode;
+}

package/dist/types/Analysis/Passes/Utility/CharacterCountAnalyzer.d.ts

@@ -0,0 +1,19 @@
+/**
+ * Quasar Analysis Framework — Character Count Analyzer (Proof of Concept)
+ *
+ * The simplest possible AnalyzerPass: it walks the Green Tree and counts
+ * text characters.  This validates that the full pipeline works:
+ *
+ *   Green Tree → Analyzer → Contribution → Aggregated Report
+ *
+ * No algorithms, no colours, no decisions — just validating the pipe.
+ */
+import type { AnalyzerPass } from '../../Contracts/Pass';
+import type { PipelineContext } from '../../Contracts/PipelineContext';
+import type { Contribution } from '../../Contracts/Contribution';
+import type { GreenNode } from '../../../Syntax/GreenNode';
+export declare class CharacterCountAnalyzer implements AnalyzerPass {
+    readonly id = "character-count";
+    run(tree: GreenNode, _context: PipelineContext): Contribution[];
+    private countChars;
+}

package/dist/types/Analysis/Pipeline/Pipeline.d.ts

@@ -0,0 +1,69 @@
+/**
+ * Quasar Analysis Framework — Pipeline
+ *
+ * The Pipeline is itself a Pass — it can be composed inside larger
+ * pipelines.  Execution is strictly ordered:
+ *
+ *   1. All analysis passes run, collecting contributions.
+ *   2. The aggregated AnalysisReport is fed to each decision pass.
+ *   3. Each transform pass receives the current tree + plan and
+ *      returns a new tree (never mutating the original).
+ *
+ * @example
+ * ```ts
+ * const pipeline = new Pipeline([
+ *   { stage: 'analysis', pass: new CharacterCountAnalyzer() },
+ * ])
+ * const report = pipeline.run(tree, context)
+ * ```
+ */
+import type { AnalyzerPass, DecisionPass, TransformPass, TransformationPlan } from '../Contracts/Pass';
+import type { AnalysisReport } from '../Contracts/AnalysisReport';
+import type { PipelineContext } from '../Contracts/PipelineContext';
+import type { PipelineStage } from './PipelineStage';
+import type { GreenNode } from '../../Syntax/GreenNode';
+interface StageEntry {
+    readonly stage: PipelineStage;
+    readonly pass: AnalyzerPass | DecisionPass | TransformPass;
+}
+export interface PipelineResult {
+    /** The final (possibly transformed) Green Tree. */
+    readonly tree: GreenNode;
+    /** The aggregated analysis report. */
+    readonly report: AnalysisReport;
+    /**
+     * The plan the last DecisionPass produced, empty when none ran.
+     *
+     * Usually this is an intermediate the transform stage consumes and the
+     * caller never needs. It is surfaced because a plan is not always something
+     * to execute against the tree: a pass may describe edits meant to be applied
+     * to the source text by range, in which case the plan *is* the output and
+     * there is no transform stage to hand it to.
+     */
+    readonly plan: TransformationPlan;
+}
+export declare class Pipeline {
+    private readonly stages;
+    constructor(stages: readonly StageEntry[]);
+    /**
+     * Execute the full pipeline against `tree` with the given `context`.
+     *
+     * @returns The final tree and analysis report.
+     */
+    run(tree: GreenNode, context: PipelineContext): PipelineResult;
+    /**
+     * Use PipelineBuilder to construct a Pipeline:
+     *
+     * ```ts
+     * import { PipelineBuilder } from './PipelineBuilder'
+     * const pipeline = new PipelineBuilder()
+     *   .analysis(new CharacterCountAnalyzer())
+     *   .build()
+     * ```
+     */
+    private runAnalysis;
+    private runDecision;
+    private runTransform;
+    private buildReport;
+}
+export {};

package/dist/types/Analysis/Pipeline/PipelineBuilder.d.ts

@@ -0,0 +1,31 @@
+/**
+ * Quasar Analysis Framework — Pipeline Builder
+ *
+ * Provides a fluent API for assembling a Pipeline from individually
+ * registered passes.  Each stage (analysis / decision / transform)
+ * has its own registration method so TypeScript catches misuse at
+ * compile time.
+ *
+ * @example
+ * ```ts
+ * const pipeline = Pipeline
+ *   .builder()
+ *   .analysis(new CharacterCountAnalyzer())
+ *   .decision(new DefaultDecision())
+ *   .transform(new CollapseGradientTransform())
+ *   .build()
+ * ```
+ */
+import type { AnalyzerPass, DecisionPass, TransformPass } from '../Contracts/Pass';
+import { Pipeline } from './Pipeline';
+export declare class PipelineBuilder {
+    private readonly passes;
+    /** Register one or more AnalyzerPasses (observation stage). */
+    analysis(...passes: AnalyzerPass[]): this;
+    /** Register one or more DecisionPasses (planning stage). */
+    decision(...passes: DecisionPass[]): this;
+    /** Register one or more TransformPasses (mutation stage). */
+    transform(...passes: TransformPass[]): this;
+    /** Build the Pipeline from the registered passes. */
+    build(): Pipeline;
+}

package/dist/types/Analysis/Pipeline/PipelineStage.d.ts

@@ -0,0 +1,17 @@
+/**
+ * Quasar Analysis Framework — Pipeline Stage
+ *
+ * Passes are grouped into stages that execute in order:
+ *
+ *   1. Analysis  — observe the tree, produce Contributions
+ *   2. Decision  — consume the AnalysisReport, produce a TransformationPlan
+ *   3. Transform — apply the plan to produce a new Green Tree
+ *
+ * @see Pass
+ */
+export declare const PipelineStage: {
+    readonly Analysis: 'analysis';
+    readonly Decision: 'decision';
+    readonly Transform: 'transform';
+};
+export type PipelineStage = (typeof PipelineStage)[keyof typeof PipelineStage];

package/dist/types/Analysis/Utils/color-utils.d.ts

@@ -0,0 +1,60 @@
+/**
+ * Quasar Analysis Framework — Color Utilities
+ *
+ * Shared utility functions for color node analysis across all passes.
+ * Extracted here to avoid duplication across GradientAnalyzer,
+ * RainbowAnalyzer, MergeableColorAnalyzer, etc.
+ *
+ * @module
+ */
+import type { GreenNode } from '../../Syntax/GreenNode';
+/**
+ * Extract the hex colour from a [color] GreenNode.
+ * Supports both "=#FF0000" and "#FF0000" formats.
+ * Returns null if the node is not a color node or has invalid hex.
+ */
+export declare function extractHex(node: GreenNode): string | null;
+/**
+ * Extract the size value from a [size] / [font_size] GreenNode.
+ * Supports "=150", "=90" formats.
+ * Returns null if the node is not a size node.
+ */
+export declare function extractSize(node: GreenNode): number | null;
+/**
+ * Sigmoid function to map a raw score to [0, 1] confidence.
+ * Centered at 0: sigmoid(0) = 0.5
+ * steepness controls the sharpness of the transition.
+ */
+export declare function sigmoid(x: number, steepness?: number): number;
+/**
+ * A detected sequence of adjacent similar nodes in the Green Tree.
+ */
+export interface NodeSequence {
+    /** Extracted values (hex colours, sizes, etc.) in order */
+    readonly values: (string | number)[];
+    /** Start index in the parent's children array */
+    readonly startIdx: number;
+    /** End index (exclusive) in the parent's children array */
+    readonly endIdx: number;
+}
+/**
+ * Extract consecutive sequences of [color] or [font_size] nodes
+ * from a parent's children array.
+ *
+ * @param children - Direct children of a container node
+ * @param kind     - The node kind to extract ('color' or 'font_size')
+ * @param extract  - Function to extract values from matching nodes
+ * @returns Array of sequences found
+ */
+export declare function extractSequences<T extends string | number>(children: GreenNode[], kind: string, extract: (node: GreenNode) => T | null): Array<{
+    values: T[];
+    startIdx: number;
+    endIdx: number;
+}>;
+/**
+ * Check if there are formatting tags between nodes in a sequence.
+ */
+export declare function checkFormattingBreaks(children: GreenNode[], seq: {
+    startIdx: number;
+    endIdx: number;
+}, targetKind: string): boolean;

package/dist/types/Analysis/__tests__/Integration.test.d.ts

@@ -0,0 +1,8 @@
+/**
+ * Quasar Analysis Framework — Integration Tests
+ *
+ * End-to-end tests that exercise the full pipeline with real passes:
+ *   GradientAnalyzer → DefaultDecision → CollapseGradientTransform
+ *   MergeableColorAnalyzer → DefaultDecision → MergeColorsTransform
+ */
+export {};

package/dist/types/Analysis/__tests__/PaletteRemap.test.d.ts

@@ -0,0 +1,14 @@
+/**
+ * Quasar Analysis Framework — Palette Remap
+ *
+ * Covers `ColorUsageAnalyzer` and `PaletteRemapDecision` together, because
+ * neither is useful alone: the analyzer supplies per-tag offsets, the gradient
+ * analyzer supplies the ramp those tags belong to, and the decision joins them.
+ *
+ * Most assertions run the plan through `applyPlan` and check the resulting
+ * *document*. Asserting on action payloads alone would let an off-by-one in a
+ * range pass unnoticed; rewriting the source with them cannot.
+ *
+ * @see RoundTrip.test.ts — establishes that editing by range is the safe move
+ */
+export {};

package/dist/types/Analysis/__tests__/Pipeline.test.d.ts

@@ -0,0 +1,10 @@
+/**
+ * Quasar Analysis Framework — Pipeline Tests
+ *
+ * Validates that the core pipeline infrastructure works:
+ * - Pass interfaces are correctly typed
+ * - PipelineBuilder assembles passes
+ * - Pipeline executes them in order
+ * - CharacterCountAnalyzer (PoC) produces expected metrics
+ */
+export {};

package/dist/types/Analysis/__tests__/RoundTrip.test.d.ts

@@ -0,0 +1,30 @@
+/**
+ * Quasar Analysis Framework — Source Round-Trip Fidelity
+ *
+ * Every other test in this folder builds Green Trees by hand with
+ * `greenNode()` / `greenLeaf()`. That proves the passes work, but it never
+ * proves the framework survives contact with a *parsed* document — and any
+ * feature that re-themes an existing user document depends on exactly that.
+ *
+ * This suite closes the gap by exercising the full chain end to end:
+ *
+ *   source → BBCodeDocumentModel.rebuild → greenRoot
+ *          → Pipeline.run → greenToRedNode → BBCodeExporter.export → source'
+ *
+ * It answers two questions a document-rewriting feature has to answer before
+ * it writes a single byte:
+ *
+ *   1. Is `source' === source` when nothing was transformed?
+ *      (If not, re-exporting a whole document silently rewrites regions the
+ *      user never asked to touch.)
+ *
+ *   2. Do the `range` offsets on Contributions land on the original source
+ *      with character precision?
+ *      (If they do, edits can be applied surgically to those spans and the
+ *      untouched remainder of the document is never re-serialized.)
+ *
+ * The answers are: yes for canonical BBCode, and yes for offsets — but the
+ * exporter normalizes several non-canonical spellings, and corrupts three
+ * bare tags outright. Those are pinned below.
+ */
+export {};

package/dist/types/Analysis/__tests__/SymbolAnalyzer.test.d.ts

@@ -0,0 +1,11 @@
+/**
+ * Quasar Analysis Framework — Symbol Analyzer
+ *
+ * Exercised against *parsed* documents rather than hand-built Green Trees,
+ * because the analyzer's whole contract is that its offsets address real
+ * source. Every assertion that involves a range slices it back out of the
+ * input, so a drifting offset fails the test rather than passing silently.
+ *
+ * @see RoundTrip.test.ts — the same discipline applied to the export boundary
+ */
+export {};

package/dist/types/Analysis/index.d.ts

@@ -0,0 +1,40 @@
+/**
+ * Quasar Analysis Framework — Public API
+ *
+ * A pipeline-based analysis and transformation engine for Green Trees.
+ *
+ * @module
+ * @see Analysis/ARCHITECTURE.md (planned)
+ */
+export type { Pass } from './Contracts/Pass';
+export type { AnalyzerPass, DecisionPass, TransformPass } from './Contracts/Pass';
+export type { TransformationPlan, TransformAction } from './Contracts/Pass';
+export type { Contribution } from './Contracts/Contribution';
+export type { SemanticContribution, DiagnosticContribution, OptimizationContribution, MetricsContribution, } from './Contracts/Contribution';
+export { ContributionKind } from './Contracts/Contribution';
+export type { AnalysisReport } from './Contracts/AnalysisReport';
+export type { PipelineContext } from './Contracts/PipelineContext';
+export { PipelineMode, ExportTarget } from './Contracts/PipelineContext';
+export { Pipeline } from './Pipeline/Pipeline';
+export type { PipelineResult } from './Pipeline/Pipeline';
+export { PipelineBuilder } from './Pipeline/PipelineBuilder';
+export { PipelineStage } from './Pipeline/PipelineStage';
+export { CharacterCountAnalyzer } from './Passes/Utility/CharacterCountAnalyzer';
+export { MergeableColorAnalyzer } from './Passes/Analysis/MergeableColorAnalyzer';
+export { GradientAnalyzer, findCollapsibleGradients, formatGradientTag } from './Passes/Analysis/GradientAnalyzer';
+export type { GradientModel, GradientDiagnostics, GradientStop, CollapsibleGradient } from './Passes/Analysis/GradientAnalyzer';
+export { RainbowAnalyzer } from './Passes/Analysis/RainbowAnalyzer';
+export type { RainbowModel, RainbowDiagnostics } from './Passes/Analysis/RainbowAnalyzer';
+export { WaveAnalyzer } from './Passes/Analysis/WaveAnalyzer';
+export type { WaveModel, WaveDiagnostics } from './Passes/Analysis/WaveAnalyzer';
+export { SymbolAnalyzer } from './Passes/Analysis/SymbolAnalyzer';
+export type { SymbolGlyph, SymbolRunModel } from './Passes/Analysis/SymbolAnalyzer';
+export { ColorUsageAnalyzer } from './Passes/Analysis/ColorUsageAnalyzer';
+export type { ColorUsageModel } from './Passes/Analysis/ColorUsageAnalyzer';
+export { DefaultDecision } from './Passes/Decision/DefaultDecision';
+export { PaletteRemapDecision } from './Passes/Decision/PaletteRemapDecision';
+export type { Palette, PaletteRemapOptions, RemapAction } from './Passes/Decision/PaletteRemapDecision';
+export { CollapseGradientTransform } from './Passes/Transform/CollapseGradientTransform';
+export { RainbowCollapseTransform } from './Passes/Transform/RainbowCollapseTransform';
+export { WaveCollapseTransform } from './Passes/Transform/WaveCollapseTransform';
+export { MergeColorsTransform } from './Passes/Transform/MergeColorsTransform';