@miliastry/quasar 1.0.6 → 1.1.0

package/dist/types/Analysis/Contracts/AnalysisReport.d.ts

@@ -0,0 +1,22 @@
+/**
+ * Quasar Analysis Framework — Analysis Report
+ *
+ * Once all AnalyzerPasses have run, their Contributions are collected
+ * into an immutable AnalysisReport.  This report is the sole input to
+ * the DecisionPass(es).
+ *
+ * We deliberately keep the aggregator simple for now — just an array
+ * of contributions.  As more pass types emerge we may introduce a
+ * structured Aggregator that indexes/categorises contributions.
+ *
+ * @see DecisionPass
+ */
+import type { Contribution } from './Contribution';
+export interface AnalysisReport {
+    /** All contributions gathered from every AnalyzerPass. */
+    readonly contributions: readonly Contribution[];
+    /** Total number of analysis passes that ran. */
+    readonly passCount: number;
+    /** Wall-clock time spent in analysis (ms). */
+    readonly elapsedMs: number;
+}

package/dist/types/Analysis/Contracts/Contribution.d.ts

@@ -0,0 +1,68 @@
+/**
+ * Quasar Analysis Framework — Contribution Types
+ *
+ * Every AnalyzerPass produces an array of Contributions.  A Contribution
+ * is a discriminated union so that downstream consumers (DecisionPass,
+ * AnalysisReport consumers, debug UI) can switch on `kind` and get
+ * perfect TypeScript narrowing.
+ *
+ * @see AnalysisReport
+ */
+export declare const ContributionKind: {
+    readonly Semantic: 'semantic';
+    readonly Diagnostic: 'diagnostic';
+    readonly Optimization: 'optimization';
+    readonly Metrics: 'metrics';
+};
+export type ContributionKind = (typeof ContributionKind)[keyof typeof ContributionKind];
+/**
+ * A semantic pattern recognised in the tree (gradient, wave, rainbow,…).
+ * These describe *meaning* of the document, not just surface syntax.
+ */
+export interface SemanticContribution {
+    readonly kind: typeof ContributionKind.Semantic;
+    readonly label: string;
+    readonly confidence: number;
+    readonly range: {
+        start: number;
+        end: number;
+    };
+    readonly metadata: Record<string, unknown>;
+    /** Human-readable description (optional). */
+    readonly description?: string;
+}
+/**
+ * A diagnostic (warning, error, info) attached to a range in the tree.
+ */
+export interface DiagnosticContribution {
+    readonly kind: typeof ContributionKind.Diagnostic;
+    readonly severity: 'error' | 'warning' | 'info' | 'hint';
+    readonly message: string;
+    readonly range?: {
+        start: number;
+        end: number;
+    };
+    readonly code?: string;
+}
+/**
+ * An optimisation opportunity detected in the tree (mergeable colours,
+ * redundant wrapping, empty tags, …).
+ */
+export interface OptimizationContribution {
+    readonly kind: typeof ContributionKind.Optimization;
+    readonly label: string;
+    readonly description: string;
+    readonly estimatedImprovement?: string;
+    readonly range: {
+        start: number;
+        end: number;
+    };
+}
+/**
+ * Aggregate metrics about the tree (character count, node depth, …).
+ */
+export interface MetricsContribution {
+    readonly kind: typeof ContributionKind.Metrics;
+    readonly metrics: Record<string, number | string>;
+}
+export type Contribution = SemanticContribution | DiagnosticContribution | OptimizationContribution | MetricsContribution;

package/dist/types/Analysis/Contracts/Pass.d.ts

