@jsprismarine/spawning 0.0.0 → 0.16.0-unstable-20261029135432

package/dist/conditions.es.js

@@ -0,0 +1,186 @@
+import { distanceSquared, passAt } from "./world.es.js";
+import { SPAWN_CONSTANTS } from "./constants.es.js";
+import { DIFFICULTIES } from "./rules.es.js";
+import { evaluateFilter } from "@jsprismarine/entities";
+// src/conditions.ts
+/**
+* The cooldowns `minecraft:delay_filter` keeps.
+*
+* The three pillager patrol conditions each name their own identifier, which
+* is how one per-difficulty cooldown exists per world rather than one per
+* condition.
+*/
+var SpawnDelays = class {
+	ready = /* @__PURE__ */ new Map();
+	/** The tick the named cooldown next allows a spawn, or undefined when it has never run. */
+	readyAt(identifier) {
+		return this.ready.get(identifier);
+	}
+	/** Sets the tick at which the named cooldown allows the next spawn. */
+	schedule(identifier, tick) {
+		this.ready.set(identifier, tick);
+	}
+	/** Draws a delay inside the filter's range and schedules it from `tick`. */
+	scheduleFrom(delay, tick, random) {
+		if (delay.identifier === void 0) return;
+		const span = Math.max(0, delay.max - delay.min);
+		this.schedule(delay.identifier, tick + delay.min + Math.floor(random.nextFloat() * (span + 1)));
+	}
+};
+var rejected = (component) => ({
+	passed: false,
+	rejectedBy: component
+});
+var PASSED = { passed: true };
+/**
+* Builds the filter context a `minecraft:biome_filter` reads.
+*
+* A spawn rule has no entity yet, so the `self` subject is the position: its
+* biome tags answer `has_biome_tag`, its biome answers `is_biome`, and its
+* site flags answer `is_snow_covered`, `is_underground`, `is_underwater` and
+* `in_lava`. Every other test the shared grammar allows goes unanswered and is
+* reported, which is what the engine does for a fact it cannot establish.
+*/
+var spawnFilterContext = (world, at) => {
+	return {
+		self: {
+			flag: (name) => {
+				switch (name) {
+					case "is_snow_covered": return world.site("snow_covered", at);
+					case "is_underground": return world.site("underground", at);
+					case "is_underwater":
+					case "in_water": return world.site("underwater", at);
+					case "in_lava": return world.site("lava", at);
+					default: return;
+				}
+			},
+			names: (name) => {
+				if (name === "has_biome_tag") return world.biomeTags(at);
+				if (name === "is_biome") {
+					const biome = world.biome?.(at);
+					return biome === void 0 ? void 0 : [biome];
+				}
+			}
+		},
+		world: {
+			difficulty: () => world.difficulty(),
+			weather: () => world.weather()
+		}
+	};
+};
+/** The light a brightness filter compares, after the darkening weather applies to it. */
+var brightnessAt = (world, at, adjustForWeather, constants) => {
+	const light = world.light(at);
+	if (!adjustForWeather) return light;
+	const weather = world.weather();
+	if (weather === "rain") return Math.max(0, light - constants.rainDarkening);
+	if (weather === "thunder") return Math.max(0, light - constants.thunderDarkening);
+	return light;
+};
+var difficultyRank = (difficulty) => DIFFICULTIES.indexOf(difficulty);
+/** The distance from a position to the nearest player, or undefined when no player is loaded. */
+var nearestPlayerDistance = (world, at) => {
+	let best;
+	for (const player of world.players()) {
+		const distance = distanceSquared(player.position, at);
+		if (best === void 0 || distance < best) best = distance;
+	}
+	return best === void 0 ? void 0 : Math.sqrt(best);
+};
+var matchesBlock = (identifier, names) => identifier !== void 0 && names.includes(identifier);
+/**
+* Decides whether one condition allows a spawn at a position.
+*
+* The components run cheapest first, and the first one that rejects names
+* itself in the result. A condition that declares neither
+* `minecraft:spawns_underwater` nor `minecraft:spawns_lava` refuses a position
+* inside either liquid, which is the reading that keeps land mobs out of the
+* ocean; Mojang states the components and not that rule.
+*
+* @param requestedPass - The pass the spawn loop is evaluating, or absent to
+*   derive it from the world's site facts.
+*/
+var evaluateSpawnCondition = (condition, at, context, requestedPass) => {
+	const { world } = context;
+	const constants = context.constants ?? SPAWN_CONSTANTS;
+	const pass = requestedPass ?? passAt(world, at);
+	if (condition.spawnsOnSurface || condition.spawnsUnderground) {
+		if (pass === "surface" && !condition.spawnsOnSurface) return rejected("minecraft:spawns_underground");
+		if (pass === "underground" && !condition.spawnsUnderground) return rejected("minecraft:spawns_on_surface");
+	}
+	const inWater = world.site("underwater", at);
+	const inLava = world.site("lava", at);
+	if (condition.spawnsUnderwater && !inWater) return rejected("minecraft:spawns_underwater");
+	if (condition.spawnsLava && !inLava) return rejected("minecraft:spawns_lava");
+	if (!condition.spawnsUnderwater && inWater) return rejected("minecraft:spawns_underwater");
+	if (!condition.spawnsLava && inLava) return rejected("minecraft:spawns_lava");
+	if (condition.disallowSpawnsInBubble && world.site("bubble_column", at)) return rejected("minecraft:disallow_spawns_in_bubble");
+	if (condition.height !== void 0 && (at.y < condition.height.min || at.y > condition.height.max)) return rejected("minecraft:height_filter");
+	if (condition.blocks !== void 0) {
+		if (!matchesBlock(world.block({
+			x: at.x,
+			y: at.y - 1,
+			z: at.z
+		}), condition.blocks)) return rejected("minecraft:spawns_on_block_filter");
+	}
+	if (condition.preventedBlocks !== void 0) {
+		if (matchesBlock(world.block({
+			x: at.x,
+			y: at.y - 1,
+			z: at.z
+		}), condition.preventedBlocks)) return rejected("minecraft:spawns_on_block_prevented_filter");
+	}
+	if (condition.aboveBlocks !== void 0) {
+		let found = false;
+		for (let depth = 1; depth <= condition.aboveBlocks.distance && !found; depth += 1) found = matchesBlock(world.block({
+			x: at.x,
+			y: at.y - depth,
+			z: at.z
+		}), condition.aboveBlocks.blocks);
+		if (!found) return rejected("minecraft:spawns_above_block_filter");
+	}
+	if (condition.brightness !== void 0) {
+		const light = brightnessAt(world, at, condition.brightness.adjustForWeather, constants);
+		if (light < condition.brightness.min || light > condition.brightness.max) return rejected("minecraft:brightness_filter");
+	}
+	if (condition.difficulty !== void 0) {
+		const rank = difficultyRank(world.difficulty());
+		if (rank < difficultyRank(condition.difficulty.min) || rank > difficultyRank(condition.difficulty.max)) return rejected("minecraft:difficulty_filter");
+	}
+	if (condition.worldAge !== void 0) {
+		const age = world.age();
+		if (age < condition.worldAge.min) return rejected("minecraft:world_age_filter");
+		if (condition.worldAge.max >= 0 && age > condition.worldAge.max) return rejected("minecraft:world_age_filter");
+	}
+	if (condition.mobEvent !== void 0 && !world.mobEventActive(condition.mobEvent)) return rejected("minecraft:mob_event_filter");
+	if (condition.distance !== void 0) {
+		const distance = nearestPlayerDistance(world, at);
+		if (distance === void 0 || distance < condition.distance.min || distance > condition.distance.max) return rejected("minecraft:distance_filter");
+	}
+	if (condition.playerInVillage !== void 0) {
+		const { distance, villageBorderTolerance } = condition.playerInVillage;
+		if (!world.players().filter((player) => distanceSquared(player.position, at) <= distance * distance).some((player) => {
+			const border = world.villageBorderDistance?.(player.position);
+			return border !== void 0 && border <= villageBorderTolerance;
+		})) return rejected("minecraft:player_in_village_filter");
+	}
+	if (condition.biomeFilter !== void 0) {
+		const options = {};
+		if (context.onUnanswered !== void 0) options.onUnanswered = context.onUnanswered;
+		if (!evaluateFilter(condition.biomeFilter, spawnFilterContext(world, at), options)) return rejected("minecraft:biome_filter");
+	}
+	if (condition.density !== void 0) {
+		const limit = pass === "surface" ? condition.density.surface : condition.density.underground;
+		if (limit >= 0 && world.typeCount(context.identifier, at, constants.densityRadius) >= limit) return rejected("minecraft:density_limit");
+	}
+	if (condition.delay !== void 0) {
+		const identifier = condition.delay.identifier;
+		const readyAt = identifier === void 0 ? void 0 : context.delays?.readyAt(identifier);
+		if (readyAt !== void 0 && context.tick < readyAt) return rejected("minecraft:delay_filter");
+		if (context.random.nextFloat() * 100 >= condition.delay.spawnChance) return rejected("minecraft:delay_filter");
+	}
+	return PASSED;
+};
+export { SpawnDelays, evaluateSpawnCondition, spawnFilterContext };
+
+//# sourceMappingURL=data:application/json;charset=utf-8;base64,{"version":3,"file":"conditions.es.js","names":[],"sources":["../src/conditions.ts"],"sourcesContent":["import type { EvaluateFilterOptions, FilterContext, FilterEntityView } from '@jsprismarine/entities';\nimport { evaluateFilter } from '@jsprismarine/entities';\nimport type { RandomSource } from '@jsprismarine/predicates';\n\nimport type { SpawnConstants } from './constants';\nimport { SPAWN_CONSTANTS } from './constants';\nimport type { Difficulty, SpawnCondition, SpawnDelay, SpawnRuleComponent } from './rules';\nimport { DIFFICULTIES } from './rules';\nimport type { SpawnPass, SpawnPosition, SpawnWorld } from './world';\nimport { distanceSquared, passAt } from './world';\n\n/**\n * Deciding whether one condition of a spawn rule allows a position.\n *\n * A rule's `conditions` are alternatives: the rule allows a position when any\n * one condition does. Each condition is a conjunction of its components, and\n * this module reports which component rejected a position so a server can\n * explain an empty spawn attempt and a test can name the component it covers.\n *\n * `minecraft:biome_filter` goes through the filter evaluator of\n * `@jsprismarine/entities`, because spawn rules, entity definitions and trade\n * tables share one filter grammar and one evaluator.\n */\n\n/** What one condition evaluation produced. */\nexport interface SpawnConditionResult {\n    readonly passed: boolean;\n    /** The first component that rejected the position, absent when the condition passed. */\n    readonly rejectedBy?: SpawnRuleComponent;\n}\n\n/** Reads the cooldowns `minecraft:delay_filter` keeps, keyed by its `identifier`. */\nexport interface SpawnDelayView {\n    /** The tick the named cooldown next allows a spawn, or undefined when it has never run. */\n    readyAt(identifier: string): number | undefined;\n}\n\n/**\n * The cooldowns `minecraft:delay_filter` keeps.\n *\n * The three pillager patrol conditions each name their own identifier, which\n * is how one per-difficulty cooldown exists per world rather than one per\n * condition.\n */\nexport class SpawnDelays implements SpawnDelayView {\n    private readonly ready = new Map<string, number>();\n\n    /** The tick the named cooldown next allows a spawn, or undefined when it has never run. */\n    public readyAt(identifier: string): number | undefined {\n        return this.ready.get(identifier);\n    }\n\n    /** Sets the tick at which the named cooldown allows the next spawn. */\n    public schedule(identifier: string, tick: number): void {\n        this.ready.set(identifier, tick);\n    }\n\n    /** Draws a delay inside the filter's range and schedules it from `tick`. */\n    public scheduleFrom(delay: SpawnDelay, tick: number, random: RandomSource): void {\n        if (delay.identifier === undefined) return;\n        const span = Math.max(0, delay.max - delay.min);\n        this.schedule(delay.identifier, tick + delay.min + Math.floor(random.nextFloat() * (span + 1)));\n    }\n}\n\n/** Everything one condition evaluation needs beyond the condition and the position. */\nexport interface SpawnConditionContext {\n    readonly world: SpawnWorld;\n    /** The entity the rule spawns, which `minecraft:density_limit` counts. */\n    readonly identifier: string;\n    readonly random: RandomSource;\n    /** The current world tick, which `minecraft:delay_filter` compares. */\n    readonly tick: number;\n    readonly constants?: SpawnConstants;\n    readonly delays?: SpawnDelayView;\n    /** Receives every biome filter test the evaluator could not answer. */\n    readonly onUnanswered?: EvaluateFilterOptions['onUnanswered'];\n}\n\nconst rejected = (component: SpawnRuleComponent): SpawnConditionResult => ({ passed: false, rejectedBy: component });\n\nconst PASSED: SpawnConditionResult = { passed: true };\n\n/**\n * Builds the filter context a `minecraft:biome_filter` reads.\n *\n * A spawn rule has no entity yet, so the `self` subject is the position: its\n * biome tags answer `has_biome_tag`, its biome answers `is_biome`, and its\n * site flags answer `is_snow_covered`, `is_underground`, `is_underwater` and\n * `in_lava`. Every other test the shared grammar allows goes unanswered and is\n * reported, which is what the engine does for a fact it cannot establish.\n */\nexport const spawnFilterContext = (world: SpawnWorld, at: SpawnPosition): FilterContext => {\n    const self: FilterEntityView = {\n        flag: (name) => {\n            switch (name) {\n                case 'is_snow_covered':\n                    return world.site('snow_covered', at);\n                case 'is_underground':\n                    return world.site('underground', at);\n                case 'is_underwater':\n                case 'in_water':\n                    return world.site('underwater', at);\n                case 'in_lava':\n                    return world.site('lava', at);\n                default:\n                    return undefined;\n            }\n        },\n        names: (name) => {\n            if (name === 'has_biome_tag') return world.biomeTags(at);\n            if (name === 'is_biome') {\n                const biome = world.biome?.(at);\n                return biome === undefined ? undefined : [biome];\n            }\n            return undefined;\n        }\n    };\n\n    return {\n        self,\n        world: { difficulty: () => world.difficulty(), weather: () => world.weather() }\n    };\n};\n\n/** The light a brightness filter compares, after the darkening weather applies to it. */\nconst brightnessAt = (\n    world: SpawnWorld,\n    at: SpawnPosition,\n    adjustForWeather: boolean,\n    constants: SpawnConstants\n): number => {\n    const light = world.light(at);\n    if (!adjustForWeather) return light;\n    const weather = world.weather();\n    if (weather === 'rain') return Math.max(0, light - constants.rainDarkening);\n    if (weather === 'thunder') return Math.max(0, light - constants.thunderDarkening);\n    return light;\n};\n\nconst difficultyRank = (difficulty: Difficulty): number => DIFFICULTIES.indexOf(difficulty);\n\n/** The distance from a position to the nearest player, or undefined when no player is loaded. */\nconst nearestPlayerDistance = (world: SpawnWorld, at: SpawnPosition): number | undefined => {\n    let best: number | undefined;\n    for (const player of world.players()) {\n        const distance = distanceSquared(player.position, at);\n        if (best === undefined || distance < best) best = distance;\n    }\n    return best === undefined ? undefined : Math.sqrt(best);\n};\n\nconst matchesBlock = (identifier: string | undefined, names: readonly string[]): boolean =>\n    identifier !== undefined && names.includes(identifier);\n\n/**\n * Decides whether one condition allows a spawn at a position.\n *\n * The components run cheapest first, and the first one that rejects names\n * itself in the result. A condition that declares neither\n * `minecraft:spawns_underwater` nor `minecraft:spawns_lava` refuses a position\n * inside either liquid, which is the reading that keeps land mobs out of the\n * ocean; Mojang states the components and not that rule.\n *\n * @param requestedPass - The pass the spawn loop is evaluating, or absent to\n *   derive it from the world's site facts.\n */\nexport const evaluateSpawnCondition = (\n    condition: SpawnCondition,\n    at: SpawnPosition,\n    context: SpawnConditionContext,\n    requestedPass?: SpawnPass\n): SpawnConditionResult => {\n    const { world } = context;\n    const constants = context.constants ?? SPAWN_CONSTANTS;\n    const pass = requestedPass ?? passAt(world, at);\n\n    if (condition.spawnsOnSurface || condition.spawnsUnderground) {\n        if (pass === 'surface' && !condition.spawnsOnSurface) return rejected('minecraft:spawns_underground');\n        if (pass === 'underground' && !condition.spawnsUnderground) return rejected('minecraft:spawns_on_surface');\n    }\n\n    const inWater = world.site('underwater', at);\n    const inLava = world.site('lava', at);\n    if (condition.spawnsUnderwater && !inWater) return rejected('minecraft:spawns_underwater');\n    if (condition.spawnsLava && !inLava) return rejected('minecraft:spawns_lava');\n    if (!condition.spawnsUnderwater && inWater) return rejected('minecraft:spawns_underwater');\n    if (!condition.spawnsLava && inLava) return rejected('minecraft:spawns_lava');\n\n    if (condition.disallowSpawnsInBubble && world.site('bubble_column', at))\n        return rejected('minecraft:disallow_spawns_in_bubble');\n\n    if (condition.height !== undefined && (at.y < condition.height.min || at.y > condition.height.max))\n        return rejected('minecraft:height_filter');\n\n    if (condition.blocks !== undefined) {\n        const below = world.block({ x: at.x, y: at.y - 1, z: at.z });\n        if (!matchesBlock(below, condition.blocks)) return rejected('minecraft:spawns_on_block_filter');\n    }\n\n    if (condition.preventedBlocks !== undefined) {\n        const below = world.block({ x: at.x, y: at.y - 1, z: at.z });\n        if (matchesBlock(below, condition.preventedBlocks))\n            return rejected('minecraft:spawns_on_block_prevented_filter');\n    }\n\n    if (condition.aboveBlocks !== undefined) {\n        // The component names no direction. \"Spawns above block\" reads as the\n        // entity standing above one of the blocks, so the scan runs downward\n        // from the position for `distance` blocks.\n        let found = false;\n        for (let depth = 1; depth <= condition.aboveBlocks.distance && !found; depth += 1) {\n            found = matchesBlock(world.block({ x: at.x, y: at.y - depth, z: at.z }), condition.aboveBlocks.blocks);\n        }\n        if (!found) return rejected('minecraft:spawns_above_block_filter');\n    }\n\n    if (condition.brightness !== undefined) {\n        const light = brightnessAt(world, at, condition.brightness.adjustForWeather, constants);\n        if (light < condition.brightness.min || light > condition.brightness.max)\n            return rejected('minecraft:brightness_filter');\n    }\n\n    if (condition.difficulty !== undefined) {\n        const rank = difficultyRank(world.difficulty());\n        if (rank < difficultyRank(condition.difficulty.min) || rank > difficultyRank(condition.difficulty.max))\n            return rejected('minecraft:difficulty_filter');\n    }\n\n    if (condition.worldAge !== undefined) {\n        const age = world.age();\n        if (age < condition.worldAge.min) return rejected('minecraft:world_age_filter');\n        if (condition.worldAge.max >= 0 && age > condition.worldAge.max) return rejected('minecraft:world_age_filter');\n    }\n\n    if (condition.mobEvent !== undefined && !world.mobEventActive(condition.mobEvent))\n        return rejected('minecraft:mob_event_filter');\n\n    if (condition.distance !== undefined) {\n        const distance = nearestPlayerDistance(world, at);\n        if (distance === undefined || distance < condition.distance.min || distance > condition.distance.max)\n            return rejected('minecraft:distance_filter');\n    }\n\n    if (condition.playerInVillage !== undefined) {\n        const { distance, villageBorderTolerance } = condition.playerInVillage;\n        const inRange = world.players().filter((player) => distanceSquared(player.position, at) <= distance * distance);\n        const nearVillage = inRange.some((player) => {\n            const border = world.villageBorderDistance?.(player.position);\n            return border !== undefined && border <= villageBorderTolerance;\n        });\n        if (!nearVillage) return rejected('minecraft:player_in_village_filter');\n    }\n\n    if (condition.biomeFilter !== undefined) {\n        const options: EvaluateFilterOptions = {};\n        if (context.onUnanswered !== undefined) options.onUnanswered = context.onUnanswered;\n        if (!evaluateFilter(condition.biomeFilter, spawnFilterContext(world, at), options))\n            return rejected('minecraft:biome_filter');\n    }\n\n    if (condition.density !== undefined) {\n        const limit = pass === 'surface' ? condition.density.surface : condition.density.underground;\n        if (limit >= 0 && world.typeCount(context.identifier, at, constants.densityRadius) >= limit)\n            return rejected('minecraft:density_limit');\n    }\n\n    if (condition.delay !== undefined) {\n        const identifier = condition.delay.identifier;\n        const readyAt = identifier === undefined ? undefined : context.delays?.readyAt(identifier);\n        if (readyAt !== undefined && context.tick < readyAt) return rejected('minecraft:delay_filter');\n        if (context.random.nextFloat() * 100 >= condition.delay.spawnChance) return rejected('minecraft:delay_filter');\n    }\n\n    return PASSED;\n};\n"],"mappings":"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"}

