@pixerate/editor 0.266.2 → 0.268.0

package/skills/pixerate-image-editor/references/smart-objects.md

@@ -35,3 +35,13 @@ How to work with smart objects in the image editor (see the main skill for the t
   the user may want to mask, blend or reorder them later.
 - **Linked or not**: duplicate a smart object `linked: true` for repeated elements that must stay
   identical (a logo placed twice); use `linked: false` when the copies will be edited apart.
+
+## Pitfalls
+
+- While contents are open (`edit_smart_object_contents`), `list_layers` and every tool see the
+  contents, not the document, and `export_psd` / saving write the document without the open
+  edits. Close with `close_smart_object_contents` before anything else.
+- Smart filters run over the canvas, like layer filters: a blur clamps at the canvas edge, and a
+  smart object is drawn only up to 512 px beyond the canvas. `get_transform_frame` on a smart
+  object returns the contents' rectangle (contents px) as the `frame`, and a warp `mesh` in
+  contents px.

package/skills/pixerate-paint-editor/SKILL.md

@@ -42,6 +42,12 @@ is never part of a layer. Coordinates are document pixels, (0, 0) top-left, y do
   same two ratios. `get_mixer_brush` reads what the brush carries; `clean_mixer_brush` wipes it.
 - **Grain**: a brush's grain response times the paper's `depth` decides how much light pressure
   skips the valleys. Pencil, pastel and charcoal are grainy; airbrush, marker and ink are not.
+  A brush can also carry its own texture, `tip.grain` (a pattern such as `sanded` or `canvas`, or
+  an image source; `texturised` stays put, `moving` rolls with the tip), which shows on any paper.
+- **Image tips**: a stamp tip whose stamp is an image source (`source:<id>`, added with the
+  brush library's `add_brush_source`) paints every dab as that image in the paint colour, with
+  hardness, roundness, angle, pressure size, `dynamics.count`, `flip` and jitter. Strokes record
+  the source, and the saved painting carries its bytes, so replays and exports match.
 - **Strokes are data.** Every stroke is recorded (brush, colour, raw points, seed, symmetry
   copies) and gets a `strokeId`. `replay_strokes` paints recorded strokes again, exactly or
   varied. That is the main way an agent should make many similar marks.
@@ -321,7 +327,7 @@ Listing, saving, sharing and previewing brushes are the brush library's tools (`
 | Tool | Use |
 | --- | --- |
 | `paint_stroke` | Paint one stroke through `points` (document px; `pressure` 0..1, `t` ms, `tiltX` / `tiltY` or `altitude` / `azimuth`, `twist`) with `brushId` (default the active brush), optional per-stroke `brush` facet changes (as `set_brush` takes), `color` or `paint` (a gradient for this stroke), `layerId`, `seed`, `snapToPerspective`. The symmetry guide adds its copies; a sampling tracing image supplies the colour when `color` is missing. Returns `layerId`, `bounds`, `dabs`, `strokeId` and, for brushes that pick up paint, `mixerLoad` (what the brush carries now). Refused on locked, hidden or group layers, with the fix in the message. |
-| `stroke_path` | Brush SVG path data (`path`, document px; M, L, C, Q, A, Z…) with the active brush or `brushId` / `brush`, as if drawn along it by hand: each subpath one recorded stroke, sampled every `spacing` px (default 2), with a `pressure` profile spread along each subpath (`[0.2, 1, 0.2]` tapers both ends). One undo step. Returns `layerId`, `bounds`, `dabs` and `strokeIds` (for `replay_strokes`, `update_stroke`). Use it for clean curves, outlines of shapes and lettering guides instead of working out points; use `paint_stroke` when the marks need time or tilt. |
+| `stroke_path` | Brush SVG path data (`path`, document px; M, L, C, Q, A, Z…) with the active brush or `brushId` / `brush`, as if drawn along it by hand: each subpath one recorded stroke, sampled every `spacing` px (default 2), with a `pressure` profile spread along each subpath (`[0.2, 1, 0.2]` tapers both ends) and optional `speed` (px/ms, stamps each sample with `t`). With an agent director, each subpath is painted live in turn. One undo step. Returns `layerId`, `bounds`, `dabs` and `strokeIds` (for `replay_strokes`, `update_stroke`). Use it for clean curves, outlines of shapes and lettering guides instead of working out points; use `paint_stroke` when the marks need variable timing or tilt. |
 | `list_strokes` | Read the recorded strokes, oldest first (default the last 100): id, layer, brush, colour, point count, seed, bounds, `live`. With `ids`, their points too; with `layerId`, one layer's. With `live: true`, the editable strokes of stroke layers as they are now, bottom first: the ids for the stroke layer tools. |
 | `get_live_stroke` | Read the stroke the user is painting right now (layer, brush, colour, samples so far; `live: false` when none). For painting along with the user; hosts stream the samples live. |
 | `stroke_at` | Read the top-most stroke of a stroke layer that painted the pixel at `x`, `y`, or null. Use it to pick one stroke among overlapping ones. |
@@ -339,7 +345,7 @@ Listing, saving, sharing and previewing brushes are the brush library's tools (`
 
 | Tool | Use |
 | --- | --- |
-| `get_wet_paint` | Read the wet paint: `wet`, the clock, `paused`, `speed`, `tilt`, the kernel (`backend`, `message` when it runs slower than it could), the GPU accelerator (`engine`) and each wet layer (`wetCells`, `wetBounds`, `activeTiles`, settings, flow map). Call after wet strokes. |
+| `get_wet_paint` | Read the wet paint: `wet`, the clock, `paused`, `speed`, `tilt`, the kernel (`backend`, `message` when it runs slower than it could, e.g. on one thread because the page is not cross-origin isolated (COOP / COEP)), the GPU accelerator (`engine`) and each wet layer (`wetCells`, `wetBounds`, `activeTiles`, settings, flow map). Call after wet strokes. |
 | `advance_wet_paint` | Let time pass: `steps` (120 = one second at the default speed) or `seconds`. The paint spreads, blooms, runs and dries. Not an undo step. Returns `steps`, `clock`, `stillWet`, `layers`. Call after a group of wet strokes, before `render_preview`. |
 | `dry_paint` | Dry wet paint at once where it is (one layer with `layerId` or all, optionally inside `rect`). One undo step. Returns `dried` (layer ids and rectangles) and `stillWet`. Dry before glazing over a wash. |
 | `wet_paper` | Pre-wet the paper with clear water over `rect` (default the canvas) on a layer, `amount` 0..1, for wet-in-wet. One undo step. Returns the rectangle and `wet`. Then paint into it. |
@@ -462,7 +468,8 @@ The host may add the shared document tools (see `pixerate-agent-tools`). A paint
   keep taking its colours.
 - **Strokes take real time when the host shows your cursor.** With a director (the demo and
   editors that set `createPaintEditorToolProvider({ director })`), `paint_stroke` paints live at
-  the pace of the points' `t` (else about 1.5 px per ms, at most ~1.8 s), and `fill_layer` /
+  the pace of the points' `t` (else about 1.5 px per ms, at most ~1.8 s), `stroke_path` paints
+  each subpath in turn (paced by its `speed` when given) as one undo step, and `fill_layer` /
   `replay_strokes` move the cursor first. Results and undo are the same; it is one more reason to
   paint a few long strokes and replay them rather than many short ones. A stroke fails with "A
   stroke is in progress" while the user is painting; try it again afterwards.
@@ -470,7 +477,10 @@ The host may add the shared document tools (see `pixerate-agent-tools`). A paint
   flowed; `advance_wet_paint` first. Paint that should stay exactly where it was laid needs
   `dry_paint` (or a dry medium).
 - **Wet strokes on one layer interact**; washes that must not mix go on separate layers, or dry
-  the first before painting the second (glazing). At most 8 layers hold wet paint at once.
+  the first before painting the second (glazing). At most 8 layers hold wet paint at once, and the simulation holds at most 328 wet tiles (256 × 256 px each) across them; water that spreads past
+  that limit is lost (`dry_paint` frees tiles). Multi-threaded wet media needs a cross-origin isolated
+  page (COOP / COEP, for `SharedArrayBuffer`) and runs on one thread otherwise, more slowly but with
+  the same result.
 - **Undoing far back** past the wet undo memory (512 MB by default) leaves that paint dry as it
   looked, rather than wet.
 - **Replays repeat what was recorded**: strokes, fills, clears, flattened relief and wet events.

package/skills/pixerate-paint-editor/references/brush-facets.md

@@ -8,7 +8,9 @@ more; this is where each one went.
 | Engine setting | Facet |
 | --- | --- |
 | Tip size, hardness, spacing, angle, roundness, opacity, flow, blend | `tip` |
-| Smoothing, pressure, tilt, velocity, jitter, scatter, rotation | `dynamics` |
+| Smoothing, pressure, tilt, velocity, jitter, scatter, rotation, dabs per step (`count`), random `flip` | `dynamics` |
+| Image tip | `tip` `{ shape: 'stamp', stamps: ['source:<id>'] }` (an image source from `add_brush_source`) |
+| Texture inside the tip | `tip.grain` `{ source: 'sanded' or 'source:<id>', mode: 'texturised' or 'moving', scale, depth, contrast, invert }` |
 | Grain, pick-up and mix (behavior), blender and smudge strength | `behaviour` (`grain`, `exchange`, `strength`, `distance`, `length`, `mixing`) |
 | Mixer Brush reservoir | `behaviour.exchange.reservoir` (`load`, `refill`, `loadsColour`) |
 | Wet engine (medium, water, pigment, body…) | `behaviour.surface` `wet` and `behaviour.wet` |

package/skills/pixerate-paint-editor/references/wet-media.md

@@ -28,6 +28,15 @@
   dries it first (in the same undo step).
 - **Time** runs by itself in an editor on screen (`pause_wet_paint` stops it); for an agent with
   no screen, nothing moves until `advance_wet_paint` or `dry_paint`.
+- **Extent limit (8 wet layers, 328 tiles).** The simulation holds at most 8 wet layers and 328
+  live tiles of 256 × 256 px across them (one wasm32 memory, under 4 GB). Water that spreads beyond
+  them is lost (`get_wet_paint` reports `activeTiles` per layer, so watch the total); dry
+  finished washes with `dry_paint` to free their tiles before painting another large wash.
+- **Multi-threading and COOP / COEP.** Stepping wet tiles across Web Workers needs
+  `SharedArrayBuffer`, which browsers only expose on cross-origin isolated pages
+  (`Cross-Origin-Opener-Policy: same-origin` and `Cross-Origin-Embedder-Policy: require-corp` or
+  `credentialless`). Without cross-origin isolation the simulation runs on one thread, more slowly
+  but with identical results, and `get_wet_paint` says why in the kernel's `message`.
 - **The GPU only draws.** With WebGPU and a large wet area (16 tiles of 256 px by default), Engine B
   shades the wet paint on the GPU; the CPU engine still computes every step, so the painting,
   `dry_paint`, saving, export and replay come out the same with it on or off. `get_wet_paint`

package/skills/pixerate-paint-sketch-to-finish/SKILL.md

@@ -66,6 +66,7 @@ This skill is the method. `pixerate-paint-editor` has the full tool reference.
 | Clean geometric lines (curves, circles, borders) | `stroke_path` with SVG path data and a `pressure` taper, on the Ink layer |
 | Flats | `marker` or a flat brush on a layer under the ink |
 | Patterned or textured flats (sky, gradient, galaxy) | `set_effect_paint` with a provider generator, then a flat dry brush on the Flats layer; `set_color` after |
+| Textured passes (dry brush, sponge, foliage) | A brush with `tip.grain` (`set_brush` `{ tip: { grain: { source: "sanded", depth: 0.6 } } }`) or an image tip from the brush library, with `dynamics.angleJitter` and `flip` so repeats don't show |
 | Shadows | Clipped layer, `multiply` or `shadow`, a cool colour |
 | Light, glow | Clipped layer, `highlight` or `screen` |
 | Warm or cool a whole area | Clipped layer in `tint` |

package/skills/pixerate-vector/SKILL.md

@@ -1,6 +1,6 @@
 ---
 name: pixerate-vector
-description: How to draw and edit vector artwork in the Pixerate vector editor through its vector.* commands - adding shapes and SVG paths, text (point, area, on a path, styles, Create Outlines), symbols and instances, CAD constraints, artboards and frames with resizing constraints, connectors, fills, strokes, stacked fills and strokes with blend modes, drop shadows, glows and blurs, clipping and opacity masks, gradients (linear, radial, conic, mesh, freeform), stroke alignment, arrowheads, variable-width and tapered strokes, live corner radii, boolean operations and Pathfinder (unite, subtract, divide, trim), Shape Builder, paint bucket, path effects (trim, repeater, zig zag, offset), envelope warps and free distort, blends and morphing, anchor editing (join, smooth, simplify, knife, eraser), align, distribute, group, and SVG import and export. Use when creating an icon, logo, illustration, glyph, badge or any Bezier path artwork, or editing an SVG in a Pixerate vector editor.
+description: How to draw and edit vector artwork in the Pixerate vector editor through its vector.* commands - adding shapes and SVG paths, text (point, area, on a path, styles, Create Outlines), symbols and instances, CAD constraints, artboards and frames with resizing constraints, connectors, stacked fills and strokes with blend modes, brushstrokes with brush character and paper grain, drop shadows, glows and blurs, clipping and opacity masks, gradients (linear, radial, conic, mesh, freeform), stroke alignment, arrowheads, variable-width and tapered strokes, live corner radii, boolean operations and Pathfinder (unite, subtract, divide, trim), Shape Builder, paint bucket, path effects (trim, repeater, zig zag, offset), envelope warps and free distort, blends and morphing, anchor editing (join, smooth, simplify, knife, eraser), align, distribute, group, and SVG import and export. Use when creating an icon, logo, illustration, glyph, badge or Bezier path artwork, or editing an SVG in a Pixerate vector editor.
 ---
 
 # Pixerate vector editor
@@ -20,7 +20,9 @@ carry a live effect stack. Every command is a `vector.*` command run with `run_c
   `{ type, stops: [{ offset, color, opacity?, midpoint? }], ... }`.
 - **Appearance**: a path can stack several fills and several strokes (bottom to top; all fills
   draw under all strokes), each with its own paint, `opacity`, `blendMode` and `visible`, and
-  each stroke with its own width, alignment, dashes, caps, joins, arrowheads and profile. Layers
+  each stroke with its own width, alignment, dashes, caps, joins, arrowheads and profile, or a
+  **brushstroke** (`vector.addBrushstroke`, `vector.setBrushstroke`, `vector.listBrushes`) painted
+  along the outline with a dry or wet brush, a Mixer Brush, smudge or blender, gradient paint, seeded jitter and paper grain. Layers
   are addressed by `index` in their stack, 0 at the bottom. `fill` / `stroke` and the stroke
   settings of `vector.setStyle` are shorthands for the **top** layer; `null` clears the stack.
   Any node can also have a `blendMode` and `filters` (drop / inner shadow, outer / inner glow,
@@ -101,7 +103,7 @@ the pitfalls, and uses the commands below.
   than splitting text into separate nodes, so it still edits as one paragraph. Create Outlines
   only for final artwork or logos that must not depend on fonts; keep a copy as text if it may
   change.
-- **Paths, strokes, booleans, gradients, stacks, masks, shadows, connectors, constraints and
+- **Paths, strokes, brushstrokes, booleans, gradients, stacks, masks, shadows, connectors, constraints and
   vertical text:** read [references/best-practices.md](references/best-practices.md) first.
 - **Non-destructive first.** Live booleans (`vector.boolean` with `live: true`), path effects
   and envelopes keep the operands editable. A destructive boolean or Pathfinder replaces its
@@ -373,12 +375,20 @@ contents whole while you work, without losing the mask.
 
 | Command | Use it to |
 | --- | --- |
-| `vector.listBrushes` | List the brushes a brushstroke can use: the dry presets (pencils, pastels, charcoal, crayon, chalk, markers, inks, ballpoint, gel pen, fineliner), then saved brushes from the brush library the vector profile admits, with their sizes and `builtin`. Brushes it refuses (wet, thick, particles, stickers, tools) are refused by `vector.addBrushstroke` with the reason. A saved brush is kept in the layer, so the document renders without the library. |
-| `vector.addBrushstroke` | Paint paths with a brush along their outline (`brushId`, `size`, `pressure` profile such as [0.2, 1, 0.2] for a taper, `color`, default the brush's default colour (ballpoint blue, chalk), else the path's stroke; `keepColour` keeps the path's colour): sketchy, hand-drawn or inked lines that stay editable. Pass a `seed` (any integer) so the brush gets its character, the seeded jitter and paper grain that make pencil, pastel and charcoal look real; `paper` picks the grain (`{ pattern, seed, scale, depth }`) or `null` turns it off. Returns the stroke stacks. |
-| `vector.setBrushstroke` | Change brushstroke layer `index` of path `id`: brush (another brush without `color` takes its default colour, unless `keepColour`; giving the same `brushId` again takes that saved brush as the library has it now), size, pressure, colour, opacity, `seed` (a new seed is a new take on the same stroke; null: plain dabs) and `paper` (replaced whole; null: no grain; {}: the default sanded paper). Remove it with `vector.removeStroke`. |
+| `vector.listBrushes` | List the brushes a brushstroke can use: the dry presets (pencils, pastels, charcoal, crayon, chalk, markers, inks, ballpoint, gel pen, fineliner, gradient and multi-colour brushes), wet paint (watercolour, gouache, wet oils), the Mixer Brush, smudge and blender, then saved brushes from the brush library the vector profile admits, with their sizes and `builtin`, plus the editor's `colorScheme` and `colorLocked`. Brushes it refuses (thick paint, particles, stickers, erasers, the wet tools) are refused by `vector.addBrushstroke` with the reason. A saved brush is kept in the layer, so the document renders without the library. |
+| `vector.addBrushstroke` | Paint paths with a brush along their outline (`brushId`, `size`, `pressure` profile such as [0.2, 1, 0.2] for a taper, `color`, default the brush's default colour (ballpoint blue, chalk), else the path's stroke; `keepColour`, or a lock from `vector.setColorLocked`, keeps the path's colour): sketchy, hand-drawn or inked lines that stay editable. Pass a `seed` (any integer) so the brush gets its character, the seeded jitter and paper grain that make pencil, pastel and charcoal look real; `paper` picks the grain (`{ pattern, seed, scale, depth }`) or `null` turns it off. `paint` is gradient paint sampled dab by dab along the path (`{ type: 'gradient', stops, map: { by: 'distance', length, repeat } }`, lengths in document units; also pressure, direction, across-tip, random; not velocity or time). Returns the stroke stacks. |
+| `vector.setBrushstroke` | Change brushstroke layer `index` of path `id`: brush (another brush without `color` takes its default colour, unless `keepColour` or the colour is locked; giving the same `brushId` again takes that saved brush as the library has it now), size, pressure, colour, opacity, `seed` (a new seed is a new take on the same stroke; null: plain dabs), `paper` (replaced whole; null: no grain; {}: the default sanded paper) and `paint` (gradient paint, replaced whole; null: the colour again). Remove it with `vector.removeStroke`. |
+| `vector.setColorLocked` | Lock (`locked: true`) or unlock brushstroke colours ("Keep my colour"): while locked, `vector.addBrushstroke` and `vector.setBrushstroke` with another brush keep the path's or layer's colour instead of the brush's default; an explicit `color` still applies. Strokes already made are unchanged. Respect a lock the person set. Editor state, not an undo step. Returns `{ colorScheme, colorLocked }`. |
+| `vector.setColorScheme` | Set `scheme` `light` or `dark`: the side of light / dark default colours (chalk) that brushstrokes made from now on take. Existing strokes keep their colour. Usually the host's job. Returns `{ colorScheme, colorLocked }`. |
 
 Give brushstrokes a `seed` unless you want flat, even dabs: without one a charcoal or pastel line looks like a felt pen. Use different seeds on neighbouring strokes so they do not repeat each other, and `paper: null` for clean ink or marker lines that should not catch grain. The grain is laid in each path's own space, so it moves with the path.
 
+**Colour along the stroke.** For colour that changes along the path, give the brushstroke `paint` (`by: 'distance'` with `length` about the path's length and `repeat: 'clamp'` runs the gradient once from start to end; `across-tip` loads the brush with several colours side by side; `pressure` follows the pressure profile). A gradient as the layer colour also works: its `strokeMode` `along` runs it from each subpath's start to its end, `across` lays it across the tip, and `within` (the default) lays it over the path's box. Gradient and multi-colour presets (`gradient-round`, `rainbow-marker`) paint their own gradient; their `paint` stops take the layer colour.
+
+**Wet paint** (`watercolor-round`, `watercolor-wash`, `gouache`, `oil-round`) bleeds, blooms and granulates in its own small wet area, then dries. That takes a few seconds per stroke, so the canvas shows the paint as laid first and swaps in the settled stroke when it is ready; SVG and PDF exports always wait for it. Prefer a handful of wet strokes to dozens of short ones.
+
+**Mixer Brush, smudge and blender** act on what lies beneath the stroke: the shapes below it in the document and the path's own fills and lower strokes. Put the path above the art it should work on (`vector.arrange`), give it no visible stroke of its own if only the effect should show, and draw it after the shapes are final: the stroke re-renders whenever something beneath it changes. They pick up fills (solid and gradient), plain strokes and other brushstrokes; not text, placed images, filters or masks. The result is drawn over the art, so a smudge can drag colour out onto bare paper but can't wipe the art away. The Mixer Brush paints from its reservoir (the layer colour) even with nothing beneath it; a smudge or blender over nothing draws nothing.
+
 ### Editor settings
 
 | Command | Use it to |

package/skills/pixerate-vector/references/best-practices.md

@@ -19,6 +19,7 @@ Detail for `SKILL.md`'s best practices, by topic.
   `outside` for outlines around artwork; open paths always stroke centred. Use round caps and
   joins for friendly line icons, miter for geometric ones. Keep one stroke width across an icon
   set (for example 1.5 or 2 units on a 24-unit grid).
+- **Brushstrokes and brush character.** Use `vector.addBrushstroke` (after `vector.listBrushes`) when a path should look hand-drawn (pencil, charcoal, pastel, chalk, marker, ink) while staying an editable Bezier path. Pass a `seed` for pencil, pastel, charcoal and chalk (without one the brush paints plain, even dabs with no jitter or grain), and a different seed on neighbouring paths so their strokes do not repeat. Use a `pressure` taper such as `[0.2, 1, 0.2]` for strokes that start and end lightly. For clean ink or marker lines leave out the seed, or pass `paper: null` to keep the jitter without grain. Remove a brushstroke layer with `vector.removeStroke`.
 - **Icon grid.** Use a square artboard (24, 32 or 48 units), keep a padding margin, place
   coordinates on whole or half units so strokes render crisp, and align optical centres.
 - **Gradients.** Two to four stops are usually enough. Use `interpolation: "oklab"` for

package/skills/pixerate-vector/references/commands.md

@@ -180,3 +180,22 @@ inside the intended face.
 | transparency | 0–100 % see-through (50) | – | The lens's own fill, see-through. |
 
 The lens shows what is drawn before it (below it), follows edits there, and keeps its own bounds. Move it with `vector.transform` like any path. Remove it with `vector.removeLens`.
+
+## Brushstrokes (`vector.listBrushes`, `vector.addBrushstroke`, `vector.setBrushstroke`)
+
+A brushstroke is a stroke layer (kind brushstroke) in a path's appearance stack that paints a dry
+brush along the path's outline; the path stays editable and the stroke follows it.
+
+| Parameter | Meaning |
+| --- | --- |
+| `ids` / `id` | `vector.addBrushstroke`: paths or groups (`ids`, default the selection; a group paints every path inside). `vector.setBrushstroke`: one path `id` plus the stroke layer `index` (from `vector.getAppearance`, 0 the bottom). |
+| `brushId` | Required on add. A preset or saved brush id from `vector.listBrushes` (dry brushes only: pencils, pastels, charcoal, crayon, chalk, markers, inks, ballpoint, gel pen, fineliner). Wet, thick, particle, sticker and tool brushes are refused. |
+| `size` | Brush diameter in document units, up to 500 (default the brush's own; `null` on set restores it). |
+| `pressure` | Pressure profile 0–1 spread evenly from start to end (`[0.2, 1, 0.2]` tapers both ends; default full pressure; `null` on set). |
+| `color` | CSS colour. Default: the brush's own default colour (e.g. the ballpoint's blue) unless `keepColour`, else the path's stroke colour, else black. |
+| `keepColour` | Use the path's (or, on set with another `brushId`, the layer's) colour instead of the brush's default colour. |
+| `opacity` | Layer opacity 0–1 (default 1). `index` on add places the layer in the stroke stack (default on top). |
+| `seed` | Integer 0–2147483647 that turns on the brush's character: seeded size, angle, opacity and scatter jitter plus paper grain. The same seed renders the same stroke. Without a seed (or `null` on set) the brush paints plain, even dabs. |
+| `paper` | Applies with a `seed`: `{ pattern?, seed?, scale?, depth? }` for the grain (pattern `sanded` by default, `rough`, `cold-pressed`, `canvas`, `linen`; `scale` 0.25–8; `depth` 0–1, default 0.5). Omitted: the sanded paper; `null`: jitter without grain. On set it is replaced whole and `{}` is the default paper. |
+
+Remove a brushstroke with `vector.removeStroke`, like any stroke layer.