@rpgjs/map-builder 0.0.0-stage → 5.0.0

package/dist/skins/game.js

@@ -0,0 +1,21 @@
+import { SKIN_COLORS, framesSkin, ghostLayer } from "./default.js";
+//#region src/skins/game.ts
+/**
+* A skin for players rather than editors: a glowing outline instead of a
+* technical frame, and a ghost that can pulse and take the colours of the game.
+*/
+function gameSkin(options = {}) {
+	return framesSkin({
+		color: options.color ?? 16436245,
+		outline: options.outline ?? "glow"
+	}, ghostLayer({
+		valid: options.ghost?.valid ?? SKIN_COLORS.valid,
+		invalid: options.ghost?.invalid ?? SKIN_COLORS.invalid,
+		alpha: options.ghost?.alpha ?? .7,
+		pulse: options.pulse ?? false
+	}));
+}
+//#endregion
+export { gameSkin };
+
+//# sourceMappingURL=game.js.map

package/dist/skins/game.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"game.js","names":[],"sources":["../../src/skins/game.ts"],"sourcesContent":["import { SKIN_COLORS, framesSkin, ghostLayer } from \"./default\";\nimport type { Skin } from \"./types\";\n\nexport interface GameSkinOptions {\n  /** Colours of the ghost of the item being placed. */\n  readonly ghost?: { readonly valid?: number; readonly invalid?: number; readonly alpha?: number };\n  /** `\"glow\"` (default) gives selections a soft halo, `\"line\"` a plain frame. */\n  readonly outline?: \"line\" | \"glow\";\n  /** Colour of selections and hovers. */\n  readonly color?: number;\n  /** Makes the ghost pulse. */\n  readonly pulse?: boolean;\n}\n\n/**\n * A skin for players rather than editors: a glowing outline instead of a\n * technical frame, and a ghost that can pulse and take the colours of the game.\n */\nexport function gameSkin(options: GameSkinOptions = {}): Skin {\n  return framesSkin(\n    { color: options.color ?? 0xfacc15, outline: options.outline ?? \"glow\" },\n    ghostLayer({\n      valid: options.ghost?.valid ?? SKIN_COLORS.valid,\n      invalid: options.ghost?.invalid ?? SKIN_COLORS.invalid,\n      alpha: options.ghost?.alpha ?? 0.7,\n      pulse: options.pulse ?? false,\n    }),\n  );\n}\n"],"mappings":";;;;;;AAkBA,SAAgB,SAAS,UAA2B,CAAC,GAAS;CAC5D,OAAO,WACL;EAAE,OAAO,QAAQ,SAAS;EAAU,SAAS,QAAQ,WAAW;CAAO,GACvE,WAAW;EACT,OAAO,QAAQ,OAAO,SAAS,YAAY;EAC3C,SAAS,QAAQ,OAAO,WAAW,YAAY;EAC/C,OAAO,QAAQ,OAAO,SAAS;EAC/B,OAAO,QAAQ,SAAS;CAC1B,CAAC,CACH;AACF"}

package/dist/skins/index.d.ts

@@ -0,0 +1,5 @@
+export * from './types';
+export { drawFrames, frameLayer, nodeOf, type DrawnFrame } from './frames';
+export { defaultSkin, framesSkin, ghostLayer, SKIN_COLORS, type FrameLookOptions, type GhostLookOptions } from './default';
+export { gameSkin, type GameSkinOptions } from './game';
+//# sourceMappingURL=index.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../src/skins/index.ts"],"names":[],"mappings":"AAAA,cAAc,SAAS,CAAC;AACxB,OAAO,EAAE,UAAU,EAAE,UAAU,EAAE,MAAM,EAAE,KAAK,UAAU,EAAE,MAAM,UAAU,CAAC;AAC3E,OAAO,EAAE,WAAW,EAAE,UAAU,EAAE,UAAU,EAAE,WAAW,EAAE,KAAK,gBAAgB,EAAE,KAAK,gBAAgB,EAAE,MAAM,WAAW,CAAC;AAC3H,OAAO,EAAE,QAAQ,EAAE,KAAK,eAAe,EAAE,MAAM,QAAQ,CAAC"}

package/dist/skins/index.js

@@ -0,0 +1,5 @@
+import { drawFrames, frameLayer, nodeOf } from "./frames.js";
+import { SKIN_COLORS, defaultSkin, framesSkin, ghostLayer } from "./default.js";
+import { defineSkin, mergeSkin } from "./types.js";
+import { gameSkin } from "./game.js";
+export { SKIN_COLORS, defaultSkin, defineSkin, drawFrames, frameLayer, framesSkin, gameSkin, ghostLayer, mergeSkin, nodeOf };

package/dist/skins/types.d.ts

@@ -0,0 +1,46 @@
+import { Container } from 'pixi.js';
+import { AssetResolver } from '../model/assets';
+import { InteractionSnapshot } from '../interaction/controller';
+import { SceneNode } from '../renderer/scene';
+import { TextureStore } from '../renderer/textures';
+/** What a skin layer can reach to draw itself. */
+export interface SkinContext {
+    /** Draw into this container: it sits in the overlay stage, above the map. */
+    readonly layer: Container;
+    readonly textures: TextureStore;
+    readonly assets: AssetResolver;
+    /** What is drawn on the map right now: where things are, how big they are. */
+    nodes(): readonly SceneNode[];
+    /** Call when something async finished (an image loaded) and the layer should draw again. */
+    requestUpdate(): void;
+}
+/** One visual of the interaction layer. It reads the published state and draws it; it never changes anything. */
+export interface SkinLayer {
+    /** Called whenever the interaction state or the map changes. */
+    update(snapshot: InteractionSnapshot): void;
+    /** Called every frame with the time elapsed, for animations. */
+    tick?(deltaMs: number): void;
+    destroy(): void;
+}
+export type SkinLayerFactory = (context: SkinContext) => SkinLayer;
+/**
+ * How the interaction layer looks. Every part is optional and replaceable on its
+ * own, so a game can restyle the ghost and keep the default selection.
+ */
+export interface Skin {
+    /** Frames around what is selected. */
+    readonly selection?: SkinLayerFactory;
+    /** What is under the pointer. */
+    readonly hover?: SkinLayerFactory;
+    /** Where the dragged things would land, valid or not. */
+    readonly drag?: SkinLayerFactory;
+    /** The rubber band of a selection in progress. */
+    readonly marquee?: SkinLayerFactory;
+    /** The item being placed, following the pointer. */
+    readonly ghost?: SkinLayerFactory;
+}
+/** Checks a skin at compile time. */
+export declare const defineSkin: (skin: Skin) => Skin;
+/** A skin is a set of parts: `override` replaces the parts it defines and keeps the others of `base`. */
+export declare const mergeSkin: (base: Skin, override: Skin | undefined) => Skin;
+//# sourceMappingURL=types.d.ts.map

