apphx 1.1.0 → 2.0.0

package/examples/mygo-web.factory.json

@@ -0,0 +1,18 @@
+{
+  "stateDir": ".factory",
+  "workspaceRoot": "workspaces",
+  "allowLocalExecution": false,
+  "allowCloudBuild": false,
+  "packageTarget": "dmg",
+  "executionEnv": [],
+  "verification": {
+    "prerequisites": [["go", "version"], ["go", "tool", "mygo", "version"], ["bun", "--version"]],
+    "checks": [["go", "vet", "./..."], ["go", "test", "./..."], ["bun", "run", "build"]],
+    "runtime": [["go", "run", "./cmd/acceptance"]]
+  },
+  "packaging": {
+    "provider": "local",
+    "commands": [["go", "tool", "mygo", "build", "-platform", "darwin/arm64", "-sign", "-", "-skip-notarize", "-o", "build"]],
+    "artifactPath": "build/darwin-arm64/MyGo App 0.1.0.dmg"
+  }
+}

package/examples/mygo-web.json

@@ -0,0 +1,16 @@
+{
+  "id": "mygo-web-local-notes",
+  "name": "MyGo App",
+  "framework": "mygo",
+  "platform": "macos",
+  "channel": "local",
+  "version": "0.1.0",
+  "screenshotsDir": "build/screenshots",
+  "purpose": "Capture and recover private offline desktop notes with a web frontend",
+  "audience": "Mac users keeping local working notes",
+  "differentiators": ["Offline note editing with a reversible owner-controlled backup"],
+  "acceptance": ["Launch the actual packaged macOS app and use its visible web frontend to create and edit a note, then restart and recover the saved text", "Export notes, remove local data and restore the same notes through the desktop UI; record actual window screenshots"],
+  "constraints": ["Use go.mod, mygo.config.ts and a real frontend package.json with its committed dependency lock; this paired profile illustrates an existing Bun frontend with a real build script, not a requirement to migrate package managers", "Pin github.com/egoist/mygo v0.3.0 and its cmd/mygo tool directive in go.mod; use Go 1.27.1", "Set the MyGo app name to MyGo App and version to 0.1.0; match darwin/arm64 output paths in the paired profile", "Prepare generated frontend bindings and lockfiles before verification; implement cmd/acceptance to launch and drive the real desktop app and fail on UI assertion errors, not merely run browser or headless tests", "No accounts, network dependency, Developer ID, notarization, upload or publishing"],
+  "hiddenFeatures": false,
+  "reviewBypass": false
+}

package/examples/mygo.factory.json

@@ -0,0 +1,18 @@
+{
+  "stateDir": ".factory",
+  "workspaceRoot": "workspaces",
+  "allowLocalExecution": false,
+  "allowCloudBuild": false,
+  "packageTarget": "app",
+  "executionEnv": [],
+  "verification": {
+    "prerequisites": [["go", "version"], ["go", "tool", "mygo", "version"]],
+    "checks": [["go", "vet", "./..."], ["go", "test", "./..."]],
+    "runtime": [["go", "run", "./cmd/acceptance"]]
+  },
+  "packaging": {
+    "provider": "local",
+    "commands": [["go", "tool", "mygo", "build", "-platform", "darwin/arm64", "-sign", "-", "-skip-notarize", "-skip-dmg", "-o", "build"]],
+    "artifactPath": "build/darwin-arm64/MyGo App.app"
+  }
+}

package/examples/mygo.json

@@ -0,0 +1,16 @@
+{
+  "id": "mygo-local-notes",
+  "name": "MyGo App",
+  "framework": "mygo",
+  "platform": "macos",
+  "channel": "local",
+  "version": "0.1.0",
+  "screenshotsDir": "build/screenshots",
+  "purpose": "Capture and recover private offline desktop notes",
+  "audience": "Mac users keeping local working notes",
+  "differentiators": ["Offline note editing with a reversible owner-controlled backup"],
+  "acceptance": ["Launch the actual macOS app, create and edit a note through its visible UI, then restart and recover the saved text", "Export notes, remove local data and restore the same notes through the desktop UI; record actual window screenshots"],
+  "constraints": ["Use native MyGo UI with go.mod and mygo.json, without requiring package.json or Bun", "Pin github.com/egoist/mygo v0.3.0 and its cmd/mygo tool directive in go.mod; use Go 1.27.1", "Set the MyGo app name to MyGo App and version to 0.1.0; match darwin/arm64 output paths in the paired profile", "Implement cmd/acceptance as a real app-specific desktop harness that launches and drives the actual app, waits for UI assertions and fails on errors; go test or a headless view test alone is insufficient", "No accounts, network dependency, Developer ID, notarization, upload or publishing"],
+  "hiddenFeatures": false,
+  "reviewBypass": false
+}

package/examples/react-native.factory.json