package/dist/constants.cjs.cjs

@@ -0,0 +1,29 @@
+"use strict";
+Object.defineProperty(exports, Symbol.toStringTag, { value: "Module" });
+// src/constants.ts
+/**
+* The numbers this project chose, read from
+* `src/tables/spawnConstants.json`. A host replaces the whole table through
+* `SpawnerOptions.constants`.
+*/
+var SPAWN_CONSTANTS = require("./tables/spawnConstants.cjs.cjs").default;
+/**
+* The cap one pool is allowed in the spawn region right now.
+*
+* @param players - How many players the spawn region holds, which scales a
+* `per_player` cap.
+* @returns The cap, or undefined when the pool has none and other machinery
+* limits it.
+*/
+var poolCapFor = (pool, players, constants = SPAWN_CONSTANTS) => {
+	const entry = constants.pools[pool];
+	if (entry === void 0 || entry.cap === null) return void 0;
+	return entry.scope === "per_player" ? entry.cap * players : entry.cap;
+};
+/** How many ticks pass between two spawn cycles of one pool. */
+var cycleTicksFor = (pool, constants = SPAWN_CONSTANTS) => constants.pools[pool]?.cycleTicks;
+exports.SPAWN_CONSTANTS = SPAWN_CONSTANTS;
+exports.cycleTicksFor = cycleTicksFor;
+exports.poolCapFor = poolCapFor;
+
+//# sourceMappingURL=data:application/json;charset=utf-8;base64,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

