@v12-engine/create 0.1.1 → 0.4.0

package/starters/melee/layers/tests/tests/heroes.test.ts

@@ -0,0 +1,402 @@
+/**
+ * The heroes, tested with no page on a small flat map: their callings and innates, what each of their abilities does,
+ * the altars that train them and the tavern that hires them
+ */
+import {
+	applyBuff,
+	callingsOf,
+	checkRules,
+	damaged,
+	type Entity,
+	fighting,
+	hasBuff,
+	heroOf,
+	hire,
+	isPhasing,
+	learn,
+	MAP_CREEPS,
+	setHeroLevel,
+	shieldOf,
+	statsOf,
+	type World
+} from '@v12-engine/engine'
+import { run, TEST_PLAYERS, testWorld } from '@v12-engine/engine/testing'
+import { describe, expect, it } from 'vitest'
+import { game as melee } from '../src/game'
+import { harvested, heroes, HOLLOW_HEROES, KINGDOM_HEROES } from '../src/melee/heroes'
+
+const rules = melee.toRules()
+
+const ME = 1
+const FOE = 2
+const NEUTRAL = 0
+/** The camps' creeps: everyone's enemy */
+const CREEPS = MAP_CREEPS
+
+/** What each hero is, as the plan has it: its callings and its innate */
+const PLANNED: Record<string, { callings: Record<string, number>; innate: string }> = {
+	oathbreaker: { callings: { vanguard: 3, keeper: 1 }, innate: 'bulwark' },
+	dawnPriest: { callings: { keeper: 3, arcanist: 1 }, innate: 'mercysEcho' },
+	stormcaller: { callings: { arcanist: 3, binder: 2 }, innate: 'staticCharge' },
+	galeHunter: { callings: { ranger: 3, roamer: 1 }, innate: 'steadyAim' },
+	gravelord: { callings: { reaver: 3, vanguard: 1, keeper: 1 }, innate: 'bloodTithe' },
+	rimeWitch: { callings: { binder: 3, arcanist: 2 }, innate: 'shatter' },
+	duskblade: { callings: { stalker: 3, roamer: 2 }, innate: 'shadowStep' },
+	boneReaver: { callings: { roamer: 3, reaver: 2 }, innate: 'harvest' }
+}
+
+async function arena(): Promise<World> {
+	const world = await testWorld(rules, {
+		size: 64,
+		players: [...TEST_PLAYERS.map((player) => ({ ...player })), { id: CREEPS, name: 'Creeps', team: 1000, color: [0.42, 0.36, 0.3], creeps: true }]
+	})
+	for (const player of [ME, FOE]) world.player(player).resources.gold = 10000
+	return world
+}
+
+/** Picks no fight of its own: what it does is the test's */
+function calm(unit: Entity): Entity {
+	unit.get(fighting)!.passive = true
+	return unit
+}
+
+/** A hero of a type at a level, every point it has put into what it learns, in order, full of mana; picking no fights */
+function hero(world: World, type: string, owner = ME, at = { x: 30, z: 30 }, level = 10): Entity {
+	const made = calm(world.spawn(type, owner, at))
+	setHeroLevel(world, made, level)
+	for (let round = 0; round < 3; round++) for (const id of made.def.hero!.learns) learn(world, made, id)
+	made.mana = made.maxMana
+	return made
+}
+
+/** Units of the enemy's that stand where they are put and pick no fights: what the abilities are tried on */
+const target = (world: World, at: { x: number; z: number }, type = 'footman', owner = FOE): Entity => calm(world.spawn(type, owner, at))
+
+/** A tick on, so that a player knows of what was just made and may aim at it */
+const seen = (world: World) => run(world, 0.1)
+
+const cast = (world: World, caster: Entity, ability: string, aim: { target?: Entity; point?: { x: number; z: number } } = {}) =>
+	world.issue({
+		type: 'cast',
+		player: caster.owner,
+		entities: [caster.id],
+		ability,
+		...(aim.target && { target: aim.target.id }),
+		...(aim.point && { point: { x: aim.point.x, z: aim.point.z } })
+	})
+
+const hurt = (unit: Entity) => unit.health < unit.maxHealth
+
+describe('the heroes', () => {
+	it('are eight, each with its callings and innate as planned, of the game’s callings, the rules whole', () => {
+		expect(checkRules(rules).filter((problem) => problem.level === 'error')).toEqual([])
+		expect(heroes.map((def) => def.id).sort()).toEqual(Object.keys(PLANNED).sort())
+		const known = new Set(callingsOf(rules).map((calling) => calling.id))
+		for (const def of heroes) {
+			expect(def.hero!.callings, def.id).toEqual(PLANNED[def.id].callings)
+			expect(def.hero!.innate, def.id).toBe(PLANNED[def.id].innate)
+			for (const calling of Object.keys(def.hero!.callings!)) expect(known.has(calling), calling).toBe(true)
+			// three abilities and an ultimate, one of them at least a passive or a toggle, and two of the hero spells
+			const learns = def.hero!.learns.map((id) => rules.abilities!.find((ability) => ability.id === id)!)
+			expect(learns, def.id).toHaveLength(4)
+			expect(learns.filter((ability) => ability.ultimate), def.id).toHaveLength(1)
+			expect(
+				learns.some((ability) => ability.target === 'passive' || ability.effects.some((effect) => effect.type === 'toggle')),
+				def.id
+			).toBe(true)
+			expect(def.hero!.spells, def.id).toHaveLength(2)
+		}
+	})
+
+	it('of the Kingdom are trained at its altar, of the Restless at theirs, and the tavern hires any', async () => {
+		const unit = (id: string) => rules.units.find((def) => def.id === id)!
+		expect(unit('altar').trains).toEqual(KINGDOM_HEROES)
+		expect(unit('darkAltar').trains).toEqual(HOLLOW_HEROES)
+		expect([...unit('tavern').hires!].sort()).toEqual([...KINGDOM_HEROES, ...HOLLOW_HEROES].sort())
+		const world = await arena()
+		const tavern = world.spawn('tavern', NEUTRAL, { x: 30, z: 30 })
+		world.spawn('footman', ME, { x: 27, z: 30 })
+		const gold = world.player(ME).resources.gold
+		// a hero of the other side, hired once
+		const hired = hire(world, tavern, 'duskblade', ME)!
+		expect(hired.def.id).toBe('duskblade')
+		expect(heroOf(hired)?.level).toBe(1)
+		expect(world.player(ME).resources.gold).toBe(gold - 425)
+		expect(hire(world, tavern, 'duskblade', ME)).toBeUndefined()
+		expect(hire(world, tavern, 'oathbreaker', ME)?.def.id).toBe('oathbreaker')
+		expect(hire(world, tavern, 'stormcaller', ME)?.def.id).toBe('stormcaller')
+		// three heroes at most, however they come
+		expect(hire(world, tavern, 'gravelord', ME)).toBeUndefined()
+	})
+})
+
+describe('what their abilities do', () => {
+	it('Oathbreaker: charges in and taunts, shields allies, makes a last stand', async () => {
+		const world = await arena()
+		const me = hero(world, 'oathbreaker')
+		const ally = hero(world, 'dawnPriest', ME, { x: 28, z: 32 })
+		const foe = target(world, { x: 36, z: 30 })
+		seen(world)
+		cast(world, me, 'oathCharge', { point: foe.pos })
+		run(world, 1.5)
+		expect(hurt(foe)).toBe(true)
+		expect(hasBuff(foe, 'taunted')).toBe(true)
+		cast(world, me, 'shieldwall')
+		run(world, 0.2)
+		expect(shieldOf(me)).toBeGreaterThan(0)
+		run(world, 1)
+		cast(world, me, 'lastStand')
+		run(world, 0.5)
+		expect(hasBuff(me, 'lastStand')).toBe(true)
+		expect(hasBuff(foe, 'taunted')).toBe(true)
+		void ally
+	})
+
+	it('Oathbreaker’s Bulwark: he takes a fifth of what an allied hero near him takes; Iron Resolve strikes back', async () => {
+		const world = await arena()
+		const me = hero(world, 'oathbreaker')
+		const ally = hero(world, 'galeHunter', ME, { x: 33, z: 30 })
+		run(world, 0.5)
+		expect(hasBuff(ally, 'bulwarkWard')).toBe(true)
+		const [mine, theirs] = [me.health, ally.health]
+		world.damage(ally, 100, undefined, { damageType: 'true' })
+		expect(theirs - ally.health).toBeCloseTo(80, 0)
+		expect(mine - me.health).toBeCloseTo(20, 0)
+		// far from him, none of it
+		world.place(ally, { x: 55, z: 55 })
+		run(world, 2)
+		const far = ally.health
+		world.damage(ally, 100, undefined, { damageType: 'true' })
+		expect(far - ally.health).toBeCloseTo(100, 0)
+		// a footman striking him is struck back
+		const footman = world.spawn('footman', FOE, { x: 31, z: 30 })
+		run(world, 4)
+		expect(hurt(footman)).toBe(true)
+	})
+
+	it('Dawn Priest: heals, burns and cleanses, and Sanctuary saves a life; Mercy’s Echo shields what overflows', async () => {
+		const world = await arena()
+		const me = hero(world, 'dawnPriest')
+		const ally = hero(world, 'oathbreaker', ME, { x: 33, z: 30 })
+		const foe = target(world, { x: 34, z: 32 })
+		run(world, 0.5)
+		// the aura
+		expect(hasBuff(ally, 'dawnlight')).toBe(true)
+		// healing a whole ally: what spills over is a shield
+		cast(world, me, 'holyLight', { target: ally })
+		run(world, 1)
+		expect(shieldOf(ally)).toBeGreaterThan(0)
+		applyBuff(world, ally, 'iceRooted', 5, foe)
+		cast(world, me, 'cleansingFlame', { point: { x: 34, z: 31 } })
+		run(world, 1)
+		expect(hasBuff(ally, 'iceRooted')).toBe(false)
+		expect(hurt(foe)).toBe(true)
+		cast(world, me, 'sanctuary', { target: ally })
+		run(world, 1)
+		expect(hasBuff(ally, 'sanctuary')).toBe(true)
+		world.damage(ally, 100000, foe, { damageType: 'true' })
+		expect(ally.alive).toBe(true)
+		expect(ally.health).toBeCloseTo(ally.maxHealth * 0.3, -1)
+		expect(hasBuff(ally, 'hallowed')).toBe(true)
+	})
+
+	it('Stormcaller: a tornado, lightning that leaps, a storm that throws up who crosses it; every fourth spell free and arcing', async () => {
+		const world = await arena()
+		const me = hero(world, 'stormcaller')
+		const foes = [target(world, { x: 35, z: 30 }), target(world, { x: 36, z: 32 }), target(world, { x: 37, z: 29 })]
+		seen(world)
+		cast(world, me, 'tornado', { point: foes[0].pos })
+		run(world, 2.5)
+		expect(hurt(foes[0])).toBe(true)
+		expect(me.buffs.find((buff) => buff.id === 'staticCharge')?.stacks).toBe(1)
+		for (const foe of foes) foe.health = foe.maxHealth
+		cast(world, me, 'chainLightning', { target: foes[0] })
+		run(world, 1.5)
+		expect(foes.filter(hurt).length).toBeGreaterThanOrEqual(2)
+		// Gale Ward: what his abilities hurt is slowed
+		expect(foes.some((foe) => hasBuff(foe, 'buffeted'))).toBe(true)
+		cast(world, me, 'eyeOfTheStorm', { point: { x: 36, z: 30 } })
+		run(world, 1.5)
+		expect(hasBuff(foes[0], 'stormSlow')).toBe(true)
+		// that was the third: the fourth costs nothing, and arcs to one more
+		expect(me.buffs.find((buff) => buff.id === 'staticCharge')?.stacks).toBe(3)
+		// once Chain Lightning is ready again
+		run(world, 9)
+		const outside = target(world, { x: 30, z: 36 })
+		const near = target(world, { x: 33, z: 37 })
+		seen(world)
+		me.mana = 100
+		const struck: number[] = []
+		world.events.on(damaged, ({ target: hit, ability }) => {
+			if (ability === 'staticCharge') struck.push(hit.id)
+		})
+		cast(world, me, 'chainLightning', { target: outside })
+		run(world, 1.5)
+		expect(me.mana).toBeGreaterThanOrEqual(100)
+		expect(struck).toEqual([near.id])
+		expect(hasBuff(me, 'staticCharge')).toBe(false)
+	})
+
+	it('Gale Hunter: a bolt through a line, a roll and a harder shot, a storm of arrows; Steady Aim standing still', async () => {
+		const world = await arena()
+		const me = hero(world, 'galeHunter')
+		const foes = [target(world, { x: 35, z: 30 }), target(world, { x: 39, z: 30 })]
+		seen(world)
+		const range = statsOf(world, me).attackRange
+		run(world, 2.7)
+		expect(me.buffs.find((buff) => buff.id === 'steadied')?.stacks).toBe(4)
+		expect(statsOf(world, me).attackRange).toBeCloseTo(range + 2, 3)
+		cast(world, me, 'piercingBolt', { point: { x: 45, z: 30 } })
+		run(world, 1.5)
+		expect(foes.every(hurt)).toBe(true)
+		cast(world, me, 'tumble', { point: { x: 30, z: 26 } })
+		run(world, 0.3)
+		expect(me.pos.z).toBeLessThan(28)
+		expect(hasBuff(me, 'tumbleShot')).toBe(true)
+		// standing, the aim steadies again; walking loses it (an order made him pick fights again: not now)
+		calm(me)
+		world.issue({ type: 'order', player: ME, entities: [me.id], order: { type: 'stop' } })
+		run(world, 2)
+		expect(hasBuff(me, 'steadied')).toBe(true)
+		world.issue({ type: 'order', player: ME, entities: [me.id], order: { type: 'move', point: { x: 10, z: 10 } } })
+		run(world, 1)
+		expect(hasBuff(me, 'steadied')).toBe(false)
+		// back into range, and the arrows fall
+		cast(world, me, 'arrowstorm', { point: foes[1].pos })
+		expect(run(world, 4, () => hasBuff(foes[1], 'pinned'))).toBeLessThan(4)
+	})
+
+	it('Gravelord: pays with health, drains, and raises the dead; his aura for his allies', async () => {
+		const world = await arena()
+		const me = hero(world, 'gravelord')
+		const ally = world.spawn('ghoul', ME, { x: 32, z: 32 })
+		const foe = target(world, { x: 34, z: 30 })
+		run(world, 0.5)
+		expect(me.maxMana).toBe(0)
+		expect(hasBuff(ally, 'deathless')).toBe(true)
+		const health = me.health
+		cast(world, me, 'graveLash', { target: foe })
+		run(world, 0.8)
+		expect(hurt(foe)).toBe(true)
+		expect(hasBuff(foe, 'graveChill')).toBe(true)
+		// 60 of health paid for it
+		expect(me.health).toBeLessThan(health)
+		foe.health = foe.maxHealth
+		me.health = 300
+		cast(world, me, 'siphon', { target: foe })
+		run(world, 3.5)
+		expect(hurt(foe)).toBe(true)
+		// the dead around him rise
+		for (let i = 0; i < 4; i++) world.damage(target(world, { x: 28 + i, z: 27 }), 100000, me, { damageType: 'true' })
+		run(world, 0.5)
+		cast(world, me, 'armyOfTheGrave')
+		run(world, 1)
+		expect(world.query({ type: 'skeleton', owner: ME }).length).toBeGreaterThan(0)
+		expect(hasBuff(ally, 'graveRallied')).toBe(true)
+	})
+
+	it('Rime Witch: freezes, roots, a blizzard that freezes who stays; Shatter for her allies’ blows', async () => {
+		const world = await arena()
+		const me = hero(world, 'rimeWitch')
+		const ally = hero(world, 'oathbreaker', ME, { x: 31, z: 32 })
+		const foes = [target(world, { x: 35, z: 30 }), target(world, { x: 35, z: 33 })]
+		seen(world)
+		cast(world, me, 'rimeBolt', { target: foes[0] })
+		run(world, 0.6)
+		expect(hasBuff(foes[0], 'frozen')).toBe(true)
+		// her own blow does not shatter it; an ally's does, harder
+		world.damage(foes[0], 10, me, { damageType: 'true' })
+		expect(hasBuff(foes[0], 'frozen')).toBe(true)
+		const before = foes[0].health
+		world.damage(foes[0], 100, ally, { damageType: 'true' })
+		expect(before - foes[0].health).toBeCloseTo(135, 0)
+		expect(hasBuff(foes[0], 'frozen')).toBe(false)
+		cast(world, me, 'grasp', { point: foes[1].pos })
+		run(world, 0.8)
+		expect(hasBuff(foes[1], 'iceRooted')).toBe(true)
+		cast(world, me, 'whiteout', { point: { x: 35, z: 31 } })
+		run(world, 3)
+		expect(foes.some((foe) => hasBuff(foe, 'frozen'))).toBe(true)
+	})
+
+	it('Duskblade: in the shadows after three quiet seconds, a mark that bursts, a fade through a crowd, an eclipse', async () => {
+		const world = await arena()
+		const me = hero(world, 'duskblade')
+		const foe = target(world, { x: 36, z: 30 })
+		seen(world)
+		run(world, 3.5)
+		expect(hasBuff(me, 'shadowed')).toBe(true)
+		// hurt, out of them
+		world.damage(me, 10, foe)
+		expect(hasBuff(me, 'shadowed')).toBe(false)
+		cast(world, me, 'duskMark', { target: foe })
+		run(world, 1)
+		expect(hasBuff(foe, 'duskMark')).toBe(true)
+		const marked = foe.health
+		run(world, 4)
+		// it burst as it ran out
+		expect(foe.health).toBeLessThan(marked)
+		cast(world, me, 'fade')
+		run(world, 0.3)
+		expect(isPhasing(world, me)).toBe(true)
+		run(world, 3)
+		const other = target(world, { x: 34, z: 34 })
+		seen(world)
+		cast(world, me, 'eclipse', { target: other })
+		run(world, 0.5)
+		expect(hasBuff(other, 'eclipsed')).toBe(true)
+		expect(Math.hypot(me.pos.x - other.pos.x, me.pos.z - other.pos.z)).toBeLessThan(3)
+	})
+
+	it('Duskblade: her first strike from the shadows deals more and silences', async () => {
+		const world = await arena()
+		const me = hero(world, 'duskblade')
+		run(world, 3.5)
+		expect(hasBuff(me, 'shadowed')).toBe(true)
+		me.get(fighting)!.passive = false
+		const foe = target(world, { x: 31.5, z: 30 })
+		const blows: number[] = []
+		world.events.on(damaged, ({ target: hit, source, amount }) => {
+			if (hit === foe && source === me) blows.push(amount)
+		})
+		// her first strike: out of the shadows, the foe silenced
+		run(world, 3, () => !hasBuff(me, 'shadowed'))
+		run(world, 0.1)
+		expect(hasBuff(foe, 'hushed')).toBe(true)
+		run(world, 3)
+		expect(blows.length).toBeGreaterThanOrEqual(3)
+	})
+
+	it('Bone Reaver: cleaves, gorges on a creep, a pit of bones; Harvest grows with kills and halves on death', async () => {
+		const world = await arena()
+		const me = hero(world, 'boneReaver')
+		const foe = target(world, { x: 32, z: 30 })
+		const creep = calm(world.spawn('ogre', CREEPS, { x: 29, z: 32 }))
+		// what is nobody's, not a camp's: left alone
+		const nobodys = calm(world.spawn('ogre', NEUTRAL, { x: 31, z: 32 }))
+		seen(world)
+		cast(world, me, 'boneCleaver')
+		run(world, 0.8)
+		expect(hurt(foe)).toBe(true)
+		expect(hurt(creep)).toBe(true)
+		expect(hurt(nobodys)).toBe(false)
+		const health = statsOf(world, me).health
+		// what is left of it, Gorge's to finish
+		creep.health = 300
+		cast(world, me, 'gorge', { target: creep })
+		run(world, 1.5)
+		expect(creep.alive).toBe(false)
+		expect(me.get(harvested)?.count).toBe(1)
+		expect(statsOf(world, me).health).toBe(health + 6)
+		// a hero is five
+		const rival = hero(world, 'galeHunter', FOE, { x: 40, z: 40 }, 1)
+		world.damage(rival, 100000, me, { damageType: 'true' })
+		expect(me.get(harvested)?.count).toBe(6)
+		expect(me.buffs.find((buff) => buff.id === 'harvest')?.stacks).toBe(6)
+		cast(world, me, 'bonePit', { point: me.pos })
+		run(world, 0.5)
+		expect(hasBuff(me, 'bonePitFrenzy')).toBe(true)
+		world.damage(me, 100000, foe, { damageType: 'true' })
+		expect(me.get(harvested)?.count).toBe(3)
+	})
+})

