@rpgjs/map-builder 0.0.0-stage → 5.0.0

package/dist/terrain/editing.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"editing.js","names":[],"sources":["../../src/terrain/editing.ts"],"sourcesContent":["import type { Unsubscribe } from \"../model/result\";\nimport type { InteractionController, Tool } from \"../interaction/controller\";\nimport type { PointerInput } from \"../interaction/input\";\nimport type { IntentDefinition } from \"../interaction/intents\";\nimport type { PipelineStep } from \"../interaction/pipeline\";\nimport { tryReadTerrain } from \"./data\";\nimport { covers, readRect, shapeBounds } from \"./mask\";\nimport { MAX_PAINT_COST, paintCost } from \"./patches\";\nimport { NO_MATERIAL, type TerrainShape } from \"./types\";\n\ndeclare module \"../interaction/intents\" {\n  interface IntentRegistry {\n    /** Paint a shape of the terrain with a material, or erase it with `null`. */\n    \"terrain.paint\": { readonly shape: TerrainShape; readonly material: string | null };\n  }\n}\n\n/** The `terrain.paint` intent: one patch, after the rules of the pipeline. */\nexport const terrainPaintIntent: IntentDefinition<\"terrain.paint\"> = {\n  resolve(intent, { state }) {\n    if (!tryReadTerrain(state)) return { ok: false, reason: \"no-terrain\", message: \"This map has no terrain\" };\n    return { type: \"terrain.paint\", shape: intent.shape, material: intent.material };\n  },\n};\n\n/** Registers the intent, unless a feature already did. */\nexport function registerTerrainIntents(controller: InteractionController): Unsubscribe {\n  return controller.hasIntent(\"terrain.paint\") ? () => undefined : controller.registerIntent(\"terrain.paint\", terrainPaintIntent);\n}\n\n/**\n * Only paint over certain materials: `requireTerrain([\"grass\", \"dirt\"])` lets a game till grass and nothing else.\n * Checks every pixel the shape would cover. Pixels outside the map count as wrong ground.\n */\nexport function requireTerrain(materials: readonly string[]): PipelineStep<\"terrain.paint\"> {\n  return (intent, context, next) => {\n    const terrain = tryReadTerrain(context.state);\n    if (!terrain) return context.reject(\"no-terrain\", \"This map has no terrain\");\n    const allowed = new Set(materials.map((id) => terrain.materials.findIndex((material) => material.id === id)).filter((index) => index >= 0));\n    const bounds = shapeBounds(terrain.mask, intent.shape);\n    if (!bounds) return context.reject(\"outside-map\", \"Nothing of this lies on the map\");\n    // The check below tests every pixel against the shape: bound it as the patch does.\n    if (paintCost(terrain.mask, intent.shape) > MAX_PAINT_COST) return context.reject(\"too-large\", \"This is too large to paint at once\");\n    // One read of the whole region: reading pixel by pixel would decode a chunk for each of them.\n    const values = readRect(terrain.mask, bounds);\n    for (let y = bounds.y; y < bounds.y + bounds.height; y += 1) {\n      for (let x = bounds.x; x < bounds.x + bounds.width; x += 1) {\n        if (!covers(terrain.mask, intent.shape, x, y)) continue;\n        const value = values[(y - bounds.y) * bounds.width + (x - bounds.x)]!;\n        if (value === NO_MATERIAL || !allowed.has(value)) {\n          return context.reject(\"wrong-ground\", `Can only be painted over ${materials.join(\", \")}`);\n        }\n      }\n    }\n    return next();\n  };\n}\n\n/** Refuses shapes that reach outside the map. Without it they are clipped. */\nexport function withinTerrain(): PipelineStep<\"terrain.paint\"> {\n  return (intent, context, next) => {\n    const terrain = tryReadTerrain(context.state);\n    if (!terrain) return context.reject(\"no-terrain\", \"This map has no terrain\");\n    const shape = intent.shape;\n    const width = terrain.mask.width * terrain.mask.scale;\n    const height = terrain.mask.height * terrain.mask.scale;\n    const box = shape.type === \"fill\" ? { x0: 0, y0: 0, x1: width, y1: height } : shape.type === \"circle\" ? { x0: shape.x - shape.radius, y0: shape.y - shape.radius, x1: shape.x + shape.radius, y1: shape.y + shape.radius }\n      : shape.type === \"rect\" ? { x0: shape.x, y0: shape.y, x1: shape.x + shape.width, y1: shape.y + shape.height }\n        : { x0: Math.min(...shape.points.map((p) => p[0])) - shape.radius, y0: Math.min(...shape.points.map((p) => p[1])) - shape.radius, x1: Math.max(...shape.points.map((p) => p[0])) + shape.radius, y1: Math.max(...shape.points.map((p) => p[1])) + shape.radius };\n    if (box.x0 < 0 || box.y0 < 0 || box.x1 > width || box.y1 > height) return context.reject(\"outside-map\", \"This reaches outside the map\");\n    return next();\n  };\n}\n\n/** Keeps a brush from being bigger than a game wants. */\nexport function maxRadius(limit: number): PipelineStep<\"terrain.paint\"> {\n  return (intent, _context, next) => {\n    const shape = intent.shape;\n    if ((shape.type === \"circle\" || shape.type === \"stroke\") && shape.radius > limit) return next({ ...intent, shape: { ...shape, radius: limit } });\n    return next();\n  };\n}\n\nexport interface BrushOptions {\n  /** Material to paint, or `null` to erase. */\n  readonly material: string | null;\n  /** Radius in world pixels. */\n  readonly radius: number;\n  /** Distance between two points of a stroke, in world pixels. Defaults to a third of the radius. */\n  readonly spacing?: number;\n}\n\nexport interface BrushApi {\n  /** Starts painting with the pointer: pressing paints, dragging paints a line, releasing ends the stroke. */\n  start(options: BrushOptions): void;\n  stop(): void;\n  readonly active: BrushOptions | null;\n}\n\nexport interface BrushTool {\n  readonly tool: Tool;\n  readonly api: BrushApi;\n}\n\nlet strokes = 0;\n\n/**\n * The tool that paints. Each press-drag-release is one undo step, however many patches it made. It only\n * submits intents: whatever rules the pipeline has, and wherever the model commits (here or on an authority),\n * apply as for anything else.\n */\nexport function terrainBrush(options: { readonly modes?: readonly string[] } = {}): BrushTool {\n  let brush: BrushOptions | null = null;\n  let last: { x: number; y: number } | null = null;\n  let key = \"\";\n\n  const paintAt = (controller: InteractionController, shape: TerrainShape): void => {\n    if (!brush) return;\n    controller.submit({ type: \"terrain.paint\", shape, material: brush.material }, { coalesce: key });\n  };\n\n  const end = (): void => {\n    last = null;\n    key = \"\";\n  };\n\n  const tool: Tool = {\n    id: \"terrain-brush\",\n    modes: options.modes ?? [\"edit\"],\n    // Painting comes before selecting: while a brush is in hand, a press paints.\n    priority: 90,\n    pointerDown(input: PointerInput, controller) {\n      if (!brush || input.button !== 0) return false;\n      strokes += 1;\n      key = `terrain-stroke-${strokes}`;\n      last = { x: input.x, y: input.y };\n      paintAt(controller, { type: \"circle\", x: input.x, y: input.y, radius: brush.radius });\n      return true;\n    },\n    pointerMove(input: PointerInput, controller) {\n      if (!brush || !last) return false;\n      const spacing = brush.spacing ?? Math.max(1, brush.radius / 3);\n      if (Math.hypot(input.x - last.x, input.y - last.y) < spacing) return true;\n      paintAt(controller, { type: \"stroke\", points: [[last.x, last.y], [input.x, input.y]], radius: brush.radius });\n      last = { x: input.x, y: input.y };\n      return true;\n    },\n    pointerUp: end,\n    cancel: end,\n  };\n\n  return {\n    tool,\n    api: {\n      start(next) {\n        brush = next;\n      },\n      stop() {\n        brush = null;\n        end();\n      },\n      get active() {\n        return brush;\n      },\n    },\n  };\n}\n"],"mappings":"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"}