package/dist/skins/types.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"types.d.ts","sourceRoot":"","sources":["../../src/skins/types.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,SAAS,EAAE,MAAM,SAAS,CAAC;AACzC,OAAO,KAAK,EAAE,aAAa,EAAE,MAAM,iBAAiB,CAAC;AACrD,OAAO,KAAK,EAAE,mBAAmB,EAAE,MAAM,2BAA2B,CAAC;AACrE,OAAO,KAAK,EAAE,SAAS,EAAE,MAAM,mBAAmB,CAAC;AACnD,OAAO,KAAK,EAAE,YAAY,EAAE,MAAM,sBAAsB,CAAC;AAEzD,kDAAkD;AAClD,MAAM,WAAW,WAAW;IAC1B,6EAA6E;IAC7E,QAAQ,CAAC,KAAK,EAAE,SAAS,CAAC;IAC1B,QAAQ,CAAC,QAAQ,EAAE,YAAY,CAAC;IAChC,QAAQ,CAAC,MAAM,EAAE,aAAa,CAAC;IAC/B,8EAA8E;IAC9E,KAAK,IAAI,SAAS,SAAS,EAAE,CAAC;IAC9B,4FAA4F;IAC5F,aAAa,IAAI,IAAI,CAAC;CACvB;AAED,iHAAiH;AACjH,MAAM,WAAW,SAAS;IACxB,gEAAgE;IAChE,MAAM,CAAC,QAAQ,EAAE,mBAAmB,GAAG,IAAI,CAAC;IAC5C,gEAAgE;IAChE,IAAI,CAAC,CAAC,OAAO,EAAE,MAAM,GAAG,IAAI,CAAC;IAC7B,OAAO,IAAI,IAAI,CAAC;CACjB;AAED,MAAM,MAAM,gBAAgB,GAAG,CAAC,OAAO,EAAE,WAAW,KAAK,SAAS,CAAC;AAEnE;;;GAGG;AACH,MAAM,WAAW,IAAI;IACnB,sCAAsC;IACtC,QAAQ,CAAC,SAAS,CAAC,EAAE,gBAAgB,CAAC;IACtC,iCAAiC;IACjC,QAAQ,CAAC,KAAK,CAAC,EAAE,gBAAgB,CAAC;IAClC,yDAAyD;IACzD,QAAQ,CAAC,IAAI,CAAC,EAAE,gBAAgB,CAAC;IACjC,kDAAkD;IAClD,QAAQ,CAAC,OAAO,CAAC,EAAE,gBAAgB,CAAC;IACpC,oDAAoD;IACpD,QAAQ,CAAC,KAAK,CAAC,EAAE,gBAAgB,CAAC;CACnC;AAED,qCAAqC;AACrC,eAAO,MAAM,UAAU,GAAI,MAAM,IAAI,KAAG,IAAY,CAAC;AAErD,yGAAyG;AACzG,eAAO,MAAM,SAAS,GAAI,MAAM,IAAI,EAAE,UAAU,IAAI,GAAG,SAAS,KAAG,IAAkC,CAAC"}

package/dist/skins/types.js

@@ -0,0 +1,12 @@
+//#region src/skins/types.ts
+/** Checks a skin at compile time. */
+var defineSkin = (skin) => skin;
+/** A skin is a set of parts: `override` replaces the parts it defines and keeps the others of `base`. */
+var mergeSkin = (base, override) => ({
+	...base,
+	...override
+});
+//#endregion
+export { defineSkin, mergeSkin };
+
+//# sourceMappingURL=types.js.map

package/dist/skins/types.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"types.js","names":[],"sources":["../../src/skins/types.ts"],"sourcesContent":["import type { Container } from \"pixi.js\";\nimport type { AssetResolver } from \"../model/assets\";\nimport type { InteractionSnapshot } from \"../interaction/controller\";\nimport type { SceneNode } from \"../renderer/scene\";\nimport type { TextureStore } from \"../renderer/textures\";\n\n/** What a skin layer can reach to draw itself. */\nexport interface SkinContext {\n  /** Draw into this container: it sits in the overlay stage, above the map. */\n  readonly layer: Container;\n  readonly textures: TextureStore;\n  readonly assets: AssetResolver;\n  /** What is drawn on the map right now: where things are, how big they are. */\n  nodes(): readonly SceneNode[];\n  /** Call when something async finished (an image loaded) and the layer should draw again. */\n  requestUpdate(): void;\n}\n\n/** One visual of the interaction layer. It reads the published state and draws it; it never changes anything. */\nexport interface SkinLayer {\n  /** Called whenever the interaction state or the map changes. */\n  update(snapshot: InteractionSnapshot): void;\n  /** Called every frame with the time elapsed, for animations. */\n  tick?(deltaMs: number): void;\n  destroy(): void;\n}\n\nexport type SkinLayerFactory = (context: SkinContext) => SkinLayer;\n\n/**\n * How the interaction layer looks. Every part is optional and replaceable on its\n * own, so a game can restyle the ghost and keep the default selection.\n */\nexport interface Skin {\n  /** Frames around what is selected. */\n  readonly selection?: SkinLayerFactory;\n  /** What is under the pointer. */\n  readonly hover?: SkinLayerFactory;\n  /** Where the dragged things would land, valid or not. */\n  readonly drag?: SkinLayerFactory;\n  /** The rubber band of a selection in progress. */\n  readonly marquee?: SkinLayerFactory;\n  /** The item being placed, following the pointer. */\n  readonly ghost?: SkinLayerFactory;\n}\n\n/** Checks a skin at compile time. */\nexport const defineSkin = (skin: Skin): Skin => skin;\n\n/** A skin is a set of parts: `override` replaces the parts it defines and keeps the others of `base`. */\nexport const mergeSkin = (base: Skin, override: Skin | undefined): Skin => ({ ...base, ...override });\n"],"mappings":";;AA+CA,IAAa,cAAc,SAAqB;;AAGhD,IAAa,aAAa,MAAY,cAAsC;CAAE,GAAG;CAAM,GAAG;AAAS"}