@@ -0,0 +1,18 @@
+{
+  "stateDir": ".factory",
+  "workspaceRoot": "workspaces",
+  "allowLocalExecution": false,
+  "allowCloudBuild": false,
+  "packageTarget": "aab",
+  "executionEnv": ["ANDROID_HOME", "ANDROID_DEVICE_ID"],
+  "verification": {
+    "prerequisites": [["node", "--version"], ["java", "-version"], ["adb", "version"]],
+    "checks": [["npm", "run", "lint"], ["npm", "test", "--", "--runInBand"]],
+    "runtime": [["npm", "run", "test:e2e", "--", "--platform", "android", "--device", "${ANDROID_DEVICE_ID}"]]
+  },
+  "packaging": {
+    "provider": "local",
+    "commands": [["./android/gradlew", "-p", "android", ":app:bundleRelease"]],
+    "artifactPath": "android/app/build/outputs/bundle/release/app-release.aab"
+  }
+}

package/examples/react-native.json

@@ -0,0 +1,16 @@
+{
+  "id": "rn-field-notes",
+  "name": "Offline field notes",
+  "framework": "react-native",
+  "platform": "android",
+  "channel": "local",
+  "version": "1.0.0",
+  "screenshotsDir": "build/screenshots",
+  "purpose": "Capture field notes offline and restore an owner-exported backup",
+  "audience": "Field researchers",
+  "differentiators": ["Timestamped notes with a reversible local backup workflow"],
+  "acceptance": ["Create and edit a note offline, restart the app and recover the saved text", "Export notes, delete local data and restore the same notes from the export", "Run real device acceptance for both workflows using the project's test:e2e script and save actual screenshots"],
+  "constraints": ["Preserve React Native's android native host, lockfile and existing scripts; adapt lint, test and test:e2e to their real equivalents", "The test:e2e script must exercise the app on ANDROID_DEVICE_ID, not return a canned success", "No accounts, tracking, hidden features or network dependency"],
+  "hiddenFeatures": false,
+  "reviewBypass": false
+}

package/examples/runtime/android-java/app/build.gradle

@@ -0,0 +1,7 @@
+// Deliberately no downloaded Android Gradle Plugin. This application compiles with
+// the owner-selected SDK: aapt -> javac -> d8 -> zipalign -> apksigner.
+plugins { id 'base' }
+tasks.register('assembleDebug', Exec) {
+    workingDir rootProject.projectDir
+    commandLine providers.gradleProperty('node').getOrElse('node'), 'sdk-build.mjs'
+}

package/examples/runtime/android-java/app/src/main/AndroidManifest.xml

@@ -0,0 +1,8 @@
+<manifest xmlns:android="http://schemas.android.com/apk/res/android" package="dev.apphx.runtime">
+  <uses-sdk android:minSdkVersion="23" android:targetSdkVersion="35" />
+  <application android:label="apphx Local Records" android:theme="@android:style/Theme.Material.Light.NoActionBar" android:allowBackup="false" android:debuggable="true">
+    <activity android:name=".MainActivity" android:exported="true">
+      <intent-filter><action android:name="android.intent.action.MAIN"/><category android:name="android.intent.category.LAUNCHER"/></intent-filter>
+    </activity>
+  </application>
+</manifest>

package/examples/runtime/android-java/app/src/main/java/dev/apphx/runtime/MainActivity.java

@@ -0,0 +1,44 @@
+package dev.apphx.runtime;
+
+import android.app.Activity;
+import android.os.Bundle;
+import android.content.SharedPreferences;
+import android.widget.Button;
+import android.widget.EditText;
+import android.widget.LinearLayout;
+import android.widget.TextView;
+
+public final class MainActivity extends Activity {
+    @Override public void onCreate(Bundle state) {
+        super.onCreate(state);
+        SharedPreferences records = getSharedPreferences("records", MODE_PRIVATE);
+        LinearLayout layout = new LinearLayout(this);
+        layout.setOrientation(LinearLayout.VERTICAL);
+        layout.setPadding(32, 64, 32, 32);
+        TextView title = new TextView(this);
+        title.setText("Local record notebook");
+        title.setTextSize(24);
+        EditText input = new EditText(this);
+        input.setSingleLine(true);
+        input.setHint("Record text");
+        input.setContentDescription("Record text");
+        TextView saved = new TextView(this);
+        saved.setTextSize(22);
+        saved.setText(records.getString("record", "No saved record"));
+        saved.setContentDescription("Saved record");
+        Button save = new Button(this);
+        save.setText("Save record");
+        save.setContentDescription("Save record");
+        save.setOnClickListener(view -> {
+            String value = input.getText().toString().trim();
+            if (value.isEmpty()) { input.setError("Enter a record"); return; }
+            if (!records.edit().putString("record", value).commit()) {
+                input.setError("Could not save record"); return;
+            }
+            saved.setText(value);
+            input.setText("");
+        });
+        layout.addView(title); layout.addView(input); layout.addView(save); layout.addView(saved);
+        setContentView(layout);
+    }
+}

package/examples/runtime/android-java/sdk-build.mjs