package/dist/terrain/index.d.ts

@@ -0,0 +1,10 @@
+export * from './types';
+export * from './rle';
+export * from './mask';
+export * from './data';
+export * from './patches';
+export * from './define';
+export * from './scheduler';
+export * from './kernel';
+export * from './editing';
+//# sourceMappingURL=index.d.ts.map

package/dist/terrain/index.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../src/terrain/index.ts"],"names":[],"mappings":"AAAA,cAAc,SAAS,CAAC;AACxB,cAAc,OAAO,CAAC;AACtB,cAAc,QAAQ,CAAC;AACvB,cAAc,QAAQ,CAAC;AACvB,cAAc,WAAW,CAAC;AAC1B,cAAc,UAAU,CAAC;AACzB,cAAc,aAAa,CAAC;AAC5B,cAAc,UAAU,CAAC;AACzB,cAAc,WAAW,CAAC"}

package/dist/terrain/index.js

@@ -0,0 +1,10 @@
+import { NO_MATERIAL, TERRAIN_DATA_VERSION, TERRAIN_EXTENSION_ID } from "./types.js";
+import { readTerrain, terrainIssues, tryReadTerrain } from "./data.js";
+import { decodeRuns, encodeRuns } from "./rle.js";
+import { chunkCount, clipRect, covers, createMask, paintShape, readAll, readChunk, readPixel, readRect, shapeBounds, writeRect } from "./mask.js";
+import { blendRadius, controlPixels, dirtyOfPatch, globalOverlayMaterials, growRect, overlayMaterials, renderMargin, toKernelDocument, widestBlend, writeControl } from "./kernel.js";
+import { createTerrainScheduler } from "./scheduler.js";
+import { MAX_PAINT_COST, paintCost, terrainPatchHandlers } from "./patches.js";
+import { maxRadius, registerTerrainIntents, requireTerrain, terrainBrush, terrainPaintIntent, withinTerrain } from "./editing.js";
+import { defineTerrain, paint } from "./define.js";
+export { MAX_PAINT_COST, NO_MATERIAL, TERRAIN_DATA_VERSION, TERRAIN_EXTENSION_ID, blendRadius, chunkCount, clipRect, controlPixels, covers, createMask, createTerrainScheduler, decodeRuns, defineTerrain, dirtyOfPatch, encodeRuns, globalOverlayMaterials, growRect, maxRadius, overlayMaterials, paint, paintCost, paintShape, readAll, readChunk, readPixel, readRect, readTerrain, registerTerrainIntents, renderMargin, requireTerrain, shapeBounds, terrainBrush, terrainIssues, terrainPaintIntent, terrainPatchHandlers, toKernelDocument, tryReadTerrain, widestBlend, withinTerrain, writeControl, writeRect };

package/dist/terrain/kernel.d.ts

@@ -0,0 +1,57 @@
+import { RasterImage, TerrainMapDocument } from '@rpgjs/render-map2d';
+import { MapPatch } from '../model/patches';
+import { WorldRect } from './scheduler';
+import { MaskRect, TerrainData, TerrainMode } from './types';
+/**
+ * What the terrain feature feeds the kernel (`@rpgjs/render-map2d`) with. Types only: this file
+ * never imports the kernel at runtime, so the data model stays usable without it.
+ */
+/** Where a material's texture comes from: the decoded image, and the part of it to use. */
+export interface MaterialSource {
+    readonly src: string;
+    readonly frame?: readonly [x: number, y: number, width: number, height: number];
+}
+/** A message-friendly description of the terrain to render. */
+export interface TerrainRenderInit {
+    readonly data: TerrainData;
+    /** World size, in pixels. */
+    readonly size: readonly [width: number, height: number];
+    readonly tileSize: number;
+    /** By material id. */
+    readonly sources: {
+        readonly [materialId: string]: MaterialSource;
+    };
+    /** Decoded images, by `src`. */
+    readonly images: {
+        readonly [src: string]: RasterImage;
+    };
+}
+/** How far a material's mode blends into its surroundings, in pixels. */
+export declare function blendRadius(mode: TerrainMode | undefined): number;
+/**
+ * How far a changed mask changes pixels: the widest blend of the materials and transitions, or the reach
+ * of an overlay (nine-slice, local presets), plus a few pixels for the tails of the soft mask.
+ */
+export declare function widestBlend(data: TerrainData): number;
+/**
+ * The margin to give the kernel around a region so that it gets the pixels of a larger render: the widest
+ * blend, or how far a hole or a wall reaches (its height or depth) if that is more.
+ */
+export declare function renderMargin(data: TerrainData): number;
+/**
+ * Materials drawn as an overlay of the whole mask: the kernel caches it, so a change of the mask has to drop
+ * that cache (the render host does).
+ */
+export declare function overlayMaterials(data: TerrainData): readonly number[];
+/** Those whose pixels may change anywhere when the mask changes under them: everything is rendered again. */
+export declare function globalOverlayMaterials(data: TerrainData): readonly number[];
+/** The mask as the kernel's control image: material index in red and green, opaque where something is painted. */
+export declare function controlPixels(data: TerrainData): Uint8ClampedArray;
+/** Writes values over a rectangle of a control image (what `terrain.paint` and `terrain.region` change). */
+export declare function writeControl(pixels: Uint8ClampedArray, maskWidth: number, rect: MaskRect, values: ArrayLike<number>): void;
+/** The document the kernel renders. `controlPixels` is the control image, kept up to date by the caller. */
+export declare function toKernelDocument(init: TerrainRenderInit, control: Uint8ClampedArray): TerrainMapDocument;
+/** What to render again after a patch, in world pixels. `"all"` when the patch can change anything. */
+export declare function dirtyOfPatch(patch: MapPatch, data: TerrainData, grow: number): WorldRect | "all" | "none";
+export declare const growRect: (rect: WorldRect, by: number) => WorldRect;
+//# sourceMappingURL=kernel.d.ts.map