package/dist/terrain/data.d.ts

@@ -0,0 +1,10 @@
+import { MapIssue } from '../model/errors';
+import { MapState } from '../model/definition';
+import { TerrainData } from './types';
+/** Problems of a terrain extension value, with their paths. Empty when it is valid. */
+export declare function terrainIssues(value: unknown, path?: string): MapIssue[];
+/** The terrain of a state. `undefined` when the map has none; throws when what it has is invalid. */
+export declare function readTerrain(state: MapState): TerrainData | undefined;
+/** Same, without throwing: for code that decides what to draw. */
+export declare function tryReadTerrain(state: MapState): TerrainData | undefined;
+//# sourceMappingURL=data.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"data.d.ts","sourceRoot":"","sources":["../../src/terrain/data.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,QAAQ,EAAE,MAAM,iBAAiB,CAAC;AAEhD,OAAO,KAAK,EAAE,QAAQ,EAAE,MAAM,qBAAqB,CAAC;AAEpD,OAAO,EAA8C,KAAK,WAAW,EAAE,MAAM,SAAS,CAAC;AAIvF,uFAAuF;AACvF,wBAAgB,aAAa,CAAC,KAAK,EAAE,OAAO,EAAE,IAAI,SAAuB,GAAG,QAAQ,EAAE,CAgDrF;AAED,qGAAqG;AACrG,wBAAgB,WAAW,CAAC,KAAK,EAAE,QAAQ,GAAG,WAAW,GAAG,SAAS,CAMpE;AAED,kEAAkE;AAClE,wBAAgB,cAAc,CAAC,KAAK,EAAE,QAAQ,GAAG,WAAW,GAAG,SAAS,CAMvE"}

package/dist/terrain/data.js

@@ -0,0 +1,83 @@
+import { isFiniteNumberValue, isJsonValue, isPlainObject } from "../model/json.js";
+import { MapDefinitionError } from "../model/errors.js";
+import { TERRAIN_EXTENSION_ID } from "./types.js";
+//#region src/terrain/data.ts
+var MODES = /* @__PURE__ */ new Set([
+	"hard",
+	"fade",
+	"nine-slice",
+	"water",
+	"custom"
+]);
+/** Problems of a terrain extension value, with their paths. Empty when it is valid. */
+function terrainIssues(value, path = "extensions.terrain") {
+	const issues = [];
+	const bad = (where, message) => issues.push({
+		path: `${path}${where}`,
+		message
+	});
+	if (!isPlainObject(value) || !isJsonValue(value)) return [{
+		path,
+		message: "must be a JSON object"
+	}];
+	if (value.version !== 1) bad(".version", `must be 1`);
+	const ids = /* @__PURE__ */ new Set();
+	if (!Array.isArray(value.materials)) bad(".materials", "must be an array");
+	else {
+		if (value.materials.length > 65534) bad(".materials", "too many materials");
+		value.materials.forEach((material, index) => {
+			if (!isPlainObject(material)) return bad(`.materials[${index}]`, "must be an object");
+			if (typeof material.id !== "string" || material.id.length === 0) bad(`.materials[${index}].id`, "must be a non-empty string");
+			else if (ids.has(material.id)) bad(`.materials[${index}].id`, `"${material.id}" is used twice`);
+			else ids.add(material.id);
+			if (typeof material.texture !== "string" || material.texture.length === 0) bad(`.materials[${index}].texture`, "must be an asset reference");
+			if (material.mode !== void 0 && (!isPlainObject(material.mode) || !MODES.has(String(material.mode.type)))) bad(`.materials[${index}].mode`, "must be a render mode");
+		});
+	}
+	if (value.transitions !== void 0) if (!Array.isArray(value.transitions)) bad(".transitions", "must be an array");
+	else value.transitions.forEach((rule, index) => {
+		if (!isPlainObject(rule) || !ids.has(String(rule.from)) || !ids.has(String(rule.to))) bad(`.transitions[${index}]`, "must link two materials of the palette");
+	});
+	const mask = value.mask;
+	if (!isPlainObject(mask)) bad(".mask", "must be an object");
+	else {
+		for (const field of [
+			"scale",
+			"width",
+			"height",
+			"chunk"
+		]) if (!isFiniteNumberValue(mask[field]) || mask[field] <= 0) bad(`.mask.${field}`, "must be a positive number");
+		for (const field of [
+			"width",
+			"height",
+			"chunk"
+		]) if (isFiniteNumberValue(mask[field]) && !Number.isInteger(mask[field])) bad(`.mask.${field}`, "must be an integer");
+		if (!isFiniteNumberValue(mask.fill) || !Number.isInteger(mask.fill) || mask.fill < 0 || mask.fill > 65535) bad(".mask.fill", "must be a material index or 65535");
+		else if (mask.fill !== 65535 && Array.isArray(value.materials) && mask.fill >= value.materials.length) bad(".mask.fill", "points past the palette");
+		if (!isPlainObject(mask.chunks)) bad(".mask.chunks", "must be an object");
+		else for (const [chunkKey, encoded] of Object.entries(mask.chunks)) if (!/^\d+,\d+$/.test(chunkKey) || typeof encoded !== "string") bad(`.mask.chunks["${chunkKey}"]`, "must be a string under a `col,row` key");
+	}
+	if (value.morphology !== void 0 && (!Array.isArray(value.morphology) || !value.morphology.every((item) => isPlainObject(item) && typeof item.id === "string"))) bad(".morphology", "must be an array of features with an id");
+	if (value.water !== void 0 && !isPlainObject(value.water)) bad(".water", "must be an object");
+	return issues;
+}
+/** The terrain of a state. `undefined` when the map has none; throws when what it has is invalid. */
+function readTerrain(state) {
+	const value = state.extensions?.[TERRAIN_EXTENSION_ID];
+	if (value === void 0) return void 0;
+	const issues = terrainIssues(value);
+	if (issues.length > 0) throw new MapDefinitionError(issues);
+	return value;
+}
+/** Same, without throwing: for code that decides what to draw. */
+function tryReadTerrain(state) {
+	try {
+		return readTerrain(state);
+	} catch {
+		return;
+	}
+}
+//#endregion
+export { readTerrain, terrainIssues, tryReadTerrain };
+
+//# sourceMappingURL=data.js.map