@@ -0,0 +1,59 @@
+/**
+ * Quasar Analysis Framework — Pass Contracts
+ *
+ * Each pass in the analysis/transform pipeline implements one of these
+ * specialized interfaces.  The three kinds mirror LLVM's pass structure:
+ *
+ *   Analysis  — observe the tree, produce Contributions (never mutate)
+ *   Decision  — consume an AnalysisReport, produce a TransformationPlan
+ *   Transform — mutate the tree according to a plan
+ *
+ * @see ARCHITECTURE.md (Analysis Framework)
+ */
+import type { PipelineContext } from './PipelineContext';
+import type { Contribution } from './Contribution';
+import type { GreenNode } from '../../Syntax/GreenNode';
+import type { AnalysisReport } from './AnalysisReport';
+/** Every pass has an identity string and belongs to a stage. */
+export interface Pass {
+    readonly id: string;
+}
+/**
+ * An AnalyzerPass observes the Green Tree and produces one or more
+ * Contributions.  It MUST NOT mutate the tree or the context.
+ */
+export interface AnalyzerPass extends Pass {
+    run(tree: GreenNode, context: PipelineContext): Contribution[];
+}
+/**
+ * A DecisionPass consumes an AnalysisReport (which itself is the
+ * aggregated output of all AnalyzerPasses) and produces a
+ * TransformationPlan that describes *intended* tree mutations.
+ */
+export interface DecisionPass extends Pass {
+    run(report: AnalysisReport, context: PipelineContext): TransformationPlan;
+}
+/**
+ * A TransformPass receives the current Green Tree together with a
+ * TransformationPlan and returns a **new** Green Tree.  It MUST NOT
+ * mutate the original tree — immutability guarantees deterministic
+ * replay and debugging.
+ */
+export interface TransformPass extends Pass {
+    run(tree: GreenNode, plan: TransformationPlan, context: PipelineContext): GreenNode;
+}
+/**
+ * A single action described by a TransformationPlan.
+ * `kind` tells the TransformPass what to do; `payload` carries
+ * per-kind parameters.
+ */
+export interface TransformAction {
+    readonly kind: string;
+    readonly payload: Record<string, unknown>;
+}
+/**
+ * Ordered set of actions that a DecisionPass produces.
+ */
+export interface TransformationPlan {
+    readonly actions: readonly TransformAction[];
+}

package/dist/types/Analysis/Contracts/PipelineContext.d.ts

@@ -0,0 +1,34 @@
+/**
+ * Quasar Analysis Framework — Pipeline Context
+ *
+ * PipelineContext is **read-only by contract**.  It is built *before*
+ * the pipeline starts and MUST NOT be modified by any pass.
+ *
+ * If a pass needs to make information available to downstream passes it
+ * should emit a Contribution rather than mutating the context.
+ *
+ * @immutable
+ */
+export declare const PipelineMode: {
+    readonly Interactive: 'interactive';
+    readonly Batch: 'batch';
+    readonly Import: 'import';
+};
+export type PipelineMode = (typeof PipelineMode)[keyof typeof PipelineMode];
+export declare const ExportTarget: {
+    readonly Osu: 'osu';
+    readonly Miliastry: 'miliastry';
+    readonly HTML: 'html';
+    readonly Markdown: 'markdown';
+};
+export type ExportTarget = (typeof ExportTarget)[keyof typeof ExportTarget];
+export interface PipelineContext {
+    /** Where this pipeline run originates from. */
+    readonly mode: PipelineMode;
+    /** The format we intend to export to (influences decisions). */
+    readonly target: ExportTarget;
+    /** Feature flags that may enable/disable certain behaviours. */
+    readonly featureFlags: Readonly<Record<string, boolean>>;
+    /** Free-form metadata provided by the caller (e.g. selection range). */
+    readonly metadata: Readonly<Record<string, unknown>>;
+}

package/dist/types/Analysis/Passes/Analysis/ColorUsageAnalyzer.d.ts