package/dist/terrain/kernel.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"kernel.d.ts","sourceRoot":"","sources":["../../src/terrain/kernel.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,WAAW,EAAE,kBAAkB,EAAqB,MAAM,qBAAqB,CAAC;AAC9F,OAAO,KAAK,EAAE,QAAQ,EAAE,MAAM,kBAAkB,CAAC;AAEjD,OAAO,KAAK,EAAE,SAAS,EAAE,MAAM,aAAa,CAAC;AAC7C,OAAO,EAAe,KAAK,QAAQ,EAAE,KAAK,WAAW,EAAE,KAAK,WAAW,EAAE,MAAM,SAAS,CAAC;AAEzF;;;GAGG;AAEH,2FAA2F;AAC3F,MAAM,WAAW,cAAc;IAC7B,QAAQ,CAAC,GAAG,EAAE,MAAM,CAAC;IACrB,QAAQ,CAAC,KAAK,CAAC,EAAE,SAAS,CAAC,CAAC,EAAE,MAAM,EAAE,CAAC,EAAE,MAAM,EAAE,KAAK,EAAE,MAAM,EAAE,MAAM,EAAE,MAAM,CAAC,CAAC;CACjF;AAED,+DAA+D;AAC/D,MAAM,WAAW,iBAAiB;IAChC,QAAQ,CAAC,IAAI,EAAE,WAAW,CAAC;IAC3B,6BAA6B;IAC7B,QAAQ,CAAC,IAAI,EAAE,SAAS,CAAC,KAAK,EAAE,MAAM,EAAE,MAAM,EAAE,MAAM,CAAC,CAAC;IACxD,QAAQ,CAAC,QAAQ,EAAE,MAAM,CAAC;IAC1B,sBAAsB;IACtB,QAAQ,CAAC,OAAO,EAAE;QAAE,QAAQ,EAAE,UAAU,EAAE,MAAM,GAAG,cAAc,CAAA;KAAE,CAAC;IACpE,gCAAgC;IAChC,QAAQ,CAAC,MAAM,EAAE;QAAE,QAAQ,EAAE,GAAG,EAAE,MAAM,GAAG,WAAW,CAAA;KAAE,CAAC;CAC1D;AAKD,yEAAyE;AACzE,wBAAgB,WAAW,CAAC,IAAI,EAAE,WAAW,GAAG,SAAS,GAAG,MAAM,CAejE;AAeD;;;GAGG;AACH,wBAAgB,WAAW,CAAC,IAAI,EAAE,WAAW,GAAG,MAAM,CAQrD;AAED;;;GAGG;AACH,wBAAgB,YAAY,CAAC,IAAI,EAAE,WAAW,GAAG,MAAM,CAOtD;AAED;;;GAGG;AACH,wBAAgB,gBAAgB,CAAC,IAAI,EAAE,WAAW,GAAG,SAAS,MAAM,EAAE,CAMrE;AAED,6GAA6G;AAC7G,wBAAgB,sBAAsB,CAAC,IAAI,EAAE,WAAW,GAAG,SAAS,MAAM,EAAE,CAM3E;AAED,kHAAkH;AAClH,wBAAgB,aAAa,CAAC,IAAI,EAAE,WAAW,GAAG,iBAAiB,CAUlE;AAED,4GAA4G;AAC5G,wBAAgB,YAAY,CAAC,MAAM,EAAE,iBAAiB,EAAE,SAAS,EAAE,MAAM,EAAE,IAAI,EAAE,QAAQ,EAAE,MAAM,EAAE,SAAS,CAAC,MAAM,CAAC,GAAG,IAAI,CAW1H;AAID,4GAA4G;AAC5G,wBAAgB,gBAAgB,CAAC,IAAI,EAAE,iBAAiB,EAAE,OAAO,EAAE,iBAAiB,GAAG,kBAAkB,CA+BxG;AAED,uGAAuG;AACvG,wBAAgB,YAAY,CAAC,KAAK,EAAE,QAAQ,EAAE,IAAI,EAAE,WAAW,EAAE,IAAI,EAAE,MAAM,GAAG,SAAS,GAAG,KAAK,GAAG,MAAM,CAgBzG;AAED,eAAO,MAAM,QAAQ,GAAI,MAAM,SAAS,EAAE,IAAI,MAAM,KAAG,SAA2G,CAAC"}

package/dist/terrain/kernel.js