package/dist/terrain/data.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"data.js","names":[],"sources":["../../src/terrain/data.ts"],"sourcesContent":["import type { MapIssue } from \"../model/errors\";\nimport { MapDefinitionError } from \"../model/errors\";\nimport type { MapState } from \"../model/definition\";\nimport { isFiniteNumberValue, isJsonValue, isPlainObject, type JsonValue } from \"../model/json\";\nimport { TERRAIN_DATA_VERSION, TERRAIN_EXTENSION_ID, type TerrainData } from \"./types\";\n\nconst MODES = new Set([\"hard\", \"fade\", \"nine-slice\", \"water\", \"custom\"]);\n\n/** Problems of a terrain extension value, with their paths. Empty when it is valid. */\nexport function terrainIssues(value: unknown, path = \"extensions.terrain\"): MapIssue[] {\n  const issues: MapIssue[] = [];\n  const bad = (where: string, message: string) => issues.push({ path: `${path}${where}`, message });\n  if (!isPlainObject(value) || !isJsonValue(value)) return [{ path, message: \"must be a JSON object\" }];\n  if (value.version !== TERRAIN_DATA_VERSION) bad(\".version\", `must be ${TERRAIN_DATA_VERSION}`);\n\n  const ids = new Set<string>();\n  if (!Array.isArray(value.materials)) bad(\".materials\", \"must be an array\");\n  else {\n    if (value.materials.length > 0xfffe) bad(\".materials\", \"too many materials\");\n    value.materials.forEach((material: unknown, index: number) => {\n      if (!isPlainObject(material)) return bad(`.materials[${index}]`, \"must be an object\");\n      if (typeof material.id !== \"string\" || material.id.length === 0) bad(`.materials[${index}].id`, \"must be a non-empty string\");\n      else if (ids.has(material.id)) bad(`.materials[${index}].id`, `\"${material.id}\" is used twice`);\n      else ids.add(material.id);\n      if (typeof material.texture !== \"string\" || material.texture.length === 0) bad(`.materials[${index}].texture`, \"must be an asset reference\");\n      if (material.mode !== undefined && (!isPlainObject(material.mode) || !MODES.has(String(material.mode.type)))) bad(`.materials[${index}].mode`, \"must be a render mode\");\n    });\n  }\n\n  if (value.transitions !== undefined) {\n    if (!Array.isArray(value.transitions)) bad(\".transitions\", \"must be an array\");\n    else value.transitions.forEach((rule: unknown, index: number) => {\n      if (!isPlainObject(rule) || !ids.has(String(rule.from)) || !ids.has(String(rule.to))) bad(`.transitions[${index}]`, \"must link two materials of the palette\");\n    });\n  }\n\n  const mask = value.mask;\n  if (!isPlainObject(mask)) bad(\".mask\", \"must be an object\");\n  else {\n    for (const field of [\"scale\", \"width\", \"height\", \"chunk\"] as const) {\n      if (!isFiniteNumberValue(mask[field]) || (mask[field] as number) <= 0) bad(`.mask.${field}`, \"must be a positive number\");\n    }\n    for (const field of [\"width\", \"height\", \"chunk\"] as const) {\n      if (isFiniteNumberValue(mask[field]) && !Number.isInteger(mask[field])) bad(`.mask.${field}`, \"must be an integer\");\n    }\n    if (!isFiniteNumberValue(mask.fill) || !Number.isInteger(mask.fill) || mask.fill < 0 || mask.fill > 0xffff) bad(\".mask.fill\", \"must be a material index or 65535\");\n    else if (mask.fill !== 0xffff && Array.isArray(value.materials) && mask.fill >= value.materials.length) bad(\".mask.fill\", \"points past the palette\");\n    if (!isPlainObject(mask.chunks)) bad(\".mask.chunks\", \"must be an object\");\n    else for (const [chunkKey, encoded] of Object.entries(mask.chunks)) {\n      if (!/^\\d+,\\d+$/.test(chunkKey) || typeof encoded !== \"string\") bad(`.mask.chunks[\"${chunkKey}\"]`, \"must be a string under a `col,row` key\");\n    }\n  }\n  if (value.morphology !== undefined && (!Array.isArray(value.morphology) || !value.morphology.every((item: unknown) => isPlainObject(item) && typeof item.id === \"string\"))) {\n    bad(\".morphology\", \"must be an array of features with an id\");\n  }\n  if (value.water !== undefined && !isPlainObject(value.water)) bad(\".water\", \"must be an object\");\n  return issues;\n}\n\n/** The terrain of a state. `undefined` when the map has none; throws when what it has is invalid. */\nexport function readTerrain(state: MapState): TerrainData | undefined {\n  const value = state.extensions?.[TERRAIN_EXTENSION_ID] as JsonValue | undefined;\n  if (value === undefined) return undefined;\n  const issues = terrainIssues(value);\n  if (issues.length > 0) throw new MapDefinitionError(issues);\n  return value as unknown as TerrainData;\n}\n\n/** Same, without throwing: for code that decides what to draw. */\nexport function tryReadTerrain(state: MapState): TerrainData | undefined {\n  try {\n    return readTerrain(state);\n  } catch {\n    return undefined;\n  }\n}\n"],"mappings":"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"}

package/dist/terrain/define.d.ts