@@ -0,0 +1,56 @@
+/**
+ * Quasar Analysis Framework — Color Usage Analyzer
+ *
+ * Reports every `[color=#RRGGBB]` in the document, one contribution per tag.
+ *
+ * ## Why this exists alongside GradientAnalyzer
+ *
+ * `GradientAnalyzer` recognises that a run of colour tags forms a gradient and
+ * describes its *shape* — the stops, the easing, the span. What it does not
+ * describe is where each individual tag sits, because a gradient is modelled
+ * as one continuous ramp rather than as the tags that spell it out.
+ *
+ * A consumer that wants to recolour a document needs both: the shape, to know
+ * what the gradient is doing, and the tag positions, to know what to edit.
+ * This pass supplies the second half. A DecisionPass sees both contributions
+ * in the same report and can join them — which is exactly how the framework is
+ * meant to compose, since analyzer passes cannot observe each other.
+ *
+ * ## What gets reported
+ *
+ * Every colour tag, gradient member or not. Deciding which ones are
+ * interesting is a decision, and decisions belong in the decision stage.
+ *
+ * Only full six-digit hex is recognised, because that is what `extractHex`
+ * accepts. `[color=red]` and `[color=#F00]` are parsed as colours by the
+ * engine but are invisible here — a deliberate limit, since rewriting them
+ * would mean choosing a canonical spelling the author did not use.
+ *
+ * @see SemanticContribution
+ * @see GradientAnalyzer
+ */
+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 interface ColorUsageModel {
+    /** Normalised to uppercase `#RRGGBB` by `extractHex`. */
+    readonly hex: string;
+    /**
+     * Source offsets of the opening delimiter alone — `[color=#D194B3]`.
+     *
+     * Recolouring replaces this span rather than the attribute inside it. The
+     * attribute's own position would have to be derived from the delimiter's
+     * width and the hex's length, which breaks the moment the author writes
+     * `[color = #D194B3]`; the delimiter's bounds are read straight off the
+     * node. The cost is that a rewritten tag comes back in canonical spelling,
+     * which is acceptable for a tag being edited anyway.
+     */
+    readonly openStart: number;
+    readonly openEnd: number;
+}
+export declare class ColorUsageAnalyzer implements AnalyzerPass {
+    readonly id = "color-usage";
+    run(tree: GreenNode, _context: PipelineContext): Contribution[];
+    private walk;
+}

package/dist/types/Analysis/Passes/Analysis/GradientAnalyzer.d.ts

@@ -0,0 +1,111 @@
+/**
+ * Quasar Analysis Framework — Gradient Analyzer (v2)
+ *
+ * Detects sequences of [color=#HEX] tags that form a gradient pattern
+ * and reports them as SemanticContributions with a confidence score.
+ *
+ * ## Refinements over v1
+ *
+ * 1. **OKLab color space** — Uses OKLab (Bottosson 2020) for perceptual
+ *    colour distance instead of RGB.  Two colours with small OKLab distance
+ *    look nearly identical to the human eye, making gradient detection
+ *    much more accurate.
+ *
+ * 2. **Change-point detection** — Identifies gradient *stops* even when
+ *    plateaus (runs of identical colour) exist, so a sequence like
+ *    RRRR→G→BBBB is correctly parsed as a 3-stop gradient rather than
+ *    a failed linear interpolation.
+ *
+ * 3. **Sharper sigmoid (k=6)** — Better separation between "likely
+ *    gradient" and "maybe gradient" at the decision thresholds.
+ *
+ * ## Confidence features (weights sum to 1.0)
+ *
+ *   - uniformPerceptualSpacing  (+0.30)
+ *   - contiguousWrappers        (+0.25)
+ *   - noFormattingBreaks        (+0.15)
+ *   - monotonicProgression      (+0.20)
+ *   - lowPerceptualError        (+0.10)
+ *
+ * @see SemanticContribution
+ */
+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 interface GradientModel {
+    readonly colors: string[];
+    readonly easing: 'linear' | 'easeIn' | 'easeOut' | 'easeInOut';
+    readonly stops: GradientStop[];
+    readonly rangeStart: number;
+    readonly rangeEnd: number;
+    readonly charCount: number;
+    readonly diagnostics: GradientDiagnostics;
+}
+export interface GradientStop {
+    /** Hex colour at this stop */
+    readonly color: string;
+    /** Normalised position 0-1 */
+    readonly position: number;
+}
+export interface GradientDiagnostics {
+    readonly uniformSpacing: boolean;
+    readonly monotonic: boolean;
+    readonly plateauCount: number;
+    readonly maxPerceptualError: number;
+    readonly stopCount: number;
+    readonly featureScores: Readonly<Record<string, number>>;
+}
+export interface CollapsibleGradient {
+    readonly range: {
+        start: number;
+        end: number;
+    };
+    readonly colors: string[];
+    readonly stops: GradientStop[];
+    readonly easing: 'linear' | 'easeIn' | 'easeOut' | 'easeInOut';
+    readonly combinedText: string;
+    readonly replacementText: string;
+    readonly confidence: number;
+    readonly colorCount: number;
+}
+export declare function formatGradientTag(stops: GradientStop[], colors: string[], easing: 'linear' | 'easeIn' | 'easeOut' | 'easeInOut', text: string): string;
+export declare class GradientAnalyzer implements AnalyzerPass {
+    readonly id = "gradient-analyzer";
+    run(tree: GreenNode, _context: PipelineContext): Contribution[];
+    findCollapsibleGradients(tree: GreenNode, minConfidence?: number): CollapsibleGradient[];
+    private collectCollapsibleGradients;
+    /**
+     * The collapsible runs among the DIRECT children of `node`, and nothing
+     * below them.
+     *
+     * A run is a property of one children list: which siblings are `color`,
+     * what sits between them, what each one wraps. That is what makes it the
+     * unit the incremental analysis can work with — an edit rebuilds the child
+     * lists on the path down to it and nothing else, so only those lists can
+     * have gained or lost a run (see `SemanticAnalyzer.analyzeWindow`). The
+     * full scan above is this, applied to every node in pre-order; running it
+     * per list keeps the two paths producing the same items in the same order.
+     *
+     * Returns the number of runs appended to `sink`. `nodeStart` is the absolute
+     * offset of `node`, so the ranges come out in document coordinates.
+     */
+    collapsibleGradientsAt(node: GreenNode, nodeStart: number, sink: CollapsibleGradient[], minConfidence?: number): number;
+    private findGradients;
+    /**
+     * Detect gradient stops from a sequence of hex colours, handling plateaus.
+     *
+     * Algorithm: Scan for "significant changes" in perceptual distance.
+     * Wherever the cumulative perceptual distance from the last stop exceeds a
+     * threshold, a new stop is recorded.  This naturally skips over plateaus.
+     */
+    private detectStops;
+    private buildDiagnostics;
+    private calculateRawScore;
+}
+export declare function findCollapsibleGradients(tree: GreenNode, minConfidence?: number): CollapsibleGradient[];
+/**
+ * The collapsible runs among the direct children of `node`, whose absolute
+ * start is `nodeStart`. See {@link GradientAnalyzer.collapsibleGradientsAt}.
+ */
+export declare function collapsibleGradientsAt(node: GreenNode, nodeStart: number, sink: CollapsibleGradient[], minConfidence?: number): number;