@@ -0,0 +1,198 @@
+import "./types.js";
+import { readAll, shapeBounds } from "./mask.js";
+//#region src/terrain/kernel.ts
+var DEFAULT_BLEND = 18;
+var WATER_BLEND = 16;
+/** How far a material's mode blends into its surroundings, in pixels. */
+function blendRadius(mode) {
+	if (!mode) return DEFAULT_BLEND;
+	switch (mode.type) {
+		case "hard":
+		case "nine-slice": return 0;
+		case "fade": return typeof mode.width === "number" && mode.width > 0 ? mode.width : DEFAULT_BLEND;
+		case "water": return mode.border === false ? 8 : WATER_BLEND;
+		case "custom": {
+			const width = Number(mode.params?.blendRadius ?? mode.params?.width);
+			return Number.isFinite(width) && width >= 0 ? width : DEFAULT_BLEND;
+		}
+	}
+}
+/** Presets of the kernel whose pixels depend only on what is near: a change shows up within this many pixels. */
+var LOCAL_OVERLAY_REACH = 32;
+var LOCAL_PRESETS = /* @__PURE__ */ new Set([
+	"grass-edge",
+	"carpet",
+	"carpet-border",
+	"road-town-sidewalk",
+	"water"
+]);
+/** Whether a material is drawn as an overlay computed on the whole mask (nine-slice and presets). */
+var isOverlay = (mode) => mode?.type === "nine-slice" || mode?.type === "custom";
+/**
+* Whether a material's overlay may change far from an edit: presets that are not known to be local
+* (lane marks follow the whole road, a game's own preset is unknown) count as global.
+*/
+var isGlobalOverlay = (mode) => mode?.type === "custom" && !LOCAL_PRESETS.has(mode.shaderKey);
+/**
+* How far a changed mask changes pixels: the widest blend of the materials and transitions, or the reach
+* of an overlay (nine-slice, local presets), plus a few pixels for the tails of the soft mask.
+*/
+function widestBlend(data) {
+	let widest = 0;
+	for (const material of data.materials) {
+		widest = Math.max(widest, blendRadius(material.mode));
+		if (isOverlay(material.mode) && !isGlobalOverlay(material.mode)) widest = Math.max(widest, LOCAL_OVERLAY_REACH);
+	}
+	for (const transition of data.transitions ?? []) widest = Math.max(widest, blendRadius(transition.mode));
+	return Math.ceil(widest) + 8;
+}
+/**
+* The margin to give the kernel around a region so that it gets the pixels of a larger render: the widest
+* blend, or how far a hole or a wall reaches (its height or depth) if that is more.
+*/
+function renderMargin(data) {
+	let reach = 0;
+	for (const feature of data.morphology ?? []) {
+		const params = feature.params ?? {};
+		reach = Math.max(reach, Number(params.height ?? params.depth) || 0);
+	}
+	return Math.max(widestBlend(data), Math.ceil(reach) + 8);
+}
+/**
+* Materials drawn as an overlay of the whole mask: the kernel caches it, so a change of the mask has to drop
+* that cache (the render host does).
+*/
+function overlayMaterials(data) {
+	const indexes = [];
+	data.materials.forEach((material, index) => {
+		if (isOverlay(material.mode)) indexes.push(index);
+	});
+	return indexes;
+}
+/** Those whose pixels may change anywhere when the mask changes under them: everything is rendered again. */
+function globalOverlayMaterials(data) {
+	const indexes = [];
+	data.materials.forEach((material, index) => {
+		if (isGlobalOverlay(material.mode)) indexes.push(index);
+	});
+	return indexes;
+}
+/** The mask as the kernel's control image: material index in red and green, opaque where something is painted. */
+function controlPixels(data) {
+	const values = readAll(data.mask);
+	const pixels = new Uint8ClampedArray(values.length * 4);
+	for (let i = 0; i < values.length; i += 1) {
+		const value = values[i];
+		pixels[i * 4] = value & 255;
+		pixels[i * 4 + 1] = value >> 8;
+		pixels[i * 4 + 3] = value === 65535 ? 0 : 255;
+	}
+	return pixels;
+}
+/** Writes values over a rectangle of a control image (what `terrain.paint` and `terrain.region` change). */
+function writeControl(pixels, maskWidth, rect, values) {
+	for (let y = 0; y < rect.height; y += 1) for (let x = 0; x < rect.width; x += 1) {
+		const value = values[y * rect.width + x];
+		const offset = ((rect.y + y) * maskWidth + rect.x + x) * 4;
+		pixels[offset] = value & 255;
+		pixels[offset + 1] = value >> 8;
+		pixels[offset + 2] = 0;
+		pixels[offset + 3] = value === 65535 ? 0 : 255;
+	}
+}
+var toKernelMode = (mode) => mode;
+/** The document the kernel renders. `controlPixels` is the control image, kept up to date by the caller. */
+function toKernelDocument(init, control) {
+	const { data } = init;
+	return {
+		version: 1,
+		width: init.size[0],
+		height: init.size[1],
+		tileSize: init.tileSize,
+		textureGrid: {
+			columns: 1,
+			rows: 1,
+			tileSize: 1
+		},
+		textures: data.materials.map((material, index) => {
+			const source = init.sources[material.id];
+			const image = source ? init.images[source.src] : void 0;
+			const frame = source?.frame ?? (image ? [
+				0,
+				0,
+				image.width,
+				image.height
+			] : void 0);
+			return {
+				id: material.id,
+				index,
+				label: material.id,
+				...source ? { source: source.src } : {},
+				...frame ? { sourceRect: {
+					x: frame[0],
+					y: frame[1],
+					width: frame[2],
+					height: frame[3]
+				} } : {},
+				...material.priority !== void 0 ? { priority: material.priority } : { priority: index },
+				...material.collision !== void 0 ? { collision: material.collision } : {},
+				...material.specialType !== void 0 ? { specialType: material.specialType } : {},
+				...material.renderTileSize !== void 0 ? { renderTileSize: material.renderTileSize } : {},
+				...material.renderingStyle !== void 0 ? { renderingStyle: material.renderingStyle } : {},
+				...toKernelMode(material.mode) ? { defaultRenderMode: toKernelMode(material.mode) } : {}
+			};
+		}),
+		transitions: (data.transitions ?? []).map((rule) => ({
+			from: rule.from,
+			to: rule.to,
+			mode: toKernelMode(rule.mode),
+			...rule.priority !== void 0 ? { priority: rule.priority } : {}
+		})),
+		controlTexture: {
+			width: data.mask.width,
+			height: data.mask.height,
+			palette: data.materials.map((m) => m.id),
+			pixels: control
+		},
+		morphology: data.morphology ?? [],
+		waterAnimation: data.water ?? {
+			enabled: false,
+			speed: 1,
+			intensity: 1,
+			direction: 0
+		}
+	};
+}
+/** What to render again after a patch, in world pixels. `"all"` when the patch can change anything. */
+function dirtyOfPatch(patch, data, grow) {
+	const scale = data.mask.scale;
+	const fromMask = (rect) => rect ? growRect({
+		x: rect.x * scale,
+		y: rect.y * scale,
+		width: rect.width * scale,
+		height: rect.height * scale
+	}, grow) : "none";
+	switch (patch.type) {
+		case "terrain.paint": return fromMask(shapeBounds(data.mask, patch.shape));
+		case "terrain.region": return fromMask({
+			x: patch.x,
+			y: patch.y,
+			width: patch.width,
+			height: patch.height
+		});
+		case "terrain.materials":
+		case "terrain.morphology":
+		case "extension.set": return "all";
+		default: return "none";
+	}
+}
+var growRect = (rect, by) => ({
+	x: rect.x - by,
+	y: rect.y - by,
+	width: rect.width + by * 2,
+	height: rect.height + by * 2
+});
+//#endregion
+export { blendRadius, controlPixels, dirtyOfPatch, globalOverlayMaterials, growRect, overlayMaterials, renderMargin, toKernelDocument, widestBlend, writeControl };
+
+//# sourceMappingURL=kernel.js.map