@@ -0,0 +1,29 @@
+import { spawnSync } from 'node:child_process';
+import { mkdirSync, existsSync, rmSync } from 'node:fs';
+import { delimiter, join, resolve } from 'node:path';
+
+const sdk = process.env.ANDROID_SDK_ROOT;
+const java = process.env.JAVA_HOME;
+if (!sdk || !java) throw new Error('ANDROID_SDK_ROOT and JAVA_HOME must select installed SDK/JDK; this driver never installs tools or accepts licenses');
+const tools = join(sdk, 'build-tools', process.env.APPHX_ANDROID_BUILD_TOOLS ?? '35.0.0');
+const android = join(sdk, 'platforms', process.env.APPHX_ANDROID_PLATFORM ?? 'android-35', 'android.jar');
+const build = resolve('build');
+mkdirSync(join(build, 'classes'), { recursive: true });
+mkdirSync(join(build, 'dex'), { recursive: true });
+function run(executable, args, cwd = process.cwd()) {
+  const result = spawnSync(executable, args, { cwd, env: process.env, encoding: 'utf8', timeout: 120000 });
+  process.stdout.write(result.stdout ?? ''); process.stderr.write(result.stderr ?? '');
+  if (result.error || result.status !== 0) throw result.error ?? new Error(`${executable} exited ${result.status}`);
+}
+const unsigned = join(build, 'unsigned.apk');
+rmSync(unsigned, { force: true });
+run(join(tools, 'aapt'), ['package', '-f', '-M', 'app/src/main/AndroidManifest.xml', '-I', android, '-F', unsigned]);
+run(join(java, 'bin/javac'), ['-source', '8', '-target', '8', '-bootclasspath', [android, join(tools, 'core-lambda-stubs.jar')].join(delimiter), '-d', join(build, 'classes'), 'app/src/main/java/dev/apphx/runtime/MainActivity.java']);
+run(join(tools, 'd8'), ['--lib', android, '--min-api', '23', '--output', join(build, 'dex'), join(build, 'classes/dev/apphx/runtime/MainActivity.class')]);
+run('/usr/bin/zip', ['-q', unsigned, 'classes.dex'], join(build, 'dex'));
+run(join(tools, 'zipalign'), ['-f', '4', unsigned, join(build, 'aligned.apk')]);
+const key = join(build, 'local-only.p12');
+if (!existsSync(key)) run(join(java, 'bin/keytool'), ['-genkeypair', '-keystore', key, '-storepass', 'local-smoke-only', '-keypass', 'local-smoke-only', '-alias', 'smoke', '-keyalg', 'RSA', '-keysize', '2048', '-validity', '2', '-dname', 'CN=Local runtime smoke']);
+run(join(tools, 'apksigner'), ['sign', '--ks', key, '--ks-pass', 'pass:local-smoke-only', '--out', join(build, 'records.apk'), join(build, 'aligned.apk')]);
+run(join(tools, 'apksigner'), ['verify', '--verbose', '--print-certs', join(build, 'records.apk')]);
+run(join(tools, 'aapt'), ['dump', 'badging', join(build, 'records.apk')]);

package/examples/runtime/android-java/settings.gradle

@@ -0,0 +1,2 @@
+rootProject.name = 'apphx-runtime-records'
+include ':app'

package/examples/runtime/android-ui.mjs