package/dist/types/Analysis/Passes/Analysis/MergeableColorAnalyzer.d.ts

@@ -0,0 +1,26 @@
+/**
+ * Quasar Analysis Framework — Mergeable Color Analyzer
+ *
+ * Detects sequences of consecutive [color=#HEX] wrappers where ALL
+ * adjacent colours are identical.  These are optimisation opportunities:
+ * the user could merge them into a single `[color]` tag.
+ *
+ * Example:
+ *   [color=#FF0000]H[/color][color=#FF0000]e[/color] → mergeable
+ *   [color=#FF0000]H[/color][color=#EE1100]e[/color] → NOT mergeable
+ *
+ * @see OptimizationContribution
+ */
+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 MergeableColorAnalyzer implements AnalyzerPass {
+    readonly id = "mergeable-color";
+    run(tree: GreenNode, _context: PipelineContext): Contribution[];
+    /**
+     * Walk the tree and find consecutive color nodes with identical colours.
+     */
+    private findMergeableColorSequences;
+    private emitMergeable;
+}

package/dist/types/Analysis/Passes/Analysis/RainbowAnalyzer.d.ts

@@ -0,0 +1,47 @@
+/**
+ * Quasar Analysis Framework — Rainbow Analyzer
+ *
+ * Detects sequences of [color=#HEX] tags where the HSL hue rotates
+ * continuously while saturation and lightness remain approximately
+ * constant — the classic "rainbow" pattern.
+ *
+ * ## Confidence features
+ *
+ *   - hueRotation (+0.35) — hue changes monotonically (increasing or decreasing)
+ *   - stableSaturation (+0.20) — saturation stays within a narrow band
+ *   - stableLightness (+0.20) — lightness stays within a narrow band
+ *   - contiguousWrappers (+0.15) — no gaps in the colour sequence
+ *   - noFormattingBreaks (+0.10) — no formatting tags between colours
+ *
+ * @see SemanticContribution
+ */
+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 interface RainbowModel {
+    readonly colors: string[];
+    readonly hueStart: number;
+    readonly hueEnd: number;
+    readonly avgSaturation: number;
+    readonly avgLightness: number;
+    readonly rangeStart: number;
+    readonly rangeEnd: number;
+    readonly charCount: number;
+    readonly diagnostics: RainbowDiagnostics;
+}
+export interface RainbowDiagnostics {
+    readonly hueDelta: number;
+    readonly saturationDeviation: number;
+    readonly lightnessDeviation: number;
+    readonly isContinuous: boolean;
+    readonly featureScores: Readonly<Record<string, number>>;
+}
+export declare class RainbowAnalyzer implements AnalyzerPass {
+    readonly id = "rainbow-analyzer";
+    run(tree: GreenNode, _context: PipelineContext): Contribution[];
+    private findRainbows;
+    private extractHSL;
+    private analyzeRainbow;
+    private calculateRawScore;
+}

