@pixerate/editor 0.187.0 → 0.189.0

package/dist/image-editor/layers/paint-ui.d.cts

@@ -140,7 +140,8 @@ export interface ShortcutEvent {
  * Applies a paint shortcut. Returns true when it was one (the caller then prevents the default).
  * B / Shift+B (Mixer Brush) / E / V choose the tool; [ and ] change the size, with Shift the hardness by 25 %; 1..9 set the
  * opacity to 10..90 % and 0 to 100 %; D resets the colours to black and white; X swaps them; Q
- * toggles Quick Mask mode (painting then edits the selection).
+ * toggles Quick Mask mode (painting then edits the selection); the backslash key shows the active
+ * layer's mask as a red overlay.
  */
 export declare function handlePaintShortcut(controller: ImageEditorController, e: ShortcutEvent): boolean;
 /** One pointer sample in document pixels. */

package/dist/image-editor/layers/paint-ui.d.ts

@@ -140,7 +140,8 @@ export interface ShortcutEvent {
  * Applies a paint shortcut. Returns true when it was one (the caller then prevents the default).
  * B / Shift+B (Mixer Brush) / E / V choose the tool; [ and ] change the size, with Shift the hardness by 25 %; 1..9 set the
  * opacity to 10..90 % and 0 to 100 %; D resets the colours to black and white; X swaps them; Q
- * toggles Quick Mask mode (painting then edits the selection).
+ * toggles Quick Mask mode (painting then edits the selection); the backslash key shows the active
+ * layer's mask as a red overlay.
  */
 export declare function handlePaintShortcut(controller: ImageEditorController, e: ShortcutEvent): boolean;
 /** One pointer sample in document pixels. */

package/dist/image-editor/layers/panel.d.cts

@@ -8,8 +8,9 @@ import { type ImageLayer, type SmartFilter } from './model.cjs';
 import type { LayerPlacement } from './ops.cjs';
 /**
  * A click on a layer's mask thumbnail, as in Photoshop: Ctrl/⌘-click loads the mask as the
- * selection (with Shift adding, Alt subtracting, both intersecting), Shift-click turns the mask
- * on or off, and a plain click makes the mask the paint target.
+ * selection (with Shift adding, Alt subtracting, both intersecting), Alt-click shows the mask
+ * alone in grey (Alt+Shift-click as a red overlay; again to go back to the image), Shift-click
+ * turns the mask on or off, and a plain click makes the mask the paint target.
  */
 export declare function maskThumbnailClick(controller: ImageEditorController, layer: ImageLayer, e: {
     ctrlKey?: boolean;

package/dist/image-editor/layers/panel.d.ts

@@ -8,8 +8,9 @@ import { type ImageLayer, type SmartFilter } from './model.js';
 import type { LayerPlacement } from './ops.js';
 /**
  * A click on a layer's mask thumbnail, as in Photoshop: Ctrl/⌘-click loads the mask as the
- * selection (with Shift adding, Alt subtracting, both intersecting), Shift-click turns the mask
- * on or off, and a plain click makes the mask the paint target.
+ * selection (with Shift adding, Alt subtracting, both intersecting), Alt-click shows the mask
+ * alone in grey (Alt+Shift-click as a red overlay; again to go back to the image), Shift-click
+ * turns the mask on or off, and a plain click makes the mask the paint target.
  */
 export declare function maskThumbnailClick(controller: ImageEditorController, layer: ImageLayer, e: {
     ctrlKey?: boolean;

package/dist/image-editor/renderer.d.cts

@@ -178,6 +178,12 @@ export declare class ImageEditorRenderer {
     /** An empty selection of the image's size (Quick Mask mode with nothing selected). */
     private emptyMask;
     private overlayCache;
+    private maskViewCache;
+    private grayCache;
+    /** A layer's mask as canvas-sized coverage for its mask view, kept while the mask is unchanged. */
+    private maskViewSelection;
+    /** A mask alone in grey (white = revealed), opaque, drawn in natural image space. */
+    private drawMaskGray;
     /** A channel's tint (colour, opacity, masked or selected area), drawn in natural image space. */
     private drawMaskOverlay;
     /** Rubylith over the unselected area, drawn in natural image space. */

package/dist/image-editor/renderer.d.ts

@@ -178,6 +178,12 @@ export declare class ImageEditorRenderer {
     /** An empty selection of the image's size (Quick Mask mode with nothing selected). */
     private emptyMask;
     private overlayCache;
+    private maskViewCache;
+    private grayCache;
+    /** A layer's mask as canvas-sized coverage for its mask view, kept while the mask is unchanged. */
+    private maskViewSelection;
+    /** A mask alone in grey (white = revealed), opaque, drawn in natural image space. */
+    private drawMaskGray;
     /** A channel's tint (colour, opacity, masked or selected area), drawn in natural image space. */
     private drawMaskOverlay;
     /** Rubylith over the unselected area, drawn in natural image space. */

package/dist/image-editor/selection/gesture.d.cts

@@ -76,6 +76,16 @@ export declare function handleSelectionShortcut(controller: ImageEditorControlle
     shiftKey?: boolean;
     altKey?: boolean;
 }, onError?: (message: string) => void): boolean;
+/**
+ * The backslash key (no modifiers) shows or hides the active layer's mask as a red overlay; it
+ * does nothing when the layer has no painted mask. Returns true when the key was used.
+ */
+export declare function handleMaskViewKey(controller: ImageEditorController, e: {
+    key: string;
+    ctrlKey?: boolean;
+    metaKey?: boolean;
+    altKey?: boolean;
+}): boolean;
 /** Q (no modifiers) toggles Quick Mask mode. Returns true when the key was used. */
 export declare function handleQuickMaskKey(controller: ImageEditorController, e: {
     key: string;

package/dist/image-editor/selection/gesture.d.ts

@@ -76,6 +76,16 @@ export declare function handleSelectionShortcut(controller: ImageEditorControlle
     shiftKey?: boolean;
     altKey?: boolean;
 }, onError?: (message: string) => void): boolean;
+/**
+ * The backslash key (no modifiers) shows or hides the active layer's mask as a red overlay; it
+ * does nothing when the layer has no painted mask. Returns true when the key was used.
+ */
+export declare function handleMaskViewKey(controller: ImageEditorController, e: {
+    key: string;
+    ctrlKey?: boolean;
+    metaKey?: boolean;
+    altKey?: boolean;
+}): boolean;
 /** Q (no modifiers) toggles Quick Mask mode. Returns true when the key was used. */
 export declare function handleQuickMaskKey(controller: ImageEditorController, e: {
     key: string;

package/dist/image-editor/selection/layer-mask.d.cts

@@ -1,6 +1,12 @@
 import type { AdjustmentLayer, AdjustmentLayerMask } from '../types.cjs';
 import { type ImageProjection } from '../geometry.cjs';
 import { type SelectionMask } from './mask.cjs';
+import type { ImageLayer } from '../layers/model.cjs';
+/**
+ * A layer's painted mask over the `width × height` canvas as coverage (white = revealed), its
+ * pixels before density and feather; `null` without one (a depth mask is computed, not painted).
+ */
+export declare function layerMaskSelection(layer: ImageLayer, width: number, height: number): SelectionMask | null;
 /** Properties of a layer mask that leave its pixels intact (Photoshop's Properties › Masks). */
 export interface LayerMaskProps {
     /** 0..1 (default 1): at 0.5 the masked-out areas still get half of the adjustment. */

package/dist/image-editor/selection/layer-mask.d.ts

@@ -1,6 +1,12 @@
 import type { AdjustmentLayer, AdjustmentLayerMask } from '../types.js';
 import { type ImageProjection } from '../geometry.js';
 import { type SelectionMask } from './mask.js';
+import type { ImageLayer } from '../layers/model.js';
+/**
+ * A layer's painted mask over the `width × height` canvas as coverage (white = revealed), its
+ * pixels before density and feather; `null` without one (a depth mask is computed, not painted).
+ */
+export declare function layerMaskSelection(layer: ImageLayer, width: number, height: number): SelectionMask | null;
 /** Properties of a layer mask that leave its pixels intact (Photoshop's Properties › Masks). */
 export interface LayerMaskProps {
     /** 0..1 (default 1): at 0.5 the masked-out areas still get half of the adjustment. */

package/dist/image-editor/selection/mask.d.cts

@@ -1,11 +1,17 @@
 import type { CropBox } from '../types.cjs';
+import { TiledSurface } from '../../raster/surface.cjs';
 /**
  * A selection: one 8-bit coverage value per image pixel (0 = not selected, 255 = fully
  * selected), row-major over the whole source image in natural pixels — the same space as the
  * crop box and annotations. Soft values are partial selection (feathered or anti-aliased edges).
  *
+ * The coverage is stored as 256 × 256 tiles (`surface`, one byte per pixel, missing tiles are 0
+ * and every pixel outside the image is 0), so an empty or fully selected area costs nothing and
+ * masks share the tiles an operation did not change. `data` is the same coverage as one array,
+ * built on first read and cached for the few masks read most recently.
+ *
  * Treat a mask as immutable: every operation returns a new one, so history entries can share
- * them without copying.
+ * them without copying. Never write to `data`.
  */
 export interface SelectionMask {
     readonly width: number;
@@ -13,6 +19,8 @@ export interface SelectionMask {
     readonly data: Uint8Array;
     /** Bounding box of the non-zero coverage, or `null` when nothing is selected. */
     readonly bounds: CropBox | null;
+    /** The coverage as tiles (1 channel, default 0), shared with other masks where equal. */
+    readonly surface: TiledSurface;
 }
 /** How a new selection combines with the current one. */
 export type SelectionMode = 'replace' | 'add' | 'subtract' | 'intersect';
@@ -35,8 +43,19 @@ export interface SerializedSelection {
 }
 /** Bounding box of non-zero bytes. */
 export declare function computeSelectionBounds(width: number, height: number, data: ArrayLike<number>): CropBox | null;
+/**
+ * A selection over `width × height` from a 1-channel tiled surface in image space (Quick Mask
+ * paint, a mask): its tiles are shared, and coverage outside the image is dropped. A surface
+ * whose default is not 0 is read out instead.
+ */
+export declare function selectionFromTiles(width: number, height: number, surface: TiledSurface): SelectionMask;
 /** Wraps coverage bytes (taken over, not copied) as a selection, computing its bounds. */
 export declare function createSelectionMask(width: number, height: number, data?: Uint8Array): SelectionMask;
+/**
+ * A selection that is `data` (`rect.width × rect.height` coverage bytes) inside `rect` and
+ * nothing elsewhere, without allocating the whole image. `rect` must lie inside the image.
+ */
+export declare function selectionFromRegion(width: number, height: number, rect: CropBox, data: ArrayLike<number>): SelectionMask;
 /** Select › All. */
 export declare function fullSelection(width: number, height: number): SelectionMask;
 export declare function isSelectionEmpty(mask: SelectionMask | null | undefined): boolean;

package/dist/image-editor/selection/mask.d.ts

@@ -1,11 +1,17 @@
 import type { CropBox } from '../types.js';
+import { TiledSurface } from '../../raster/surface.js';
 /**
  * A selection: one 8-bit coverage value per image pixel (0 = not selected, 255 = fully
  * selected), row-major over the whole source image in natural pixels — the same space as the
  * crop box and annotations. Soft values are partial selection (feathered or anti-aliased edges).
  *
+ * The coverage is stored as 256 × 256 tiles (`surface`, one byte per pixel, missing tiles are 0
+ * and every pixel outside the image is 0), so an empty or fully selected area costs nothing and
+ * masks share the tiles an operation did not change. `data` is the same coverage as one array,
+ * built on first read and cached for the few masks read most recently.
+ *
  * Treat a mask as immutable: every operation returns a new one, so history entries can share
- * them without copying.
+ * them without copying. Never write to `data`.
  */
 export interface SelectionMask {
     readonly width: number;
@@ -13,6 +19,8 @@ export interface SelectionMask {
     readonly data: Uint8Array;
     /** Bounding box of the non-zero coverage, or `null` when nothing is selected. */
     readonly bounds: CropBox | null;
+    /** The coverage as tiles (1 channel, default 0), shared with other masks where equal. */
+    readonly surface: TiledSurface;
 }
 /** How a new selection combines with the current one. */
 export type SelectionMode = 'replace' | 'add' | 'subtract' | 'intersect';
@@ -35,8 +43,19 @@ export interface SerializedSelection {
 }
 /** Bounding box of non-zero bytes. */
 export declare function computeSelectionBounds(width: number, height: number, data: ArrayLike<number>): CropBox | null;
+/**
+ * A selection over `width × height` from a 1-channel tiled surface in image space (Quick Mask
+ * paint, a mask): its tiles are shared, and coverage outside the image is dropped. A surface
+ * whose default is not 0 is read out instead.
+ */
+export declare function selectionFromTiles(width: number, height: number, surface: TiledSurface): SelectionMask;
 /** Wraps coverage bytes (taken over, not copied) as a selection, computing its bounds. */
 export declare function createSelectionMask(width: number, height: number, data?: Uint8Array): SelectionMask;
+/**
+ * A selection that is `data` (`rect.width × rect.height` coverage bytes) inside `rect` and
+ * nothing elsewhere, without allocating the whole image. `rect` must lie inside the image.
+ */
+export declare function selectionFromRegion(width: number, height: number, rect: CropBox, data: ArrayLike<number>): SelectionMask;
 /** Select › All. */
 export declare function fullSelection(width: number, height: number): SelectionMask;
 export declare function isSelectionEmpty(mask: SelectionMask | null | undefined): boolean;

package/dist/image-editor/selection/shapes.d.cts

@@ -11,6 +11,14 @@ export interface ShapeSelectionOptions {
  * their top), so the cost is about pixels + edges × rows they span.
  */
 export declare function polygonCoverage(points: readonly ImagePoint[], width: number, height: number, antiAlias?: boolean): Float32Array;
+/**
+ * {@link polygonCoverage} over just the polygon's bounding box (clipped to the image): `coverage`
+ * is `box.width × box.height`; `box` is `null` when the polygon covers no pixel row or column.
+ */
+export declare function polygonCoverageBox(points: readonly ImagePoint[], width: number, height: number, antiAlias?: boolean): {
+    box: CropBox | null;
+    coverage: Float32Array;
+};
 /** Lasso / polygonal lasso: an even-odd polygon in natural image pixels. */
 export declare function polygonSelection(width: number, height: number, points: readonly ImagePoint[], options?: ShapeSelectionOptions): SelectionMask;
 /** Normalises a rectangle with a negative width or height. */

package/dist/image-editor/selection/shapes.d.ts

@@ -11,6 +11,14 @@ export interface ShapeSelectionOptions {
  * their top), so the cost is about pixels + edges × rows they span.
  */
 export declare function polygonCoverage(points: readonly ImagePoint[], width: number, height: number, antiAlias?: boolean): Float32Array;
+/**
+ * {@link polygonCoverage} over just the polygon's bounding box (clipped to the image): `coverage`
+ * is `box.width × box.height`; `box` is `null` when the polygon covers no pixel row or column.
+ */
+export declare function polygonCoverageBox(points: readonly ImagePoint[], width: number, height: number, antiAlias?: boolean): {
+    box: CropBox | null;
+    coverage: Float32Array;
+};
 /** Lasso / polygonal lasso: an even-odd polygon in natural image pixels. */
 export declare function polygonSelection(width: number, height: number, points: readonly ImagePoint[], options?: ShapeSelectionOptions): SelectionMask;
 /** Normalises a rectangle with a negative width or height. */

package/dist/image-editor/selection/tool-options.d.cts

@@ -1,4 +1,4 @@
-import type { SelectionMask, SelectionMode } from './mask.cjs';
+import { type SelectionMask, type SelectionMode } from './mask.cjs';
 import type { ColorDistance, ColorRangePreset } from './wand.cjs';
 import type { RefineEdgeParams } from './refine.cjs';
 /** Selection tools of the image editor UI. */

package/dist/image-editor/selection/tool-options.d.ts

@@ -1,4 +1,4 @@
-import type { SelectionMask, SelectionMode } from './mask.js';
+import { type SelectionMask, type SelectionMode } from './mask.js';
 import type { ColorDistance, ColorRangePreset } from './wand.js';
 import type { RefineEdgeParams } from './refine.js';
 /** Selection tools of the image editor UI. */

package/dist/image-editor/types.d.cts

@@ -314,6 +314,14 @@ export interface ImageEditorState {
     quickMask?: boolean;
     /** How the canvas shows the selection (view state; `quickMask` mirrors `'quickMask'`). */
     selectionDisplay?: 'ants' | 'quickMask' | 'none';
+    /**
+     * A layer mask shown on the canvas (view state, not saved): `gray` shows the mask alone in
+     * grey (Alt-click its thumbnail), `overlay` tints what it hides in red over the image (the \ key).
+     */
+    maskView?: {
+        layerId: string;
+        mode: 'gray' | 'overlay';
+    } | null;
     /**
      * Quick Mask mode: painting and fills without a layer edit the selection itself (white
      * selects, black deselects), shown as a tint. View state; the edits are undo steps.

package/dist/image-editor/types.d.ts

@@ -314,6 +314,14 @@ export interface ImageEditorState {
     quickMask?: boolean;
     /** How the canvas shows the selection (view state; `quickMask` mirrors `'quickMask'`). */
     selectionDisplay?: 'ants' | 'quickMask' | 'none';
+    /**
+     * A layer mask shown on the canvas (view state, not saved): `gray` shows the mask alone in
+     * grey (Alt-click its thumbnail), `overlay` tints what it hides in red over the image (the \ key).
+     */
+    maskView?: {
+        layerId: string;
+        mode: 'gray' | 'overlay';
+    } | null;
     /**
      * Quick Mask mode: painting and fills without a layer edit the selection itself (white
      * selects, black deselects), shown as a tint. View state; the edits are undo steps.

package/dist/paint-editor/index.cjs

@@ -7,7 +7,7 @@ var _chunkZ64NRDEHcjs = require('../chunk-Z64NRDEH.cjs');
 
 
 
-var _chunkX2KQQZBTcjs = require('../chunk-X2KQQZBT.cjs');
+var _chunkED4L4UD6cjs = require('../chunk-ED4L4UD6.cjs');
 require('../chunk-A2IS7EHE.cjs');
 
 
@@ -1653,11 +1653,11 @@ function header(state, options) {
   return out;
 }
 function serializePaintDocument(state, options = {}) {
-  const { layers, assets } = _chunkX2KQQZBTcjs.serializeLayers.call(void 0, state.layers);
+  const { layers, assets } = _chunkED4L4UD6cjs.serializeLayers.call(void 0, state.layers);
   return { ...header(state, options), layers, assets };
 }
 async function serializePaintDocumentExternal(state, store, options = {}) {
-  const { layers, assets } = await _chunkX2KQQZBTcjs.serializeLayersExternal.call(void 0, state.layers, store);
+  const { layers, assets } = await _chunkED4L4UD6cjs.serializeLayersExternal.call(void 0, state.layers, store);
   return { ...header(state, options), layers, assets };
 }
 function paintLayersOnly(layers, problems) {
@@ -1694,7 +1694,7 @@ function deserializePaintDocument(raw) {
   const canvas = normalizeCanvas({ width: r.width, height: r.height, dpi: _nullishCoalesce(r.dpi, () => ( void 0)) });
   const paper = _chunkYQ5C5BVKcjs.normalizePaper.call(void 0, _nullishCoalesce(r.paper, () => ( {})));
   const assets = r.assets && typeof r.assets === "object" ? r.assets : {};
-  const layers = paintLayersOnly(_chunkX2KQQZBTcjs.deserializeLayers.call(void 0, r.layers, { assets, problems }), problems);
+  const layers = paintLayersOnly(_chunkED4L4UD6cjs.deserializeLayers.call(void 0, r.layers, { assets, problems }), problems);
   const wanted = typeof r.activeLayerId === "string" ? r.activeLayerId : null;
   const activeLayerId = wanted && _chunkHGTDMKNEcjs.findLayer.call(void 0, layers, wanted) ? wanted : _nullishCoalesce(_optionalChain([_chunkHGTDMKNEcjs.flattenLayers.call(void 0, layers), 'access', _70 => _70.filter, 'call', _71 => _71((l) => l.type === "pixel"), 'access', _72 => _72.pop, 'call', _73 => _73(), 'optionalAccess', _74 => _74.id]), () => ( null));
   const wetEvents = Array.isArray(r.wetEvents) ? r.wetEvents.filter((e) => e && typeof e === "object" && Number.isInteger(e.clock) && typeof e.kind === "string") : [];
@@ -1710,7 +1710,7 @@ async function deserializePaintDocumentAsync(raw, store) {
   if (!raw || typeof raw !== "object") throw new Error("Not a paint document: expected a JSON object.");
   const r = raw;
   const problems = [];
-  const assets = await _chunkX2KQQZBTcjs.resolveExternalAssets.call(void 0, _nullishCoalesce(r.assets, () => ( {})), store, problems);
+  const assets = await _chunkED4L4UD6cjs.resolveExternalAssets.call(void 0, _nullishCoalesce(r.assets, () => ( {})), store, problems);
   const loaded = deserializePaintDocument({ ...r, assets });
   return { ...loaded, problems: [...problems, ...loaded.problems] };
 }
@@ -5409,7 +5409,7 @@ var PaintEditorController = (_class10 = class _PaintEditorController {
       return next.type === "group" ? { ...next, children: toStandard(next.children) } : next;
     });
     const layers = toStandard(dried);
-    const result = _chunkX2KQQZBTcjs.exportPsd.call(void 0, { width, height, layers: [paperLayer, ...layers], merged, resolution: dpi });
+    const result = _chunkED4L4UD6cjs.exportPsd.call(void 0, { width, height, layers: [paperLayer, ...layers], merged, resolution: dpi });
     for (const [mode, names] of changed) {
       const label = _nullishCoalesce(_optionalChain([_chunkCWM3CUUXcjs.BLEND_MODES, 'access', _271 => _271.find, 'call', _272 => _272((m) => m.id === mode), 'optionalAccess', _273 => _273.label]), () => ( mode));
       const std = _nullishCoalesce(_optionalChain([_chunkCWM3CUUXcjs.BLEND_MODES, 'access', _274 => _274.find, 'call', _275 => _275((m) => m.id === _chunkCWM3CUUXcjs.standardBlendMode.call(void 0, mode)), 'optionalAccess', _276 => _276.label]), () => ( _chunkCWM3CUUXcjs.standardBlendMode.call(void 0, mode)));

package/dist/paint-editor/index.js

@@ -7,7 +7,7 @@ import {
   resolveExternalAssets,
   serializeLayers,
   serializeLayersExternal
-} from "../chunk-FW7N64XK.js";
+} from "../chunk-ZEHTUR7Z.js";
 import "../chunk-3CI7FRMK.js";
 import {
   EffectRendererPool

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@pixerate/editor",
-  "version": "0.187.0",
+  "version": "0.189.0",
   "description": "UI-agnostic rich text and media editing core library",
   "author": "Pixerate",
   "license": "MIT",

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

@@ -297,6 +297,7 @@ in the source frame at the document's bit depth, colour mode and profile. Read
 | `add_layer_mask` | Mask any layer `from` `reveal-all`, `hide-all`, `selection`, `hide-selection` (its inverse) or `transparency` (the layer's own alpha), with optional `density` / `feather`. Replaces an existing mask. Returns the mask summary. |
 | `set_layer_mask_properties` | Change any layer mask's `density`, `feather`, `enabled` or `linked` (false: the mask stays put when the layer moves or transforms) without touching its pixels. |
 | `apply_layer_mask` | Bake a pixel layer's mask into its alpha and remove it. Destructive. |
+| `set_mask_view` | Show a layer's mask to check it (`view` `gray` alone, `overlay` red tint over what it hides, `off`; `layerId`, default active). View state only; look with `capture_view` `includeOverlays: true`, then `off`. Returns `{view, layerId}`. |
 | `remove_layer_mask` | Delete a mask without applying it; disable it instead to keep it. |
 | `layer_via_copy` | Copy the selected pixels of a pixel layer (default the active one) to a new layer above it; `cut: true` removes them from the source. Needs a selection. Returns the new layer. |
 | `rasterize_layer` | Turn a shape layer into a pixel layer showing the same pixels (same id, mask, effects, opacity, blend; the paths are gone), an annotation layer into pixels (browser only), a smart object into a pixel layer (as `rasterize_smart_object`), or bake a pixel layer's develop / blur filters into its pixels. Do it before painting over a shape or annotation, or when the user wants the filters fixed. Destructive. |

package/skills/pixerate-image-selection-masking/SKILL.md

@@ -82,7 +82,9 @@ This skill is the method. `pixerate-image-editor` has the full tool reference.
    `load_selection_from_image`).
 7. **Verify.** `render_preview` at 1024 px or more, and `capture_view` on the edge at 2–8×.
    **Check:** no fringe of the old background colour, no stair-steps, no visible line where an
-   adjustment ends. Fix by loading the mask back (`load_selection_from_mask`), refining, and
+   adjustment ends. To judge a layer mask itself, `set_mask_view` `gray` (or `overlay`) and
+   `capture_view` with `includeOverlays: true`; holes and stray grey show plainly there. Set it
+   back to `off` afterwards. Fix by loading the mask back (`load_selection_from_mask`), refining, and
    masking again.
 
 ## Decision table
@@ -192,6 +194,7 @@ This skill is the method. `pixerate-image-editor` has the full tool reference.
 - `load_selection_from_image`: AI or saved mattes
 - `load_selection_from_mask`: a layer mask back to a selection
 - `set_selection_display`: ants, Quick Mask tint or hidden
+- `set_mask_view`: a layer mask alone in grey or as a red overlay, to check it
 - `modify_selection`: expand, contract, feather, border, smooth
 - `refine_selection`: snap the edge to the image
 - `transform_selection`: move or scale the outline only