package/dist/terrain/kernel.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"kernel.js","names":[],"sources":["../../src/terrain/kernel.ts"],"sourcesContent":["import type { RasterImage, TerrainMapDocument, TerrainRenderMode } from \"@rpgjs/render-map2d\";\nimport type { MapPatch } from \"../model/patches\";\nimport { readAll, shapeBounds } from \"./mask\";\nimport type { WorldRect } from \"./scheduler\";\nimport { NO_MATERIAL, type MaskRect, type TerrainData, type TerrainMode } from \"./types\";\n\n/**\n * What the terrain feature feeds the kernel (`@rpgjs/render-map2d`) with. Types only: this file\n * never imports the kernel at runtime, so the data model stays usable without it.\n */\n\n/** Where a material's texture comes from: the decoded image, and the part of it to use. */\nexport interface MaterialSource {\n  readonly src: string;\n  readonly frame?: readonly [x: number, y: number, width: number, height: number];\n}\n\n/** A message-friendly description of the terrain to render. */\nexport interface TerrainRenderInit {\n  readonly data: TerrainData;\n  /** World size, in pixels. */\n  readonly size: readonly [width: number, height: number];\n  readonly tileSize: number;\n  /** By material id. */\n  readonly sources: { readonly [materialId: string]: MaterialSource };\n  /** Decoded images, by `src`. */\n  readonly images: { readonly [src: string]: RasterImage };\n}\n\nconst DEFAULT_BLEND = 18;\nconst WATER_BLEND = 16;\n\n/** How far a material's mode blends into its surroundings, in pixels. */\nexport function blendRadius(mode: TerrainMode | undefined): number {\n  if (!mode) return DEFAULT_BLEND;\n  switch (mode.type) {\n    case \"hard\":\n    case \"nine-slice\":\n      return 0;\n    case \"fade\":\n      return typeof mode.width === \"number\" && mode.width > 0 ? mode.width : DEFAULT_BLEND;\n    case \"water\":\n      return mode.border === false ? 8 : WATER_BLEND;\n    case \"custom\": {\n      const width = Number(mode.params?.blendRadius ?? mode.params?.width);\n      return Number.isFinite(width) && width >= 0 ? width : DEFAULT_BLEND;\n    }\n  }\n}\n\n/** Presets of the kernel whose pixels depend only on what is near: a change shows up within this many pixels. */\nconst LOCAL_OVERLAY_REACH = 32;\nconst LOCAL_PRESETS = new Set([\"grass-edge\", \"carpet\", \"carpet-border\", \"road-town-sidewalk\", \"water\"]);\n\n/** Whether a material is drawn as an overlay computed on the whole mask (nine-slice and presets). */\nconst isOverlay = (mode: TerrainMode | undefined): boolean => mode?.type === \"nine-slice\" || mode?.type === \"custom\";\n\n/**\n * Whether a material's overlay may change far from an edit: presets that are not known to be local\n * (lane marks follow the whole road, a game's own preset is unknown) count as global.\n */\nconst isGlobalOverlay = (mode: TerrainMode | undefined): boolean => mode?.type === \"custom\" && !LOCAL_PRESETS.has(mode.shaderKey);\n\n/**\n * How far a changed mask changes pixels: the widest blend of the materials and transitions, or the reach\n * of an overlay (nine-slice, local presets), plus a few pixels for the tails of the soft mask.\n */\nexport function widestBlend(data: TerrainData): number {\n  let widest = 0;\n  for (const material of data.materials) {\n    widest = Math.max(widest, blendRadius(material.mode));\n    if (isOverlay(material.mode) && !isGlobalOverlay(material.mode)) widest = Math.max(widest, LOCAL_OVERLAY_REACH);\n  }\n  for (const transition of data.transitions ?? []) widest = Math.max(widest, blendRadius(transition.mode));\n  return Math.ceil(widest) + 8;\n}\n\n/**\n * The margin to give the kernel around a region so that it gets the pixels of a larger render: the widest\n * blend, or how far a hole or a wall reaches (its height or depth) if that is more.\n */\nexport function renderMargin(data: TerrainData): number {\n  let reach = 0;\n  for (const feature of data.morphology ?? []) {\n    const params = (feature.params ?? {}) as { height?: unknown; depth?: unknown };\n    reach = Math.max(reach, Number(params.height ?? params.depth) || 0);\n  }\n  return Math.max(widestBlend(data), Math.ceil(reach) + 8);\n}\n\n/**\n * Materials drawn as an overlay of the whole mask: the kernel caches it, so a change of the mask has to drop\n * that cache (the render host does).\n */\nexport function overlayMaterials(data: TerrainData): readonly number[] {\n  const indexes: number[] = [];\n  data.materials.forEach((material, index) => {\n    if (isOverlay(material.mode)) indexes.push(index);\n  });\n  return indexes;\n}\n\n/** Those whose pixels may change anywhere when the mask changes under them: everything is rendered again. */\nexport function globalOverlayMaterials(data: TerrainData): readonly number[] {\n  const indexes: number[] = [];\n  data.materials.forEach((material, index) => {\n    if (isGlobalOverlay(material.mode)) indexes.push(index);\n  });\n  return indexes;\n}\n\n/** The mask as the kernel's control image: material index in red and green, opaque where something is painted. */\nexport function controlPixels(data: TerrainData): Uint8ClampedArray {\n  const values = readAll(data.mask);\n  const pixels = new Uint8ClampedArray(values.length * 4);\n  for (let i = 0; i < values.length; i += 1) {\n    const value = values[i]!;\n    pixels[i * 4] = value & 255;\n    pixels[i * 4 + 1] = value >> 8;\n    pixels[i * 4 + 3] = value === NO_MATERIAL ? 0 : 255;\n  }\n  return pixels;\n}\n\n/** Writes values over a rectangle of a control image (what `terrain.paint` and `terrain.region` change). */\nexport function writeControl(pixels: Uint8ClampedArray, maskWidth: number, rect: MaskRect, values: ArrayLike<number>): void {\n  for (let y = 0; y < rect.height; y += 1) {\n    for (let x = 0; x < rect.width; x += 1) {\n      const value = values[y * rect.width + x]!;\n      const offset = ((rect.y + y) * maskWidth + rect.x + x) * 4;\n      pixels[offset] = value & 255;\n      pixels[offset + 1] = value >> 8;\n      pixels[offset + 2] = 0;\n      pixels[offset + 3] = value === NO_MATERIAL ? 0 : 255;\n    }\n  }\n}\n\nconst toKernelMode = (mode: TerrainMode | undefined): TerrainRenderMode | undefined => mode as TerrainRenderMode | undefined;\n\n/** The document the kernel renders. `controlPixels` is the control image, kept up to date by the caller. */\nexport function toKernelDocument(init: TerrainRenderInit, control: Uint8ClampedArray): TerrainMapDocument {\n  const { data } = init;\n  return {\n    version: 1,\n    width: init.size[0],\n    height: init.size[1],\n    tileSize: init.tileSize,\n    textureGrid: { columns: 1, rows: 1, tileSize: 1 },\n    textures: data.materials.map((material, index) => {\n      const source = init.sources[material.id];\n      const image = source ? init.images[source.src] : undefined;\n      const frame = source?.frame ?? (image ? [0, 0, image.width, image.height] as const : undefined);\n      return {\n        id: material.id,\n        index,\n        label: material.id,\n        ...(source ? { source: source.src } : {}),\n        ...(frame ? { sourceRect: { x: frame[0], y: frame[1], width: frame[2], height: frame[3] } } : {}),\n        ...(material.priority !== undefined ? { priority: material.priority } : { priority: index }),\n        ...(material.collision !== undefined ? { collision: material.collision } : {}),\n        ...(material.specialType !== undefined ? { specialType: material.specialType } : {}),\n        ...(material.renderTileSize !== undefined ? { renderTileSize: material.renderTileSize } : {}),\n        ...(material.renderingStyle !== undefined ? { renderingStyle: material.renderingStyle } : {}),\n        ...(toKernelMode(material.mode) ? { defaultRenderMode: toKernelMode(material.mode)! } : {}),\n      };\n    }),\n    transitions: (data.transitions ?? []).map((rule) => ({ from: rule.from, to: rule.to, mode: toKernelMode(rule.mode)!, ...(rule.priority !== undefined ? { priority: rule.priority } : {}) })),\n    controlTexture: { width: data.mask.width, height: data.mask.height, palette: data.materials.map((m) => m.id), pixels: control },\n    morphology: (data.morphology ?? []) as unknown as TerrainMapDocument[\"morphology\"],\n    waterAnimation: data.water ?? { enabled: false, speed: 1, intensity: 1, direction: 0 },\n  };\n}\n\n/** What to render again after a patch, in world pixels. `\"all\"` when the patch can change anything. */\nexport function dirtyOfPatch(patch: MapPatch, data: TerrainData, grow: number): WorldRect | \"all\" | \"none\" {\n  const scale = data.mask.scale;\n  const fromMask = (rect: MaskRect | undefined): WorldRect | \"none\" =>\n    rect ? growRect({ x: rect.x * scale, y: rect.y * scale, width: rect.width * scale, height: rect.height * scale }, grow) : \"none\";\n  switch (patch.type) {\n    case \"terrain.paint\":\n      return fromMask(shapeBounds(data.mask, patch.shape));\n    case \"terrain.region\":\n      return fromMask({ x: patch.x, y: patch.y, width: patch.width, height: patch.height });\n    case \"terrain.materials\":\n    case \"terrain.morphology\":\n    case \"extension.set\":\n      return \"all\";\n    default:\n      return \"none\";\n  }\n}\n\nexport const growRect = (rect: WorldRect, by: number): WorldRect => ({ x: rect.x - by, y: rect.y - by, width: rect.width + by * 2, height: rect.height + by * 2 });\n"],"mappings":"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"}