@@ -0,0 +1,72 @@
+import { TerrainBuilder } from '../model/define-map';
+import { TerrainData, TerrainMaterial, TerrainMode, TerrainShape, TerrainTransition } from './types';
+export interface MaterialInput {
+    readonly texture: string;
+    readonly mode?: TerrainMode;
+    readonly priority?: number;
+    readonly collision?: boolean;
+    readonly specialType?: string;
+    readonly renderTileSize?: number;
+    readonly renderingStyle?: "pixel-art" | "hd-2d";
+}
+type Shapes = {
+    readonly [id: string]: MaterialInput;
+};
+type Id<M extends Shapes> = Extract<keyof M, string>;
+/** One step of the recipe that writes the mask. Later steps paint over earlier ones. */
+export interface PaintOp<I extends string = string> {
+    readonly material: I | null;
+    readonly shape: TerrainShape;
+}
+export interface LayersOptions {
+    /** World pixels per mask pixel. Defaults to 1: pixel-perfect. */
+    readonly scale?: number;
+    /** Side of a mask chunk, in mask pixels. Defaults to 256. */
+    readonly chunk?: number;
+    readonly transitions?: readonly TerrainTransition[];
+    readonly water?: TerrainData["water"];
+    /** Holes and walls, as the kernel takes them. */
+    readonly morphology?: TerrainData["morphology"];
+}
+export interface TerrainDefinition<I extends string> {
+    readonly materials: readonly TerrainMaterial[];
+    /** The recipe that writes the mask. Pass it to `defineMap({ terrain })`. */
+    layers(ops: readonly PaintOp<I>[], options?: LayersOptions): TerrainBuilder;
+    /** The terrain of a map of this size, from a recipe. */
+    build(size: readonly [number, number], ops: readonly PaintOp<I>[], options?: LayersOptions): TerrainData;
+}
+/** Ways to write the mask: shapes painted with a material. */
+export declare const paint: {
+    readonly fill: <I extends string>(material: I) => PaintOp<I>;
+    readonly circle: <I extends string>(material: I, options: {
+        x: number;
+        y: number;
+        radius: number;
+    }) => PaintOp<I>;
+    readonly rect: <I extends string>(material: I, options: {
+        x: number;
+        y: number;
+        width: number;
+        height: number;
+    }) => PaintOp<I>;
+    readonly stroke: <I extends string>(material: I, options: {
+        points: readonly (readonly [number, number])[];
+        radius: number;
+    }) => PaintOp<I>;
+    /** Erases: no material under the shape. */
+    readonly erase: (shape: TerrainShape) => PaintOp<never>;
+};
+/**
+ * Declares the materials of a terrain once, so that the recipe that paints them is checked by the compiler.
+ *
+ * ```ts
+ * const terrain = defineTerrain({
+ *   grass: { texture: "grass", mode: { type: "fade", width: 18 } },
+ *   water: { texture: "water", mode: { type: "water", foam: true }, collision: true },
+ * });
+ * defineMap(assets, { id: "forest", size: [2560, 1920], terrain: terrain.layers([paint.fill("grass"), paint.circle("water", { x: 800, y: 600, radius: 180 })]) });
+ * ```
+ */
+export declare function defineTerrain<const M extends Shapes>(materials: M): TerrainDefinition<Id<M>>;
+export {};
+//# sourceMappingURL=define.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"define.d.ts","sourceRoot":"","sources":["../../src/terrain/define.ts"],"names":[],"mappings":"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"}

package/dist/terrain/define.js

@@ -0,0 +1,91 @@
+import { MapDefinitionError } from "../model/errors.js";
+import "./types.js";
+import { createMask, paintShape } from "./mask.js";
+//#region src/terrain/define.ts
+/** Ways to write the mask: shapes painted with a material. */
+var paint = {
+	fill: (material) => ({
+		material,
+		shape: { type: "fill" }
+	}),
+	circle: (material, options) => ({
+		material,
+		shape: {
+			type: "circle",
+			...options
+		}
+	}),
+	rect: (material, options) => ({
+		material,
+		shape: {
+			type: "rect",
+			...options
+		}
+	}),
+	stroke: (material, options) => ({
+		material,
+		shape: {
+			type: "stroke",
+			points: options.points,
+			radius: options.radius
+		}
+	}),
+	/** Erases: no material under the shape. */
+	erase: (shape) => ({
+		material: null,
+		shape
+	})
+};
+/**
+* Declares the materials of a terrain once, so that the recipe that paints them is checked by the compiler.
+*
+* ```ts
+* const terrain = defineTerrain({
+*   grass: { texture: "grass", mode: { type: "fade", width: 18 } },
+*   water: { texture: "water", mode: { type: "water", foam: true }, collision: true },
+* });
+* defineMap(assets, { id: "forest", size: [2560, 1920], terrain: terrain.layers([paint.fill("grass"), paint.circle("water", { x: 800, y: 600, radius: 180 })]) });
+* ```
+*/
+function defineTerrain(materials) {
+	const list = Object.entries(materials).map(([id, input]) => ({
+		id,
+		...input
+	}));
+	const build = (size, ops, options = {}) => {
+		const scale = options.scale ?? 1;
+		if (!(scale > 0) || !Number.isFinite(scale)) throw new MapDefinitionError([{
+			path: "terrain.scale",
+			message: "must be a positive number"
+		}]);
+		let mask = createMask(size[0], size[1], {
+			scale,
+			...options.chunk !== void 0 ? { chunk: options.chunk } : {}
+		});
+		ops.forEach((op, index) => {
+			const value = op.material === null ? 65535 : list.findIndex((material) => material.id === op.material);
+			if (value < 0) throw new MapDefinitionError([{
+				path: `terrain.layers[${index}]`,
+				message: `material "${String(op.material)}" is not declared`
+			}]);
+			mask = paintShape(mask, op.shape, value).mask;
+		});
+		return {
+			version: 1,
+			materials: list,
+			...options.transitions ? { transitions: options.transitions } : {},
+			mask,
+			...options.water ? { water: options.water } : {},
+			...options.morphology ? { morphology: options.morphology } : {}
+		};
+	};
+	return {
+		materials: list,
+		build,
+		layers: (ops, options) => ({ toExtension: (size) => build(size, ops, options) })
+	};
+}
+//#endregion
+export { defineTerrain, paint };
+
+//# sourceMappingURL=define.js.map