@@ -0,0 +1,70 @@
+import assert from 'node:assert/strict';
+import { readFileSync, writeFileSync, mkdirSync } from 'node:fs';
+import { spawnSync } from 'node:child_process';
+import { join } from 'node:path';
+
+const session = JSON.parse(readFileSync(process.argv[2], 'utf8'));
+assert.match(session.avd, /^apphx-smoke-[a-f0-9]+$/);
+assert.match(session.serial, /^emulator-\d+$/);
+assert.ok(session.port > 1024 && session.port !== 5037);
+function adb(args, binary = false) {
+  const result = spawnSync(join(session.sdk, 'platform-tools/adb'), ['-P', String(session.port), '-s', session.serial, ...args], { encoding: binary ? undefined : 'utf8', timeout: 45000 });
+  if (result.error || result.status !== 0) throw result.error ?? new Error(`${args.join(' ')}: ${result.stderr}`);
+  return result.stdout;
+}
+assert.equal(adb(['emu', 'avd', 'name']).split(/\r?\n/)[0], session.avd, 'Refusing non-owned emulator');
+const app = 'dev.apphx.runtime';
+const token = 'record-' + session.avd.slice(-12);
+mkdirSync('build/screenshots', { recursive: true });
+const pause = () => new Promise(resolve => setTimeout(resolve, 500));
+async function tree() {
+  adb(['shell', 'uiautomator', 'dump', '/sdcard/apphx-window.xml']);
+  const xml = adb(['shell', 'cat', '/sdcard/apphx-window.xml']);
+  writeFileSync('build/screenshots/latest.xml', xml);
+  return xml;
+}
+function tap(xml, label) {
+  const node = [...xml.matchAll(/<node\b[^>]*>/g)].map(match => match[0]).find(node => node.includes(`text="${label}"`) || node.includes(`content-desc="${label}"`));
+  assert.ok(node, `UI control missing: ${label}`);
+  const bounds = node.match(/bounds="\[(\d+),(\d+)\]\[(\d+),(\d+)\]"/);
+  assert.ok(bounds);
+  adb(['shell', 'input', 'tap', String(Math.floor((+bounds[1] + +bounds[3]) / 2)), String(Math.floor((+bounds[2] + +bounds[4]) / 2))]);
+}
+function screenshot(name) {
+  const png = adb(['exec-out', 'screencap', '-p'], true);
+  assert.equal(png.subarray(0, 8).toString('hex'), '89504e470d0a1a0a');
+  assert.ok(png.length > 1000);
+  writeFileSync(`build/screenshots/${name}.png`, png);
+}
+try {
+  adb(['install', '-r', 'build/records.apk']);
+  adb(['shell', 'pm', 'clear', app]);
+  adb(['shell', 'am', 'start', '-W', '-n', `${app}/.MainActivity`]);
+  await pause();
+  let xml = await tree();
+  assert.ok(xml.includes('No saved record'));
+  tap(xml, 'Record text');
+  await new Promise(resolve => setTimeout(resolve, 1500));
+  for (const character of token) {
+    adb(['shell', 'input', 'text', character]);
+    await new Promise(resolve => setTimeout(resolve, 80));
+  }
+  assert.ok((await tree()).includes(`text="${token}"`), 'Native text input did not receive the complete record');
+  tap(await tree(), 'Save record');
+  await pause();
+  xml = await tree();
+  assert.ok(xml.includes(`text="${token}"`), 'Save did not reach visible UI');
+  writeFileSync('build/screenshots/saved.xml', xml); screenshot('saved');
+  adb(['shell', 'am', 'force-stop', app]);
+  adb(['shell', 'am', 'start', '-W', '-n', `${app}/.MainActivity`]);
+  await pause();
+  xml = await tree();
+  assert.ok(xml.includes(`text="${token}"`), 'Relaunch lost persisted record');
+  const preferences = adb(['shell', 'run-as', app, 'cat', 'shared_prefs/records.xml']);
+  assert.ok(preferences.includes(token));
+  writeFileSync('build/screenshots/relaunch.xml', xml); screenshot('relaunch');
+  writeFileSync('build/runtime-evidence.json', JSON.stringify({ token, avd: session.avd, serial: session.serial, adbPort: session.port, saved: true, relaunched: true, preferences }, null, 2));
+  console.log('APPHX_REAL_ANDROID ' + JSON.stringify({ token, visibleSave: true, persistedRelaunch: true }));
+} finally {
+  adb(['shell', 'am', 'force-stop', app]);
+}

package/examples/runtime/mygo-native/go.mod

@@ -0,0 +1,13 @@
+module github.com/egoist/mygo/apphx-smoke
+
+go 1.27.1
+
+require github.com/egoist/mygo v0.3.0
+
+require (
+	github.com/ebitengine/purego v0.11.1 // indirect
+	github.com/go-text/typesetting v0.3.5 // indirect
+	golang.org/x/image v0.46.0 // indirect
+)
+
+tool github.com/egoist/mygo/cmd/mygo

package/examples/runtime/mygo-native/go.sum

@@ -0,0 +1,10 @@
+github.com/ebitengine/purego v0.11.1 h1:2zpWRSQNVKN4eKsKO9eM1ILDgWfYMY9GwqRmK6XeQ/0=
+github.com/ebitengine/purego v0.11.1/go.mod h1:DCHPP08djqhNSoTfImcnHYQRZmd0qhakvrozqaEYhGQ=
+github.com/egoist/mygo v0.3.0 h1:57FdVGkm60TWBkGIbWb/S0CpppYPFjI7+vKuYsBezIY=
+github.com/egoist/mygo v0.3.0/go.mod h1:1sRzZ6jEhKE7iuEQXjyoXDgxyxQ1uTgMHDcDKZvoDIU=
+github.com/go-text/typesetting v0.3.5 h1:XZPUooClHY0Vf/rFyUyuPRNEkawARaFzLMQcXLSEyPk=
+github.com/go-text/typesetting v0.3.5/go.mod h1:XZO1hD+nQVyvVa5IicQk7FsCa4PFQaJ2soWAP1f//68=
+github.com/go-text/typesetting-utils v0.0.0-20260419141703-4ffe8874dabc h1:8FGo2It5K75XkavhTiCKExUfVaVDS1feBnLCru5qeoY=
+github.com/go-text/typesetting-utils v0.0.0-20260419141703-4ffe8874dabc/go.mod h1:3/62I4La/HBRX9TcTpBj4eipLiwzf+vhI+7whTc9V7o=
+golang.org/x/image v0.46.0 h1:b1+oYj0Jbp6K5MDT4i4/eZpYlk3V8SJhhDKh6LBHAyQ=
+golang.org/x/image v0.46.0/go.mod h1:3B3W05VGVQyuXucLINLjXKrqISASfi4Xj+iCVkLMwew=

package/examples/runtime/mygo-native/main.go