package/dist/terrain/mask.d.ts

@@ -0,0 +1,37 @@
+import { MaskRect, TerrainData, TerrainMask, TerrainShape } from './types';
+export declare const chunkCount: (mask: TerrainMask) => {
+    cols: number;
+    rows: number;
+};
+/** The values of a chunk. A chunk that is not stored is flat. */
+export declare function readChunk(mask: TerrainMask, col: number, row: number): Uint16Array;
+/** Material index at a mask pixel. */
+export declare function readPixel(mask: TerrainMask, x: number, y: number): number;
+/** Whole mask as one array, row by row. For the kernel and for tests: it is as big as the map. */
+export declare function readAll(mask: TerrainMask): Uint16Array;
+/** Values of a rectangle, row by row. The rectangle is clipped by the caller. */
+export declare function readRect(mask: TerrainMask, rect: MaskRect): Uint16Array;
+export declare function clipRect(mask: TerrainMask, rect: MaskRect): MaskRect | undefined;
+/** Bounds of a shape in mask pixels, clipped to the mask. `undefined` when it is entirely outside. */
+export declare function shapeBounds(mask: TerrainMask, shape: TerrainShape): MaskRect | undefined;
+/** Whether the centre of a mask pixel is inside the shape. */
+export declare function covers(mask: TerrainMask, shape: TerrainShape, x: number, y: number): boolean;
+export interface PaintResult {
+    readonly mask: TerrainMask;
+    /** Smallest rectangle (in mask pixels) that contains every pixel that changed. Undefined when none did. */
+    readonly changed?: MaskRect;
+    /** The values of `changed` before the change, for the inverse. */
+    readonly before?: Uint16Array;
+}
+/** Sets the material under a shape. Chunks that do not change are shared with the input. */
+export declare function paintShape(mask: TerrainMask, shape: TerrainShape, material: number): PaintResult;
+/** Writes values over a rectangle (an inverse, or an imported region). Chunks that do not change are shared. */
+export declare function writeRect(mask: TerrainMask, rect: MaskRect, values: ArrayLike<number>): PaintResult;
+/** A new, flat mask. */
+export declare function createMask(width: number, height: number, options?: {
+    scale?: number;
+    chunk?: number;
+    fill?: number;
+}): TerrainMask;
+export type { TerrainData };
+//# sourceMappingURL=mask.d.ts.map

package/dist/terrain/mask.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"mask.d.ts","sourceRoot":"","sources":["../../src/terrain/mask.ts"],"names":[],"mappings":"AAAA,OAAO,EAAe,KAAK,QAAQ,EAAE,KAAK,WAAW,EAAE,KAAK,WAAW,EAAE,KAAK,YAAY,EAAE,MAAM,SAAS,CAAC;AAM5G,eAAO,MAAM,UAAU,GAAI,MAAM,WAAW,KAAG;IAAE,IAAI,EAAE,MAAM,CAAC;IAAC,IAAI,EAAE,MAAM,CAAA;CAGzE,CAAC;AAEH,iEAAiE;AACjE,wBAAgB,SAAS,CAAC,IAAI,EAAE,WAAW,EAAE,GAAG,EAAE,MAAM,EAAE,GAAG,EAAE,MAAM,GAAG,WAAW,CAIlF;AAED,sCAAsC;AACtC,wBAAgB,SAAS,CAAC,IAAI,EAAE,WAAW,EAAE,CAAC,EAAE,MAAM,EAAE,CAAC,EAAE,MAAM,GAAG,MAAM,CAGzE;AAED,kGAAkG;AAClG,wBAAgB,OAAO,CAAC,IAAI,EAAE,WAAW,GAAG,WAAW,CActD;AAED,iFAAiF;AACjF,wBAAgB,QAAQ,CAAC,IAAI,EAAE,WAAW,EAAE,IAAI,EAAE,QAAQ,GAAG,WAAW,CAoBvE;AAED,wBAAgB,QAAQ,CAAC,IAAI,EAAE,WAAW,EAAE,IAAI,EAAE,QAAQ,GAAG,QAAQ,GAAG,SAAS,CAMhF;AAED,sGAAsG;AACtG,wBAAgB,WAAW,CAAC,IAAI,EAAE,WAAW,EAAE,KAAK,EAAE,YAAY,GAAG,QAAQ,GAAG,SAAS,CAkBxF;AAYD,8DAA8D;AAC9D,wBAAgB,MAAM,CAAC,IAAI,EAAE,WAAW,EAAE,KAAK,EAAE,YAAY,EAAE,CAAC,EAAE,MAAM,EAAE,CAAC,EAAE,MAAM,GAAG,OAAO,CAqB5F;AAED,MAAM,WAAW,WAAW;IAC1B,QAAQ,CAAC,IAAI,EAAE,WAAW,CAAC;IAC3B,2GAA2G;IAC3G,QAAQ,CAAC,OAAO,CAAC,EAAE,QAAQ,CAAC;IAC5B,kEAAkE;IAClE,QAAQ,CAAC,MAAM,CAAC,EAAE,WAAW,CAAC;CAC/B;AAED,4FAA4F;AAC5F,wBAAgB,UAAU,CAAC,IAAI,EAAE,WAAW,EAAE,KAAK,EAAE,YAAY,EAAE,QAAQ,EAAE,MAAM,GAAG,WAAW,CA0ChG;AAED,gHAAgH;AAChH,wBAAgB,SAAS,CAAC,IAAI,EAAE,WAAW,EAAE,IAAI,EAAE,QAAQ,EAAE,MAAM,EAAE,SAAS,CAAC,MAAM,CAAC,GAAG,WAAW,CAsCnG;AAED,wBAAwB;AACxB,wBAAgB,UAAU,CAAC,KAAK,EAAE,MAAM,EAAE,MAAM,EAAE,MAAM,EAAE,OAAO,GAAE;IAAE,KAAK,CAAC,EAAE,MAAM,CAAC;IAAC,KAAK,CAAC,EAAE,MAAM,CAAC;IAAC,IAAI,CAAC,EAAE,MAAM,CAAA;CAAO,GAAG,WAAW,CAUtI;AAED,YAAY,EAAE,WAAW,EAAE,CAAC"}

