@pixerate/editor 0.280.0 → 0.282.0

package/dist/image-editor/index.js

@@ -8,7 +8,7 @@ import {
   parseOpenTypeFont,
   removeAnchorsKeepingShape,
   traceField
-} from "../chunk-HN57I7KT.js";
+} from "../chunk-CG3FBNXE.js";
 import {
   ADJUSTMENT_KEYS,
   ADJUSTMENT_KINDS,
@@ -409,7 +409,7 @@ import {
   writePsd,
   xyToTempTint,
   xyToUv
-} from "../chunk-NJDEKU5D.js";
+} from "../chunk-2YGYYVSG.js";
 import {
   flattenPath,
   rasterizeCoverage
@@ -683,14 +683,14 @@ import {
   warpMeshParamAt,
   warpMeshRows,
   warpPresetMesh
-} from "../chunk-YOM76H2V.js";
+} from "../chunk-VEX6YVNG.js";
 import {
   IMAGE_PROFILE,
   checkBrush,
   closest,
   createBrushLibrary,
   resolveBrush
-} from "../chunk-PPDUCZZV.js";
+} from "../chunk-YRGTQLDN.js";
 import "../chunk-JL6YH5WD.js";
 import "../chunk-RWDSSK2I.js";
 import {

package/dist/paint-editor/antimatter.d.cts

@@ -0,0 +1,154 @@
+/**
+ * Antimatter paint (`engine: 'antimatter'`, `marks.kind: 'antimatter'`): animated blasts that
+ * detonate where the brush touches paint across any visible layer, inverting colours in the core,
+ * removing alpha, burning a soot ring around the crater, denting thick relief, clearing core light,
+ * and throwing white-hot ballistic sparks on the active layer.
+ */
+import { type PaintGradientSource } from '../paint/gradient-paint.cjs';
+import { TiledSurface, type RasterRect } from '../raster/surface.cjs';
+import type { PaintBrush } from './brushes.cjs';
+import { type EffectPaintPixels } from './effect-paint.cjs';
+import { type PenPoint, type StrokeCopy } from './engine.cjs';
+import { DEFAULT_ANTIMATTER, INVERT_MODES, normalizeAntimatter, type AntimatterSettings, type InvertMode } from './mark-settings.cjs';
+import type { ThickChannels } from './thick.cjs';
+export { DEFAULT_ANTIMATTER, INVERT_MODES, normalizeAntimatter, type AntimatterSettings, type InvertMode };
+/** One detonation along an antimatter stroke. */
+export interface AntimatterBlast {
+    index: number;
+    x: number;
+    y: number;
+    /** Blast radius in document pixels. */
+    radius: number;
+    /** Tip diameter at the dab that fired this blast. */
+    tipSize: number;
+    /** Tip opacity at the dab that fired this blast (`0..1`). */
+    tipOpacity: number;
+    /** Fuel (`0..1`) that triggered this blast. */
+    fuel: number;
+    /** Copy-specific seed for noise and sparks. */
+    seed: number;
+    /** Spark target colour (0..255 RGB). */
+    color: [number, number, number];
+    /** Light intensity (`0..1`) sparks write to `doc.light` on the active layer. */
+    lightAmount: number;
+    /** Number of sparks spawned by this blast. */
+    sparkCount: number;
+    /** Birth timestamp in ms (from `PenPoint.t` or the host clock). */
+    t: number;
+}
+/** Summary returned on `PaintStrokeResult.antimatter`. */
+export interface AntimatterStats {
+    blasts: number;
+    sparks: number;
+    fuel: number;
+    layers: string[];
+    skippedLayers: string[];
+}
+/** One visible layer that supplies fuel to the antimatter stroke (and is edited if `editable`). */
+export interface AntimatterTarget {
+    id: string;
+    /** True for unlocked pixel layers (not stroke, sticker or effect layers). */
+    editable: boolean;
+    lockTransparency: boolean;
+    opacity: number;
+    offset: {
+        x: number;
+        y: number;
+    };
+    /** Pre-stroke pixel surface (read-only fuel & recomposite source). */
+    base: TiledSurface;
+    /** Pre-stroke light channel (`doc.light[id]`), if any. */
+    baseLight?: TiledSurface | null;
+    /** Pre-stroke thick-paint channels (`doc.thick[id]`), if any. */
+    baseThick?: ThickChannels | null;
+}
+/** Per-layer output surfaces produced by `AntimatterStrokeDriver`. */
+export interface AntimatterLayerOutput {
+    id: string;
+    surface: TiledSurface;
+    light: TiledSurface | null;
+    thick: ThickChannels | null;
+    changed: boolean;
+}
+export interface AntimatterStrokeInit {
+    activeLayerId: string;
+    targets: readonly AntimatterTarget[];
+    brush: PaintBrush;
+    /** Paint colour 0..255 RGBA. */
+    color: readonly [number, number, number, number];
+    seed: number;
+    copies: readonly StrokeCopy[];
+    selection?: {
+        width: number;
+        height: number;
+        data: ArrayLike<number>;
+    } | null;
+    paint?: PaintGradientSource | null;
+    effect?: EffectPaintPixels | null;
+    /** Current clock in ms for stamping blast birth times during live strokes. */
+    now?: () => number;
+}
+/** Smooth 2D value noise in `0..1` using only `Math.floor` and `hash2` (identical across TS and Swift). */
+export declare function blastNoise2D(ux: number, uy: number, salt: number): number;
+/** Inverts an 8-bit sRGB colour in OKLab space by flipping lightness `1 - L` and hue `(-a, -b)`. */
+export declare function invertOklab8(r: number, g: number, b: number): [number, number, number];
+/** Core (`0..1`) and soot-ring (`0..1`) weights for a heat value `h` in `0..1`. */
+export declare function heatProfile(h: number): {
+    core: number;
+    ring: number;
+};
+export declare class AntimatterStrokeDriver {
+    readonly init: AntimatterStrokeInit;
+    dabCount: number;
+    bounds: RasterRect | null;
+    readonly blasts: AntimatterBlast[];
+    private readonly smoother;
+    private readonly copies;
+    private readonly states;
+    private readonly sampler;
+    private readonly sample;
+    private readonly effRgb;
+    private readonly heat;
+    private readonly heatCoords;
+    private tipBuf;
+    private lastRaw;
+    private lastFed;
+    private totalFuel;
+    private readonly reachedSkipped;
+    private readonly editedIds;
+    private readonly outputs;
+    constructor(init: AntimatterStrokeInit);
+    /** Pushes raw pen samples and returns the bounding rectangles of any blasts that fired. */
+    push(points: readonly PenPoint[]): RasterRect[];
+    /** Flushes the smoother tail and finishes the stroke. */
+    finish(): RasterRect[];
+    private processDabs;
+    /** Measures fuel (`0..1`) under `d` from the pre-stroke pixels of every visible layer. */
+    private measureFuel;
+    private fireBlast;
+    /** Writes one blast into `heatMap` (at `progress` 0..1) and returns the bounding rectangle including sparks. */
+    private writeBlastToHeat;
+    /** Recomposites all editable target layers from their pre-stroke tiles using the current committed `heat` and `blasts`. */
+    private recompositeAll;
+    /**
+     * Builds per-layer outputs for the given `heatMap` and blast progress function `progressOf(b)`.
+     * At `progressOf(b) === 1`, no flash or shock ring is drawn and sparks reach 100%, matching the
+     * committed pixels bit-for-bit.
+     */
+    private buildOutputs;
+    /** Draws sparks and (when `progress < 1`) the view-only flash and expanding shock ring on the active layer. */
+    private drawActiveExtras;
+    /**
+     * Renders the blast state at `now` (ms) for view-only blast animation.
+     * When `active` is `false` (all blasts have reached `progress === 1`), `outputs` match `layerOutputs()` bit-for-bit.
+     */
+    renderAtTime(now: number): {
+        outputs: AntimatterLayerOutput[];
+        active: boolean;
+    };
+    hasBlasts(): boolean;
+    /** Rebases blast birth times so the earliest blast starts at `now` ms. */
+    rebaseTime(now: number): void;
+    layerOutputs(): AntimatterLayerOutput[];
+    stats(): AntimatterStats;
+}

package/dist/paint-editor/antimatter.d.ts

@@ -0,0 +1,154 @@
+/**
+ * Antimatter paint (`engine: 'antimatter'`, `marks.kind: 'antimatter'`): animated blasts that
+ * detonate where the brush touches paint across any visible layer, inverting colours in the core,
+ * removing alpha, burning a soot ring around the crater, denting thick relief, clearing core light,
+ * and throwing white-hot ballistic sparks on the active layer.
+ */
+import { type PaintGradientSource } from '../paint/gradient-paint.js';
+import { TiledSurface, type RasterRect } from '../raster/surface.js';
+import type { PaintBrush } from './brushes.js';
+import { type EffectPaintPixels } from './effect-paint.js';
+import { type PenPoint, type StrokeCopy } from './engine.js';
+import { DEFAULT_ANTIMATTER, INVERT_MODES, normalizeAntimatter, type AntimatterSettings, type InvertMode } from './mark-settings.js';
+import type { ThickChannels } from './thick.js';
+export { DEFAULT_ANTIMATTER, INVERT_MODES, normalizeAntimatter, type AntimatterSettings, type InvertMode };
+/** One detonation along an antimatter stroke. */
+export interface AntimatterBlast {
+    index: number;
+    x: number;
+    y: number;
+    /** Blast radius in document pixels. */
+    radius: number;
+    /** Tip diameter at the dab that fired this blast. */
+    tipSize: number;
+    /** Tip opacity at the dab that fired this blast (`0..1`). */
+    tipOpacity: number;
+    /** Fuel (`0..1`) that triggered this blast. */
+    fuel: number;
+    /** Copy-specific seed for noise and sparks. */
+    seed: number;
+    /** Spark target colour (0..255 RGB). */
+    color: [number, number, number];
+    /** Light intensity (`0..1`) sparks write to `doc.light` on the active layer. */
+    lightAmount: number;
+    /** Number of sparks spawned by this blast. */
+    sparkCount: number;
+    /** Birth timestamp in ms (from `PenPoint.t` or the host clock). */
+    t: number;
+}
+/** Summary returned on `PaintStrokeResult.antimatter`. */
+export interface AntimatterStats {
+    blasts: number;
+    sparks: number;
+    fuel: number;
+    layers: string[];
+    skippedLayers: string[];
+}
+/** One visible layer that supplies fuel to the antimatter stroke (and is edited if `editable`). */
+export interface AntimatterTarget {
+    id: string;
+    /** True for unlocked pixel layers (not stroke, sticker or effect layers). */
+    editable: boolean;
+    lockTransparency: boolean;
+    opacity: number;
+    offset: {
+        x: number;
+        y: number;
+    };
+    /** Pre-stroke pixel surface (read-only fuel & recomposite source). */
+    base: TiledSurface;
+    /** Pre-stroke light channel (`doc.light[id]`), if any. */
+    baseLight?: TiledSurface | null;
+    /** Pre-stroke thick-paint channels (`doc.thick[id]`), if any. */
+    baseThick?: ThickChannels | null;
+}
+/** Per-layer output surfaces produced by `AntimatterStrokeDriver`. */
+export interface AntimatterLayerOutput {
+    id: string;
+    surface: TiledSurface;
+    light: TiledSurface | null;
+    thick: ThickChannels | null;
+    changed: boolean;
+}
+export interface AntimatterStrokeInit {
+    activeLayerId: string;
+    targets: readonly AntimatterTarget[];
+    brush: PaintBrush;
+    /** Paint colour 0..255 RGBA. */
+    color: readonly [number, number, number, number];
+    seed: number;
+    copies: readonly StrokeCopy[];
+    selection?: {
+        width: number;
+        height: number;
+        data: ArrayLike<number>;
+    } | null;
+    paint?: PaintGradientSource | null;
+    effect?: EffectPaintPixels | null;
+    /** Current clock in ms for stamping blast birth times during live strokes. */
+    now?: () => number;
+}
+/** Smooth 2D value noise in `0..1` using only `Math.floor` and `hash2` (identical across TS and Swift). */
+export declare function blastNoise2D(ux: number, uy: number, salt: number): number;
+/** Inverts an 8-bit sRGB colour in OKLab space by flipping lightness `1 - L` and hue `(-a, -b)`. */
+export declare function invertOklab8(r: number, g: number, b: number): [number, number, number];
+/** Core (`0..1`) and soot-ring (`0..1`) weights for a heat value `h` in `0..1`. */
+export declare function heatProfile(h: number): {
+    core: number;
+    ring: number;
+};
+export declare class AntimatterStrokeDriver {
+    readonly init: AntimatterStrokeInit;
+    dabCount: number;
+    bounds: RasterRect | null;
+    readonly blasts: AntimatterBlast[];
+    private readonly smoother;
+    private readonly copies;
+    private readonly states;
+    private readonly sampler;
+    private readonly sample;
+    private readonly effRgb;
+    private readonly heat;
+    private readonly heatCoords;
+    private tipBuf;
+    private lastRaw;
+    private lastFed;
+    private totalFuel;
+    private readonly reachedSkipped;
+    private readonly editedIds;
+    private readonly outputs;
+    constructor(init: AntimatterStrokeInit);
+    /** Pushes raw pen samples and returns the bounding rectangles of any blasts that fired. */
+    push(points: readonly PenPoint[]): RasterRect[];
+    /** Flushes the smoother tail and finishes the stroke. */
+    finish(): RasterRect[];
+    private processDabs;
+    /** Measures fuel (`0..1`) under `d` from the pre-stroke pixels of every visible layer. */
+    private measureFuel;
+    private fireBlast;
+    /** Writes one blast into `heatMap` (at `progress` 0..1) and returns the bounding rectangle including sparks. */
+    private writeBlastToHeat;
+    /** Recomposites all editable target layers from their pre-stroke tiles using the current committed `heat` and `blasts`. */
+    private recompositeAll;
+    /**
+     * Builds per-layer outputs for the given `heatMap` and blast progress function `progressOf(b)`.
+     * At `progressOf(b) === 1`, no flash or shock ring is drawn and sparks reach 100%, matching the
+     * committed pixels bit-for-bit.
+     */
+    private buildOutputs;
+    /** Draws sparks and (when `progress < 1`) the view-only flash and expanding shock ring on the active layer. */
+    private drawActiveExtras;
+    /**
+     * Renders the blast state at `now` (ms) for view-only blast animation.
+     * When `active` is `false` (all blasts have reached `progress === 1`), `outputs` match `layerOutputs()` bit-for-bit.
+     */
+    renderAtTime(now: number): {
+        outputs: AntimatterLayerOutput[];
+        active: boolean;
+    };
+    hasBlasts(): boolean;
+    /** Rebases blast birth times so the earliest blast starts at `now` ms. */
+    rebaseTime(now: number): void;
+    layerOutputs(): AntimatterLayerOutput[];
+    stats(): AntimatterStats;
+}

package/dist/paint-editor/brush-controls.d.cts

@@ -47,6 +47,7 @@ export interface BrushEngineControls {
 export declare const IRIDESCENCE_SLIDERS: readonly SliderControl[];
 export declare const GHOST_SLIDERS: readonly SliderControl[];
 export declare const MUTATION_SLIDERS: readonly SliderControl[];
+export declare const ANTIMATTER_SLIDERS: readonly SliderControl[];
 /**
  * The controls the active brush's engine adds to the brush panel (`null` for the eraser):
  * blender strength and blend distance; smudge strength and length; the Mixer Brush's pick-up,

package/dist/paint-editor/brush-controls.d.ts

@@ -47,6 +47,7 @@ export interface BrushEngineControls {
 export declare const IRIDESCENCE_SLIDERS: readonly SliderControl[];
 export declare const GHOST_SLIDERS: readonly SliderControl[];
 export declare const MUTATION_SLIDERS: readonly SliderControl[];
+export declare const ANTIMATTER_SLIDERS: readonly SliderControl[];
 /**
  * The controls the active brush's engine adds to the brush panel (`null` for the eraser):
  * blender strength and blend distance; smudge strength and length; the Mixer Brush's pick-up,

package/dist/paint-editor/brush-model.d.cts

@@ -9,14 +9,15 @@ import type { MixingModel } from '../paint/exchange.cjs';
 import { type PaintGradientSource, type PaintSource } from '../paint/gradient-paint.cjs';
 import { type MixerSettings } from '../paint/mixer.cjs';
 import { DEFAULT_LIVE_PATTERNS, LIVE_PATTERN_KINDS, LIVE_PATTERN_PRESETS, normalizeLivePatterns, type LivePatternKind, type LivePatternsInput, type LivePatternsSettings } from '../paint/live-patterns.cjs';
-import { type BristleSettings, type ParticleSettings, type StickerSettings } from './mark-settings.cjs';
-export { DEFAULT_LIVE_PATTERNS, LIVE_PATTERN_KINDS, LIVE_PATTERN_PRESETS, normalizeLivePatterns, type LivePatternKind, type LivePatternsInput, type LivePatternsSettings };
+import { DEFAULT_ANTIMATTER, INVERT_MODES, normalizeAntimatter, type AntimatterSettings, type BristleSettings, type InvertMode, type ParticleSettings, type StickerSettings } from './mark-settings.cjs';
+export { DEFAULT_ANTIMATTER, DEFAULT_LIVE_PATTERNS, INVERT_MODES, LIVE_PATTERN_KINDS, LIVE_PATTERN_PRESETS, normalizeAntimatter, normalizeLivePatterns, type AntimatterSettings, type InvertMode, type LivePatternKind, type LivePatternsInput, type LivePatternsSettings, };
 /**
  * How a brush makes marks: `dab` (dabs into a stroke buffer, or dab by dab through the pick-up /
  * mix exchange when its behaviour asks for it), `eraser` (removes alpha), `mixer` (the Mixer
- * Brush), `blender` (mixes the colours under and near the tip) or `smudge` (drags paint along).
+ * Brush), `blender` (mixes the colours under and near the tip), `smudge` (drags paint along), or
+ * `antimatter` (animated blasts that invert, scorch and destroy paint across every visible layer).
  */
-export type PaintBrushEngine = 'dab' | 'eraser' | 'mixer' | 'blender' | 'smudge' | 'wet' | 'impasto' | 'particle' | 'bristle' | 'sticker';
+export type PaintBrushEngine = 'dab' | 'eraser' | 'mixer' | 'blender' | 'smudge' | 'wet' | 'impasto' | 'particle' | 'bristle' | 'sticker' | 'antimatter';
 export declare const PAINT_BRUSH_ENGINES: readonly PaintBrushEngine[];
 export type PaintBrushCategory = 'pencil' | 'pastel' | 'charcoal' | 'airbrush' | 'marker' | 'ink' | 'paint' | 'eraser' | 'blender' | 'smudge' | 'mixer' | 'watercolor' | 'wet-tool' | 'oil' | 'impasto' | 'procedural' | 'bristle' | 'sticker' | 'light' | 'custom';
 export declare const PAINT_BRUSH_CATEGORIES: readonly PaintBrushCategory[];
@@ -282,6 +283,8 @@ export interface PaintBrush {
     bristle: BristleSettings;
     /** Sticker engine only: the stamps and how they are sprayed. */
     sticker: StickerSettings;
+    /** Antimatter engine only: blast size, spacing, threshold, inversion, scorch, annihilation, sparks, crater and duration. */
+    antimatter: AntimatterSettings;
     /** Light paint: the light it lays with its colour (amount 0: none). */
     light: LightSettings;
     /** UV-fluorescent ink: glows under the virtual UV blacklight (amount 0: none). */
@@ -334,7 +337,7 @@ export interface SpraySettings {
     size: number;
 }
 export declare const DEFAULT_SPRAY: Readonly<SpraySettings>;
-export type PaintBrushInput = Partial<Omit<PaintBrush, 'tip' | 'dynamics' | 'mixer' | 'behavior' | 'blender' | 'smudge' | 'wet' | 'impasto' | 'particle' | 'bristle' | 'sticker' | 'paint' | 'light' | 'fluorescence' | 'thermochromic' | 'iridescence' | 'ghost' | 'mutation' | 'ferro' | 'spray' | 'tipGrain' | 'livePatterns'>> & {
+export type PaintBrushInput = Partial<Omit<PaintBrush, 'tip' | 'dynamics' | 'mixer' | 'behavior' | 'blender' | 'smudge' | 'wet' | 'impasto' | 'particle' | 'bristle' | 'sticker' | 'antimatter' | 'paint' | 'light' | 'fluorescence' | 'thermochromic' | 'iridescence' | 'ghost' | 'mutation' | 'ferro' | 'spray' | 'tipGrain' | 'livePatterns'>> & {
     spray?: Partial<SpraySettings> | null;
     /** Tip grain (`null` removes it). */
     tipGrain?: Partial<TipGrainSettings> | null;
@@ -363,6 +366,7 @@ export type PaintBrushInput = Partial<Omit<PaintBrush, 'tip' | 'dynamics' | 'mix
     particle?: Partial<ParticleSettings>;
     bristle?: Partial<BristleSettings>;
     sticker?: Partial<StickerSettings>;
+    antimatter?: Partial<AntimatterSettings>;
 };
 /** Whether a brush can pick paint up from the canvas (the pick-up / mix ratios apply): dab, mixer and wet brushes. */
 export declare function isWetCapable(brush: Pick<PaintBrush, 'engine'>): boolean;

package/dist/paint-editor/brush-model.d.ts

@@ -9,14 +9,15 @@ import type { MixingModel } from '../paint/exchange.js';
 import { type PaintGradientSource, type PaintSource } from '../paint/gradient-paint.js';
 import { type MixerSettings } from '../paint/mixer.js';
 import { DEFAULT_LIVE_PATTERNS, LIVE_PATTERN_KINDS, LIVE_PATTERN_PRESETS, normalizeLivePatterns, type LivePatternKind, type LivePatternsInput, type LivePatternsSettings } from '../paint/live-patterns.js';
-import { type BristleSettings, type ParticleSettings, type StickerSettings } from './mark-settings.js';
-export { DEFAULT_LIVE_PATTERNS, LIVE_PATTERN_KINDS, LIVE_PATTERN_PRESETS, normalizeLivePatterns, type LivePatternKind, type LivePatternsInput, type LivePatternsSettings };
+import { DEFAULT_ANTIMATTER, INVERT_MODES, normalizeAntimatter, type AntimatterSettings, type BristleSettings, type InvertMode, type ParticleSettings, type StickerSettings } from './mark-settings.js';
+export { DEFAULT_ANTIMATTER, DEFAULT_LIVE_PATTERNS, INVERT_MODES, LIVE_PATTERN_KINDS, LIVE_PATTERN_PRESETS, normalizeAntimatter, normalizeLivePatterns, type AntimatterSettings, type InvertMode, type LivePatternKind, type LivePatternsInput, type LivePatternsSettings, };
 /**
  * How a brush makes marks: `dab` (dabs into a stroke buffer, or dab by dab through the pick-up /
  * mix exchange when its behaviour asks for it), `eraser` (removes alpha), `mixer` (the Mixer
- * Brush), `blender` (mixes the colours under and near the tip) or `smudge` (drags paint along).
+ * Brush), `blender` (mixes the colours under and near the tip), `smudge` (drags paint along), or
+ * `antimatter` (animated blasts that invert, scorch and destroy paint across every visible layer).
  */
-export type PaintBrushEngine = 'dab' | 'eraser' | 'mixer' | 'blender' | 'smudge' | 'wet' | 'impasto' | 'particle' | 'bristle' | 'sticker';
+export type PaintBrushEngine = 'dab' | 'eraser' | 'mixer' | 'blender' | 'smudge' | 'wet' | 'impasto' | 'particle' | 'bristle' | 'sticker' | 'antimatter';
 export declare const PAINT_BRUSH_ENGINES: readonly PaintBrushEngine[];
 export type PaintBrushCategory = 'pencil' | 'pastel' | 'charcoal' | 'airbrush' | 'marker' | 'ink' | 'paint' | 'eraser' | 'blender' | 'smudge' | 'mixer' | 'watercolor' | 'wet-tool' | 'oil' | 'impasto' | 'procedural' | 'bristle' | 'sticker' | 'light' | 'custom';
 export declare const PAINT_BRUSH_CATEGORIES: readonly PaintBrushCategory[];
@@ -282,6 +283,8 @@ export interface PaintBrush {
     bristle: BristleSettings;
     /** Sticker engine only: the stamps and how they are sprayed. */
     sticker: StickerSettings;
+    /** Antimatter engine only: blast size, spacing, threshold, inversion, scorch, annihilation, sparks, crater and duration. */
+    antimatter: AntimatterSettings;
     /** Light paint: the light it lays with its colour (amount 0: none). */
     light: LightSettings;
     /** UV-fluorescent ink: glows under the virtual UV blacklight (amount 0: none). */
@@ -334,7 +337,7 @@ export interface SpraySettings {
     size: number;
 }
 export declare const DEFAULT_SPRAY: Readonly<SpraySettings>;
-export type PaintBrushInput = Partial<Omit<PaintBrush, 'tip' | 'dynamics' | 'mixer' | 'behavior' | 'blender' | 'smudge' | 'wet' | 'impasto' | 'particle' | 'bristle' | 'sticker' | 'paint' | 'light' | 'fluorescence' | 'thermochromic' | 'iridescence' | 'ghost' | 'mutation' | 'ferro' | 'spray' | 'tipGrain' | 'livePatterns'>> & {
+export type PaintBrushInput = Partial<Omit<PaintBrush, 'tip' | 'dynamics' | 'mixer' | 'behavior' | 'blender' | 'smudge' | 'wet' | 'impasto' | 'particle' | 'bristle' | 'sticker' | 'antimatter' | 'paint' | 'light' | 'fluorescence' | 'thermochromic' | 'iridescence' | 'ghost' | 'mutation' | 'ferro' | 'spray' | 'tipGrain' | 'livePatterns'>> & {
     spray?: Partial<SpraySettings> | null;
     /** Tip grain (`null` removes it). */
     tipGrain?: Partial<TipGrainSettings> | null;
@@ -363,6 +366,7 @@ export type PaintBrushInput = Partial<Omit<PaintBrush, 'tip' | 'dynamics' | 'mix
     particle?: Partial<ParticleSettings>;
     bristle?: Partial<BristleSettings>;
     sticker?: Partial<StickerSettings>;
+    antimatter?: Partial<AntimatterSettings>;
 };
 /** Whether a brush can pick paint up from the canvas (the pick-up / mix ratios apply): dab, mixer and wet brushes. */
 export declare function isWetCapable(brush: Pick<PaintBrush, 'engine'>): boolean;

package/dist/paint-editor/controller.d.cts

@@ -308,6 +308,8 @@ export interface PaintStrokeInit {
     stencils?: boolean;
     /** Mask with these stencils instead (replays pass the ones recorded with the stroke). */
     maskStencils?: readonly Stencil[];
+    /** Antimatter strokes: the fuel layer ids (the visible pixel layers when painted). A replay reads fuel from exactly these and changes the editable ones, whatever is visible now. */
+    targets?: readonly string[];
 }
 export interface LayerUpdate {
     name?: string;
@@ -511,6 +513,9 @@ export declare class PaintEditorController {
     private cached;
     private session;
     private live;
+    private liveMulti;
+    private liveThickMulti;
+    private liveLightMulti;
     private liveLayers;
     private dirty;
     private seedCounter;
@@ -528,6 +533,13 @@ export declare class PaintEditorController {
     private liveEffectAt;
     /** The view's stroke layers at `effectTime`, each with the document surface it was drawn from (stale once that changes). */
     private animatedLayers;
+    /** Blast animation frames (view only), kept apart from live effect frames so neither replaces the other. */
+    private blastLayers;
+    /** Blast animation light / thick channels (`null` light: none at this frame). */
+    private animatedLight;
+    private animatedThick;
+    private activeBlastAnim;
+    private playingClock;
     /** `renderAnimationFrame` / `withEffectTime`: layer surfaces at another time, for one render. */
     private frameOverride;
     /** The area each stroke painted (document pixels; `null`: nothing), learnt as it is painted or drawn, so a stroke layer edit redraws only where it changes (see `drawLiveStrokes`). */
@@ -1860,6 +1872,17 @@ export declare class PaintEditorController {
     }): {
         stop(): void;
     };
+    /**
+     * The fuel layers of an antimatter stroke: every visible, non-temporary pixel layer (group
+     * opacity multiplied in), or on a replay exactly the recorded `targetIds` whatever their
+     * visibility now. The editable ones (not locked, stroke, sticker or effect layers) change.
+     */
+    private antimatterTargetsOf;
+    /** Applies every target layer's output from an antimatter stroke into a new document state. */
+    private applyAntimatterOutputs;
+    private startBlastAnimation;
+    private stepBlastAnimation;
+    private clearBlastAnimation;
     /**
      * Runs `fn` with the painting as it is `time` ms into its live effects (see `getAnimation`): for
      * exports at a moment. Nothing in the document changes.

package/dist/paint-editor/controller.d.ts

@@ -308,6 +308,8 @@ export interface PaintStrokeInit {
     stencils?: boolean;
     /** Mask with these stencils instead (replays pass the ones recorded with the stroke). */
     maskStencils?: readonly Stencil[];
+    /** Antimatter strokes: the fuel layer ids (the visible pixel layers when painted). A replay reads fuel from exactly these and changes the editable ones, whatever is visible now. */
+    targets?: readonly string[];
 }
 export interface LayerUpdate {
     name?: string;
@@ -511,6 +513,9 @@ export declare class PaintEditorController {
     private cached;
     private session;
     private live;
+    private liveMulti;
+    private liveThickMulti;
+    private liveLightMulti;
     private liveLayers;
     private dirty;
     private seedCounter;
@@ -528,6 +533,13 @@ export declare class PaintEditorController {
     private liveEffectAt;
     /** The view's stroke layers at `effectTime`, each with the document surface it was drawn from (stale once that changes). */
     private animatedLayers;
+    /** Blast animation frames (view only), kept apart from live effect frames so neither replaces the other. */
+    private blastLayers;
+    /** Blast animation light / thick channels (`null` light: none at this frame). */
+    private animatedLight;
+    private animatedThick;
+    private activeBlastAnim;
+    private playingClock;
     /** `renderAnimationFrame` / `withEffectTime`: layer surfaces at another time, for one render. */
     private frameOverride;
     /** The area each stroke painted (document pixels; `null`: nothing), learnt as it is painted or drawn, so a stroke layer edit redraws only where it changes (see `drawLiveStrokes`). */
@@ -1860,6 +1872,17 @@ export declare class PaintEditorController {
     }): {
         stop(): void;
     };
+    /**
+     * The fuel layers of an antimatter stroke: every visible, non-temporary pixel layer (group
+     * opacity multiplied in), or on a replay exactly the recorded `targetIds` whatever their
+     * visibility now. The editable ones (not locked, stroke, sticker or effect layers) change.
+     */
+    private antimatterTargetsOf;
+    /** Applies every target layer's output from an antimatter stroke into a new document state. */
+    private applyAntimatterOutputs;
+    private startBlastAnimation;
+    private stepBlastAnimation;
+    private clearBlastAnimation;
     /**
      * Runs `fn` with the painting as it is `time` ms into its live effects (see `getAnimation`): for
      * exports at a moment. Nothing in the document changes.