@@ -0,0 +1,173 @@
+package main
+
+import (
+    "encoding/json"
+    "flag"
+    "fmt"
+    "os"
+    "path/filepath"
+    "time"
+
+    "github.com/ebitengine/purego/objc"
+    "github.com/egoist/mygo"
+    "github.com/egoist/mygo/internal/darwin"
+    "github.com/egoist/mygo/ui"
+)
+
+type counter struct { value int; stateFile string; failure error; frames int; callbacks int; diagnostic bool }
+func (c *counter) change(value int) {
+    c.callbacks++
+    if c.diagnostic { fmt.Fprintf(os.Stderr,"APPHX_NATIVE_CALLBACK frame=%d callback=%d from=%d to=%d\n",c.frames,c.callbacks,c.value,value) }
+    c.value = value
+    if c.stateFile != "" { c.failure = os.WriteFile(c.stateFile, []byte(fmt.Sprint(value)), 0600) }
+}
+func (c *counter) view(ctx *ui.Context) {
+    c.frames++
+    if c.diagnostic { fmt.Fprintf(os.Stderr,"APPHX_NATIVE_VIEW frame=%d value=%d callbacks=%d\n",c.frames,c.value,c.callbacks) }
+    ui.Column(ctx).Fill().Center().Gap(16).Children(func() {
+        ui.Text(ctx, "MyGo · apphx desktop acceptance").FontSize(16)
+        ui.Textf(ctx, "%d", c.value).FontSize(52).Bold()
+        ui.Row(ctx).Gap(12).Children(func() {
+            ui.Button(ctx.Key("decrement"), "−").Label("Decrement").OnClick(func() { c.change(c.value - 1) })
+            ui.Button(ctx.Key("reset"), "Reset").Label("Reset").OnClick(func() { c.change(0) })
+            ui.PrimaryButton(ctx.Key("increment"), "+").Label("Increment").OnClick(func() { c.change(c.value + 1) })
+        })
+        ui.Text(ctx, "Native macOS window · local ad-hoc build").FontSize(12)
+    })
+}
+func nativePress(handle uintptr, label string) (allowed, accepted bool) {
+    children := objc.RegisterName("accessibilityChildren")
+    title := objc.RegisterName("accessibilityTitle")
+    name := objc.RegisterName("accessibilityLabel")
+    utf8 := objc.RegisterName("UTF8String")
+    press := objc.RegisterName("accessibilityPerformPress")
+    var walk func(objc.ID) bool
+    walk = func(node objc.ID) bool {
+        text := func(selector objc.SEL) string { value := node.Send(selector); if value == 0 { return "" }; return objc.Send[string](value, utf8) }
+        if text(name)+text(title) == label {
+            allowed = objc.Send[bool](node,objc.RegisterName("isAccessibilitySelectorAllowed:"),press)
+            if allowed { accepted = objc.Send[bool](node,press) }
+            return true
+        }
+        list := node.Send(children)
+        for i,n := uint64(0),objc.Send[uint64](list,objc.RegisterName("count")); i<n; i++ { if walk(list.Send(objc.RegisterName("objectAtIndex:"),i)) { return true } }
+        return false
+    }
+    walk(objc.ID(handle).Send(objc.RegisterName("contentView")))
+    return
+}
+func nativeWindowState(handle uintptr) map[string]any {
+    window := objc.ID(handle)
+    application := objc.ID(objc.GetClass("NSApplication")).Send(objc.RegisterName("sharedApplication"))
+    return map[string]any{"occlusionState": objc.Send[uint64](window,objc.RegisterName("occlusionState")), "isVisible": objc.Send[bool](window,objc.RegisterName("isVisible")), "isKeyWindow": objc.Send[bool](window,objc.RegisterName("isKeyWindow")), "isOnActiveSpace": objc.Send[bool](window,objc.RegisterName("isOnActiveSpace")), "applicationActive": objc.Send[bool](application,objc.RegisterName("isActive"))}
+}
+func nativeReady(state map[string]any) bool {
+    return state["isVisible"].(bool) && state["occlusionState"].(uint64)&2 != 0 && state["applicationActive"].(bool) && state["isKeyWindow"].(bool)
+}
+func main() {
+    mode := flag.String("acceptance", "", "first or relaunch actual native-window acceptance")
+    stateFile := flag.String("state-file", "", "isolated counter state")
+    screenshot := flag.String("screenshot", "", "actual window content PNG")
+    flag.Parse()
+    c := &counter{stateFile: *stateFile, diagnostic: *mode != ""}
+    if bytes, err := os.ReadFile(*stateFile); err == nil { if _, err := fmt.Sscan(string(bytes), &c.value); err != nil { panic(err) } } else if !os.IsNotExist(err) { panic(err) }
+    type outcome struct { Report map[string]any; Err error }
+    complete := make(chan outcome, 1)
+    mygo.App.WhenReady(func() {
+        window := mygo.NewWindow(mygo.WindowOptions{Title: "apphx MyGo acceptance", Width: 520, Height: 340, Content: ui.View(c.view)})
+        if *mode == "" { return }
+        go func() {
+            report := map[string]any{"mode": *mode}
+            fail := func(err error) {
+                mygo.RunOnMain(func() { report["failureFrames"] = c.frames; report["failureCallbacks"] = c.callbacks; report["failureTree"] = darwin.TestAccessibility(window.NativeHandle()); report["failureNativeWindow"] = nativeWindowState(window.NativeHandle()) })
+                complete <- outcome{Report: report, Err: err}; mygo.App.Quit()
+            }
+            deadline := time.Now().Add(20*time.Second)
+            ready := false
+            focusRequested := false
+            for time.Now().Before(deadline) {
+                mygo.RunOnMain(func() {
+                    found := false
+                    for _, node := range darwin.TestAccessibility(window.NativeHandle()) { if node.Role == "AXButton" && node.Label == "Increment" && node.Frame[2] > 0 && node.Frame[3] > 0 { found = true } }
+                    // A shown AX tree can belong to an occluded window whose display link does not tick.
+                    if found && c.frames > 0 && !focusRequested { report["focusRequestedAfterFrame"] = c.frames; window.Focus(); focusRequested = true }
+                    state := nativeWindowState(window.NativeHandle())
+                    ready = found && nativeReady(state)
+                })
+                if ready { break }
+                time.Sleep(25*time.Millisecond)
+            }
+            if !ready || !window.IsVisible() { fail(fmt.Errorf("actual visible native accessibility tree did not become ready")); return }
+            report["visible"] = window.IsVisible()
+            mygo.RunOnMain(func() { report["readyFrames"] = c.frames; report["readyTree"] = darwin.TestAccessibility(window.NativeHandle()); report["readyNativeWindow"] = nativeWindowState(window.NativeHandle()) })
+            width,height := window.ContentSize(); report["width"] = width; report["height"] = height
+            initial := 0
+            mygo.RunOnMain(func() { initial = c.value })
+            report["initial"] = initial
+            expected := 0
+            labels := []string{"Increment", "Increment", "Decrement"}
+            final := 1
+            if *mode == "relaunch" { expected = 1; labels = []string{"Reset"}; final = 0 }
+            if initial != expected { fail(fmt.Errorf("persisted initial value=%d want=%d",initial,expected)); return }
+            wanted := initial
+            transitions := []int{}
+            for index, label := range labels {
+                performed := false
+                var actionError error
+                mygo.RunOnMain(func() {
+                    state := nativeWindowState(window.NativeHandle())
+                    if !nativeReady(state) { actionError = fmt.Errorf("native foreground readiness lost before %s: %v",label,state); return }
+                    beforeFrames,beforeCallbacks := c.frames,c.callbacks
+                    allowed,accepted := nativePress(window.NativeHandle(),label)
+                    performed = accepted
+                    fmt.Fprintf(os.Stderr,"APPHX_NATIVE_SELECTOR label=%s allowed=%v accepted=%v framesBefore=%d framesAfter=%d callbacksBefore=%d callbacksAfter=%d value=%d\n",label,allowed,accepted,beforeFrames,c.frames,beforeCallbacks,c.callbacks,c.value)
+                })
+                if actionError != nil { fail(actionError); return }
+                if !performed { fail(fmt.Errorf("real accessibility action did not reach %s",label)); return }
+                switch label { case "Increment": wanted++; case "Decrement": wanted--; case "Reset": wanted = 0 }
+                deadline := time.Now().Add(5*time.Second)
+                observed,callbacks := initial,0
+                rendered := false
+                for time.Now().Before(deadline) {
+                    mygo.RunOnMain(func() {
+                        observed,callbacks = c.value,c.callbacks
+                        rendered = false
+                        for _, node := range darwin.TestAccessibility(window.NativeHandle()) { if node.Role == "AXStaticText" && node.Label == fmt.Sprint(wanted) && node.Value == fmt.Sprint(wanted) { rendered = true } }
+                    })
+                    if observed == wanted && rendered && callbacks == index+1 { break }
+                    time.Sleep(15*time.Millisecond)
+                }
+                if observed != wanted || !rendered || callbacks != index+1 { fail(fmt.Errorf("%s did not transition value=%d want=%d rendered=%v callbacks=%d wantCallbacks=%d",label,observed,wanted,rendered,callbacks,index+1)); return }
+                fmt.Fprintf(os.Stderr,"APPHX_NATIVE_TRANSITION label=%s value=%d rendered=%v callbacks=%d\n",label,observed,rendered,callbacks)
+                transitions = append(transitions,observed)
+            }
+            report["transitions"] = transitions
+            observed := 0
+            var persistenceError error
+            mygo.RunOnMain(func() { observed = c.value; persistenceError = c.failure })
+            if persistenceError != nil || observed != final { fail(fmt.Errorf("native action state=%d want=%d persistence=%v",observed,final,persistenceError)); return }
+            report["actions"] = labels; report["final"] = observed
+            mygo.RunOnMain(func() { report["finalNativeWindow"] = nativeWindowState(window.NativeHandle()); report["finalFrames"] = c.frames; report["finalCallbacks"] = c.callbacks })
+            if !nativeReady(report["finalNativeWindow"].(map[string]any)) { fail(fmt.Errorf("native foreground readiness lost after actions")); return }
+            if *screenshot != "" {
+                bytes,err := window.CapturePage()
+                if err != nil { fail(err); return }
+                captureReady := false
+                mygo.RunOnMain(func() { captureReady = nativeReady(nativeWindowState(window.NativeHandle())) })
+                if !captureReady { fail(fmt.Errorf("native foreground readiness lost during screenshot capture")); return }
+                if err := os.MkdirAll(filepath.Dir(*screenshot),0700); err != nil { fail(err); return }
+                if err := os.WriteFile(*screenshot,bytes,0600); err != nil { fail(err); return }
+                report["screenshot"] = *screenshot
+            }
+            complete <- outcome{Report: report}
+            mygo.App.Quit()
+        }()
+    })
+    if err := mygo.App.Run(); err != nil { panic(err) }
+    if *mode != "" {
+        result := <-complete
+        bytes,_ := json.Marshal(result.Report)
+        fmt.Println("APPHX_REAL_MYGO_UI "+string(bytes))
+        if result.Err != nil { fmt.Fprintln(os.Stderr,result.Err); os.Exit(1) }
+    }
+}