package/dist/constants.d.ts

@@ -0,0 +1,73 @@
+import type { PopulationPool } from './rules';
+/**
+ * The numbers the spawning algorithm needs and Mojang does not publish.
+ *
+ * Mojang documents the pool names and every spawn rule component's
+ * parameters, and publishes no spawn attempt rate, no cap value, no spawn
+ * radius and no light algorithm. The only numbers in print are the
+ * tilde-hedged "Typical Cap" column of `EntitySpawningDeepDive.md`. Every
+ * number here is therefore this project's choice, it lives in
+ * `src/tables/spawnConstants.json` rather than in code so it is visible and
+ * replaceable, and each one carries a `source` string saying where it came
+ * from.
+ */
+/** Whether a pool's cap covers the whole spawn region or scales with the players in it. */
+export type PoolCapScope = 'per_player' | 'per_region';
+/** One pool's cap, cadence and the provenance of both. */
+export interface PoolConstants {
+    /** The cap, or null for a pool the documentation leaves to other machinery. */
+    readonly cap: number | null;
+    readonly scope: PoolCapScope;
+    /** How many ticks pass between two spawn cycles of this pool. */
+    readonly cycleTicks: number;
+    /** Where the two numbers came from, quoted so a reader can judge them. */
+    readonly source: string;
+}
+/** The whole constants table. */
+export interface SpawnConstants {
+    /** Why none of these numbers are Mojang's. */
+    readonly provenance: string;
+    readonly pools: Readonly<Record<string, PoolConstants>>;
+    /** How far from a player, in chunks, the spawner looks for a position. */
+    readonly spawnRadiusChunks: number;
+    readonly spawnRadiusSource: string;
+    /** How many chunks one cycle samples per player. */
+    readonly chunksPerCycle: number;
+    /** How many positions one cycle tries in each sampled chunk. */
+    readonly positionsPerChunk: number;
+    readonly attemptSource: string;
+    /** How far from the anchor, in blocks, a herd member may be placed. */
+    readonly herdRadius: number;
+    readonly herdRadiusSource: string;
+    /** The radius `minecraft:density_limit` counts entities over. */
+    readonly densityRadius: number;
+    readonly densityRadiusSource: string;
+    /** How much rain lowers the light an `adjust_for_weather` brightness filter compares. */
+    readonly rainDarkening: number;
+    /** How much a thunderstorm lowers that light. */
+    readonly thunderDarkening: number;
+    readonly darkeningSource: string;
+    /** How far from every player, in chunks, a mob is culled. */
+    readonly despawnRadiusChunks: number;
+    /** The height at and below which every mob despawns. */
+    readonly despawnFloorY: number;
+    readonly despawnSource: string;
+}
+/**
+ * The numbers this project chose, read from
+ * `src/tables/spawnConstants.json`. A host replaces the whole table through
+ * `SpawnerOptions.constants`.
+ */
+export declare const SPAWN_CONSTANTS: SpawnConstants;
+/**
+ * The cap one pool is allowed in the spawn region right now.
+ *
+ * @param players - How many players the spawn region holds, which scales a
+ * `per_player` cap.
+ * @returns The cap, or undefined when the pool has none and other machinery
+ * limits it.
+ */
+export declare const poolCapFor: (pool: PopulationPool | string, players: number, constants?: SpawnConstants) => number | undefined;
+/** How many ticks pass between two spawn cycles of one pool. */
+export declare const cycleTicksFor: (pool: PopulationPool | string, constants?: SpawnConstants) => number | undefined;
+//# sourceMappingURL=constants.d.ts.map

