@datamoc/mw_games 0.26.1 → 0.30.0

package/CHANGELOG.md

@@ -7,6 +7,140 @@ the public API may still change between minor versions.
 
 ## [Unreleased]
 
+## [0.30.0] - 2026-10-07
+
+P41, the browser driver's four measured gaps: the viewport option (inner size through the
+protocol, not window flags), the trusted keyboard channel (press through CDP key events and
+BiDi key actions, with the WebDriver key-value table), the Firefox tap that actually reaches
+Pixi 8's EventSystem (the in-page synthetic sequence, measured and documented), and headed
+mode. Live-verified on Chrome and Firefox: exact 800x600 viewport, keys delivered, the
+Firefox tap advancing a real Pixi page.
+
+## [0.29.0] - 2026-10-07
+
+P37's touch half: the on-screen keyboard. Rows of keys as data, rendered through the
+theme's own Button, each tap feeding the same core.Input paths a physical key travels -
+dispatchText for a typing key, the new dispatchAction for an action key - so a TextPrompt
+cannot tell the two apart. TextPrompt grows a keyboard option that hosts one beneath the
+field and resizes the window to fit it, UPPERCASE_KEYBOARD is one shipped default, and
+the interface example's Name prompt carries it as the reviewed touch pattern.
+
+## [0.28.0] - 2026-10-07
+
+The 0.27.0 consumer wave sharpened asks: the pixel-dungeon port proposal file
+audited what 0.27 shipped against what a real consumer needs, and this release
+closes the four framework-side gaps it found. Flights fades and spins in the
+units games author (fadeIn: progress, spinDegrees), Beam thins as it fades and
+stretches a single art asset along its span with anchor control,
+ParticleEmitter.attach gates visibility (fog-of-war) beside emission, and the
+interface example carries the reviewed TextPrompt hosting pattern a seed or name
+prompt can be copied from.
+
+### Added
+
+- `Flights` fade and spin in the units consumers author them in (P40): `fadeIn:
+  'progress'` (or `true`) eases a sprite's alpha 0 to 1 along the flight's own
+  progress - the tween's clock, so the fade cannot desynchronise from a duration
+  the caller re-computed - while a number keeps its seconds-from-launch meaning,
+  and `spinDegrees` is `spin` in degrees per second, converted once, so an
+  authored angular speed needs no radian arithmetic at the call site.
+
+- `Beam` thins and stretches (P35): `thin: true` narrows the body with its own
+  remaining life the way the alpha fades (a plain line's stroke, a strip's height,
+  a stretched sprite's `scale.y`), and the `texture` option's object form -
+  `{ source, stretch?, anchor? }` - stretches one art asset along the whole span
+  instead of tiling it, anchored across the thickness (0.5 by default) for ray
+  art that repeats badly. The bare-texture form tiles exactly as it always has.
+
+- `ParticleEmitter.attach` takes a `visible` callback beside `enabled` (P36): a
+  false return hides the emitter and every particle it has in the air, so a
+  fog-of-war gate keeps an aura's spray out of unexplored space without the
+  consumer re-placing `visible` every frame. Drawing only - the simulation
+  keeps stepping behind the invisibility, emission keeps following `enabled`,
+  and `detach()` leaves the emitter visible.
+
+- The interface example's new Name button is the reviewed `TextPrompt` hosting
+  pattern (P37): push it on a `WindowStack` and it owns typing, caret edits,
+  confirm-gated-by-`validate`, cancellation and closing - a seed or name prompt
+  with no DOM `<input>` overlay to copy around.
+
+## [0.27.0] - 2026-10-07
+
+Two strands in one release. A run is durable and drives the AI (roadmap 396-397): the
+versioned replay envelope refuses another game or framework build by name, `LastRun` keeps
+the newest recording, `runCheckpoint`/`resumeRunPlayer` restore a run mid-run, and the
+`file://` plumbing (download, picker, Blob read) ships with it; `imitationFromReplay` turns
+a recorded run into training samples against its own seeded environment, `runSeededEpisode`
+plays a whole run from a named seed behind any deterministic chooser, and `ai.Suggester`
+is the throttled, non-mutating hint source. The render and UI strand: `Flights` owns live
+projectile flights, `Beam`/`Beams` draw one-shot beams, `TextPrompt` asks for one line with
+IME and screen-reader support, `MessageLog.lastEntries` reads retained entries back, and
+`ParticleEmitter.attach` follows a target; `core.FloatSource` narrows the injectable random
+stream for float-only helpers.
+
+### Added
+
+- `core.FloatSource` splits `core.RandomSource`: helpers that draw floats only
+  (`float`, `chance`, `weighted`, `weightedKey`) accept the narrower
+  `{ float(): number }`, so a float-only stream needs no dead `int`. The
+  integer helpers (`int`, `range`, `normalRange`, `element`, `shuffle`) keep
+  requiring the full source; `element` stays wide deliberately, because it
+  draws through `int()` and re-spelling that draw would change its stream.
+
+- `MessageLog.lastEntries(n)` reads the newest retained entries back as plain
+  `{ text, level }` records, oldest first, without scraping rendered children:
+  entries the wrapped-line budget already dropped are gone, over-count reads
+  everything retained, and zero or negative reads nothing. The slice lives in
+  the pure `takeLastEntries` beside the existing `linesToDrop` budget, so the
+  readback contract is testable without a renderer.
+
+- `ParticleEmitter.attach(target)` follows a display object or position thunk on
+  every update tick and every `burst()`, with `offsetX`/`offsetY`, an `enabled`
+  callback gating tick emission, and auto-detach for destroyed targets;
+  `detach()` keeps the last position. The follow math is tested headless through
+  textureless emitters.
+
+- `Flights` owns a scene's live projectile flights over the existing `Projectile`:
+  `add(sprite | texture, from, to, { speed, tint?, spin?, fadeIn?, onArrive? })`
+  returns a handle, `update(dt)` drives positions with per-flight spin and fade,
+  each arrival dispatches once after leaving the list, and `cancel()`/`clear()`
+  forget without dispatching. Caller sprites stay caller-owned; texture-built
+  sprites are parented here and destroyed with their flight.
+
+- `Beam`/`Beams` draw one-shot beams between two screen points: a fading line by
+  default, a fading repeating texture strip with `texture`, additive blend unless
+  opted out, `retarget` for tracking endpoints, and `update` reporting expiry
+  exactly once so the `Beams` group can remove finished beams itself.
+
+- `TextPrompt` asks for one line of text over a `TextModel`: typing through
+  `onText` (the newest open prompt wins), caret and edits through
+  `left`/`right`/`backspace`/`delete` actions, `confirm` gated by `validate` and
+  `cancel` giving up. IME compositions preview until they commit, and the
+  message plus validation errors announce through `screenReader` (assertive for
+  the errors), with an injectable announcer for tests.
+
+- A run is durable now (roadmap 396): `exportReplayFile`/`importReplayFile` wrap a
+  recording in a versioned, self-describing envelope that refuses another game or
+  framework build by name, `LastRun` keeps the newest recording (one deep, bounded,
+  over the same storage a save slot uses), and `runCheckpoint`/`resumeRunPlayer`
+  pair the partial recording with the saved state so a restored run resumes mid-run
+  instead of restarting - `Recorder` and `Player` both take `fromFrame`, and
+  `parseReplayEvents` factors out the half of `deserializeReplay`'s check that
+  validates an already-parsed array. The `file://` plumbing rides along:
+  `downloadReplayFile` (a Blob download, never `fetch()`), `pickReplayFile`
+  (the file picker, null on cancel) and `readReplayFile` (any `Blob`, headless
+  Node included).
+
+- Replays train and drive the AI (roadmap 397): `imitationFromReplay` walks a
+  recorded run against the same seeded `TrainingEnvironment` it was played on and
+  returns the `(observation, action)` samples a game's own trainer fits;
+  `runSeededEpisode` plays a whole run with any deterministic chooser (a heuristic,
+  a `NeuralPolicy`'s argmax, not just a `NeuralModel` like `runRollouts`) from a
+  named seed, recording every chosen action so runs compare across builds and
+  policies; and `ai.Suggester` is the in-game suggestion mode, the same decision
+  call pointed at a hint UI instead of the world, throttled by a frame-count budget
+  and never mutating state to compute a hint.
+
 ## [0.26.1] - 2026-10-07
 
 The 0.26.0 follow-up: its Chrome end-to-end test failed on every CI run, so the

package/README.md

@@ -15,7 +15,7 @@ playable in the browser with no download, plus the generated API reference.
 planning or porting a demanding game with mwg, with links to the [mwg reference](https://github.com/datamoc/mwg/blob/main/REFERENCE.md)
 and the [mwg Pixel Dungeon study](https://datamoc.github.io/mwg-pixel-dungeon/).
 
-> **Status: pre-alpha (v0.17.1).** Every module in the shared floor below, plus optional
+> **Status: pre-alpha (v0.29.0).** Every module in the shared floor below, plus optional
 > 3D, mobile (Capacitor) and desktop (WebView2) packaging, is built and tested - see
 > [ROADMAP.md](https://github.com/datamoc/mwg/blob/main/ROADMAP.md) for open work, and
 > [CLOSED.md](https://github.com/datamoc/mwg/blob/main/CLOSED.md) for the full, numbered shipped history.
@@ -205,6 +205,7 @@ only some do.
 | | screen transitions: fade, flash, tint | `mwg/two-d/render` |
 | **ui** | windows, lists, tooltips, markdown labels | `mwg/two-d/ui` |
 | | text and fonts, including non-latin fallback | PixiJS |
+| | modal single-line text entry, with validation and an on-screen keyboard for touch | `mwg/two-d/ui` |
 | | pointer, keyboard and gamepad input with rebinding | `mwg/core` |
 | **text** | message tables per language, compiled at build time | `mwg/i18n` |
 | | plurals, gendered forms, interpolation, and Python f-string-style format specs | `mwg/i18n` |