package/examples/runtime/mygo-native/main_test.go

@@ -0,0 +1,14 @@
+package main
+
+import (
+  "testing"
+  "github.com/egoist/mygo/ui"
+)
+func TestCounterView(t *testing.T) {
+  state := &counter{}
+  view := ui.NewTester(state.view, 520, 340)
+  for _, label := range []string{"Increment", "Increment", "Decrement"} { if err := view.Click(label); err != nil { t.Fatal(err) } }
+  if state.value != 1 || !view.HasText("1") { t.Fatalf("counter=%d",state.value) }
+  if err := view.Click("Reset"); err != nil { t.Fatal(err) }
+  if state.value != 0 { t.Fatalf("reset counter=%d",state.value) }
+}

package/examples/runtime/mygo-native/mygo.json

@@ -0,0 +1 @@
+{"name":"MyGo App","identifier":"org.example.apphx.mygo.smoke","version":"0.1.0","out":"build","macos":{"signingIdentity":"-"}}

package/examples/runtime/mygo-web/bun.lock

@@ -0,0 +1,15 @@
+{
+  "lockfileVersion": 1,
+  "configVersion": 1,
+  "workspaces": {
+    "": {
+      "name": "apphx-mygo-web-smoke",
+      "dependencies": {
+        "mygo-runtime": "0.3.0",
+      },
+    },
+  },
+  "packages": {
+    "mygo-runtime": ["mygo-runtime@0.3.0", "", {}, "sha512-/GOa5qX6HmbUFDQlJ/ZPRUDXW5wURuTfH/aPNprTH19nibnblEIP+MIvfnDotK3ZYfXUcfkiPpZouXtRDseagA=="],
+  }
+}