package/dist/terrain/define.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"define.js","names":[],"sources":["../../src/terrain/define.ts"],"sourcesContent":["import type { JsonValue } from \"../model/json\";\nimport type { TerrainBuilder } from \"../model/define-map\";\nimport { MapDefinitionError } from \"../model/errors\";\nimport { createMask, paintShape } from \"./mask\";\nimport { TERRAIN_DATA_VERSION, type TerrainData, type TerrainMaterial, type TerrainMode, type TerrainShape, type TerrainTransition } from \"./types\";\n\nexport interface MaterialInput {\n  readonly texture: string;\n  readonly mode?: TerrainMode;\n  readonly priority?: number;\n  readonly collision?: boolean;\n  readonly specialType?: string;\n  readonly renderTileSize?: number;\n  readonly renderingStyle?: \"pixel-art\" | \"hd-2d\";\n}\n\ntype Shapes = { readonly [id: string]: MaterialInput };\ntype Id<M extends Shapes> = Extract<keyof M, string>;\n\n/** One step of the recipe that writes the mask. Later steps paint over earlier ones. */\nexport interface PaintOp<I extends string = string> {\n  readonly material: I | null;\n  readonly shape: TerrainShape;\n}\n\nexport interface LayersOptions {\n  /** World pixels per mask pixel. Defaults to 1: pixel-perfect. */\n  readonly scale?: number;\n  /** Side of a mask chunk, in mask pixels. Defaults to 256. */\n  readonly chunk?: number;\n  readonly transitions?: readonly TerrainTransition[];\n  readonly water?: TerrainData[\"water\"];\n  /** Holes and walls, as the kernel takes them. */\n  readonly morphology?: TerrainData[\"morphology\"];\n}\n\nexport interface TerrainDefinition<I extends string> {\n  readonly materials: readonly TerrainMaterial[];\n  /** The recipe that writes the mask. Pass it to `defineMap({ terrain })`. */\n  layers(ops: readonly PaintOp<I>[], options?: LayersOptions): TerrainBuilder;\n  /** The terrain of a map of this size, from a recipe. */\n  build(size: readonly [number, number], ops: readonly PaintOp<I>[], options?: LayersOptions): TerrainData;\n}\n\n/** Ways to write the mask: shapes painted with a material. */\nexport const paint = {\n  fill: <I extends string>(material: I): PaintOp<I> => ({ material, shape: { type: \"fill\" } }),\n  circle: <I extends string>(material: I, options: { x: number; y: number; radius: number }): PaintOp<I> => ({ material, shape: { type: \"circle\", ...options } }),\n  rect: <I extends string>(material: I, options: { x: number; y: number; width: number; height: number }): PaintOp<I> => ({ material, shape: { type: \"rect\", ...options } }),\n  stroke: <I extends string>(material: I, options: { points: readonly (readonly [number, number])[]; radius: number }): PaintOp<I> => ({ material, shape: { type: \"stroke\", points: options.points, radius: options.radius } }),\n  /** Erases: no material under the shape. */\n  erase: (shape: TerrainShape): PaintOp<never> => ({ material: null, shape }),\n} as const;\n\n/**\n * Declares the materials of a terrain once, so that the recipe that paints them is checked by the compiler.\n *\n * ```ts\n * const terrain = defineTerrain({\n *   grass: { texture: \"grass\", mode: { type: \"fade\", width: 18 } },\n *   water: { texture: \"water\", mode: { type: \"water\", foam: true }, collision: true },\n * });\n * defineMap(assets, { id: \"forest\", size: [2560, 1920], terrain: terrain.layers([paint.fill(\"grass\"), paint.circle(\"water\", { x: 800, y: 600, radius: 180 })]) });\n * ```\n */\nexport function defineTerrain<const M extends Shapes>(materials: M): TerrainDefinition<Id<M>> {\n  const list: TerrainMaterial[] = Object.entries(materials).map(([id, input]) => ({ id, ...input }));\n  const build = (size: readonly [number, number], ops: readonly PaintOp<Id<M>>[], options: LayersOptions = {}): TerrainData => {\n    const scale = options.scale ?? 1;\n    if (!(scale > 0) || !Number.isFinite(scale)) throw new MapDefinitionError([{ path: \"terrain.scale\", message: \"must be a positive number\" }]);\n    let mask = createMask(size[0], size[1], { scale, ...(options.chunk !== undefined ? { chunk: options.chunk } : {}) });\n    ops.forEach((op, index) => {\n      const value = op.material === null ? 0xffff : list.findIndex((material) => material.id === op.material);\n      if (value < 0) throw new MapDefinitionError([{ path: `terrain.layers[${index}]`, message: `material \"${String(op.material)}\" is not declared` }]);\n      mask = paintShape(mask, op.shape, value).mask;\n    });\n    return {\n      version: TERRAIN_DATA_VERSION,\n      materials: list,\n      ...(options.transitions ? { transitions: options.transitions } : {}),\n      mask,\n      ...(options.water ? { water: options.water } : {}),\n      ...(options.morphology ? { morphology: options.morphology } : {}),\n    };\n  };\n  return {\n    materials: list,\n    build,\n    layers: (ops, options) => ({ toExtension: (size) => build(size, ops, options) as unknown as JsonValue }),\n  };\n}\n"],"mappings":";;;;;AA6CA,IAAa,QAAQ;CACnB,OAAyB,cAA6B;EAAE;EAAU,OAAO,EAAE,MAAM,OAAO;CAAE;CAC1F,SAA2B,UAAa,aAAmE;EAAE;EAAU,OAAO;GAAE,MAAM;GAAU,GAAG;EAAQ;CAAE;CAC7J,OAAyB,UAAa,aAAkF;EAAE;EAAU,OAAO;GAAE,MAAM;GAAQ,GAAG;EAAQ;CAAE;CACxK,SAA2B,UAAa,aAA6F;EAAE;EAAU,OAAO;GAAE,MAAM;GAAU,QAAQ,QAAQ;GAAQ,QAAQ,QAAQ;EAAO;CAAE;;CAE3N,QAAQ,WAAyC;EAAE,UAAU;EAAM;CAAM;AAC3E;;;;;;;;;;;;AAaA,SAAgB,cAAsC,WAAwC;CAC5F,MAAM,OAA0B,OAAO,QAAQ,SAAS,CAAC,CAAC,KAAK,CAAC,IAAI,YAAY;EAAE;EAAI,GAAG;CAAM,EAAE;CACjG,MAAM,SAAS,MAAiC,KAAgC,UAAyB,CAAC,MAAmB;EAC3H,MAAM,QAAQ,QAAQ,SAAS;EAC/B,IAAI,EAAE,QAAQ,MAAM,CAAC,OAAO,SAAS,KAAK,GAAG,MAAM,IAAI,mBAAmB,CAAC;GAAE,MAAM;GAAiB,SAAS;EAA4B,CAAC,CAAC;EAC3I,IAAI,OAAO,WAAW,KAAK,IAAI,KAAK,IAAI;GAAE;GAAO,GAAI,QAAQ,UAAU,KAAA,IAAY,EAAE,OAAO,QAAQ,MAAM,IAAI,CAAC;EAAG,CAAC;EACnH,IAAI,SAAS,IAAI,UAAU;GACzB,MAAM,QAAQ,GAAG,aAAa,OAAO,QAAS,KAAK,WAAW,aAAa,SAAS,OAAO,GAAG,QAAQ;GACtG,IAAI,QAAQ,GAAG,MAAM,IAAI,mBAAmB,CAAC;IAAE,MAAM,kBAAkB,MAAM;IAAI,SAAS,aAAa,OAAO,GAAG,QAAQ,EAAE;GAAmB,CAAC,CAAC;GAChJ,OAAO,WAAW,MAAM,GAAG,OAAO,KAAK,CAAC,CAAC;EAC3C,CAAC;EACD,OAAO;GACL,SAAA;GACA,WAAW;GACX,GAAI,QAAQ,cAAc,EAAE,aAAa,QAAQ,YAAY,IAAI,CAAC;GAClE;GACA,GAAI,QAAQ,QAAQ,EAAE,OAAO,QAAQ,MAAM,IAAI,CAAC;GAChD,GAAI,QAAQ,aAAa,EAAE,YAAY,QAAQ,WAAW,IAAI,CAAC;EACjE;CACF;CACA,OAAO;EACL,WAAW;EACX;EACA,SAAS,KAAK,aAAa,EAAE,cAAc,SAAS,MAAM,MAAM,KAAK,OAAO,EAA0B;CACxG;AACF"}