package/dist/types/Analysis/Passes/Analysis/SymbolAnalyzer.d.ts

@@ -0,0 +1,89 @@
+/**
+ * Quasar Analysis Framework — Symbol Analyzer
+ *
+ * Detects decorative Unicode glyphs — `✧ ⚔ ☽ ━ ◈` — in document text and
+ * reports them as SemanticContributions.
+ *
+ * The colour analyzers recognise structure that BBCode itself encodes: a
+ * gradient is a *sequence of tags*, so the tree already separates it from the
+ * prose around it. Symbols have no such marker. They are ordinary characters
+ * inside ordinary text nodes, indistinguishable at the syntax level from the
+ * words beside them. Recognising them therefore has to happen at the character
+ * level, against the Unicode blocks they come from.
+ *
+ * ## Runs, not characters
+ *
+ * Symbols are reported as contiguous *runs*, because the two ways a document
+ * uses them need different treatment:
+ *
+ *   `✧ airi ✧`      two one-glyph runs — ornaments framing a word
+ *   `✧⋆⋅⋆⋅⋆✧`       one seven-glyph run — a divider line
+ *
+ * Swapping the first means substituting glyph for glyph. Swapping the second
+ * means replacing the whole line with a different divider. A run of
+ * `MIN_SEPARATOR_LENGTH` or more is labelled `Separator`; anything shorter is
+ * labelled `Symbol`. Both carry per-glyph offsets in their metadata, so a
+ * consumer can address either the run or its individual characters.
+ *
+ * ## Confidence
+ *
+ * Detection is exact — a code point is either in a decorative block or it is
+ * not. Confidence answers the question that actually matters: is this glyph
+ * *ornamental*, or does it carry meaning? A dingbat is almost always
+ * decoration; `≈` in a sentence is probably arithmetic, and re-theming it
+ * would corrupt the text.
+ *
+ * Each block carries a base confidence, a run takes the *lowest* of its
+ * members — a run is only as safely ornamental as its least ornamental glyph —
+ * and separator-length runs receive a bonus, because a seven-character line of
+ * symbols is decoration regardless of which blocks it draws from.
+ *
+ * @see SemanticContribution
+ */
+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 interface SymbolGlyph {
+    readonly char: string;
+    readonly codePoint: number;
+    /** Unicode block name this glyph was matched in. */
+    readonly block: string;
+    /** Absolute source offsets, UTF-16 code units — `source.slice(start, end)`. */
+    readonly start: number;
+    readonly end: number;
+}
+export interface SymbolRunModel {
+    /** The run exactly as it appears in the source. */
+    readonly text: string;
+    readonly glyphs: readonly SymbolGlyph[];
+    /** Distinct block names present, in first-seen order. */
+    readonly blocks: readonly string[];
+    /** Length in glyphs — not in UTF-16 units, which astral symbols inflate. */
+    readonly length: number;
+    /** Whether the run was long enough to read as a divider. */
+    readonly isSeparator: boolean;
+}
+export declare class SymbolAnalyzer implements AnalyzerPass {
+    readonly id = "symbol";
+    run(tree: GreenNode, _context: PipelineContext): Contribution[];
+    /**
+     * Descend the tree, accumulating absolute offsets.
+     *
+     * Green nodes carry widths rather than positions (see `GreenNode.ts`), so
+     * the offsets a Contribution reports are built on the way down. Only `text`
+     * leaves are scanned: an element node's own `text` holds its attributes
+     * (`=#D194B3`), which are syntax, not content.
+     */
+    private walk;
+    /**
+     * Find runs of decorative glyphs in one text leaf.
+     *
+     * Iterates by code point, not by index: an astral symbol such as `🌸`
+     * occupies two UTF-16 units, and stepping one unit at a time would split it
+     * into unpaired surrogates that match no block. The offsets recorded stay in
+     * UTF-16 units so they address the source directly.
+     */
+    private scanText;
+    private toContribution;
+}