package/examples/runtime/mygo-web/go.mod

@@ -0,0 +1,9 @@
+module example.com/apphx-mygo-web
+
+go 1.27.1
+
+require github.com/egoist/mygo v0.3.0
+
+require github.com/ebitengine/purego v0.11.1 // indirect
+
+tool github.com/egoist/mygo/cmd/mygo

package/examples/runtime/mygo-web/go.sum

@@ -0,0 +1,8 @@
+github.com/ebitengine/purego v0.11.1 h1:2zpWRSQNVKN4eKsKO9eM1ILDgWfYMY9GwqRmK6XeQ/0=
+github.com/ebitengine/purego v0.11.1/go.mod h1:DCHPP08djqhNSoTfImcnHYQRZmd0qhakvrozqaEYhGQ=
+github.com/egoist/mygo v0.3.0 h1:57FdVGkm60TWBkGIbWb/S0CpppYPFjI7+vKuYsBezIY=
+github.com/egoist/mygo v0.3.0/go.mod h1:1sRzZ6jEhKE7iuEQXjyoXDgxyxQ1uTgMHDcDKZvoDIU=
+github.com/go-text/typesetting v0.3.5 h1:XZPUooClHY0Vf/rFyUyuPRNEkawARaFzLMQcXLSEyPk=
+github.com/go-text/typesetting v0.3.5/go.mod h1:XZO1hD+nQVyvVa5IicQk7FsCa4PFQaJ2soWAP1f//68=
+golang.org/x/image v0.46.0 h1:b1+oYj0Jbp6K5MDT4i4/eZpYlk3V8SJhhDKh6LBHAyQ=
+golang.org/x/image v0.46.0/go.mod h1:3B3W05VGVQyuXucLINLjXKrqISASfi4Xj+iCVkLMwew=

package/examples/runtime/mygo-web/index.html

@@ -0,0 +1 @@
+<!doctype html><html><head><meta charset="UTF-8"><title>MyGo Web Acceptance</title><style>:root{font-family:system-ui;color-scheme:light dark}body{margin:0;padding:40px}main{max-width:460px;margin:auto}button{font:inherit;padding:10px 16px;margin:8px 8px 8px 0}output{display:block;font-size:48px;margin:24px 0}#status{min-height:30px}</style></head><body><main><h1>MyGo + WKWebView</h1><p>Compiled Go service with a bundled TypeScript frontend.</p><output id="count" aria-live="polite">0</output><button id="add">Add 3</button><button id="subtract">Subtract 10</button><p id="status" role="status">Ready</p></main><script type="module" src="./main.js"></script></body></html>

package/examples/runtime/mygo-web/main.go