package/dist/terrain/editing.d.ts

@@ -0,0 +1,54 @@
+import { Unsubscribe } from '../model/result';
+import { InteractionController, Tool } from '../interaction/controller';
+import { IntentDefinition } from '../interaction/intents';
+import { PipelineStep } from '../interaction/pipeline';
+import { TerrainShape } from './types';
+declare module "../interaction/intents" {
+    interface IntentRegistry {
+        /** Paint a shape of the terrain with a material, or erase it with `null`. */
+        "terrain.paint": {
+            readonly shape: TerrainShape;
+            readonly material: string | null;
+        };
+    }
+}
+/** The `terrain.paint` intent: one patch, after the rules of the pipeline. */
+export declare const terrainPaintIntent: IntentDefinition<"terrain.paint">;
+/** Registers the intent, unless a feature already did. */
+export declare function registerTerrainIntents(controller: InteractionController): Unsubscribe;
+/**
+ * Only paint over certain materials: `requireTerrain(["grass", "dirt"])` lets a game till grass and nothing else.
+ * Checks every pixel the shape would cover. Pixels outside the map count as wrong ground.
+ */
+export declare function requireTerrain(materials: readonly string[]): PipelineStep<"terrain.paint">;
+/** Refuses shapes that reach outside the map. Without it they are clipped. */
+export declare function withinTerrain(): PipelineStep<"terrain.paint">;
+/** Keeps a brush from being bigger than a game wants. */
+export declare function maxRadius(limit: number): PipelineStep<"terrain.paint">;
+export interface BrushOptions {
+    /** Material to paint, or `null` to erase. */
+    readonly material: string | null;
+    /** Radius in world pixels. */
+    readonly radius: number;
+    /** Distance between two points of a stroke, in world pixels. Defaults to a third of the radius. */
+    readonly spacing?: number;
+}
+export interface BrushApi {
+    /** Starts painting with the pointer: pressing paints, dragging paints a line, releasing ends the stroke. */
+    start(options: BrushOptions): void;
+    stop(): void;
+    readonly active: BrushOptions | null;
+}
+export interface BrushTool {
+    readonly tool: Tool;
+    readonly api: BrushApi;
+}
+/**
+ * The tool that paints. Each press-drag-release is one undo step, however many patches it made. It only
+ * submits intents: whatever rules the pipeline has, and wherever the model commits (here or on an authority),
+ * apply as for anything else.
+ */
+export declare function terrainBrush(options?: {
+    readonly modes?: readonly string[];
+}): BrushTool;
+//# sourceMappingURL=editing.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"editing.d.ts","sourceRoot":"","sources":["../../src/terrain/editing.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,WAAW,EAAE,MAAM,iBAAiB,CAAC;AACnD,OAAO,KAAK,EAAE,qBAAqB,EAAE,IAAI,EAAE,MAAM,2BAA2B,CAAC;AAE7E,OAAO,KAAK,EAAE,gBAAgB,EAAE,MAAM,wBAAwB,CAAC;AAC/D,OAAO,KAAK,EAAE,YAAY,EAAE,MAAM,yBAAyB,CAAC;AAI5D,OAAO,EAAe,KAAK,YAAY,EAAE,MAAM,SAAS,CAAC;AAEzD,OAAO,QAAQ,wBAAwB,CAAC;IACtC,UAAU,cAAc;QACtB,6EAA6E;QAC7E,eAAe,EAAE;YAAE,QAAQ,CAAC,KAAK,EAAE,YAAY,CAAC;YAAC,QAAQ,CAAC,QAAQ,EAAE,MAAM,GAAG,IAAI,CAAA;SAAE,CAAC;KACrF;CACF;AAED,8EAA8E;AAC9E,eAAO,MAAM,kBAAkB,EAAE,gBAAgB,CAAC,eAAe,CAKhE,CAAC;AAEF,0DAA0D;AAC1D,wBAAgB,sBAAsB,CAAC,UAAU,EAAE,qBAAqB,GAAG,WAAW,CAErF;AAED;;;GAGG;AACH,wBAAgB,cAAc,CAAC,SAAS,EAAE,SAAS,MAAM,EAAE,GAAG,YAAY,CAAC,eAAe,CAAC,CAsB1F;AAED,8EAA8E;AAC9E,wBAAgB,aAAa,IAAI,YAAY,CAAC,eAAe,CAAC,CAa7D;AAED,yDAAyD;AACzD,wBAAgB,SAAS,CAAC,KAAK,EAAE,MAAM,GAAG,YAAY,CAAC,eAAe,CAAC,CAMtE;AAED,MAAM,WAAW,YAAY;IAC3B,6CAA6C;IAC7C,QAAQ,CAAC,QAAQ,EAAE,MAAM,GAAG,IAAI,CAAC;IACjC,8BAA8B;IAC9B,QAAQ,CAAC,MAAM,EAAE,MAAM,CAAC;IACxB,mGAAmG;IACnG,QAAQ,CAAC,OAAO,CAAC,EAAE,MAAM,CAAC;CAC3B;AAED,MAAM,WAAW,QAAQ;IACvB,4GAA4G;IAC5G,KAAK,CAAC,OAAO,EAAE,YAAY,GAAG,IAAI,CAAC;IACnC,IAAI,IAAI,IAAI,CAAC;IACb,QAAQ,CAAC,MAAM,EAAE,YAAY,GAAG,IAAI,CAAC;CACtC;AAED,MAAM,WAAW,SAAS;IACxB,QAAQ,CAAC,IAAI,EAAE,IAAI,CAAC;IACpB,QAAQ,CAAC,GAAG,EAAE,QAAQ,CAAC;CACxB;AAID;;;;GAIG;AACH,wBAAgB,YAAY,CAAC,OAAO,GAAE;IAAE,QAAQ,CAAC,KAAK,CAAC,EAAE,SAAS,MAAM,EAAE,CAAA;CAAO,GAAG,SAAS,CAuD5F"}

