ranger-compiler 3.5.1 → 3.5.2

package/dist/lib/evg/agent/smoke.sh

@@ -0,0 +1,230 @@
+#!/usr/bin/env bash
+#
+# The four verbs, against the fixtures. Guards the CLI itself: EVGPatch has a
+# suite, but nothing else would notice a verb that stopped parsing its flags,
+# printed the compiler's chatter onto stdout, or quietly found nothing.
+set -euo pipefail
+
+here=$(cd "$(dirname "$0")" && pwd)
+root=$(cd "$here/../../.." && pwd)
+cd "$root"
+work=$(mktemp -d)
+trap 'rm -rf "$work"' EXIT
+
+fail() { echo "SMOKE FAIL: $1" >&2; exit 1; }
+
+# outline: every node, and the truncation notice when there is more
+out=$(npm run --silent agent -- outline lib/evg/agent/fixtures/card.evg.json)
+echo "$out" | grep -q '0/0/k:title' || fail "outline lost the keyed path"
+echo "$out" | grep -q 'Orders'      || fail "outline lost the text"
+npm run --silent agent -- outline lib/evg/agent/fixtures/card.evg.json --depth=1 \
+  | grep -q 'deeper nodes not shown' || fail "outline truncated in silence"
+
+# query: JSON, and only the two cards
+npm run --silent agent -- query lib/evg/agent/fixtures/card.evg.json .card \
+  | grep -q '"count":2' || fail "query did not find both cards"
+
+# measure: finds all four defects in the broken fixture, and none in the good one
+found=$(npm run --silent agent -- measure lib/evg/agent/fixtures/broken.evg.json --width=600 --height=300)
+echo "$found" | grep -q '"count":4' || fail "measure did not find the four defects: $found"
+npm run --silent agent -- measure lib/evg/agent/fixtures/card.evg.json --width=600 --height=400 \
+  | grep -q '"count":0' || fail "measure reported a defect in a sound document"
+
+# the numbers, not just the verdict: an overlap says by how much, and a sound
+# document still says how much room is left under its content
+echo "$found" | grep -q 'overlap by 100×40' || fail "overlap did not carry the amount: $found"
+npm run --silent agent -- measure lib/evg/agent/fixtures/card.evg.json --width=600 --height=400 \
+  | grep -q '"bottomFree"' || fail "measure did not report the free space"
+
+# a control somebody DREW. The fixture holds two switches that lay out the
+# same: one made of boxes, one that says `role: switch`. The first is named
+# with its path, the second is not — a document that declares what a node IS
+# is the whole difference, and it is what a kit's control carries.
+drawn=$(npm run --silent agent -- measure lib/evg/agent/fixtures/drawn.evg.json --width=390 --height=200)
+echo "$drawn" | grep -q '"drawn"' || fail "measure did not notice a drawn switch: $drawn"
+echo "$drawn" | grep -q '0/0/1: a pill with a knob' || fail "the drawn switch was not named by its path: $drawn"
+echo "$drawn" | grep -q '0/1/0: a pill' && fail "a control that declares its role was reported as drawn: $drawn"
+echo "$drawn" | grep -q '0/2: a groove with a knob' || fail "measure did not notice a drawn slider: $drawn"
+echo "$drawn" | grep -q '"count":0' || fail "a drawn control is not a layout defect and must not move count: $drawn"
+
+# alignment: the defect every other check passes. A stack that shares no edge,
+# and an overlay one padding to the right of the column it floats over.
+cat > "$work/ragged.evg.json" <<'JSON'
+{"evg":1,"root":{"tag":"div","props":{"display":"flex","width":"390px","height":"844px","padding-left":"16px","padding-right":"16px","gap":"8px"},"children":[
+  {"tag":"div","props":{"width":"200px","height":"40px","margin-left":"20px"}},
+  {"tag":"div","props":{"width":"200px","height":"40px","margin-left":"60px"}},
+  {"tag":"div","props":{"width":"200px","height":"40px","margin-left":"4px"}}
+]}}
+JSON
+ragged=$(npm run --silent agent -- measure "$work/ragged.evg.json")
+echo "$ragged" | grep -q '"count":0' || fail "the ragged fixture should have no DEFECT: $ragged"
+echo "$ragged" | grep -q 'share no edge' || fail "measure did not notice the ragged column: $ragged"
+
+# the overlay case: the column is tidy, the bar floating over it is one padding
+# to the right, and every other check passes it
+cat > "$work/bar.evg.json" <<'JSON'
+{"evg":1,"root":{"tag":"div","props":{"display":"flex","width":"390px","height":"844px","padding-left":"16px","padding-right":"16px","gap":"8px"},"children":[
+  {"tag":"div","props":{"height":"40px"}},
+  {"tag":"div","props":{"height":"40px"}},
+  {"tag":"div","props":{"position":"absolute","left":"16px","bottom":"16px","width":"358px","height":"52px"}}
+]}}
+JSON
+bar=$(npm run --silent agent -- measure "$work/bar.evg.json")
+echo "$bar" | grep -q '"count":0' || fail "the overlay fixture should have no DEFECT: $bar"
+echo "$bar" | grep -q 'one padding' \
+  || fail "measure did not notice the overlay one padding off: $bar"
+if npm run --silent agent -- measure lib/evg/agent/fixtures/card.evg.json | grep -q '"align"'; then
+  fail "a tidy document must not report alignment noise"
+fi
+
+# --boxes: where each node really is, and how far the next one starts
+boxes=$(npm run --silent agent -- measure lib/evg/agent/fixtures/card.evg.json --boxes --at=0)
+echo "$boxes" | grep -q '"gapNext"' || fail "--boxes did not report a distance: $boxes"
+echo "$boxes" | grep -q '"x":' || fail "--boxes did not report positions"
+if npm run --silent agent -- measure lib/evg/agent/fixtures/card.evg.json | grep -q '"boxes"'; then
+  fail "boxes should cost nothing unless asked for"
+fi
+
+# patch: applies, writes, and the inverse puts it back
+cp lib/evg/agent/fixtures/card.evg.json "$work/doc.json"
+cat > "$work/ops.json" <<'JSON'
+{"ops":[
+  {"op":"set-text","at":"0/0/k:title","value":"Invoices"},
+  {"op":"set-prop","at":"0/0","prop":"border-width","value":"1px"}
+]}
+JSON
+npm run --silent agent -- patch "$work/doc.json" "$work/ops.json" | grep -q '"applied":2' \
+  || fail "patch did not apply"
+npm run --silent agent -- outline "$work/doc.json" | grep -q 'Invoices' || fail "the edit did not land"
+
+# patch answers with the layout it produced, without being asked: an agent that
+# patches and stops has changed a picture it cannot see
+cat > "$work/tint.json" <<'JSON'
+{"ops":[
+  {"op":"set-prop","at":"0/0","prop":"background-color","value":"rgb(255,251,235)"}
+]}
+JSON
+cp lib/evg/agent/fixtures/broken.evg.json "$work/broken.json"
+told=$(npm run --silent agent -- patch "$work/broken.json" "$work/tint.json")
+echo "$told" | grep -q '"layout"' || fail "patch did not report the layout: $told"
+echo "$told" | grep -q 'overlap by' \
+  || fail "patch did not name the defect in the document it just wrote: $told"
+echo "$told" | grep -q '"count":4' \
+  || fail "patch's layout count is not the measure's: $told"
+
+cat > "$work/undo.json" <<'JSON'
+{"ops":[
+  {"op":"set-prop","at":"0/0","prop":"border-width","value":""},
+  {"op":"set-text","at":"0/0/k:title","value":"Orders"}
+]}
+JSON
+npm run --silent agent -- patch "$work/doc.json" "$work/undo.json" > /dev/null
+npm run --silent agent -- outline "$work/doc.json" > "$work/after.txt"
+cp lib/evg/agent/fixtures/card.evg.json "$work/orig.json"
+npm run --silent agent -- outline "$work/orig.json" > "$work/before.txt"
+diff -q "$work/before.txt" "$work/after.txt" > /dev/null || fail "the inverse did not restore the document"
+
+# an op that lands on the tag default: applied, absent from the file, and SAID
+# so. EVG divs are flex-direction: column, so setting column on one removes the
+# line rather than adding it, and an agent that only re-reads the file decides
+# the tool dropped its edit.
+cat > "$work/dflt.json" <<'JSON'
+{"ops":[
+  {"op":"set-prop","at":"0/0","prop":"flex-direction","value":"column"}
+]}
+JSON
+said=$(npm run --silent agent -- patch "$work/doc.json" "$work/dflt.json")
+echo "$said" | grep -q '"atDefault"' || fail "patch did not report the default-valued op: $said"
+echo "$said" | grep -q '"prop":"flex-direction"' || fail "atDefault did not name the property"
+if npm run --silent agent -- outline "$work/doc.json" | grep -q 'flex-direction=column'; then
+  fail "a default should not be written — the note is what carries it"
+fi
+cat > "$work/back.json" <<'JSON'
+{"ops":[
+  {"op":"set-prop","at":"0/0","prop":"flex-direction","value":"row"}
+]}
+JSON
+if npm run --silent agent -- patch "$work/doc.json" "$work/back.json" | grep -q '"atDefault"'; then
+  fail "a value that is not the default must not be reported as one"
+fi
+npm run --silent agent -- outline "$work/doc.json" | grep -q 'flex-direction=row' \
+  || fail "a non-default flex-direction did not survive the write"
+cp lib/evg/agent/fixtures/card.evg.json "$work/doc.json"
+
+# a rejected op leaves the document alone
+cat > "$work/bad.json" <<'JSON'
+{"ops":[
+  {"op":"set-prop","at":"0/0","prop":"border-width","value":"2px"},
+  {"op":"set-prop","at":"0/0","prop":"aspect-ratio","value":"16/9"}
+]}
+JSON
+npm run --silent agent -- patch "$work/doc.json" "$work/bad.json" | grep -q '"ok":false' \
+  || fail "an unknown property was accepted"
+npm run --silent agent -- outline "$work/doc.json" > "$work/unchanged.txt"
+diff -q "$work/before.txt" "$work/unchanged.txt" > /dev/null \
+  || fail "a rejected batch still changed the document"
+
+# a bitmap, through the tracer and into the document. The picture must arrive
+# as vector the document can hold, and the palette must be countable — an agent
+# that cannot see the photograph has to be able to theme a screen from it.
+if [ ! -f lib/evg/bin/evg_image_tool.js ]; then
+  echo "building evg_image_tool…"
+  npm run --silent agent:image > "$work/image-build.log" 2>&1 \
+    || { tail -20 "$work/image-build.log"; fail "could not build evg_image_tool"; }
+fi
+cp lib/evg/web/tracer/sample.png "$work/shot.png"
+traced=$(cd "$work" && node "$root/lib/evg/bin/evg_image_tool.js" shot.png --out=shot --width=180)
+echo "$traced" | grep -q '"colors"' || fail "the tracer reported no palette: $traced"
+echo "$traced" | grep -q '"share"' || fail "the palette has no shares: $traced"
+[ -f "$work/shot.svg" ] || fail "no traced SVG"
+[ -f "$work/shot.ops.json" ] || fail "no ops file to insert the picture with"
+cp lib/evg/agent/fixtures/card.evg.json "$work/pic.json"
+npm run --silent agent -- patch "$work/pic.json" "$work/shot.ops.json" | grep -q '"ok":true' \
+  || fail "the traced picture would not apply"
+npm run --silent agent -- outline "$work/pic.json" | grep -q '^0/0 *svg' \
+  || fail "the picture is not in the document as an svg node"
+
+# a two-stop gradient, which EVG spells two ways and the painters used to know
+# only one of: `gradient-from` / `gradient-to` is what the display list, the GPU
+# backend and the Figma importer all speak, and it drew on the GPU and nowhere
+# else. A flat render means the pair is being ignored again.
+npm run --silent agent:render -- lib/evg/agent/fixtures/gradient.evg.json "$work/grad.png" -w 400 -h 260 > /dev/null 2>&1
+[ -f "$work/grad.png" ] || fail "the gradient fixture did not render"
+distinct=$(node -e '
+const fs=require("fs"),zlib=require("zlib");
+const d=fs.readFileSync(process.argv[1]);
+// walk the IDAT chunks, inflate, and count distinct colours on one scanline
+let i=8,idat=[];
+while(i<d.length){const len=d.readUInt32BE(i);const t=d.toString("latin1",i+4,i+8);
+if(t==="IDAT")idat.push(d.subarray(i+8,i+8+len));i+=12+len;}
+const raw=zlib.inflateSync(Buffer.concat(idat));
+const w=d.readUInt32BE(16), stride=w*4+1, row=60;
+const seen=new Set();
+for(let x=30;x<170;x++){const o=row*stride+1+x*4;seen.add(raw[o]+","+raw[o+1]+","+raw[o+2]);}
+console.log(seen.size);
+' "$work/grad.png")
+[ "$distinct" -gt 20 ] || fail "the gradient rendered as $distinct colour(s) across its width — a flat fill, not a gradient"
+echo "  gradient       $distinct distinct colours across the band"
+
+# a diagram, which is a different shape of document: everything absolutely
+# positioned, every shape a path whose box is 0x0 and whose geometry is in `d`
+if [ -f gallery/rangerflow/bin/rangerflow_demo.js ]; then
+  npm run --silent rangerflow:mermaid > /dev/null 2>&1 || fail "the mermaid demo did not run"
+  diagram=gallery/rangerflow/out/rangerflow-mermaid.evg.json
+  [ -f "$diagram" ] || fail "the mermaid demo wrote no editable document"
+  npm run --silent agent -- measure "$diagram" | grep -q '"count":0' \
+    || fail "measure found a defect in a diagram RangerFlow laid out itself"
+  cp "$diagram" "$work/d.json"
+  cat > "$work/dops.json" <<'JSON'
+{"ops":[{"op":"set-prop","at":"0/51","prop":"d","value":"M 1650 354 L 1732 354 L 1750 390 L 1668 390 Z"}]}
+JSON
+  npm run --silent agent -- patch "$work/d.json" "$work/dops.json" | grep -q '"applied":1' \
+    || fail "could not edit a path in a diagram"
+  npm run --silent agent -- measure "$work/d.json" | grep -q "past the page width" \
+    || fail "a shape moved off the page was not reported — path bounds are not being read"
+  echo "  diagram        measured, edited, and the off-page shape reported"
+else
+  echo "  diagram        skipped (rangerflow demo not built)"
+fi
+
+echo "ALL PASS — outline, query, measure, patch, undo, rejection"

package/dist/lib/evg/android/README.md

@@ -0,0 +1,97 @@
+# `lib/evg/android` — EVG's display list, on Android and on a JVM
+
+The backend the Android ports share: an `EVGDisplayList` in, `android.graphics`
+or Java2D out. No app lives here, and neither does any knowledge of one.
+
+```text
+   EVGDisplayList                    ← eight command kinds, absolute pixels,
+        │                              resolved colours. Whoever built it.
+        ▼
+   EvgPainter                        ← the walk. Written once.
+        │
+        ├── AndroidEvgSurface        android.graphics.Canvas   ← the app
+        ├── AwtEvgSurface            java.awt.Graphics2D       ← the checks
+        └── RecordingSurface         a tally, then one of the above
+```
+
+| Path | What it is |
+| --- | --- |
+| `src/main/kotlin/…/EvgSurface.kt` | The eight things a backend has to draw |
+| `src/main/kotlin/…/EvgPainter.kt` | Display list → surface calls |
+| `src/main/kotlin/…/RecordingSurface.kt` | Counts what the painter dispatched, so coverage is a number |
+| `src/main/kotlin/…/EvgEngineThread.kt` | The engine on its own thread: `post`, `ask`, `sync`, and frames coalesced and delivered through `View.post` — platform-free, so a JVM check can use it too |
+| `src/android/kotlin/…/AndroidEvgSurface.kt` | `android.graphics` implementation, plus `FaceSet` and `ImageStore` |
+| `src/android/kotlin/…/RippleEffect.kt` | `evg-surface-effect: ripple` as an AGSL post-process (API 33+) |
+| `src/android/kotlin/…/AndroidTextMeasurer.kt` | Skia measures the text the layout is made with, through the `FaceSet` the surface paints with — installed above the app, so the first layout already has it |
+| `src/awt/kotlin/…/AwtEvgSurface.kt` | The same surface on Java2D, so a port is testable without a device |
+| `src/awt/kotlin/…/AwtTextMeasurer.kt` | The Java2D twin of the measurer, and `AwtFaces`, the one place a family becomes a `Font` for both the surface and the measurer |
+| `androidstubs/` | Platform declarations, so a host type-checks with no SDK installed |
+
+## Why it is source, not a library
+
+A port compiles these files into its own build. That is not laziness about
+publishing a `.aar`: the painter has to name the generated `EVGDisplayList`
+type, and every port generates its own copy of EVG by compiling its own Ranger
+tree. So the one thing the ports agree on is the **package** that generated code
+goes into — `fi.ranger.rgr` — and the painter imports
+`fi.ranger.rgr.EVGDisplayList` from there. Two apps, two compilations, one
+import line, and no serialisation boundary in between.
+
+Each port's `scripts/build-ranger.sh` puts that `package` line at the top of the
+file the compiler wrote.
+
+## Who uses it
+
+* [`gallery/pptx/android`](../../../gallery/pptx/android/README.md) — the slide viewer.
+  Adds `TouchRouter`, a `SlideView` and the four bundled faces a deck was
+  measured with.
+* [`gallery/ui/android`](../../../gallery/ui/android/README.md) — the dashboard demo. Adds
+  a viewport facade and a `DashboardView`, and draws with the platform's own
+  sans because that is what the page was laid out against.
+* [`gallery/realtrainer/android`](../../../gallery/realtrainer/android/README.md) — the
+  RealTrainer demo. The page is the view rather than a fitted document, and
+  the host adds the soft keyboard through an `InputConnection`; the stubs
+  under `androidstubs/InputMethod.kt` are its.
+
+All three are a facade in Ranger plus a `View`. That is the claim this directory
+exists to make good on: the seam is the display list, so a new host is a page of
+delegation rather than a second renderer.
+
+## The one thing that is not a surface
+
+`evg-surface-effect: ripple` is not a draw command and cannot be: it is a pass
+over the finished pixels. `RippleEffect` is that pass on Android — the display
+list's `effectKind` and its dozen `effect*` numbers, handed to a `RuntimeShader`
+through `RenderEffect.createRuntimeShaderEffect`, which is the same stage
+`evg-webgl.js` runs its own version in. It is a translation of that shader, not
+a second one; API 33 and later, a no-op below.
+
+## Scroll layers, and what this painter does not do yet
+
+A clip that can scroll arrives with `layer` set on its PUSH_CLIP — see
+`EVGDisplayList.refreshLayers`. An app that keeps its list across a scroll
+hands the painter the SAME list, with the commands inside that clip already
+moved to where the scroll put them, so `EvgPainter.paint` draws the right
+frame without knowing a layer from any other clip. What the host saves is
+the layout and the list build; what it still pays is rasterising every
+command in the layer, every frame.
+
+The next step, when a long page on a device asks for it, is the one the
+browser painter took: keep what was made from the layer. Here that is a
+`Bitmap` the size of the layer's range, painted once per `buildSeq` through
+a `Canvas` over it, and drawn per frame at the layer's clip with
+`layerShiftX/Y` subtracted from the shift it was painted at — a scroll
+frame is then one `drawBitmap` under the clip and the commands outside the
+layer. The list's `layerFirst`/`layerLast` give the command range; nothing
+else in the list has to change.
+
+## What the surfaces do not agree on
+
+Both honour clipping and multi-ring even-odd paths, which the software
+rasteriser drops. They differ in one place, and it is a platform fact rather
+than a choice: a hardware-accelerated `Canvas` ignores `BlurMaskFilter`, so
+`AndroidEvgSurface` **draws** a shadow's falloff — the silhouette a few times,
+each pass grown and fainter — while `AwtEvgSurface` filters it. See the comment
+on `canBlur`.
+
+**License: AGPL-3.0-or-later** (Gallery).

package/dist/lib/evg/android/androidstubs/AndroidStubs.kt

@@ -0,0 +1,175 @@
+// ============================================================================
+// Compile-time stubs for the Android platform classes this host uses.
+// ============================================================================
+//
+// `AndroidEvgSurface`, `SlideView` and `MainActivity` are the three files that
+// cannot be checked without an Android SDK, and an SDK is a 600 MB download
+// from a host that is not always reachable. These declarations are enough for
+// `kotlinc` to TYPE-CHECK those three files: every member below is one this
+// host actually calls, with the signature the platform gives it.
+//
+// They are never compiled into the APK and never packaged. The real
+// `android.jar` is on the compile classpath of the Gradle build and wins there;
+// this file exists only for `scripts/typecheck-host.sh`.
+//
+// What this proves: the host's Kotlin is well-formed, its overrides match, its
+// types line up, and it calls nothing that does not exist. What it does not
+// prove: that the platform's implementations behave as the host expects — a
+// stub cannot draw. Treat a green typecheck as "it will compile", not as
+// "it works".
+//
+// If a signature here disagrees with the SDK, the Gradle build is the one that
+// is right and this file is the one to fix.
+// ============================================================================
+
+@file:Suppress("UNUSED_PARAMETER", "unused")
+
+package android.graphics
+
+class Bitmap {
+    @JvmField val width: Int = 0
+    @JvmField val height: Int = 0
+}
+
+object BitmapFactory {
+    fun decodeByteArray(data: ByteArray, offset: Int, length: Int): Bitmap? = null
+}
+
+class BlurMaskFilter(radius: Float, style: Blur) : MaskFilter() {
+    enum class Blur { NORMAL, SOLID, OUTER, INNER }
+}
+
+open class MaskFilter
+
+/**
+ * `RuntimeShader` is AGSL — Skia's own shading language, handed to apps at API
+ * 33. The constructor compiles, and it THROWS on a program it cannot compile,
+ * which is why the host that builds one catches.
+ */
+class RuntimeShader(sksl: String) : Shader() {
+    fun setFloatUniform(name: String, value: Float) {}
+    fun setFloatUniform(name: String, a: Float, b: Float) {}
+    fun setFloatUniform(name: String, a: Float, b: Float, c: Float) {}
+    fun setFloatUniform(name: String, a: Float, b: Float, c: Float, d: Float) {}
+    fun setFloatUniform(name: String, values: FloatArray) {}
+    fun setIntUniform(name: String, value: Int) {}
+    fun setInputShader(name: String, shader: Shader) {}
+}
+
+/**
+ * A post-process over a view's finished pixels. `createRuntimeShaderEffect`
+ * renders the view into a texture, binds it to the named `uniform shader`, and
+ * lets the program decide every pixel — the same stage the WebGL host runs its
+ * surface effects in.
+ */
+class RenderEffect {
+    companion object {
+        fun createRuntimeShaderEffect(shader: RuntimeShader, uniformShaderName: String): RenderEffect =
+            RenderEffect()
+
+        fun createBlurEffect(radiusX: Float, radiusY: Float, tile: Shader.TileMode): RenderEffect =
+            RenderEffect()
+    }
+}
+
+open class Shader {
+    enum class TileMode { CLAMP, REPEAT, MIRROR }
+}
+
+class LinearGradient(
+    x0: Float, y0: Float, x1: Float, y1: Float,
+    color0: Int, color1: Int, tile: Shader.TileMode,
+) : Shader()
+
+class Matrix {
+    fun setScale(sx: Float, sy: Float) {}
+    fun setScale(sx: Float, sy: Float, px: Float, py: Float) {}
+    fun postTranslate(dx: Float, dy: Float) {}
+    fun postConcat(other: Matrix) {}
+}
+
+class RectF() {
+    constructor(src: RectF) : this()
+    fun set(l: Float, t: Float, r: Float, b: Float) {}
+    fun offset(dx: Float, dy: Float) {}
+}
+
+class Path {
+    enum class FillType { WINDING, EVEN_ODD, INVERSE_WINDING, INVERSE_EVEN_ODD }
+    enum class Direction { CW, CCW }
+
+    var fillType: FillType = FillType.WINDING
+    fun reset() {}
+    fun moveTo(x: Float, y: Float) {}
+    fun lineTo(x: Float, y: Float) {}
+    fun close() {}
+    fun addRoundRect(rect: RectF, rx: Float, ry: Float, dir: Direction) {}
+}
+
+class Typeface {
+    companion object {
+        val DEFAULT: Typeface = Typeface()
+        val DEFAULT_BOLD: Typeface = Typeface()
+        const val NORMAL = 0
+        const val BOLD = 1
+        const val ITALIC = 2
+        const val BOLD_ITALIC = 3
+        fun createFromFile(path: java.io.File): Typeface = Typeface()
+        fun create(family: Typeface?, style: Int): Typeface = Typeface()
+    }
+}
+
+object Color {
+    const val WHITE: Int = -1
+    fun alpha(color: Int): Int = 0
+    fun rgb(r: Int, g: Int, b: Int): Int = 0
+}
+
+class Paint() {
+    constructor(flags: Int) : this()
+
+    companion object {
+        const val ANTI_ALIAS_FLAG = 1
+        const val SUBPIXEL_TEXT_FLAG = 128
+    }
+
+    enum class Style { FILL, STROKE, FILL_AND_STROKE }
+    enum class Join { MITER, ROUND, BEVEL }
+    enum class Cap { BUTT, ROUND, SQUARE }
+
+    class FontMetrics {
+        @JvmField var ascent: Float = 0f
+        @JvmField var descent: Float = 0f
+        @JvmField var leading: Float = 0f
+    }
+
+    var color: Int = 0
+    var style: Style = Style.FILL
+    var shader: Shader? = null
+    var maskFilter: MaskFilter? = null
+    var strokeWidth: Float = 0f
+    var strokeJoin: Join = Join.MITER
+    var strokeCap: Cap = Cap.BUTT
+    var typeface: Typeface? = null
+    var textSize: Float = 0f
+    val fontMetrics: FontMetrics = FontMetrics()
+    fun measureText(text: String): Float = 0f
+}
+
+open class Canvas {
+    val isHardwareAccelerated: Boolean = false
+    fun save(): Int = 0
+    fun restore() {}
+    fun restoreToCount(count: Int) {}
+    fun clipRect(left: Float, top: Float, right: Float, bottom: Float): Boolean = true
+    fun clipPath(path: Path): Boolean = true
+    fun rotate(degrees: Float, px: Float, py: Float) {}
+    fun scale(sx: Float, sy: Float) {}
+    fun translate(dx: Float, dy: Float) {}
+    fun drawColor(color: Int) {}
+    fun drawRect(rect: RectF, paint: Paint) {}
+    fun drawRoundRect(rect: RectF, rx: Float, ry: Float, paint: Paint) {}
+    fun drawPath(path: Path, paint: Paint) {}
+    fun drawText(text: String, x: Float, y: Float, paint: Paint) {}
+    fun drawBitmap(bitmap: Bitmap, matrix: Matrix, paint: Paint?) {}
+}

package/dist/lib/evg/android/androidstubs/Annotation.kt

@@ -0,0 +1,10 @@
+// Compile-time stub. See AndroidStubs.kt.
+package android.annotation
+
+@Target(
+    AnnotationTarget.FUNCTION,
+    AnnotationTarget.PROPERTY,
+    AnnotationTarget.CLASS,
+    AnnotationTarget.VALUE_PARAMETER,
+)
+annotation class SuppressLint(vararg val value: String)

package/dist/lib/evg/android/androidstubs/App.kt

@@ -0,0 +1,30 @@
+// Compile-time stub. See AndroidStubs.kt.
+@file:Suppress("UNUSED_PARAMETER", "unused")
+
+package android.app
+
+import android.content.Context
+import android.content.Intent
+import android.os.Bundle
+import android.view.Menu
+import android.view.MenuItem
+import android.view.View
+
+open class Activity : Context() {
+    companion object {
+        const val RESULT_OK = -1
+        const val RESULT_CANCELED = 0
+    }
+
+    var title: CharSequence = ""
+    val intent: Intent? = null
+
+    protected open fun onCreate(savedInstanceState: Bundle?) {}
+    fun setContentView(view: View) {}
+    fun startActivityForResult(intent: Intent, requestCode: Int) {}
+    open fun onCreateOptionsMenu(menu: Menu): Boolean = false
+    fun invalidateOptionsMenu() {}
+    open fun onOptionsItemSelected(item: MenuItem): Boolean = false
+    protected open fun onActivityResult(requestCode: Int, resultCode: Int, data: Intent?) {}
+    open fun onBackPressed() {}
+}

package/dist/lib/evg/android/androidstubs/Content.kt

@@ -0,0 +1,41 @@
+// Compile-time stub. See AndroidStubs.kt.
+@file:Suppress("UNUSED_PARAMETER", "unused")
+
+package android.content
+
+import android.content.res.AssetManager
+import android.content.res.Resources
+import android.net.Uri
+
+open class Context {
+    companion object {
+        const val INPUT_METHOD_SERVICE = "input_method"
+    }
+
+    val assets: AssetManager = AssetManager()
+    val cacheDir: java.io.File = java.io.File(".")
+    val contentResolver: ContentResolver = ContentResolver()
+    open val resources: Resources = Resources()
+    open fun getSystemService(name: String): Any? = null
+}
+
+class ContentResolver {
+    fun openInputStream(uri: Uri): java.io.InputStream? = null
+}
+
+class Intent() {
+    constructor(action: String) : this()
+
+    companion object {
+        const val ACTION_OPEN_DOCUMENT = "android.intent.action.OPEN_DOCUMENT"
+        const val ACTION_VIEW = "android.intent.action.VIEW"
+        const val CATEGORY_OPENABLE = "android.intent.category.OPENABLE"
+        const val EXTRA_MIME_TYPES = "android.intent.extra.MIME_TYPES"
+    }
+
+    var type: String? = null
+    var data: Uri? = null
+    val action: String? = null
+    fun addCategory(category: String): Intent = this
+    fun putExtra(name: String, value: Array<String>): Intent = this
+}

package/dist/lib/evg/android/androidstubs/ContentRes.kt

@@ -0,0 +1,12 @@
+// Compile-time stub. See AndroidStubs.kt.
+@file:Suppress("UNUSED_PARAMETER", "unused")
+
+package android.content.res
+
+class AssetManager {
+    fun open(fileName: String): java.io.InputStream = java.io.ByteArrayInputStream(ByteArray(0))
+}
+
+class Resources {
+    val displayMetrics: android.util.DisplayMetrics = android.util.DisplayMetrics()
+}

package/dist/lib/evg/android/androidstubs/InputMethod.kt

@@ -0,0 +1,46 @@
+// Compile-time stub. See AndroidStubs.kt.
+//
+// The input-method half of the platform, as far as the RealTrainer host uses
+// it: the connection a soft keyboard commits text through, the attributes a
+// view fills in for it, and the manager that shows and hides it.
+@file:Suppress("UNUSED_PARAMETER", "unused")
+
+package android.view.inputmethod
+
+import android.os.IBinder
+import android.view.KeyEvent
+import android.view.View
+
+interface InputConnection {
+    fun commitText(text: CharSequence?, newCursorPosition: Int): Boolean
+    fun deleteSurroundingText(beforeLength: Int, afterLength: Int): Boolean
+    fun setComposingText(text: CharSequence?, newCursorPosition: Int): Boolean
+    fun finishComposingText(): Boolean
+    fun sendKeyEvent(event: KeyEvent): Boolean
+}
+
+open class BaseInputConnection(targetView: View, fullEditor: Boolean) : InputConnection {
+    override fun commitText(text: CharSequence?, newCursorPosition: Int): Boolean = true
+    override fun deleteSurroundingText(beforeLength: Int, afterLength: Int): Boolean = true
+    override fun setComposingText(text: CharSequence?, newCursorPosition: Int): Boolean = true
+    override fun finishComposingText(): Boolean = true
+    override fun sendKeyEvent(event: KeyEvent): Boolean = true
+}
+
+class EditorInfo {
+    companion object {
+        const val TYPE_CLASS_TEXT = 1
+        const val TYPE_TEXT_FLAG_NO_SUGGESTIONS = 0x80000
+        const val IME_ACTION_NONE = 1
+        const val IME_FLAG_NO_EXTRACT_UI = 0x10000000
+    }
+
+    @JvmField var inputType: Int = 0
+    @JvmField var imeOptions: Int = 0
+}
+
+class InputMethodManager {
+    fun showSoftInput(view: View, flags: Int): Boolean = true
+    fun hideSoftInputFromWindow(windowToken: IBinder?, flags: Int): Boolean = true
+    fun restartInput(view: View) {}
+}

package/dist/lib/evg/android/androidstubs/Net.kt

@@ -0,0 +1,6 @@
+// Compile-time stub. See AndroidStubs.kt.
+package android.net
+
+class Uri {
+    val lastPathSegment: String? = null
+}