@pixerate/editor 0.99.0 → 0.101.0

package/dist/vector/index.d.cts

@@ -1,5 +1,5 @@
-import { d as Vec2$1, e as VectorSubpath, b as VectorBounds, f as VectorAnchor, V as VectorDocument, a as VectorNode, g as VectorPathNode, h as VectorAnchorType, i as VectorPaint, j as VectorGroupNode, k as VectorCornerKind, l as VectorWidthPoint, m as VectorGradientHandle, n as VectorGradient, o as VectorGradientStop, p as VectorViewport, q as VectorEffectType, r as VectorEffectParamsMap, s as VectorFillRule, t as VectorBooleanOperation, u as VectorEffect, v as VectorWarpMesh, w as VectorTransformHandle, x as VectorAnchorRef, y as VectorPathfinderOperation, z as VectorTool, A as VectorDefaults, B as VectorStyle, C as VectorHandleRef, D as VectorSegmentRef, E as VectorBlendOptions, F as VectorModifiers, c as VectorSvgExportOptions, G as VectorGradientPatch, H as VectorAlign, I as VectorDistribute, J as VectorArrange, K as VectorAverageAxis, L as VectorArrowhead, M as VectorBlendSpacing, N as VectorGradientInterpolation, O as VectorGradientSpread, P as VectorGradientType, Q as VectorStrokeAlign, R as VectorStrokeGradientMode, S as VectorRenderStrokeParts, T as VectorPaintDef, U as VectorArrowAlign, W as VectorBlend, X as VectorMergeMode, Y as VectorLineJoin } from '../svg-C9r284x8.cjs';
-export { Z as VECTOR_ARROWHEADS, _ as VECTOR_BLEND_SPACINGS, $ as VECTOR_CORNER_KINDS, a0 as VECTOR_EFFECT_TYPES, a1 as VECTOR_GRADIENT_INTERPOLATIONS, a2 as VECTOR_GRADIENT_MAX_PERIODS, a3 as VECTOR_GRADIENT_MIN_STOPS, a4 as VECTOR_GRADIENT_SPREADS, a5 as VECTOR_GRADIENT_TYPES, a6 as VECTOR_MERGE_MODES, a7 as VECTOR_PATHFINDER_OPERATIONS, a8 as VECTOR_STROKE_GRADIENT_MODES, a9 as VECTOR_TOOLS, aa as VECTOR_TRANSFORM_HANDLES, ab as VectorCorner, ac as VectorGradientPoints, ad as VectorGradientRamp, ae as VectorGradientSvgOptions, af as VectorGradientUnits, ag as VectorLineCap, ah as VectorMatrix, ai as VectorPaintSvgOptions, aj as VectorRgba, ak as VectorSvgImportOptions, al as VectorSvgPatternDef, am as VectorSvgWrapper, an as VectorWarpStyle, ao as applyVectorCornersAttribute, ap as applyVectorGradientPatch, aq as applyVectorGradientSpread, ar as convertVectorGradient, as as defaultVectorGradient, at as expandVectorGradientSpread, au as expandVectorGradientStops, av as explicitVectorGradient, aw as gradientMidpointRemap, ax as hasExplicitGradientGeometry, ay as insertVectorGradientStop, az as isCentredVectorGradient, aA as isVectorGradient, aB as mapVectorGradient, aC as mapVectorPaint, aD as moveVectorGradientHandle, aE as moveVectorGradientStop, aF as parseSvgTransform, aG as parseVectorColor, aH as parseVectorSvg, aI as patternAttrs, aJ as periodicVectorGradientStops, aK as pinVectorGradient, aL as removeVectorGradientStop, aM as reverseVectorGradient, aN as samplePlainStops, aO as sampleVectorGradient, aP as sampleVectorGradientAt, aQ as sampleVectorPaintDefAt, aR as sanitizeVectorGradient, aS as setVectorGradientVector, aT as sortedVectorGradientStops, aU as spanVectorGradientStops, aV as transformVectorGradient, aW as transformVectorPaint, aX as vectorBoxMatrix, aY as vectorCornersAttribute, aZ as vectorDocumentToSvg, a_ as vectorGradientArea, a$ as vectorGradientAspect, b0 as vectorGradientFocalParam, b1 as vectorGradientHandles, b2 as vectorGradientMatrix, b3 as vectorGradientMidpointFromPosition, b4 as vectorGradientMidpointPosition, b5 as vectorGradientNeedsExpansion, b6 as vectorGradientParam, b7 as vectorGradientPoints, b8 as vectorGradientRamp, b9 as vectorGradientSvgDefs, ba as vectorGradientTAt, bb as vectorGradientUnitsMatrix, bc as vectorPaintToSvg, bd as vectorPathLocalBounds, be as vectorStrokeSvgParts, bf as widthProfileFromAttribute, bg as widthProfileToAttribute } from '../svg-C9r284x8.cjs';
+import { d as Vec2$1, e as VectorSubpath, b as VectorBounds, f as VectorAnchor, V as VectorDocument, a as VectorNode, g as VectorPathNode, h as VectorAnchorType, i as VectorPaint, j as VectorGroupNode, k as VectorCornerKind, l as VectorWidthPoint, m as VectorGradientHandle, n as VectorGradient, o as VectorGradientStop, p as VectorViewport, q as VectorTransformHandle, r as VectorAnchorRef, s as VectorPathfinderOperation, t as VectorTool, u as VectorDefaults, v as VectorStyle, w as VectorHandleRef, x as VectorSegmentRef, y as VectorBlendOptions, z as VectorModifiers, c as VectorSvgExportOptions, A as VectorGradientPatch, B as VectorBlendMode, C as VectorFilterType, D as VectorEffectType, E as VectorEnvelopeParams, F as VectorAlign, G as VectorDistribute, H as VectorArrange, I as VectorBooleanOperation, J as VectorAverageAxis, K as VectorWarpMesh, L as VectorArrowhead, M as VectorBlendSpacing, N as VectorGradientInterpolation, O as VectorGradientSpread, P as VectorGradientType, Q as VectorStrokeAlign, R as VectorStrokeGradientMode, S as VectorFilterParamSpec, T as VectorEffectParamSpec, U as VectorRenderStrokeParts, W as VectorPaintDef, X as VectorRenderFilter, Y as VectorArrowAlign, Z as VectorEffect, _ as VectorPaintLayer, $ as VectorStrokeLayer, a0 as VectorFilter, a1 as VectorBlend, a2 as VectorMergeMode, a3 as VectorLineJoin, a4 as VectorEffectParamsMap, a5 as VectorStrokeSettings } from '../svg-Bj1MQFh6.cjs';
+export { a6 as VECTOR_ARROWHEADS, a7 as VECTOR_BLEND_MODES, a8 as VECTOR_BLEND_SPACINGS, a9 as VECTOR_CORNER_KINDS, aa as VECTOR_EFFECT_DEFAULTS, ab as VECTOR_EFFECT_LABELS, ac as VECTOR_EFFECT_PARAM_SPECS, ad as VECTOR_EFFECT_TYPES, ae as VECTOR_FILTER_DEFAULTS, af as VECTOR_FILTER_LABELS, ag as VECTOR_FILTER_MENU, ah as VECTOR_FILTER_PARAM_SPECS, ai as VECTOR_FILTER_TYPES, aj as VECTOR_GRADIENT_INTERPOLATIONS, ak as VECTOR_GRADIENT_MAX_PERIODS, al as VECTOR_GRADIENT_MIN_STOPS, am as VECTOR_GRADIENT_SPREADS, an as VECTOR_GRADIENT_TYPES, ao as VECTOR_MERGE_MODES, ap as VECTOR_PATHFINDER_OPERATIONS, aq as VECTOR_STROKE_GRADIENT_MODES, ar as VECTOR_TOOLS, as as VECTOR_TRANSFORM_HANDLES, at as VectorAppearanceShape, au as VectorBooleanOperand, av as VectorCorner, aw as VectorFillRule, ax as VectorFilterParamsMap, ay as VectorFilterPrimitive, az as VectorGradientPoints, aA as VectorGradientRamp, aB as VectorGradientSvgOptions, aC as VectorGradientUnits, aD as VectorLineCap, aE as VectorMatrix, aF as VectorPaintSvgOptions, aG as VectorRgba, aH as VectorStrokeLayerKind, aI as VectorSvgImportOptions, aJ as VectorSvgPatternDef, aK as VectorSvgWrapper, aL as VectorWarpStyle, aM as activeVectorEffects, aN as activeVectorFilters, aO as applyVectorCornersAttribute, aP as applyVectorEffects, aQ as applyVectorGradientPatch, aR as applyVectorGradientSpread, aS as clearVectorLiveBooleanCache, aT as convertVectorGradient, aU as createVectorEffect, aV as createVectorFilter, aW as defaultVectorGradient, aX as expandVectorAppearance, aY as expandVectorAppearances, aZ as expandVectorGradientSpread, a_ as expandVectorGradientStops, a$ as explicitVectorGradient, b0 as foldVectorBooleanOperands, b1 as gradientMidpointRemap, b2 as hasExplicitGradientGeometry, b3 as hasOwnVectorAppearance, b4 as hasVectorAppearance, b5 as insertVectorGradientStop, b6 as isCentredVectorGradient, b7 as isVectorFilterType, b8 as isVectorGradient, b9 as isVectorLiveBoolean, ba as mapVectorGradient, bb as mapVectorPaint, bc as moveVectorGradientHandle, bd as moveVectorGradientStop, be as normalizeVectorEffectParams, bf as normalizeVectorFilterParams, bg as parseSvgTransform, bh as parseVectorColor, bi as parseVectorSvg, bj as patternAttrs, bk as periodicVectorGradientStops, bl as pinVectorGradient, bm as removeVectorGradientStop, bn as reverseVectorGradient, bo as samplePlainStops, bp as sampleVectorGradient, bq as sampleVectorGradientAt, br as sampleVectorPaintDefAt, bs as sanitizeVectorEffects, bt as sanitizeVectorFilters, bu as sanitizeVectorGradient, bv as setVectorGradientVector, bw as sortedVectorGradientStops, bx as spanVectorGradientStops, by as transformVectorEffects, bz as transformVectorGradient, bA as transformVectorPaint, bB as vectorAppearanceNodes, bC as vectorAppearanceOutline, bD as vectorAppearanceShapes, bE as vectorBoxMatrix, bF as vectorCornersAttribute, bG as vectorDocumentToSvg, bH as vectorEffectInputBounds, bI as vectorEffectInputPaths, bJ as vectorEnteredGroups, bK as vectorEnvelopeFrame, bL as vectorEnvelopeMap, bM as vectorEnvelopeMesh, bN as vectorFilterMarkup, bO as vectorFilterParamKeys, bP as vectorFilterReach, bQ as vectorFilterSvg, bR as vectorGradientArea, bS as vectorGradientAspect, bT as vectorGradientFocalParam, bU as vectorGradientHandles, bV as vectorGradientMatrix, bW as vectorGradientMidpointFromPosition, bX as vectorGradientMidpointPosition, bY as vectorGradientNeedsExpansion, bZ as vectorGradientParam, b_ as vectorGradientPoints, b$ as vectorGradientRamp, c0 as vectorGradientSvgDefs, c1 as vectorGradientTAt, c2 as vectorGradientUnitsMatrix, c3 as vectorLiveBooleanSteps, c4 as vectorNodeEnvelope, c5 as vectorNodeFilterSvg, c6 as vectorNodeLocalPaintBounds, c7 as vectorOperandOperation, c8 as vectorPaintToSvg, c9 as vectorPathLocalBounds, ca as vectorStrokeSvgParts, cb as widthProfileFromAttribute, cc as widthProfileToAttribute } from '../svg-Bj1MQFh6.cjs';
 import { P as Point } from '../types-BFkYA4eF.cjs';
 import { a as BezierPathInput, A as AffineMatrix$1, B as BezierPath, c as BezierSegment } from '../bezier-BfwIbVTl.cjs';
 export { S as SvgGradientDef } from '../bezier-BfwIbVTl.cjs';