package/dist/constants.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"constants.d.ts","sourceRoot":"","sources":["../src/constants.ts"],"names":[],"mappings":"AACA,OAAO,KAAK,EAAE,cAAc,EAAE,MAAM,SAAS,CAAC;AAE9C;;;;;;;;;;;GAWG;AAEH,2FAA2F;AAC3F,MAAM,MAAM,YAAY,GAAG,YAAY,GAAG,YAAY,CAAC;AAEvD,0DAA0D;AAC1D,MAAM,WAAW,aAAa;IAC1B,+EAA+E;IAC/E,QAAQ,CAAC,GAAG,EAAE,MAAM,GAAG,IAAI,CAAC;IAC5B,QAAQ,CAAC,KAAK,EAAE,YAAY,CAAC;IAC7B,iEAAiE;IACjE,QAAQ,CAAC,UAAU,EAAE,MAAM,CAAC;IAC5B,0EAA0E;IAC1E,QAAQ,CAAC,MAAM,EAAE,MAAM,CAAC;CAC3B;AAED,iCAAiC;AACjC,MAAM,WAAW,cAAc;IAC3B,8CAA8C;IAC9C,QAAQ,CAAC,UAAU,EAAE,MAAM,CAAC;IAC5B,QAAQ,CAAC,KAAK,EAAE,QAAQ,CAAC,MAAM,CAAC,MAAM,EAAE,aAAa,CAAC,CAAC,CAAC;IACxD,0EAA0E;IAC1E,QAAQ,CAAC,iBAAiB,EAAE,MAAM,CAAC;IACnC,QAAQ,CAAC,iBAAiB,EAAE,MAAM,CAAC;IACnC,oDAAoD;IACpD,QAAQ,CAAC,cAAc,EAAE,MAAM,CAAC;IAChC,gEAAgE;IAChE,QAAQ,CAAC,iBAAiB,EAAE,MAAM,CAAC;IACnC,QAAQ,CAAC,aAAa,EAAE,MAAM,CAAC;IAC/B,uEAAuE;IACvE,QAAQ,CAAC,UAAU,EAAE,MAAM,CAAC;IAC5B,QAAQ,CAAC,gBAAgB,EAAE,MAAM,CAAC;IAClC,iEAAiE;IACjE,QAAQ,CAAC,aAAa,EAAE,MAAM,CAAC;IAC/B,QAAQ,CAAC,mBAAmB,EAAE,MAAM,CAAC;IACrC,yFAAyF;IACzF,QAAQ,CAAC,aAAa,EAAE,MAAM,CAAC;IAC/B,iDAAiD;IACjD,QAAQ,CAAC,gBAAgB,EAAE,MAAM,CAAC;IAClC,QAAQ,CAAC,eAAe,EAAE,MAAM,CAAC;IACjC,6DAA6D;IAC7D,QAAQ,CAAC,mBAAmB,EAAE,MAAM,CAAC;IACrC,wDAAwD;IACxD,QAAQ,CAAC,aAAa,EAAE,MAAM,CAAC;IAC/B,QAAQ,CAAC,aAAa,EAAE,MAAM,CAAC;CAClC;AAED;;;;GAIG;AAGH,eAAO,MAAM,eAAe,EAAY,cAAc,CAAC;AAEvD;;;;;;;GAOG;AACH,eAAO,MAAM,UAAU,SACb,cAAc,GAAG,MAAM,WACpB,MAAM,cACJ,cAAc,KAC1B,MAAM,GAAG,SAIX,CAAC;AAEF,gEAAgE;AAChE,eAAO,MAAM,aAAa,SAChB,cAAc,GAAG,MAAM,cAClB,cAAc,KAC1B,MAAM,GAAG,SAA8C,CAAC"}