@@ -0,0 +1,60 @@
+package main
+import (
+ "context"
+ "encoding/json"
+ "errors"
+ "flag"
+ "fmt"
+ "os"
+ "path/filepath"
+ "time"
+ "github.com/egoist/mygo"
+)
+type Counter struct { value int; state string }
+func(c *Counter)Change(delta int)(int,error){
+ if c.value+delta<0{return c.value,errors.New("negative totals are rejected")}
+ next:=c.value+delta
+ if c.state!=""{if err:=os.MkdirAll(filepath.Dir(c.state),0700);err!=nil{return c.value,err};if err:=os.WriteFile(c.state,[]byte(fmt.Sprint(next)),0600);err!=nil{return c.value,err}}
+ c.value=next;return c.value,nil
+}
+func(c *Counter)Value()int{return c.value}
+func main(){
+ acceptance:=flag.Bool("acceptance",false,"run real WKWebView acceptance")
+ screenshot:=flag.String("screenshot","","window PNG")
+ state:=flag.String("state-file","","durable counter file")
+ relaunch:=flag.Bool("relaunch",false,"verify persisted state without adding")
+ flag.Parse()
+ service:=&Counter{state:*state}
+ if *state!=""{data,err:=os.ReadFile(*state);if err==nil{if _,err=fmt.Sscan(string(data),&service.value);err!=nil{panic(err)}}else if !os.IsNotExist(err){panic(err)}}
+ mygo.Bind(service)
+ type outcome struct{report map[string]any;err error};done:=make(chan outcome,1)
+ mygo.App.WhenReady(func(){
+  window:=mygo.NewWindow(mygo.WindowOptions{Title:"apphx MyGo Web acceptance",Width:640,Height:440,URL:"/"})
+  if !*acceptance{return}
+  go func(){
+   ctx,cancel:=context.WithTimeout(context.Background(),25*time.Second);defer cancel()
+   finish:=func(report map[string]any,err error){done<-outcome{report,err};mygo.App.Quit()}
+   ready:=false
+   for ctx.Err()==nil{value,err:=window.Page().EvalContext(ctx,"window.smokeReady === true");if err==nil&&value==true{ready=true;break};time.Sleep(25*time.Millisecond)}
+   if !ready||!window.IsVisible(){finish(nil,fmt.Errorf("real visible WKWebView did not become ready"));return}
+   startup,err:=mygo.EvalAs[map[string]any](window.Page(),"({visibleTotal:Number(document.querySelector('#count').textContent),ready:window.smokeReady === true})")
+   if err!=nil{finish(startup,err);return}
+   startup["goValue"]=service.Value()
+   startup["visible"]=window.IsVisible()
+   expected:=0;if *relaunch{expected=3}
+   if startup["visibleTotal"]!=float64(expected)||service.Value()!=expected{
+    if *screenshot!=""{if png,captureErr:=window.CapturePage();captureErr==nil{if os.MkdirAll(filepath.Dir(*screenshot),0700)==nil{_ = os.WriteFile(*screenshot+".startup.png",png,0600)}}}
+    finish(startup,fmt.Errorf("ordinary startup UI/backend mismatch before acceptance actions: %v; want %d",startup,expected));return
+   }
+ report,err:=mygo.EvalAs[map[string]any](window.Page(),fmt.Sprintf("window.runAcceptance(%t)",*relaunch))
+   if err!=nil{finish(report,err);return}
+   if report["goValue"]!=float64(3)||report["visibleTotal"]!=float64(3)||report["negativeRejected"]!=true{finish(report,fmt.Errorf("bridge/UI invariants failed: %v",report));return}
+   report["startup"]=startup
+   report["visible"]=window.IsVisible()
+   if *screenshot!=""{png,err:=window.CapturePage();if err!=nil{finish(report,err);return};if err=os.MkdirAll(filepath.Dir(*screenshot),0700);err!=nil{finish(report,err);return};if err=os.WriteFile(*screenshot,png,0600);err!=nil{finish(report,err);return};report["screenshot"]=*screenshot}
+   finish(report,nil)
+  }()
+ })
+ if err:=mygo.App.Run();err!=nil{panic(err)}
+ if *acceptance{result:=<-done;bytes,_:=json.Marshal(result.report);fmt.Println("APPHX_REAL_MYGO_WEB "+string(bytes));if result.err!=nil{fmt.Fprintln(os.Stderr,result.err);os.Exit(1)}}
+}

package/examples/runtime/mygo-web/mygo.config.ts

@@ -0,0 +1,10 @@
+export default {
+  name: "MyGo Web App",
+  identifier: "org.example.apphx.mygo.web.smoke",
+  version: "0.1.0",
+  buildCommand: "bun run build:web",
+  frontendDist: "dist",
+  bindings: "src/mygo.ts",
+  out: "build",
+  macos: { signingIdentity: "-" },
+};

package/examples/runtime/mygo-web/package.json

@@ -0,0 +1 @@
+{"name":"apphx-mygo-web-smoke","private":true,"scripts":{"build:web":"bun build ./src/main.ts --outdir dist && cp index.html dist/index.html"},"dependencies":{"mygo-runtime":"0.3.0"}}