@@ -388,17 +388,6 @@ declare function pressureWidthProfile(samples: readonly {
     tolerance?: number;
 }): VectorWidthPoint[];
 
-/**
- * The Gradient tool's on-canvas annotator: a bar from the start (or centre) handle to the end (or
- * radius) handle with the colour stops under it and midpoint diamonds above it, plus a radial,
- * conic or diamond gradient's extent outline, aspect handle and (radial) focal point. All in
- * screen pixels, for hit-testing and the overlay.
- *
- * After vectorcraft `crates/tools/src/xform/gradient.rs` (`Annotator`: stop chips below the bar,
- * midpoints above it, a stop dragged off the bar is removed, a click on the bar adds one), ArtCraft,
- * MIT OR Apache-2.0 — see THIRD_PARTY_NOTICES.md.
- */
-
 /** Which paint of the selection the Gradient tool and the gradient editor work on. */
 type VectorGradientTarget = 'fill' | 'stroke';
 /** A part of the annotator under the pointer. */
@@ -456,9 +445,9 @@ interface VectorGradientAnnotator {
     extent: string | null;
 }
 /** The path whose `target` paint the annotator shows: the first path of the selection with a gradient there. */
-declare function vectorGradientTargetPath(doc: VectorDocument, selection: readonly string[], target: VectorGradientTarget): VectorPathNode | null;
+declare function vectorGradientTargetPath(doc: VectorDocument, selection: readonly string[], target: VectorGradientTarget, layer?: number | null): VectorPathNode | null;
 /** The annotator of the selection's gradient (`target` paint), in screen pixels, or null when it has none. */