package/dist/constants.es.js

@@ -0,0 +1,26 @@
+import spawnConstants_default from "./tables/spawnConstants.es.js";
+// src/constants.ts
+/**
+* The numbers this project chose, read from
+* `src/tables/spawnConstants.json`. A host replaces the whole table through
+* `SpawnerOptions.constants`.
+*/
+var SPAWN_CONSTANTS = spawnConstants_default;
+/**
+* The cap one pool is allowed in the spawn region right now.
+*
+* @param players - How many players the spawn region holds, which scales a
+* `per_player` cap.
+* @returns The cap, or undefined when the pool has none and other machinery
+* limits it.
+*/
+var poolCapFor = (pool, players, constants = SPAWN_CONSTANTS) => {
+	const entry = constants.pools[pool];
+	if (entry === void 0 || entry.cap === null) return void 0;
+	return entry.scope === "per_player" ? entry.cap * players : entry.cap;
+};
+/** How many ticks pass between two spawn cycles of one pool. */
+var cycleTicksFor = (pool, constants = SPAWN_CONSTANTS) => constants.pools[pool]?.cycleTicks;
+export { SPAWN_CONSTANTS, cycleTicksFor, poolCapFor };
+
+//# sourceMappingURL=data:application/json;charset=utf-8;base64,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