package/dist/terrain/mask.js

@@ -0,0 +1,244 @@
+import { NO_MATERIAL } from "./types.js";
+import { decodeRuns, encodeRuns } from "./rle.js";
+//#region src/terrain/mask.ts
+/** Pure operations on the chunked mask. Nothing here mutates its input. */
+var key = (col, row) => `${col},${row}`;
+var chunkCount = (mask) => ({
+	cols: Math.ceil(mask.width / mask.chunk),
+	rows: Math.ceil(mask.height / mask.chunk)
+});
+/** The values of a chunk. A chunk that is not stored is flat. */
+function readChunk(mask, col, row) {
+	const stored = mask.chunks[key(col, row)];
+	if (stored === void 0) return new Uint16Array(mask.chunk * mask.chunk).fill(mask.fill);
+	return decodeRuns(stored, mask.chunk * mask.chunk);
+}
+/** Material index at a mask pixel. */
+function readPixel(mask, x, y) {
+	if (x < 0 || y < 0 || x >= mask.width || y >= mask.height) return NO_MATERIAL;
+	return readChunk(mask, Math.floor(x / mask.chunk), Math.floor(y / mask.chunk))[y % mask.chunk * mask.chunk + x % mask.chunk];
+}
+/** Whole mask as one array, row by row. For the kernel and for tests: it is as big as the map. */
+function readAll(mask) {
+	const out = new Uint16Array(mask.width * mask.height);
+	const { cols, rows } = chunkCount(mask);
+	for (let row = 0; row < rows; row += 1) for (let col = 0; col < cols; col += 1) {
+		const chunk = readChunk(mask, col, row);
+		const width = Math.min(mask.chunk, mask.width - col * mask.chunk);
+		const height = Math.min(mask.chunk, mask.height - row * mask.chunk);
+		for (let y = 0; y < height; y += 1) out.set(chunk.subarray(y * mask.chunk, y * mask.chunk + width), (row * mask.chunk + y) * mask.width + col * mask.chunk);
+	}
+	return out;
+}
+/** Values of a rectangle, row by row. The rectangle is clipped by the caller. */
+function readRect(mask, rect) {
+	const out = new Uint16Array(rect.width * rect.height);
+	const c0 = Math.floor(rect.x / mask.chunk);
+	const c1 = Math.floor((rect.x + rect.width - 1) / mask.chunk);
+	const r0 = Math.floor(rect.y / mask.chunk);
+	const r1 = Math.floor((rect.y + rect.height - 1) / mask.chunk);
+	for (let row = r0; row <= r1; row += 1) for (let col = c0; col <= c1; col += 1) {
+		const chunk = readChunk(mask, col, row);
+		const x0 = Math.max(rect.x, col * mask.chunk);
+		const x1 = Math.min(rect.x + rect.width, (col + 1) * mask.chunk);
+		const y0 = Math.max(rect.y, row * mask.chunk);
+		const y1 = Math.min(rect.y + rect.height, (row + 1) * mask.chunk);
+		for (let y = y0; y < y1; y += 1) {
+			const from = (y - row * mask.chunk) * mask.chunk + (x0 - col * mask.chunk);
+			out.set(chunk.subarray(from, from + (x1 - x0)), (y - rect.y) * rect.width + (x0 - rect.x));
+		}
+	}
+	return out;
+}
+function clipRect(mask, rect) {
+	const x0 = Math.max(0, Math.floor(rect.x));
+	const y0 = Math.max(0, Math.floor(rect.y));
+	const x1 = Math.min(mask.width, Math.ceil(rect.x + rect.width));
+	const y1 = Math.min(mask.height, Math.ceil(rect.y + rect.height));
+	return x1 > x0 && y1 > y0 ? {
+		x: x0,
+		y: y0,
+		width: x1 - x0,
+		height: y1 - y0
+	} : void 0;
+}
+/** Bounds of a shape in mask pixels, clipped to the mask. `undefined` when it is entirely outside. */
+function shapeBounds(mask, shape) {
+	const s = mask.scale;
+	switch (shape.type) {
+		case "fill": return {
+			x: 0,
+			y: 0,
+			width: mask.width,
+			height: mask.height
+		};
+		case "circle": return clipRect(mask, {
+			x: (shape.x - shape.radius) / s,
+			y: (shape.y - shape.radius) / s,
+			width: shape.radius * 2 / s + 1,
+			height: shape.radius * 2 / s + 1
+		});
+		case "rect": return clipRect(mask, {
+			x: shape.x / s,
+			y: shape.y / s,
+			width: shape.width / s,
+			height: shape.height / s
+		});
+		case "stroke": {
+			if (shape.points.length === 0) return void 0;
+			const xs = shape.points.map((p) => p[0]);
+			const ys = shape.points.map((p) => p[1]);
+			const x0 = Math.min(...xs) - shape.radius;
+			const y0 = Math.min(...ys) - shape.radius;
+			return clipRect(mask, {
+				x: x0 / s,
+				y: y0 / s,
+				width: (Math.max(...xs) - Math.min(...xs) + shape.radius * 2) / s + 1,
+				height: (Math.max(...ys) - Math.min(...ys) + shape.radius * 2) / s + 1
+			});
+		}
+	}
+}
+var distanceToSegment2 = (px, py, ax, ay, bx, by) => {
+	const dx = bx - ax;
+	const dy = by - ay;
+	const length2 = dx * dx + dy * dy;
+	const t = length2 === 0 ? 0 : Math.max(0, Math.min(1, ((px - ax) * dx + (py - ay) * dy) / length2));
+	const cx = ax + t * dx;
+	const cy = ay + t * dy;
+	return (px - cx) ** 2 + (py - cy) ** 2;
+};
+/** Whether the centre of a mask pixel is inside the shape. */
+function covers(mask, shape, x, y) {
+	const wx = (x + .5) * mask.scale;
+	const wy = (y + .5) * mask.scale;
+	switch (shape.type) {
+		case "fill": return true;
+		case "circle": return (wx - shape.x) ** 2 + (wy - shape.y) ** 2 <= shape.radius ** 2;
+		case "rect": return wx >= shape.x && wx < shape.x + shape.width && wy >= shape.y && wy < shape.y + shape.height;
+		case "stroke": {
+			const r2 = shape.radius ** 2;
+			if (shape.points.length === 1) return (wx - shape.points[0][0]) ** 2 + (wy - shape.points[0][1]) ** 2 <= r2;
+			for (let i = 1; i < shape.points.length; i += 1) {
+				const a = shape.points[i - 1];
+				const b = shape.points[i];
+				if (distanceToSegment2(wx, wy, a[0], a[1], b[0], b[1]) <= r2) return true;
+			}
+			return false;
+		}
+	}
+}
+/** Sets the material under a shape. Chunks that do not change are shared with the input. */
+function paintShape(mask, shape, material) {
+	const bounds = shapeBounds(mask, shape);
+	if (!bounds) return { mask };
+	const c0 = Math.floor(bounds.x / mask.chunk);
+	const c1 = Math.floor((bounds.x + bounds.width - 1) / mask.chunk);
+	const r0 = Math.floor(bounds.y / mask.chunk);
+	const r1 = Math.floor((bounds.y + bounds.height - 1) / mask.chunk);
+	const next = { ...mask.chunks };
+	let minX = Infinity, minY = Infinity, maxX = -1, maxY = -1;
+	for (let row = r0; row <= r1; row += 1) for (let col = c0; col <= c1; col += 1) {
+		const values = readChunk(mask, col, row);
+		let dirty = false;
+		const x0 = Math.max(bounds.x, col * mask.chunk);
+		const x1 = Math.min(bounds.x + bounds.width, (col + 1) * mask.chunk);
+		const y0 = Math.max(bounds.y, row * mask.chunk);
+		const y1 = Math.min(bounds.y + bounds.height, (row + 1) * mask.chunk);
+		for (let y = y0; y < y1; y += 1) for (let x = x0; x < x1; x += 1) {
+			if (!covers(mask, shape, x, y)) continue;
+			const index = (y - row * mask.chunk) * mask.chunk + (x - col * mask.chunk);
+			if (values[index] === material) continue;
+			values[index] = material;
+			dirty = true;
+			if (x < minX) minX = x;
+			if (x > maxX) maxX = x;
+			if (y < minY) minY = y;
+			if (y > maxY) maxY = y;
+		}
+		if (!dirty) continue;
+		const encoded = encodeRuns(values);
+		if (values.every((value) => value === mask.fill)) delete next[key(col, row)];
+		else next[key(col, row)] = encoded;
+	}
+	if (maxX < 0) return { mask };
+	const changed = {
+		x: minX,
+		y: minY,
+		width: maxX - minX + 1,
+		height: maxY - minY + 1
+	};
+	const before = readRect(mask, changed);
+	return {
+		mask: {
+			...mask,
+			chunks: next
+		},
+		changed,
+		before
+	};
+}
+/** Writes values over a rectangle (an inverse, or an imported region). Chunks that do not change are shared. */
+function writeRect(mask, rect, values) {
+	const clipped = clipRect(mask, rect);
+	if (!clipped || clipped.x !== rect.x || clipped.y !== rect.y || clipped.width !== rect.width || clipped.height !== rect.height) return { mask };
+	const c0 = Math.floor(rect.x / mask.chunk);
+	const c1 = Math.floor((rect.x + rect.width - 1) / mask.chunk);
+	const r0 = Math.floor(rect.y / mask.chunk);
+	const r1 = Math.floor((rect.y + rect.height - 1) / mask.chunk);
+	const next = { ...mask.chunks };
+	let minX = Infinity, minY = Infinity, maxX = -1, maxY = -1;
+	for (let row = r0; row <= r1; row += 1) for (let col = c0; col <= c1; col += 1) {
+		const chunk = readChunk(mask, col, row);
+		let dirty = false;
+		const x0 = Math.max(rect.x, col * mask.chunk);
+		const x1 = Math.min(rect.x + rect.width, (col + 1) * mask.chunk);
+		const y0 = Math.max(rect.y, row * mask.chunk);
+		const y1 = Math.min(rect.y + rect.height, (row + 1) * mask.chunk);
+		for (let y = y0; y < y1; y += 1) for (let x = x0; x < x1; x += 1) {
+			const value = values[(y - rect.y) * rect.width + (x - rect.x)];
+			const index = (y - row * mask.chunk) * mask.chunk + (x - col * mask.chunk);
+			if (chunk[index] === value) continue;
+			chunk[index] = value;
+			dirty = true;
+			if (x < minX) minX = x;
+			if (x > maxX) maxX = x;
+			if (y < minY) minY = y;
+			if (y > maxY) maxY = y;
+		}
+		if (!dirty) continue;
+		if (chunk.every((value) => value === mask.fill)) delete next[key(col, row)];
+		else next[key(col, row)] = encodeRuns(chunk);
+	}
+	if (maxX < 0) return { mask };
+	const changed = {
+		x: minX,
+		y: minY,
+		width: maxX - minX + 1,
+		height: maxY - minY + 1
+	};
+	return {
+		mask: {
+			...mask,
+			chunks: next
+		},
+		changed,
+		before: readRect(mask, changed)
+	};
+}
+/** A new, flat mask. */
+function createMask(width, height, options = {}) {
+	const scale = options.scale ?? 1;
+	return {
+		scale,
+		width: Math.ceil(width / scale),
+		height: Math.ceil(height / scale),
+		chunk: options.chunk ?? 256,
+		fill: options.fill ?? 65535,
+		chunks: {}
+	};
+}
+//#endregion
+export { chunkCount, clipRect, covers, createMask, paintShape, readAll, readChunk, readPixel, readRect, shapeBounds, writeRect };
+
+//# sourceMappingURL=mask.js.map