-declare function getVectorGradientAnnotator(doc: VectorDocument, selection: readonly string[], viewport: VectorViewport, target: VectorGradientTarget): VectorGradientAnnotator | null;
+declare function getVectorGradientAnnotator(doc: VectorDocument, selection: readonly string[], viewport: VectorViewport, target: VectorGradientTarget, layer?: number | null): VectorGradientAnnotator | null;
 /** Where `p` lies relative to the bar: offset along it (0 at the start, 1 at the end) and distance towards the stop chips. */
 declare function vectorGradientBarPosition(a: Pick<VectorGradientAnnotator, 'start' | 'end' | 'normal'>, p: Vec2$1): {
     offset: number;
@@ -467,185 +456,6 @@ declare function vectorGradientBarPosition(a: Pick<VectorGradientAnnotator, 'sta
 /** The annotator part under screen point `p`: stops, then midpoints, the handles and the bar. */
 declare function hitVectorGradientAnnotator(a: VectorGradientAnnotator, p: Vec2$1): VectorGradientPart | null;
 
-/**
- * Live appearance: path effect stacks and live boolean groups, evaluated on demand while the
- * stored anchors and children stay editable.
- *
- * `expandVectorAppearance` is the one place the effected geometry is made (cached per node
- * object, so an edit recomputes only the nodes it replaced). Rendering, hit-testing, bounds,
- * snapping, booleans, the Pathfinder, the Shape Builder and SVG export all read it, the way they
- * read live corners through `subpathsToBezier`; Expand Appearance stores it.
- *
- * Stacking follows After Effects' shape layers (effectcraft `crates/render/src/shapes.rs`): an
- * effect acts on every path above it — the node's own outline, or for a group every path of its
- * children (nested groups included, as drawn by their own effects) — in the order of the stack,
- * and effects placed after a repeater act on its copies. The result paints with the style of the
- * path each shape came from; Merge Paths and live booleans paint with the bottom one's.
- *
- * Live booleans fold their operands bottom to top, each combined with the result below it by its
- * own operation or the group's, and every prefix of the fold is cached under a rolling hash of the
- * operands it covers, so editing one operand recombines only the operands from it up; the cache
- * drops its least recently used half when full. Live groups are hit by their result except while
- * they are being edited (`vectorEnteredGroups`).
- *
- * Ported from ArtCraft (MIT OR Apache-2.0, © ArtCraft Team and contributors; see
- * THIRD_PARTY_NOTICES.md): the stacking rule of effectcraft `crates/render/src/shapes.rs`
- * (`collect()`); figcraft `crates/render/src/boolean.rs` (`fold_cached`, `PathCache`) and
- * `crates/engine/src/booleans.rs` (`operand_op`, `result_outline`); and the live-object model of
- * vectorcraft `crates/doc/src/live.rs` (`expand_live`, `expanded_group`, `subtree_has_live`).
- */
-
-/** One shape of a node's appearance: a path in the node's own space, painted in `source`'s style. */
-interface VectorAppearanceShape {
-    /** The path whose style paints it. */
-    source: VectorPathNode;
-    path: BezierPath;
-    /** Opacity factor relative to the node (its own opacity not included). */
-    opacity: number;
-    /** Draw-order key (compared element by element). */
-    order: number[];
-}
-/** Default parameters of each effect type. */
-declare const VECTOR_EFFECT_DEFAULTS: {
-    readonly [K in VectorEffectType]: VectorEffectParamsMap[K];
-};
-declare const VECTOR_EFFECT_LABELS: Record<VectorEffectType, string>;
-/** How a panel edits one effect parameter. */
-type VectorEffectParamSpec = {
-    key: string;
-    label: string;
-    kind: 'number';
-    min?: number;
-    max?: number;
-    step: number;
-    slider?: boolean;
-} | {
-    key: string;
-    label: string;
-    kind: 'vec2';
-    step: number;
-} | {
-    key: string;
-    label: string;
-    kind: 'boolean';
-} | {
-    key: string;
-    label: string;
-    kind: 'select';
-    options: {
-        value: string;
-        label: string;
-    }[];
-};
-/** The editable parameters of each effect type, in panel order. */
-declare const VECTOR_EFFECT_PARAM_SPECS: Record<VectorEffectType, VectorEffectParamSpec[]>;
-/** Envelope parameters. */
-type VectorEnvelopeParams = VectorEffectParamsMap['envelope'];
-/**
- * The envelope's mesh over `bounds` (the paths' combined bounds), in the node's space: its own
- * mesh, the flat mesh of `columns × rows` patches, or a preset split exactly into that many patches.
- */
-declare function vectorEnvelopeMesh(params: VectorEnvelopeParams, bounds: VectorBounds): VectorWarpMesh;
-/** The envelope as a map of the node's space over `bounds`, or null when it changes nothing (or the box is empty). */
-declare function vectorEnvelopeMap(params: VectorEnvelopeParams, bounds: VectorBounds | null): ((p: {
-    x: number;
-    y: number;
-}) => {
-    x: number;
-    y: number;
-}) | null;
-/**
- * Effect parameters with defaults filled in and invalid values dropped (unknown keys go too).
- * Returns null for an unknown type.
- */
-declare function normalizeVectorEffectParams<K extends VectorEffectType>(type: K, params: Record<string, unknown> | null | undefined, base?: VectorEffectParamsMap[K]): VectorEffectParamsMap[K] | null;
-/** A new effect of `type` (defaults merged with `params`), or null for an unknown type. */
-declare function createVectorEffect<K extends VectorEffectType>(type: K, id: string, params?: Partial<VectorEffectParamsMap[K]> | Record<string, unknown>): Extract<VectorEffect, {
-    type: K;
-}> | null;
-/** The node's effects that take part (enabled, of a known type). */
-declare function activeVectorEffects(node: VectorNode): VectorEffect[];
-/** Whether the node itself draws differently from its stored geometry (effects or a live boolean). */
-declare function hasOwnVectorAppearance(node: VectorNode): boolean;
-/** Whether the node or anything inside it has a live appearance. */
-declare function hasVectorAppearance(node: VectorNode): boolean;
-/** A live boolean group (its children are operands). */
-declare function isVectorLiveBoolean(node: VectorNode | null | undefined): node is VectorGroupNode & {
-    liveBoolean: VectorBooleanOperation;
-};
-/** How operand `child` of a live boolean group combines with the operands below it. */
-declare function vectorOperandOperation(group: VectorGroupNode, child: VectorNode): VectorBooleanOperation;
-/** How many boolean steps (one operand combined with the result below it) live booleans have computed: what a cache miss costs. */
-declare function vectorLiveBooleanSteps(): number;
-/** Empties the live boolean prefix cache. */
-declare function clearVectorLiveBooleanCache(): void;
-/** One operand of a live boolean: its outline (group space), fill rule and operation (unused for the bottom one). */
-interface VectorBooleanOperand {
-    path: BezierPath;
-    fillRule: VectorFillRule;
-    operation: VectorBooleanOperation;
-}
-/**
- * The result of folding `operands` bottom to top, reusing the longest cached prefix: only the
- * operands above it are combined. Invalid geometry gives an empty path.
- */
-declare function foldVectorBooleanOperands(operands: readonly VectorBooleanOperand[]): BezierPath;
-/** Applies an effect stack to shapes, top to bottom (disabled effects skipped). */
-declare function applyVectorEffects(shapes: readonly VectorAppearanceShape[], effects: readonly VectorEffect[] | null | undefined): VectorAppearanceShape[];
-/** The paths entering effect `effectId` of the node's stack (those above it applied), in the node's own space. */
-declare function vectorEffectInputPaths(node: VectorNode, effectId: string): BezierPath[] | null;
-/** The box effect `effectId` (an envelope) bends: the combined bounds of the paths entering it, in the node's own space. */
-declare function vectorEffectInputBounds(node: VectorNode, effectId: string): VectorBounds | null;
-/** The node's first enabled envelope effect, or null. */
-declare function vectorNodeEnvelope(node: VectorNode | null | undefined): Extract<VectorEffect, {
-    type: 'envelope';
-}> | null;
-/**
- * The editable mesh of a node's envelope (its own mesh, or the preset or flat mesh it stands for)
- * with the box it bends, in the node's own space; null without an envelope or contents.
- */
-declare function vectorEnvelopeFrame(node: VectorNode, effectId?: string): {
-    effectId: string;
-    bounds: VectorBounds;
-    mesh: VectorWarpMesh;
-} | null;
-/**
- * What a node draws as: shapes in its own space (its `transform` and opacity not applied),
- * bottom to top, with its effects and those of everything inside it applied. Cached per node
- * object.
- */
-declare function vectorAppearanceShapes(node: VectorNode): VectorAppearanceShape[];
-/** Everything a node draws as one path in its own space (live corners cut, effects applied). */
-declare function vectorAppearanceOutline(node: VectorNode): BezierPath;
-/** What a node draws as, one plain path per shape (ids `<id>~fx<n>`, opacity relative to the node). */
-declare function vectorAppearanceNodes(node: VectorNode): VectorPathNode[];
-/**
- * The node as plain geometry: path effects and live booleans evaluated into paths (the node
- * itself when nothing inside it is live). A path keeps its id when it draws as one shape;
- * otherwise, like any live group, it becomes a group with that id holding one path per shape
- * (ids `<id>~fx<n>`). Groups without effects of their own keep their structure. Cached per node.
- */
-declare function expandVectorAppearance(node: VectorNode): VectorNode;
-/** Every node of a list expanded (the same array when nothing in it is live). */
-declare function expandVectorAppearances(nodes: readonly VectorNode[]): VectorNode[];
-/**
- * Reads effects from untrusted data (JSON, agent input): unknown types and malformed entries are
- * dropped, parameters normalized, ids made unique.
- */
-declare function sanitizeVectorEffects(value: unknown): VectorEffect[];
-/**
- * Effect parameters carried through a linear map baked into a node's geometry (scaling or
- * flipping it): offsets and positions move with it, angles turn the other way when it mirrors.
- * Lengths such as sizes and radii are kept, like stroke widths.
- */
-declare function transformVectorEffects(effects: readonly VectorEffect[], m: AffineMatrix$1, node?: VectorNode): VectorEffect[];
-/**
- * The live groups (live booleans and groups with effects) being edited: those in `ids` and those
- * holding a node in `ids`. Their children are hit and outlined as stored instead of as drawn, so
- * each operand can be picked (figcraft `crates/engine/src/booleans.rs`, `result_outline`).
- */
-declare function vectorEnteredGroups(nodes: readonly VectorNode[], ids: readonly string[]): Set<string>;
-
 /** A map of the plane (document or node space). */
 type VectorPointMap = (p: Vec2$1) => Vec2$1;
 /** Every anchor and handle of `subpaths` through `f` (no subdivision). */
@@ -1172,9 +982,11 @@ interface VectorEditorState {
     /** Options new blends get. */
     blendDefaults: VectorBlendOptions;
     /** The paint the gradient tool and gradient editor work on, and the selected stop (index into the sorted stops). */
+    /** The paint the gradient tool and editor work on: `target`, and `layer` of its stack (null: the top layer, through the shorthand). */
     gradientEdit: {
         target: VectorGradientTarget;
         stop: number | null;
+        layer: number | null;
     };
     /**
      * Free Distort mode of the selection box: dragging a corner distorts in perspective (each corner
@@ -1270,7 +1082,7 @@ interface VectorShapeInput extends VectorStyle {
     name?: string;
 }
 /** Every field of `VectorStyle`, in the order style panels and commands list them. */
-declare const VECTOR_STYLE_KEYS: readonly ["fill", "stroke", "strokeWidth", "strokeLinecap", "strokeLinejoin", "strokeDasharray", "fillRule", "strokeAlign", "startArrow", "endArrow", "arrowAlign", "startArrowScale", "endArrowScale", "strokeWidthProfile"];
+declare const VECTOR_STYLE_KEYS: readonly ["fill", "stroke", "strokeWidth", "strokeLinecap", "strokeLinejoin", "strokeDasharray", "fillRule", "strokeAlign", "startArrow", "endArrow", "arrowAlign", "startArrowScale", "endArrowScale", "strokeWidthProfile", "fills", "strokes"];
 /** Clipboard payload type written by `copy()`. */
 declare const VECTOR_CLIPBOARD_TYPE = "pixerate/vector";
 /** Screen distance of the rotation handle above the selection box. */
@@ -1593,7 +1405,7 @@ declare class VectorEditorController {
         ids?: readonly string[];
     }): VectorActionResult;
     /** Which paint (fill or stroke) the gradient tool and editor work on. */
-    setGradientTarget(target: VectorGradientTarget): void;
+    setGradientTarget(target: VectorGradientTarget, layer?: number | null): void;
     /** Selects a stop of the gradient being edited (index into its sorted stops), or none. */
     selectGradientStop(index: number | null): void;
     /** The gradient tool's annotator for the selection (screen pixels), or null when its paint is not a gradient. */
@@ -1608,6 +1420,7 @@ declare class VectorEditorController {
     setGradient(patch: VectorGradientPatch, options?: {
         ids?: readonly string[];
         target?: VectorGradientTarget;
+        layer?: number | null;
         label?: string;
         merge?: string;
     }): VectorActionResult;
@@ -1701,6 +1514,75 @@ declare class VectorEditorController {
     outlineStroke(options?: {
         ids?: readonly string[];
     }): string[];
+    /** Paths of the selected (or given) nodes whose stacks can be edited (groups give every path inside; blend steps are left out). */
+    private stackTargets;
+    /** Applies `fn` to the `kind` stack of every target path as one undo step (an error string from any path cancels it). */
+    private editStacks;
+    /**
+     * Reads a layer patch from untrusted input: paint, opacity, blend mode, visibility and (strokes)
+     * the stroke settings, where `null` removes a setting. Returns an error string for invalid values.
+     */
+    private layerPatch;
+    /**
+     * Adds a fill or stroke layer to the selected (or given) paths (groups: every path inside), at
+     * the top of the stack or at `index` (0 is the bottom). A new stroke takes the settings of the
+     * stack's top stroke unless `layer` gives them. One undo step.
+     */
+    addPaintLayer(kind: 'fill' | 'stroke', layer?: Record<string, unknown>, options?: {
+        ids?: readonly string[];
+        index?: number;
+    }): VectorActionResult;
+    /**
+     * Changes layer `index` (0 is the bottom) of the fill or stroke stack of the selected (or given)
+     * paths: paint, opacity, blend mode, visibility and, for strokes, any stroke setting (`null`
+     * removes it). Fails, changing nothing, when a path has no layer `index`. With `merge` (true, or
+     * a key), consecutive edits of the layer fold into one undo step (a slider drag).
+     */
+    updatePaintLayer(kind: 'fill' | 'stroke', index: number, patch: Record<string, unknown>, options?: {
+        ids?: readonly string[];
+        merge?: boolean | string;
+    }): VectorActionResult;
+    /** Removes layer `index` of the fill or stroke stack of the selected (or given) paths. */
+    removePaintLayer(kind: 'fill' | 'stroke', index: number, options?: {
+        ids?: readonly string[];
+    }): VectorActionResult;
+    /** Moves layer `from` of the fill or stroke stack to position `to` (0 is the bottom) on the selected (or given) paths. */
+    movePaintLayer(kind: 'fill' | 'stroke', from: number, to: number, options?: {
+        ids?: readonly string[];
+    }): VectorActionResult;
+    /** Replaces the whole fill or stroke stack of the selected (or given) paths (malformed layers are dropped). */
+    setPaintLayers(kind: 'fill' | 'stroke', layers: readonly unknown[], options?: {
+        ids?: readonly string[];
+    }): VectorActionResult;
+    /** Sets the blend mode of the selected (or given) nodes (paths or groups); `normal` removes it. */
+    setBlendMode(mode: VectorBlendMode, options?: {
+        ids?: readonly string[];
+    }): VectorActionResult;
+    /**
+     * Adds a filter of `type` to the selected (or given) nodes, at the end of each stack (or at
+     * `index`), with default parameters merged with `params`. One undo step; returns the new filter
+     * ids (one per node, in order), empty for an unknown type or nothing selected.
+     */
+    addFilter(type: VectorFilterType, options?: {
+        ids?: readonly string[];
+        params?: Record<string, unknown>;
+        index?: number;
+    }): string[];
+    private editFilters;
+    /**
+     * Turns a filter on or off and changes its parameters (invalid values are ignored). With
+     * `merge`, consecutive updates of the same filter fold into one undo step.
+     */
+    updateFilter(nodeId: string, filterId: string, patch: {
+        enabled?: boolean;
+        params?: Record<string, unknown>;
+    }, options?: {
+        merge?: boolean | string;
+    }): VectorActionResult;
+    /** Removes a filter from a node's stack. */
+    removeFilter(nodeId: string, filterId: string): VectorActionResult;
+    /** Moves a filter to position `index` of its node's stack. */
+    moveFilter(nodeId: string, filterId: string, index: number): VectorActionResult;
     /** Selected (or given) nodes that can carry effects: the roots of the selection. */
     private effectTargets;
     /**
@@ -2246,6 +2128,37 @@ interface VectorRenderPath {
      * `stroke`; group them under `id`, `transform` and `opacity`.
      */
     strokeParts?: VectorRenderStrokeParts;
+    /**
+     * Set when the path paints through its fill and stroke stacks (several layers, or a layer with
+     * its own opacity, blend mode or visibility): draw a `<g>` with `id`, `transform`, `opacity`,
+     * `blendMode` and `filter`, holding each layer in order, bottom to top, as a path of `d` (see
+     * `VectorRenderPaintLayer`). `fill`, `stroke` and `strokeParts` above then describe the top
+     * drawn layers only, for readers that draw one paint.
+     */
+    layers?: VectorRenderPaintLayer[];
+    /** CSS `mix-blend-mode` of the whole node (absent: normal). */
+    blendMode?: string;
+    /** `url(#id)` of the node's filter in `filters` (shadows, glows, blurs, feather). */
+    filter?: string;
+}
+/**
+ * One drawn layer of a path's paint stack: a fill (`fill` set, `stroke` none) or a stroke with its
+ * own settings and parts (`strokeParts` as on `VectorRenderPath`). Draw it with `opacity` and
+ * `mix-blend-mode: blendMode` on its element (or on the group of its parts).
+ */
+interface VectorRenderPaintLayer {
+    kind: 'fill' | 'stroke';
+    /** Index in its stack (bottom to top). */
+    index: number;
+    fill: string;
+    stroke: string;
+    strokeWidth: number;
+    strokeLinecap?: string;
+    strokeLinejoin?: string;
+    strokeDasharray?: string;
+    opacity: number;
+    blendMode?: string;
+    strokeParts?: VectorRenderStrokeParts;
 }
 interface VectorRenderGroup {
     kind: 'group';
@@ -2253,6 +2166,10 @@ interface VectorRenderGroup {
     /** SVG `transform` (`matrix(…)`) for a rotated group. */
     transform?: string;
     opacity: number;
+    /** CSS `mix-blend-mode` of the group (absent: normal). */
+    blendMode?: string;
+    /** `url(#id)` of the group's filter in `filters`. */
+    filter?: string;
     children: VectorRenderNode[];
 }
 type VectorRenderNode = VectorRenderPath | VectorRenderGroup;
@@ -2268,6 +2185,8 @@ interface VectorSceneRenderData {
      * draw each of `gradients`, then each tile filled, inside a `<pattern>`).
      */
     defs: VectorPaintDef[];
+    /** Filters referenced by nodes' `filter` (draw each as an SVG `<filter>`, see `VectorRenderFilter`). */
+    filters: VectorRenderFilter[];
     /** Visible nodes, bottom to top. */
     nodes: VectorRenderNode[];
 }
@@ -2710,6 +2629,8 @@ declare const VECTOR_STROKE_GRADIENT_MODE_LABELS: Readonly<Record<VectorStrokeGr
 /** What a gradient editor shows for the selection's `target` paint (see `getVectorGradientEditor`). */
 interface VectorGradientEditorData {
     target: 'fill' | 'stroke';
+    /** The layer of the `target` stack edited (null: the top one). */
+    layer: number | null;
     /** The first selected path's paint is a gradient. */
     gradient: VectorGradient | null;
     /** The paint as a `#rrggbb` colour when it is one (what a new gradient starts from). */
@@ -2792,6 +2713,65 @@ declare const VECTOR_EFFECT_MENU: readonly {
 }[];
 /** The Effects panel of the selection, or null when nothing that takes effects is selected. */
 declare function getVectorEffectsPanel(state: Pick<VectorEditorState, 'document' | 'selection'>): VectorEffectsPanelData | null;
+/** One fill or stroke layer as an appearance panel lists it. */
+interface VectorAppearancePanelLayer {
+    kind: 'fill' | 'stroke';
+    /** Index in its stack (0 is the bottom); what `updatePaintLayer` and friends take. */
+    index: number;
+    paint: VectorPaint;
+    /** The paint as `#rrggbb` when it is one (for a colour input). */
+    color: string | null;
+    /** A CSS `background` showing the paint (a colour, or the gradient's ramp). */
+    swatch: string;
+    gradient: boolean;
+    opacity: number;
+    blendMode: VectorBlendMode;
+    visible: boolean;
+    /** Stroke layers: width and alignment (for the compact row). */
+    strokeWidth?: number;
+    strokeAlign?: VectorStrokeAlign;
+    /** A stroke of a kind this version cannot draw (kept, shown read-only). */
+    unknownKind?: string;
+    /** The gradient editor and tool work on this layer. */
+    editing: boolean;
+}
+/** What an appearance panel shows for the selection. */
+interface VectorAppearancePanelData {
+    /** Selected nodes (blend mode and filters apply to them). */
+    nodeIds: string[];
+    /** Paths the stacks belong to (groups give every path inside); the first one's stacks are listed. */
+    pathIds: string[];
+    fills: VectorAppearancePanelLayer[];
+    strokes: VectorAppearancePanelLayer[];
+    /** The first selected node's blend mode. */
+    blendMode: VectorBlendMode;
+    mixed: {
+        fills: boolean;
+        strokes: boolean;
+        blendMode: boolean;
+    };
+    /** The filter stack, listed when one node is selected (`filterNodeId`). */
+    filterNodeId: string | null;
+    filters: VectorFiltersPanelItem[];
+}
+/** One filter of the listed stack, with what a panel needs to edit it. */
+interface VectorFiltersPanelItem {
+    id: string;
+    type: VectorFilterType;
+    label: string;
+    enabled: boolean;
+    params: Record<string, unknown>;
+    specs: readonly VectorFilterParamSpec[];
+}
+/** A CSS background for a paint: the colour, or a left-to-right ramp of a gradient's stops. */
+declare function vectorPaintSwatch(paint: VectorPaint | undefined): string;
+/** The appearance panel of the selection, or null with nothing selected. */
+declare function getVectorAppearancePanel(state: Pick<VectorEditorState, 'document' | 'selection' | 'gradientEdit'>): VectorAppearancePanelData | null;
+/** Blend modes in menu order, with their names. */
+declare const VECTOR_BLEND_MODE_MENU: readonly {
+    mode: VectorBlendMode;
+    label: string;
+}[];
 
 interface VectorCommandOptions {
     /** Id prefix (default `vector.`); use one per editor when several are registered. */
@@ -2843,6 +2823,14 @@ interface VectorNodeListing {
     liveBoolean?: VectorBooleanOperation;
     /** An operand's own operation in a live boolean group. */
     booleanOperation?: VectorBooleanOperation;
+    /** The fill stack, bottom to top, when the path has more than its `fill` says. */
+    fills?: VectorPaintLayer[];
+    /** The stroke stack, bottom to top, when the path has more than its `stroke` says. */
+    strokes?: VectorStrokeLayer[];
+    /** The node's blend mode, when not normal. */
+    blendMode?: VectorBlendMode;
+    /** The node's visual filters (shadows, glows, blurs, feather). */
+    filters?: VectorFilter[];
 }
 /**
  * Palette and agent commands for a vector editor: list, select, add shapes and paths, style,
@@ -3641,4 +3629,121 @@ declare function vectorMeshFromOutline(sp: VectorSubpath, columns?: number, rows
 /** The mesh's border as one closed subpath (clockwise from the top-left corner): what Release gives back as the envelope's shape. */
 declare function vectorMeshOutline(m: VectorWarpMesh): VectorSubpath;
 
-export { type AddVectorNodeOptions, AffineMatrix$1 as AffineMatrix, DEFAULT_VECTOR_BLEND_DISTANCE, DEFAULT_VECTOR_BLEND_STEPS, DEFAULT_VECTOR_PATH_EDIT, DEFAULT_VECTOR_SNAP, IDENTITY_MATRIX, KAPPA, LazyMouse, type MapVectorSubpathsOptions, type NearestSegment, type RecognizeInkOptions, VECTOR_ARROWHEAD_LABELS, VECTOR_BLEND_MAX_SMOOTH_STEPS, VECTOR_BLEND_MAX_STEPS, VECTOR_BLEND_SPACING_LABELS, VECTOR_BUILDER_HATCH_GAP, VECTOR_CLIPBOARD_TYPE, VECTOR_CONSTRUCTION_ANGLES, VECTOR_CORNER_KIND_LABELS, VECTOR_CORNER_WIDGET_INSET, VECTOR_DISTORT_TOLERANCE, VECTOR_EDIT_TOGGLES, VECTOR_EFFECT_DEFAULTS, VECTOR_EFFECT_LABELS, VECTOR_EFFECT_MENU, VECTOR_EFFECT_PARAM_SPECS, VECTOR_ENVELOPE_STYLE_OPTIONS, VECTOR_FILL_GAP, VECTOR_GRADIENT_INTERPOLATION_LABELS, VECTOR_GRADIENT_MIDPOINT_GAP, VECTOR_GRADIENT_OFF_BAR, VECTOR_GRADIENT_SPREAD_LABELS, VECTOR_GRADIENT_STOP_GAP, VECTOR_GRADIENT_TYPE_LABELS, VECTOR_INK_MAX_CORNERS, VECTOR_OVERLAY_THEME, VECTOR_PATHFINDER_ACTIONS, VECTOR_PATHFINDER_LABELS, VECTOR_PATH_ACTIONS, VECTOR_PENCIL_STRING_PX, VECTOR_PRESSURE_NOMINAL, VECTOR_ROTATE_HANDLE_OFFSET, VECTOR_STROKE_ALIGN_LABELS, VECTOR_STROKE_GRADIENT_MODE_LABELS, VECTOR_STYLE_KEYS, VECTOR_TOOL_GLYPHS, VECTOR_TOOL_SHORTCUTS, VECTOR_WIDTH_PRESETS, VECTOR_WIDTH_PRESET_IDS, VECTOR_WIDTH_PROFILE_MAX_POINTS, VECTOR_WIDTH_PROFILE_MAX_SCALE, VECTOR_WIDTH_SAME_T, type VariableStrokeOptions, Vec2$1 as Vec2, type VectorActionResult, VectorAlign, VectorAnchor, VectorAnchorRef, VectorAnchorType, type VectorAppearanceShape, VectorArrange, VectorArrowAlign, VectorArrowhead, type VectorArrowheadShape, VectorAverageAxis, VectorBlend, type VectorBlendControls, type VectorBlendInput, VectorBlendOptions, type VectorBlendRail, VectorBlendSpacing, type VectorBlendStart, type VectorBooleanOperand, VectorBooleanOperation, VectorBounds, type VectorBuilderHit, type VectorBuilderLinePiece, type VectorBuilderPreview, type VectorBuilderReplacement, type VectorBuilderTouched, type VectorCommandOptions, type VectorCornerInfo, VectorCornerKind, type VectorCornerWidget, VectorDefaults, type VectorDistortMode, VectorDistribute, VectorDocument, VectorEditorController, type VectorEditorOptions, type VectorEditorState, VectorEffect, type VectorEffectParamSpec, VectorEffectParamsMap, VectorEffectType, type VectorEffectsPanelData, type VectorEffectsPanelItem, type VectorEnvelopePanelData, type VectorEnvelopeParams, VectorFillRule, VectorGradient, type VectorGradientAnnotator, type VectorGradientEditorData, VectorGradientHandle, VectorGradientInterpolation, type VectorGradientPart, VectorGradientPatch, VectorGradientSpread, VectorGradientStop, type VectorGradientTarget, VectorGradientType, VectorGroupNode, type VectorGuideKind, type VectorGuideLabel, type VectorGuideLine, VectorHandleRef, type VectorHitTestOptions, type VectorHover, type VectorInkShape, type VectorInteraction, type VectorKeyInput, VectorLineJoin, VectorMergeMode, VectorModifiers, type VectorMorph, type VectorMorphContour, type VectorMorphCorrespondence, type VectorMorphOptions, VectorNode, type VectorNodeListing, type VectorOverlayRenderData, VectorPaint, VectorPaintDef, type VectorPathAction, type VectorPathEditOptions, type VectorPathEntry, type VectorPathKeyframe, VectorPathNode, type VectorPathfinderAction, VectorPathfinderOperation, type VectorPathfinderPaint, type VectorPointMap, type VectorPointSnap, type VectorPointerInput, type VectorRectSnap, type VectorRenderAnchor, type VectorRenderCornerWidget, type VectorRenderGradientAnnotator, type VectorRenderGroup, type VectorRenderGuideLabel, type VectorRenderGuideLine, type VectorRenderHandle, type VectorRenderNode, type VectorRenderPath, VectorRenderStrokeParts, type VectorRenderWidthPoint, type VectorRepeaterCopy, type VectorScaleSnap, type VectorSceneRenderData, VectorSegmentRef, type VectorSelectionBoxGeometry, type VectorSelectionFrame, type VectorSelectionStyle, type VectorShapeBuilderFace, type VectorShapeBuilderMap, type VectorShapeBuilderPlan, type VectorShapeBuilderResult, type VectorShapeInput, type VectorSnapGuides, type VectorSnapKind, type VectorSnapLeave, type VectorSnapOptions, VectorSnapTargets, VectorStrokeAlign, VectorStrokeGradientMode, type VectorStrokeParts, type VectorStrokeSpot, VectorStyle, VectorSubpath, VectorSvgExportOptions, type VectorTaperOptions, VectorTool, VectorTransformHandle, VectorViewport, VectorWarpMesh, type VectorWaveOptions, type VectorWidthHandle, VectorWidthPoint, type VectorWidthPointEdit, type VectorWidthPointRef, type VectorWidthPreset, type VectorWidthPresetInfo, activeVectorEffects, addBuilderHit, applyMatrix, applyMatrixLinear, applyVectorBlendOptions, applyVectorEffects, arrowheadInset, arrowheadPath, arrowheadWeight, bendSegment, bezierToSubpaths, boundsFromPoints, boundsIntersect, clearVectorLiveBooleanCache, cloneAnchor, cloneSubpath, cloneVectorDocument, cloneVectorNode, collectPathNodes, constrainToLeave, convertAnchor, cornerBisectorPoint, cornerRadiusChange, cornerSetback, correspondMorphContours, createVectorCommands, createVectorEffect, createVectorMorph, curvatureMoveAnchor, cutSubpathAt, dashIntervals, decomposeRigid, distortVectorNode, effectPathLength, effectPathVertexCount, effectiveStrokeAlign, ellipseSubpath, eraseFromFill, eraseFromOutline, eraserRegion, evaluateVectorPathKeyframes, expandVectorAppearance, expandVectorAppearances, expandVectorBlend, expandVectorCorners, expandVectorCornersOf, findVectorNode, fitCornerRadius, foldVectorBooleanOperands, generateVectorBlendChildren, generateWidthProfile, getAnchor, getAnchorWorld, getEditablePathIds, getTransformHandlePositions, getVectorBlendControls, getVectorCornerWidgets, getVectorEffectsPanel, getVectorEnteredGroups, getVectorEnvelopePanel, getVectorEnvelopeTarget, getVectorGradientAnnotator, getVectorGradientEditor, getVectorOverlayRenderData, getVectorSceneRenderData, getVectorSelectionBoxGeometry, getVectorSelectionFrame, getVectorSelectionStyle, getVectorWidthHandles, getVisibleAnchors, getVisibleHandles, hasOwnVectorAppearance, hasPaint, hasStrokeExtras, hasVectorAppearance, hasVectorCorners, hitTestVectorNode, hitTestVectorNodes, hitTestVectorStroke, hitVectorGradientAnnotator, inferAnchorType, insertAnchor, insertWidthPoint, interpolateMorphContours, interpolateRigidMatrix, interpolateVectorColor, interpolateVectorPaint, interpolateVectorPaths, interpolateVectorStyle, interpolateWidthProfiles, invertMatrix, isClosedBezierShape, isIdentityMatrix, isUniformWidthProfile, isVectorBlendGroup, isVectorLiveBoolean, isVectorTextTarget, joinSubpaths, knifePath, lineSubpath, locateVectorNode, mapBezierPath, mapVectorPoints, mapVectorSubpaths, matrixRotation, mergePaths, mirrorWidthProfile, morphContourToSubpath, morphPathsCross, moveAnchorHandle, multiplyMatrices, nearestSegment, nearestStrokePosition, nextVectorCornerKind, nodeMatrix, normalizeVectorEffectParams, offsetPaths, pathsCenter, planShapeBuilder, polygonSubpath, polylineBounds, pressureWidthProfile, puckerBloatPaths, recognizeInkShape, rectSubpath, refineMorphContour, refreshVectorBlends, releaseVectorBlend, removeAnchorKeepingShape, removeAnchors, removeAnchorsKeepingShape, removeRedundantPoints, removeWidthPoints, repeatPaths, resampleGradientStops, resolveVectorBlendOptions, reverseMorphContour, reverseSubpath, reverseWidthProfile, rotateMatrix, roundCornerPaths, roundSubpaths, samplePolyline, sanitizeVectorEffects, sanitizeWidthProfile, scaleFor, scaleMatrix, setAnchorCorner, setSubpathCorners, setWidthPoint, simplifyPolyline, smoothSubpath, splitIntoFaces, splitSubpathAt, starSubpath, strokePositionPoint, strokeWidthProfileOf, subpathEnclosesArea, subpathPointAt, subpathSegment, subpathSegmentCount, subpathToMorphContour, subpathsToBezier, taperWaveFactor, toVectorKeyInput, toVectorModifiers, toVectorPointerInput, transformVectorEffects, transformVectorNode, translateAnchor, translateMatrix, trimIntervals, trimPaths, trimPathsIndividually, turnMorphContour, twistPaths, unionBounds, variableStrokeOutline, variableStrokeRings, vectorAppearanceNodes, vectorAppearanceOutline, vectorAppearanceShapes, vectorBlendColorDistance, vectorBlendKeyTargets, vectorBlendKeys, vectorBlendRail, vectorBlendRailAt, vectorBlendSpine, vectorBlendStepCount, vectorBoxCorners, vectorBuilderErasedEdges, vectorCornerAt, vectorCorners, vectorDiamondPath, vectorDistortQuad, vectorEffectInputBounds, vectorEffectInputPaths, vectorEnteredGroups, vectorEnvelopeFrame, vectorEnvelopeMap, vectorEnvelopeMesh, vectorFillMap, vectorGradientBarPosition, vectorGradientTargetPath, vectorInkShapeName, vectorLiveBooleanSteps, vectorMeshFromOutline, vectorMeshOutline, vectorNodeBounds, vectorNodeEnvelope, vectorNodeRotation, vectorNodeToBezier, vectorOperandOperation, vectorPaintToHex, vectorParentMatrix, vectorPathData, vectorPathEntries, vectorPathWorldBezier, vectorPathfinderShape, vectorRepeaterCopies, vectorResizeCursor, vectorResultStyle, vectorShapeBuilderHit, vectorShapeBuilderMap, vectorShearForSide, vectorSkewMatrix, vectorStrokeGradientDefs, vectorStrokeLineArea, vectorStrokeOutline, vectorStrokeOutlinePath, vectorStrokeParts, vectorStrokeReach, vectorStrokeWidthGeometry, vectorToolLabel, vectorWorldMatrix, walkVectorNodes, widthProfileAt, widthProfileMaxScale, widthProfilePreset, widthProfilePresetId, wigglePaths, zigzagPaths };
+/**
+ * Fill and stroke stacks: several paints per path, each with its own opacity, blend mode and
+ * visibility, and each stroke with its own width, alignment, dashes, arrowheads and profile.
+ *
+ * The stacks live in `fills` / `strokes`, bottom to top; fills draw under strokes. The single
+ * `fill` / `stroke` fields (and the stroke settings) stay as shorthands that mirror the top layer
+ * of each stack, so everything written against one fill and one stroke — booleans, blends, the
+ * gradient tool, agent commands, old documents — keeps working:
+ *
+ * - A node without `fills` has the one-layer stack its `fill` says (none without a paint); the
+ *   same for strokes. Stacks of one plain layer are stored that way, so old documents and simple
+ *   nodes look exactly as before.
+ * - `normalizeVectorPaintStacks` reconciles the two forms. Loading prefers the stacks (the
+ *   shorthand is re-derived); editing prefers the shorthand: a node whose `fill` no longer matches
+ *   its top fill was written by shorthand code, so the top layer takes the new paint (`null`
+ *   clears the stack). The controller runs it after every change.
+ *
+ * Paint layers are drawn, hit-tested and exported through `vectorPaintLayerNodes`: one plain path
+ * node per layer (the node with only that fill, or only that stroke and its settings), so the
+ * existing paint, stroke-part and gradient code serves each layer unchanged.
+ *
+ * The data model follows figcraft `crates/color/src/lib.rs` (`Paint { kind, opacity, visible,
+ * blend }` in a list per node) and vectorcraft `crates/doc/src/appearance.rs` (`FillLayer` /
+ * `StrokeLayer`, each stroke with its own settings). Ported from ArtCraft (MIT OR Apache-2.0,
+ * © ArtCraft Team and contributors; see THIRD_PARTY_NOTICES.md).
+ */
+
+/** The stroke settings each stroke layer has of its own, in `VectorStyle` field names. */
+declare const VECTOR_STROKE_SETTING_KEYS: readonly (keyof VectorStrokeSettings)[];
+declare const VECTOR_BLEND_MODE_LABELS: Readonly<Record<VectorBlendMode, string>>;
+declare function isVectorBlendMode(value: unknown): value is VectorBlendMode;
+/** A blend mode as a CSS `mix-blend-mode` value, or undefined for `normal` (nothing to write). */
+declare function vectorBlendModeCss(mode: VectorBlendMode | null | undefined): string | undefined;
+/** A CSS `mix-blend-mode` value back to a blend mode (`plus-lighter` is `linear-dodge`), or null when SVG offers it but we don't. */
+declare function vectorBlendModeFromCss(value: string | null | undefined): VectorBlendMode | null;
+/** A layer with full opacity, `normal` blending, visible and (strokes) a plain paint: what the shorthand alone can say. */
+declare function isPlainVectorPaintLayer(layer: VectorPaintLayer | VectorStrokeLayer): boolean;
+/** Whether a layer is drawn: visible, a plain paint (strokes), a paint that draws something, above zero opacity. */
+declare function isDrawnVectorPaintLayer(layer: VectorPaintLayer | VectorStrokeLayer): boolean;
+/** The fill stack of a path (or style), bottom to top: `fills`, or the one layer `fill` makes. */
+declare function vectorFills(style: VectorStyle): VectorPaintLayer[];
+/** The stroke settings a style gives its shorthand stroke (only those set). */
+declare function vectorStrokeSettings(style: VectorStyle): VectorStrokeSettings;
+/** The stroke stack of a path (or style), bottom to top: `strokes`, or the one layer `stroke` and the stroke settings make. */
+declare function vectorStrokes(style: VectorStyle): VectorStrokeLayer[];
+/** Whether a style stores a stack (more than its shorthand can say). */
+declare function hasVectorPaintStacks(style: VectorStyle): boolean;
+/** The node with `fills` as its fill stack, stored canonically (see the module comment). */
+declare function withVectorFills<T extends VectorStyle>(node: T, fills: readonly VectorPaintLayer[]): T;
+/** The node with `strokes` as its stroke stack, stored canonically; the shorthand mirrors the top layer. */
+declare function withVectorStrokes<T extends VectorStyle>(node: T, strokes: readonly VectorStrokeLayer[]): T;
+/**
+ * A node with its stacks and shorthands reconciled and stored canonically (the same object when
+ * they already are). `prefer: 'stack'` (loading) re-derives the shorthand from the stacks;
+ * `'shorthand'` (after an edit, the default) reads a shorthand that disagrees with its stack's
+ * top layer as an edit of that layer: a paint repaints it, a stroke setting changes it, `null`
+ * clears the stack.
+ */
+declare function normalizeVectorPaintStacks<T extends VectorStyle>(node: T, prefer?: 'stack' | 'shorthand'): T;
+/** Reads a fill stack from untrusted data (JSON, agent input, SVG): malformed layers are dropped. */
+declare function sanitizeVectorFills(value: unknown): VectorPaintLayer[];
+/** Stroke settings from untrusted data: wrong types and out-of-range values are dropped. */
+declare function sanitizeVectorStrokeSettings(raw: Record<string, unknown>): VectorStrokeSettings;
+/**
+ * Reads a stroke stack from untrusted data. Layers of a kind this version does not know are kept
+ * as they are (a later version's brushstroke, say), so a round trip does not lose them.
+ */
+declare function sanitizeVectorStrokes(value: unknown): VectorStrokeLayer[];
+/** One layer of a path's paint as a plain path node (see `vectorPaintLayerNodes`). */
+interface VectorPaintLayerNode {
+    kind: 'fill' | 'stroke';
+    /** Index in its stack, bottom to top. */
+    index: number;
+    layer: VectorPaintLayer | VectorStrokeLayer;
+    /** The path with only this fill, or only this stroke and its settings (no stacks). */
+    node: VectorPathNode;
+    /** Visible, a plain paint, painting something, above zero opacity. */
+    drawn: boolean;
+}
+/**
+ * Every fill then every stroke of a path, bottom to top, each as the path painted by that layer
+ * alone. Cached per node object (and the layer nodes are the same objects while it is), so the
+ * paint and stroke-part caches keyed by node keep working per layer.
+ */
+declare function vectorPaintLayerNodes(node: VectorPathNode): VectorPaintLayerNode[];
+/** Whether a path draws through its stacks rather than one fill and one stroke (several layers, or one with its own opacity, blend or visibility). */
+declare function needsVectorPaintLayers(node: VectorPathNode): boolean;
+/** How far the drawn strokes of a path reach past its outline (the widest layer's reach; 0 without strokes). */
+declare function vectorStrokeStackReach(node: VectorPathNode): number;
+/** The layer a point hits (see `hitTestVectorPaintLayer`). */
+interface VectorPaintLayerHit {
+    kind: 'fill' | 'stroke';
+    index: number;
+}
+/**
+ * The topmost drawn layer of a path that `p` hits, or null: strokes top to bottom (their
+ * alignment, arrowheads and profiles respected, `tolerance` added), then fills. `path` is the
+ * node's outline in the same space as `p` (`vectorPathWorldBezier`).
+ */
+declare function hitTestVectorPaintLayer(node: VectorPathNode, path: BezierPath, p: Vec2$1, tolerance?: number): VectorPaintLayerHit | null;
+/**
+ * Whether `p` hits a path as drawn by its stacks: on a drawn layer, or, when it draws no stroke,
+ * within `tolerance` of its outline (so unpainted paths stay pickable).
+ */
+declare function hitTestVectorPaintStack(node: VectorPathNode, path: BezierPath, p: Vec2$1, tolerance?: number): boolean;
+/** Whether a fill or stroke stack holds a gradient anywhere (for transforms that move gradients). */
+declare function vectorStacksHaveGradient(style: VectorStyle): boolean;
+/** Defaults of a new layer added to a stack (a stroke takes the settings of the stack's top stroke). */
+declare function newVectorStrokeLayer(node: VectorStyle, patch?: Partial<VectorStrokeLayer>): VectorStrokeLayer;
+/**
+ * The paint the gradient tool and editor work on: layer `layer` of the fill or stroke stack, or
+ * (null, or an index the stack doesn't have) the shorthand, which is the top layer.
+ */
+declare function vectorTargetPaint(style: VectorStyle, target: 'fill' | 'stroke', layer?: number | null): VectorPaint | undefined;
+/** The node with `paint` in the place `vectorTargetPaint` reads (stored canonically). */
+declare function withVectorTargetPaint<T extends VectorStyle>(node: T, target: 'fill' | 'stroke', layer: number | null, paint: VectorPaint): T;
+
+export { type AddVectorNodeOptions, AffineMatrix$1 as AffineMatrix, DEFAULT_VECTOR_BLEND_DISTANCE, DEFAULT_VECTOR_BLEND_STEPS, DEFAULT_VECTOR_PATH_EDIT, DEFAULT_VECTOR_SNAP, IDENTITY_MATRIX, KAPPA, LazyMouse, type MapVectorSubpathsOptions, type NearestSegment, type RecognizeInkOptions, VECTOR_ARROWHEAD_LABELS, VECTOR_BLEND_MAX_SMOOTH_STEPS, VECTOR_BLEND_MAX_STEPS, VECTOR_BLEND_MODE_LABELS, VECTOR_BLEND_MODE_MENU, VECTOR_BLEND_SPACING_LABELS, VECTOR_BUILDER_HATCH_GAP, VECTOR_CLIPBOARD_TYPE, VECTOR_CONSTRUCTION_ANGLES, VECTOR_CORNER_KIND_LABELS, VECTOR_CORNER_WIDGET_INSET, VECTOR_DISTORT_TOLERANCE, VECTOR_EDIT_TOGGLES, VECTOR_EFFECT_MENU, VECTOR_ENVELOPE_STYLE_OPTIONS, VECTOR_FILL_GAP, VECTOR_GRADIENT_INTERPOLATION_LABELS, VECTOR_GRADIENT_MIDPOINT_GAP, VECTOR_GRADIENT_OFF_BAR, VECTOR_GRADIENT_SPREAD_LABELS, VECTOR_GRADIENT_STOP_GAP, VECTOR_GRADIENT_TYPE_LABELS, VECTOR_INK_MAX_CORNERS, VECTOR_OVERLAY_THEME, VECTOR_PATHFINDER_ACTIONS, VECTOR_PATHFINDER_LABELS, VECTOR_PATH_ACTIONS, VECTOR_PENCIL_STRING_PX, VECTOR_PRESSURE_NOMINAL, VECTOR_ROTATE_HANDLE_OFFSET, VECTOR_STROKE_ALIGN_LABELS, VECTOR_STROKE_GRADIENT_MODE_LABELS, VECTOR_STROKE_SETTING_KEYS, VECTOR_STYLE_KEYS, VECTOR_TOOL_GLYPHS, VECTOR_TOOL_SHORTCUTS, VECTOR_WIDTH_PRESETS, VECTOR_WIDTH_PRESET_IDS, VECTOR_WIDTH_PROFILE_MAX_POINTS, VECTOR_WIDTH_PROFILE_MAX_SCALE, VECTOR_WIDTH_SAME_T, type VariableStrokeOptions, Vec2$1 as Vec2, type VectorActionResult, VectorAlign, VectorAnchor, VectorAnchorRef, VectorAnchorType, type VectorAppearancePanelData, type VectorAppearancePanelLayer, VectorArrange, VectorArrowAlign, VectorArrowhead, type VectorArrowheadShape, VectorAverageAxis, VectorBlend, type VectorBlendControls, type VectorBlendInput, VectorBlendMode, VectorBlendOptions, type VectorBlendRail, VectorBlendSpacing, type VectorBlendStart, VectorBooleanOperation, VectorBounds, type VectorBuilderHit, type VectorBuilderLinePiece, type VectorBuilderPreview, type VectorBuilderReplacement, type VectorBuilderTouched, type VectorCommandOptions, type VectorCornerInfo, VectorCornerKind, type VectorCornerWidget, VectorDefaults, type VectorDistortMode, VectorDistribute, VectorDocument, VectorEditorController, type VectorEditorOptions, type VectorEditorState, VectorEffect, VectorEffectParamSpec, VectorEffectParamsMap, VectorEffectType, type VectorEffectsPanelData, type VectorEffectsPanelItem, type VectorEnvelopePanelData, VectorEnvelopeParams, VectorFilter, VectorFilterParamSpec, VectorFilterType, type VectorFiltersPanelItem, VectorGradient, type VectorGradientAnnotator, type VectorGradientEditorData, VectorGradientHandle, VectorGradientInterpolation, type VectorGradientPart, VectorGradientPatch, VectorGradientSpread, VectorGradientStop, type VectorGradientTarget, VectorGradientType, VectorGroupNode, type VectorGuideKind, type VectorGuideLabel, type VectorGuideLine, VectorHandleRef, type VectorHitTestOptions, type VectorHover, type VectorInkShape, type VectorInteraction, type VectorKeyInput, VectorLineJoin, VectorMergeMode, VectorModifiers, type VectorMorph, type VectorMorphContour, type VectorMorphCorrespondence, type VectorMorphOptions, VectorNode, type VectorNodeListing, type VectorOverlayRenderData, VectorPaint, VectorPaintDef, VectorPaintLayer, type VectorPaintLayerHit, type VectorPaintLayerNode, type VectorPathAction, type VectorPathEditOptions, type VectorPathEntry, type VectorPathKeyframe, VectorPathNode, type VectorPathfinderAction, VectorPathfinderOperation, type VectorPathfinderPaint, type VectorPointMap, type VectorPointSnap, type VectorPointerInput, type VectorRectSnap, type VectorRenderAnchor, type VectorRenderCornerWidget, VectorRenderFilter, type VectorRenderGradientAnnotator, type VectorRenderGroup, type VectorRenderGuideLabel, type VectorRenderGuideLine, type VectorRenderHandle, type VectorRenderNode, type VectorRenderPaintLayer, type VectorRenderPath, VectorRenderStrokeParts, type VectorRenderWidthPoint, type VectorRepeaterCopy, type VectorScaleSnap, type VectorSceneRenderData, VectorSegmentRef, type VectorSelectionBoxGeometry, type VectorSelectionFrame, type VectorSelectionStyle, type VectorShapeBuilderFace, type VectorShapeBuilderMap, type VectorShapeBuilderPlan, type VectorShapeBuilderResult, type VectorShapeInput, type VectorSnapGuides, type VectorSnapKind, type VectorSnapLeave, type VectorSnapOptions, VectorSnapTargets, VectorStrokeAlign, VectorStrokeGradientMode, VectorStrokeLayer, type VectorStrokeParts, VectorStrokeSettings, type VectorStrokeSpot, VectorStyle, VectorSubpath, VectorSvgExportOptions, type VectorTaperOptions, VectorTool, VectorTransformHandle, VectorViewport, VectorWarpMesh, type VectorWaveOptions, type VectorWidthHandle, VectorWidthPoint, type VectorWidthPointEdit, type VectorWidthPointRef, type VectorWidthPreset, type VectorWidthPresetInfo, addBuilderHit, applyMatrix, applyMatrixLinear, applyVectorBlendOptions, arrowheadInset, arrowheadPath, arrowheadWeight, bendSegment, bezierToSubpaths, boundsFromPoints, boundsIntersect, cloneAnchor, cloneSubpath, cloneVectorDocument, cloneVectorNode, collectPathNodes, constrainToLeave, convertAnchor, cornerBisectorPoint, cornerRadiusChange, cornerSetback, correspondMorphContours, createVectorCommands, createVectorMorph, curvatureMoveAnchor, cutSubpathAt, dashIntervals, decomposeRigid, distortVectorNode, effectPathLength, effectPathVertexCount, effectiveStrokeAlign, ellipseSubpath, eraseFromFill, eraseFromOutline, eraserRegion, evaluateVectorPathKeyframes, expandVectorBlend, expandVectorCorners, expandVectorCornersOf, findVectorNode, fitCornerRadius, generateVectorBlendChildren, generateWidthProfile, getAnchor, getAnchorWorld, getEditablePathIds, getTransformHandlePositions, getVectorAppearancePanel, getVectorBlendControls, getVectorCornerWidgets, getVectorEffectsPanel, getVectorEnteredGroups, getVectorEnvelopePanel, getVectorEnvelopeTarget, getVectorGradientAnnotator, getVectorGradientEditor, getVectorOverlayRenderData, getVectorSceneRenderData, getVectorSelectionBoxGeometry, getVectorSelectionFrame, getVectorSelectionStyle, getVectorWidthHandles, getVisibleAnchors, getVisibleHandles, hasPaint, hasStrokeExtras, hasVectorCorners, hasVectorPaintStacks, hitTestVectorNode, hitTestVectorNodes, hitTestVectorPaintLayer, hitTestVectorPaintStack, hitTestVectorStroke, hitVectorGradientAnnotator, inferAnchorType, insertAnchor, insertWidthPoint, interpolateMorphContours, interpolateRigidMatrix, interpolateVectorColor, interpolateVectorPaint, interpolateVectorPaths, interpolateVectorStyle, interpolateWidthProfiles, invertMatrix, isClosedBezierShape, isDrawnVectorPaintLayer, isIdentityMatrix, isPlainVectorPaintLayer, isUniformWidthProfile, isVectorBlendGroup, isVectorBlendMode, isVectorTextTarget, joinSubpaths, knifePath, lineSubpath, locateVectorNode, mapBezierPath, mapVectorPoints, mapVectorSubpaths, matrixRotation, mergePaths, mirrorWidthProfile, morphContourToSubpath, morphPathsCross, moveAnchorHandle, multiplyMatrices, nearestSegment, nearestStrokePosition, needsVectorPaintLayers, newVectorStrokeLayer, nextVectorCornerKind, nodeMatrix, normalizeVectorPaintStacks, offsetPaths, pathsCenter, planShapeBuilder, polygonSubpath, polylineBounds, pressureWidthProfile, puckerBloatPaths, recognizeInkShape, rectSubpath, refineMorphContour, refreshVectorBlends, releaseVectorBlend, removeAnchorKeepingShape, removeAnchors, removeAnchorsKeepingShape, removeRedundantPoints, removeWidthPoints, repeatPaths, resampleGradientStops, resolveVectorBlendOptions, reverseMorphContour, reverseSubpath, reverseWidthProfile, rotateMatrix, roundCornerPaths, roundSubpaths, samplePolyline, sanitizeVectorFills, sanitizeVectorStrokeSettings, sanitizeVectorStrokes, sanitizeWidthProfile, scaleFor, scaleMatrix, setAnchorCorner, setSubpathCorners, setWidthPoint, simplifyPolyline, smoothSubpath, splitIntoFaces, splitSubpathAt, starSubpath, strokePositionPoint, strokeWidthProfileOf, subpathEnclosesArea, subpathPointAt, subpathSegment, subpathSegmentCount, subpathToMorphContour, subpathsToBezier, taperWaveFactor, toVectorKeyInput, toVectorModifiers, toVectorPointerInput, transformVectorNode, translateAnchor, translateMatrix, trimIntervals, trimPaths, trimPathsIndividually, turnMorphContour, twistPaths, unionBounds, variableStrokeOutline, variableStrokeRings, vectorBlendColorDistance, vectorBlendKeyTargets, vectorBlendKeys, vectorBlendModeCss, vectorBlendModeFromCss, vectorBlendRail, vectorBlendRailAt, vectorBlendSpine, vectorBlendStepCount, vectorBoxCorners, vectorBuilderErasedEdges, vectorCornerAt, vectorCorners, vectorDiamondPath, vectorDistortQuad, vectorFillMap, vectorFills, vectorGradientBarPosition, vectorGradientTargetPath, vectorInkShapeName, vectorMeshFromOutline, vectorMeshOutline, vectorNodeBounds, vectorNodeRotation, vectorNodeToBezier, vectorPaintLayerNodes, vectorPaintSwatch, vectorPaintToHex, vectorParentMatrix, vectorPathData, vectorPathEntries, vectorPathWorldBezier, vectorPathfinderShape, vectorRepeaterCopies, vectorResizeCursor, vectorResultStyle, vectorShapeBuilderHit, vectorShapeBuilderMap, vectorShearForSide, vectorSkewMatrix, vectorStacksHaveGradient, vectorStrokeGradientDefs, vectorStrokeLineArea, vectorStrokeOutline, vectorStrokeOutlinePath, vectorStrokeParts, vectorStrokeReach, vectorStrokeSettings, vectorStrokeStackReach, vectorStrokeWidthGeometry, vectorStrokes, vectorTargetPaint, vectorToolLabel, vectorWorldMatrix, walkVectorNodes, widthProfileAt, widthProfileMaxScale, widthProfilePreset, widthProfilePresetId, wigglePaths, withVectorFills, withVectorStrokes, withVectorTargetPaint, zigzagPaths };