package/dist/despawn.cjs.cjs

@@ -0,0 +1,25 @@
+"use strict";
+Object.defineProperty(exports, Symbol.toStringTag, { value: "Module" });
+const require_world = require("./world.cjs.cjs");
+const require_constants = require("./constants.cjs.cjs");
+// src/despawn.ts
+/**
+* Decides whether one entity leaves the world for a population reason.
+*
+* The Y floor is published and is the same in both editions: every mob
+* despawns at Y=-128 and below. The simulation edge is not published; this
+* project uses `despawnRadiusChunks` on the X and Z axes, whose default of 8
+* chunks is the 128 blocks of
+* `minecraft:despawn.despawn_from_distance.max_distance`.
+*
+* @returns The reason, or undefined when the entity stays.
+*/
+var despawnReason = (candidate, world, constants = require_constants.SPAWN_CONSTANTS) => {
+	if (candidate.persistent === true) return void 0;
+	if (candidate.position.y <= constants.despawnFloorY) return "below_floor";
+	const edge = constants.despawnRadiusChunks * 16;
+	return world.players().some((player) => require_world.horizontalDistanceSquared(player.position, candidate.position) <= edge * edge) ? void 0 : "simulation_edge";
+};
+exports.despawnReason = despawnReason;
+
+//# sourceMappingURL=data:application/json;charset=utf-8;base64,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

package/dist/despawn.d.ts