package/dist/types/Analysis/Passes/Analysis/WaveAnalyzer.d.ts

@@ -0,0 +1,44 @@
+/**
+ * Quasar Analysis Framework — Wave (Size Oscillation) Analyzer
+ *
+ * Detects sequences of [size=N] tags where the sizes follow a sinusoidal
+ * (or other periodic) oscillation pattern — the classic "wave/grow" effect.
+ *
+ * ## Confidence features
+ *
+ *   - periodicPattern (+0.35) — sizes follow a clear periodic pattern
+ *   - boundedRange (+0.20) — sizes stay within a plausible min-max range
+ *   - smoothTransitions (+0.20) — adjacent size differences are small
+ *   - contiguousWrappers (+0.15) — no gaps in the size sequence
+ *   - noFormattingBreaks (+0.10) — no formatting tags between size nodes
+ *
+ * @see SemanticContribution
+ */
+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 interface WaveModel {
+    readonly sizes: number[];
+    readonly minSize: number;
+    readonly maxSize: number;
+    readonly estimatedFrequency: number;
+    readonly rangeStart: number;
+    readonly rangeEnd: number;
+    readonly charCount: number;
+    readonly diagnostics: WaveDiagnostics;
+}
+export interface WaveDiagnostics {
+    readonly periodicityScore: number;
+    readonly hasSymmetry: boolean;
+    readonly isBounded: boolean;
+    readonly transitionSmoothness: number;
+    readonly featureScores: Readonly<Record<string, number>>;
+}
+export declare class WaveAnalyzer implements AnalyzerPass {
+    readonly id = "wave-analyzer";
+    run(tree: GreenNode, _context: PipelineContext): Contribution[];
+    private findWaves;
+    private analyzeWave;
+    private calculateRawScore;
+}

package/dist/types/Analysis/Passes/Analysis/__tests__/GradientAnalyzer.test.d.ts

@@ -0,0 +1,4 @@
+/**
+ * Tests for refined GradientAnalyzer v2 (OKLab, change-point detection)
+ */
+export {};

package/dist/types/Analysis/Passes/Analysis/__tests__/MergeableColorAnalyzer.test.d.ts

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

package/dist/types/Analysis/Passes/Analysis/__tests__/RainbowAnalyzer.test.d.ts

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

package/dist/types/Analysis/Passes/Analysis/__tests__/WaveAnalyzer.test.d.ts

@@ -0,0 +1,4 @@
+/**
+ * Tests for WaveAnalyzer (size oscillation detection)
+ */
+export {};

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

@@ -0,0 +1,30 @@
+/**
+ * Quasar Analysis Framework — Default Decision
+ *
+ * Consumes an AnalysisReport and produces a TransformationPlan.
+ * The decision logic depends on the PipelineContext:
+ *
+ *   - target === 'miliastry':
+ *       Aggressively collapses detected gradients (confidence ≥ 0.6).
+ *   - target === 'osu':
+ *       Only collapses very high-confidence gradients (confidence ≥ 0.95).
+ *   - mode === 'batch' || mode === 'import':
+ *       Uses the OSU threshold by default.
+ *
+ * Optimisation opportunities (mergeable colours) are always included
+ * regardless of target, but only when the count exceeds 1.
+ *
+ * @see DecisionPass
+ * @see TransformationPlan
+ */
+import type { DecisionPass, TransformationPlan } from '../../Contracts/Pass';
+import type { AnalysisReport } from '../../Contracts/AnalysisReport';
+import type { PipelineContext } from '../../Contracts/PipelineContext';
+export declare class DefaultDecision implements DecisionPass {
+    readonly id = "default-decision";
+    run(report: AnalysisReport, context: PipelineContext): TransformationPlan;
+    /** Map contribution label → transform action kind */
+    private labelToActionKind;
+    private handleSemantic;
+    private handleOptimization;
+}