package/dist/terrain/editing.js

@@ -0,0 +1,169 @@
+import "./types.js";
+import { tryReadTerrain } from "./data.js";
+import { covers, readRect, shapeBounds } from "./mask.js";
+import { paintCost } from "./patches.js";
+//#region src/terrain/editing.ts
+/** The `terrain.paint` intent: one patch, after the rules of the pipeline. */
+var terrainPaintIntent = { resolve(intent, { state }) {
+	if (!tryReadTerrain(state)) return {
+		ok: false,
+		reason: "no-terrain",
+		message: "This map has no terrain"
+	};
+	return {
+		type: "terrain.paint",
+		shape: intent.shape,
+		material: intent.material
+	};
+} };
+/** Registers the intent, unless a feature already did. */
+function registerTerrainIntents(controller) {
+	return controller.hasIntent("terrain.paint") ? () => void 0 : controller.registerIntent("terrain.paint", terrainPaintIntent);
+}
+/**
+* Only paint over certain materials: `requireTerrain(["grass", "dirt"])` lets a game till grass and nothing else.
+* Checks every pixel the shape would cover. Pixels outside the map count as wrong ground.
+*/
+function requireTerrain(materials) {
+	return (intent, context, next) => {
+		const terrain = tryReadTerrain(context.state);
+		if (!terrain) return context.reject("no-terrain", "This map has no terrain");
+		const allowed = new Set(materials.map((id) => terrain.materials.findIndex((material) => material.id === id)).filter((index) => index >= 0));
+		const bounds = shapeBounds(terrain.mask, intent.shape);
+		if (!bounds) return context.reject("outside-map", "Nothing of this lies on the map");
+		if (paintCost(terrain.mask, intent.shape) > 5e7) return context.reject("too-large", "This is too large to paint at once");
+		const values = readRect(terrain.mask, bounds);
+		for (let y = bounds.y; y < bounds.y + bounds.height; y += 1) for (let x = bounds.x; x < bounds.x + bounds.width; x += 1) {
+			if (!covers(terrain.mask, intent.shape, x, y)) continue;
+			const value = values[(y - bounds.y) * bounds.width + (x - bounds.x)];
+			if (value === 65535 || !allowed.has(value)) return context.reject("wrong-ground", `Can only be painted over ${materials.join(", ")}`);
+		}
+		return next();
+	};
+}
+/** Refuses shapes that reach outside the map. Without it they are clipped. */
+function withinTerrain() {
+	return (intent, context, next) => {
+		const terrain = tryReadTerrain(context.state);
+		if (!terrain) return context.reject("no-terrain", "This map has no terrain");
+		const shape = intent.shape;
+		const width = terrain.mask.width * terrain.mask.scale;
+		const height = terrain.mask.height * terrain.mask.scale;
+		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
+		} : shape.type === "rect" ? {
+			x0: shape.x,
+			y0: shape.y,
+			x1: shape.x + shape.width,
+			y1: shape.y + shape.height
+		} : {
+			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
+		};
+		if (box.x0 < 0 || box.y0 < 0 || box.x1 > width || box.y1 > height) return context.reject("outside-map", "This reaches outside the map");
+		return next();
+	};
+}
+/** Keeps a brush from being bigger than a game wants. */
+function maxRadius(limit) {
+	return (intent, _context, next) => {
+		const shape = intent.shape;
+		if ((shape.type === "circle" || shape.type === "stroke") && shape.radius > limit) return next({
+			...intent,
+			shape: {
+				...shape,
+				radius: limit
+			}
+		});
+		return next();
+	};
+}
+var strokes = 0;
+/**
+* The tool that paints. Each press-drag-release is one undo step, however many patches it made. It only
+* submits intents: whatever rules the pipeline has, and wherever the model commits (here or on an authority),
+* apply as for anything else.
+*/
+function terrainBrush(options = {}) {
+	let brush = null;
+	let last = null;
+	let key = "";
+	const paintAt = (controller, shape) => {
+		if (!brush) return;
+		controller.submit({
+			type: "terrain.paint",
+			shape,
+			material: brush.material
+		}, { coalesce: key });
+	};
+	const end = () => {
+		last = null;
+		key = "";
+	};
+	return {
+		tool: {
+			id: "terrain-brush",
+			modes: options.modes ?? ["edit"],
+			priority: 90,
+			pointerDown(input, controller) {
+				if (!brush || input.button !== 0) return false;
+				strokes += 1;
+				key = `terrain-stroke-${strokes}`;
+				last = {
+					x: input.x,
+					y: input.y
+				};
+				paintAt(controller, {
+					type: "circle",
+					x: input.x,
+					y: input.y,
+					radius: brush.radius
+				});
+				return true;
+			},
+			pointerMove(input, controller) {
+				if (!brush || !last) return false;
+				const spacing = brush.spacing ?? Math.max(1, brush.radius / 3);
+				if (Math.hypot(input.x - last.x, input.y - last.y) < spacing) return true;
+				paintAt(controller, {
+					type: "stroke",
+					points: [[last.x, last.y], [input.x, input.y]],
+					radius: brush.radius
+				});
+				last = {
+					x: input.x,
+					y: input.y
+				};
+				return true;
+			},
+			pointerUp: end,
+			cancel: end
+		},
+		api: {
+			start(next) {
+				brush = next;
+			},
+			stop() {
+				brush = null;
+				end();
+			},
+			get active() {
+				return brush;
+			}
+		}
+	};
+}
+//#endregion
+export { maxRadius, registerTerrainIntents, requireTerrain, terrainBrush, terrainPaintIntent, withinTerrain };
+
+//# sourceMappingURL=editing.js.map