@@ -0,0 +1,33 @@
+import type { SpawnConstants } from './constants';
+import type { SpawnPosition, SpawnWorld } from './world';
+/**
+ * The population-level despawn rules.
+ *
+ * `minecraft:despawn` belongs to `@jsprismarine/entities`, which carries the
+ * documented per-entity policy: `despawn_from_distance`,
+ * `despawn_from_chance`, `despawn_from_inactivity` and the component's
+ * `filters`. Two rules sit outside any entity definition and belong here with
+ * the rest of the population machinery: the height every mob despawns below,
+ * and the edge of the simulated region.
+ */
+/** Why one entity despawned. */
+export type DespawnReason = 'below_floor' | 'simulation_edge';
+/** One entity the population cull looks at. */
+export interface DespawnCandidate {
+    readonly position: SpawnPosition;
+    /** Whether `minecraft:persistent` or a name tag keeps the entity loaded. */
+    readonly persistent?: boolean;
+}
+/**
+ * Decides whether one entity leaves the world for a population reason.
+ *
+ * The Y floor is published and is the same in both editions: every mob
+ * despawns at Y=-128 and below. The simulation edge is not published; this
+ * project uses `despawnRadiusChunks` on the X and Z axes, whose default of 8
+ * chunks is the 128 blocks of
+ * `minecraft:despawn.despawn_from_distance.max_distance`.
+ *
+ * @returns The reason, or undefined when the entity stays.
+ */
+export declare const despawnReason: (candidate: DespawnCandidate, world: SpawnWorld, constants?: SpawnConstants) => DespawnReason | undefined;
+//# sourceMappingURL=despawn.d.ts.map

package/dist/despawn.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"despawn.d.ts","sourceRoot":"","sources":["../src/despawn.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,cAAc,EAAE,MAAM,aAAa,CAAC;AAElD,OAAO,KAAK,EAAE,aAAa,EAAE,UAAU,EAAE,MAAM,SAAS,CAAC;AAGzD;;;;;;;;;GASG;AAEH,gCAAgC;AAChC,MAAM,MAAM,aAAa,GAAG,aAAa,GAAG,iBAAiB,CAAC;AAE9D,+CAA+C;AAC/C,MAAM,WAAW,gBAAgB;IAC7B,QAAQ,CAAC,QAAQ,EAAE,aAAa,CAAC;IACjC,4EAA4E;IAC5E,QAAQ,CAAC,UAAU,CAAC,EAAE,OAAO,CAAC;CACjC;AAED;;;;;;;;;;GAUG;AACH,eAAO,MAAM,aAAa,cACX,gBAAgB,SACpB,UAAU,cACN,cAAc,KAC1B,aAAa,GAAG,SASlB,CAAC"}

package/dist/despawn.es.js