package/starters/melee/layers/tests/tests/rules.test.ts

@@ -2,14 +2,16 @@
 import { checkRules, createRegistry, createWorldFromMap, generateMap, type World } from '@v12-engine/engine'
 import { describe, expect, it } from 'vitest'
 import { DEFAULT_MAP, mapNamed, maps } from '../src/maps'
-import { rules, start } from '../src/rules'
+import { game as melee } from '../src/game'
 import { checkMeleeMap, HALLS } from '../src/melee/maps'
 
-/** A game on a map, started as the page starts it: you are the first player, the computer the others */
+const rules = melee.toRules()
+
+/** A game on a map, started as the page starts it (`game.onStart`): you are the first player, the computer the others */
 async function game(name = DEFAULT_MAP): Promise<World> {
-	const map = mapNamed(name)
-	const world = await createWorldFromMap({ map, game: rules, seed: 1 })
-	start(world, { map, player: map.players[0].id })
+	const map = await mapNamed(name)
+	const world = await createWorldFromMap({ map, rules, seed: 1 })
+	await melee.toStart()?.(world, { map, player: map.players[0].id })
 	return world
 }
 
@@ -20,7 +22,7 @@ describe('the rules', () => {
 
 	it('give every player with a start a hall and workers, and seat the computer at all but you', async () => {
 		const world = await game()
-		const starts = mapNamed().players.filter((player) => player.start)
+		const starts = (await mapNamed()).players.filter((player) => player.start)
 		for (const player of starts) {
 			const own = [...world.index.ownedBy(player.id)]
 			expect(
@@ -42,10 +44,10 @@ describe('the rules', () => {
 		world.dispose()
 	}, 30_000)
 
-	it('read every map, each one melee can be played on', () => {
+	it('read every map, each one melee can be played on', async () => {
 		for (const [name, map] of Object.entries(maps))
 			expect(
-				checkMeleeMap(map).filter((problem) => problem.error),
+				checkMeleeMap(await map()).filter((problem) => problem.error),
 				name
 			).toEqual([])
 	})

package/starters/melee/src/game.ts

@@ -1,2 +1,32 @@
-/** The game, whole: melee's rules and how it looks (`src/melee/game.ts`, its view in `src/melee/view`) */
-export { meleeGame as game } from './melee/game'
+/**
+ * The game, whole, as every part of the project takes it (`createGame`): melee's rules (`src/melee`), its look
+ * (`src/melee/view`, fetched as the page first plays it), its maps (`src/maps.ts`) and what it does as a game starts.
+ * The page, the server, the editor and the tests all take this
+ */
+import { maps } from './maps'
+import { meleeGame } from './melee/game'
+
+export const game = meleeGame.maps(maps)
+
+/**
+ * What the game does once a world is made from a map, before anyone plays. Every player with a start is given a hall
+ * and five workers by the rules themselves; in the page, the computer plays everyone but you, each against the other
+ * teams' starts. A server seats its computers itself (`server.ts`), so there is no one to seat here
+ */
+game.onStart((world, { map, player }) => {
+	if (!map || player === undefined) return
+	const players = map.players.filter((other) => other.start)
+	for (const other of players) {
+		if (other.id === player) continue
+		const enemyBases = players.filter((rival) => rival.team !== other.team).map((rival) => rival.start!)
+		// remembered, so that a game loaded from a save of this one plays on against them
+		world.computers.seat(other.id, { enemyBases, settings: { army: { firstAttack: 360, waveSize: 6 } } })
+	}
+})
+
+// @if desktop
+// its look with what the desktop app adds to it: a Windowed setting, Quit on the pause menu
+game.view(() => Promise.all([import('./melee/view'), import('./desktop')]).then(([{ meleeView }, { desktopView }]) => desktopView(meleeView)))
+// @end
+// (saved while it runs, melee's rules and its look take their new versions with no new page: `src/melee/index.ts`
+// and `src/melee/view/index.ts` say so. A change here loads the page again)

package/starters/melee/src/maps/bay.names.ts

@@ -21,8 +21,8 @@ export type BayPaths = never
 /** The lights of the map that are named, for `client.lights.named(...)` */
 export type BayLights = never
 
-/** The effects of the map that are named, for `client.mapEffects.named(...)` */
-export type BayEffects = never
+/** The effects of the map that are named, for `client.mapFx.named(...)` */
+export type BayFx = never
 
 /** The ids of the regions, points and paths by name: what a field that names one keeps (it is handed the name) */
 export const BayIds = { regions: {  }, points: {  }, paths: {  } } as const