@@ -0,0 +1,23 @@
+import { horizontalDistanceSquared } from "./world.es.js";
+import { SPAWN_CONSTANTS } from "./constants.es.js";
+// src/despawn.ts
+/**
+* Decides whether one entity leaves the world for a population reason.
+*
+* The Y floor is published and is the same in both editions: every mob
+* despawns at Y=-128 and below. The simulation edge is not published; this
+* project uses `despawnRadiusChunks` on the X and Z axes, whose default of 8
+* chunks is the 128 blocks of
+* `minecraft:despawn.despawn_from_distance.max_distance`.
+*
+* @returns The reason, or undefined when the entity stays.
+*/
+var despawnReason = (candidate, world, constants = SPAWN_CONSTANTS) => {
+	if (candidate.persistent === true) return void 0;
+	if (candidate.position.y <= constants.despawnFloorY) return "below_floor";
+	const edge = constants.despawnRadiusChunks * 16;
+	return world.players().some((player) => horizontalDistanceSquared(player.position, candidate.position) <= edge * edge) ? void 0 : "simulation_edge";
+};
+export { despawnReason };
+
+//# sourceMappingURL=data:application/json;charset=utf-8;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiZGVzcGF3bi5lcy5qcyIsIm5hbWVzIjpbXSwic291cmNlcyI6WyIuLi9zcmMvZGVzcGF3bi50cyJdLCJzb3VyY2VzQ29udGVudCI6WyJpbXBvcnQgdHlwZSB7IFNwYXduQ29uc3RhbnRzIH0gZnJvbSAnLi9jb25zdGFudHMnO1xuaW1wb3J0IHsgU1BBV05fQ09OU1RBTlRTIH0gZnJvbSAnLi9jb25zdGFudHMnO1xuaW1wb3J0IHR5cGUgeyBTcGF3blBvc2l0aW9uLCBTcGF3bldvcmxkIH0gZnJvbSAnLi93b3JsZCc7XG5pbXBvcnQgeyBob3Jpem9udGFsRGlzdGFuY2VTcXVhcmVkIH0gZnJvbSAnLi93b3JsZCc7XG5cbi8qKlxuICogVGhlIHBvcHVsYXRpb24tbGV2ZWwgZGVzcGF3biBydWxlcy5cbiAqXG4gKiBgbWluZWNyYWZ0OmRlc3Bhd25gIGJlbG9uZ3MgdG8gYEBqc3ByaXNtYXJpbmUvZW50aXRpZXNgLCB3aGljaCBjYXJyaWVzIHRoZVxuICogZG9jdW1lbnRlZCBwZXItZW50aXR5IHBvbGljeTogYGRlc3Bhd25fZnJvbV9kaXN0YW5jZWAsXG4gKiBgZGVzcGF3bl9mcm9tX2NoYW5jZWAsIGBkZXNwYXduX2Zyb21faW5hY3Rpdml0eWAgYW5kIHRoZSBjb21wb25lbnQnc1xuICogYGZpbHRlcnNgLiBUd28gcnVsZXMgc2l0IG91dHNpZGUgYW55IGVudGl0eSBkZWZpbml0aW9uIGFuZCBiZWxvbmcgaGVyZSB3aXRoXG4gKiB0aGUgcmVzdCBvZiB0aGUgcG9wdWxhdGlvbiBtYWNoaW5lcnk6IHRoZSBoZWlnaHQgZXZlcnkgbW9iIGRlc3Bhd25zIGJlbG93LFxuICogYW5kIHRoZSBlZGdlIG9mIHRoZSBzaW11bGF0ZWQgcmVnaW9uLlxuICovXG5cbi8qKiBXaHkgb25lIGVudGl0eSBkZXNwYXduZWQuICovXG5leHBvcnQgdHlwZSBEZXNwYXduUmVhc29uID0gJ2JlbG93X2Zsb29yJyB8ICdzaW11bGF0aW9uX2VkZ2UnO1xuXG4vKiogT25lIGVudGl0eSB0aGUgcG9wdWxhdGlvbiBjdWxsIGxvb2tzIGF0LiAqL1xuZXhwb3J0IGludGVyZmFjZSBEZXNwYXduQ2FuZGlkYXRlIHtcbiAgICByZWFkb25seSBwb3NpdGlvbjogU3Bhd25Qb3NpdGlvbjtcbiAgICAvKiogV2hldGhlciBgbWluZWNyYWZ0OnBlcnNpc3RlbnRgIG9yIGEgbmFtZSB0YWcga2VlcHMgdGhlIGVudGl0eSBsb2FkZWQuICovXG4gICAgcmVhZG9ubHkgcGVyc2lzdGVudD86IGJvb2xlYW47XG59XG5cbi8qKlxuICogRGVjaWRlcyB3aGV0aGVyIG9uZSBlbnRpdHkgbGVhdmVzIHRoZSB3b3JsZCBmb3IgYSBwb3B1bGF0aW9uIHJlYXNvbi5cbiAqXG4gKiBUaGUgWSBmbG9vciBpcyBwdWJsaXNoZWQgYW5kIGlzIHRoZSBzYW1lIGluIGJvdGggZWRpdGlvbnM6IGV2ZXJ5IG1vYlxuICogZGVzcGF3bnMgYXQgWT0tMTI4IGFuZCBiZWxvdy4gVGhlIHNpbXVsYXRpb24gZWRnZSBpcyBub3QgcHVibGlzaGVkOyB0aGlzXG4gKiBwcm9qZWN0IHVzZXMgYGRlc3Bhd25SYWRpdXNDaHVua3NgIG9uIHRoZSBYIGFuZCBaIGF4ZXMsIHdob3NlIGRlZmF1bHQgb2YgOFxuICogY2h1bmtzIGlzIHRoZSAxMjggYmxvY2tzIG9mXG4gKiBgbWluZWNyYWZ0OmRlc3Bhd24uZGVzcGF3bl9mcm9tX2Rpc3RhbmNlLm1heF9kaXN0YW5jZWAuXG4gKlxuICogQHJldHVybnMgVGhlIHJlYXNvbiwgb3IgdW5kZWZpbmVkIHdoZW4gdGhlIGVudGl0eSBzdGF5cy5cbiAqL1xuZXhwb3J0IGNvbnN0IGRlc3Bhd25SZWFzb24gPSAoXG4gICAgY2FuZGlkYXRlOiBEZXNwYXduQ2FuZGlkYXRlLFxuICAgIHdvcmxkOiBTcGF3bldvcmxkLFxuICAgIGNvbnN0YW50czogU3Bhd25Db25zdGFudHMgPSBTUEFXTl9DT05TVEFOVFNcbik6IERlc3Bhd25SZWFzb24gfCB1bmRlZmluZWQgPT4ge1xuICAgIGlmIChjYW5kaWRhdGUucGVyc2lzdGVudCA9PT0gdHJ1ZSkgcmV0dXJuIHVuZGVmaW5lZDtcbiAgICBpZiAoY2FuZGlkYXRlLnBvc2l0aW9uLnkgPD0gY29uc3RhbnRzLmRlc3Bhd25GbG9vclkpIHJldHVybiAnYmVsb3dfZmxvb3InO1xuXG4gICAgY29uc3QgZWRnZSA9IGNvbnN0YW50cy5kZXNwYXduUmFkaXVzQ2h1bmtzICogMTY7XG4gICAgY29uc3QgaW5SYW5nZSA9IHdvcmxkXG4gICAgICAgIC5wbGF5ZXJzKClcbiAgICAgICAgLnNvbWUoKHBsYXllcikgPT4gaG9yaXpvbnRhbERpc3RhbmNlU3F1YXJlZChwbGF5ZXIucG9zaXRpb24sIGNhbmRpZGF0ZS5wb3NpdGlvbikgPD0gZWRnZSAqIGVkZ2UpO1xuICAgIHJldHVybiBpblJhbmdlID8gdW5kZWZpbmVkIDogJ3NpbXVsYXRpb25fZWRnZSc7XG59O1xuIl0sIm1hcHBpbmdzIjoiOzs7Ozs7Ozs7Ozs7OztBQXFDQSxJQUFhLGlCQUNULFdBQ0EsT0FDQSxZQUE0QixvQkFDQTtDQUM1QixJQUFJLFVBQVUsZUFBZSxNQUFNLE9BQU8sS0FBQTtDQUMxQyxJQUFJLFVBQVUsU0FBUyxLQUFLLFVBQVUsZUFBZSxPQUFPO0NBRTVELE1BQU0sT0FBTyxVQUFVLHNCQUFzQjtDQUk3QyxPQUhnQixNQUNYLFFBQVEsQ0FBQyxDQUNULE1BQU0sV0FBVywwQkFBMEIsT0FBTyxVQUFVLFVBQVUsUUFBUSxLQUFLLE9BQU8sSUFDeEYsSUFBVSxLQUFBLElBQVk7QUFDakMifQ==