@keepsnappy/agent 0.0.0-stage → 0.1.0-alpha.12

package/examples/farm/flows/perflab/begin-run.yaml

@@ -0,0 +1,17 @@
+# Takes the next run token of JOURNEY and activates the dormant SDK with it. Activation applies from the next app
+# launch, so the journey's own launchApp starts the measured process (plan 36 §1.2).
+appId: com.gigaverse.appdev
+---
+- runScript:
+    file: next-token.js
+    env:
+      JOURNEY: ${JOURNEY}
+- launchApp
+- runScript: ../../elements/home.js
+- extendedWaitUntil:
+    visible:
+      id: ${output.elements.home.screen}
+    timeout: 30000
+# The settings come from tokens.js (`keepsnappy farm open`): the run defaults, never written by hand here (REQ-FARM-28).
+- openLink: gigaversedev://devtools/perf-lab?activate=1&${output.perflabLinkArgs}&runToken=${output.perflabToken}
+- runFlow: ../../subflows/confirm-open-link.yaml

package/examples/farm/flows/perflab/end-run.yaml

@@ -0,0 +1,16 @@
+# End of one measured iteration: the SDK sends everything still unsent (nothing is sent while a run is active), then
+# shows `perflab.flushed` (ok | error | off). `activate=0` makes the next launch dormant again.
+appId: com.gigaverse.appdev
+---
+- runScript: send-markers.js   # the iteration's step markers, recorded by step.js, sent now that it has ended
+- openLink: gigaversedev://devtools/perf-lab?flush=1&activate=0
+- runFlow: ../../subflows/confirm-open-link.yaml
+- extendedWaitUntil:
+    visible:
+      id: perflab.flushed
+    timeout: 60000
+    optional: true   # a dormant iteration (activation failed) shows nothing; farm close marks it invalid
+- assertVisible:
+    id: perflab.flushed
+    text: ok
+    optional: true

package/examples/farm/flows/perflab/next-token.js

@@ -0,0 +1,7 @@
+// Hands out the run tokens of one journey in order: iteration i of JOURNEY gets output.perflabTokens[JOURNEY][i].
+// ES5 (Maestro runScript). An empty token (more iterations than tokens) leaves the SDK dormant: no data, no harm.
+var list = (output.perflabTokens || {})[JOURNEY] || [];
+output.perflabIdx = output.perflabIdx || {};
+var i = output.perflabIdx[JOURNEY] || 0;
+output.perflabToken = list[i] || '';
+output.perflabIdx[JOURNEY] = i + 1;

package/examples/farm/flows/perflab/run-perflab.yaml

@@ -0,0 +1,15 @@
+# e2e/flows/perflab/run-perflab.yaml (plan 36 D10). One BrowserStack session runs every iteration: the session is the
+# noise block. Untagged, so smoke/regression never select it; the dispatcher names it with --execute.
+# `times` must equal `keepsnappy farm open --repeat`. One begin/journey/end triple per journey listed in --journeys.
+appId: com.gigaverse.appdev
+onFlowComplete:
+  - runScript: send-markers.js          # a failed iteration never reaches end-run.yaml: its step markers go from here
+---
+- runFlow: ../suite/login.yaml          # clearState: the SDK starts dormant
+- runScript: tokens.js                  # generated by `keepsnappy farm open`, overlaid into the zip (--suite-overlay)
+- repeat:
+    times: 5
+    commands:
+      - runFlow: { file: begin-run.yaml, env: { JOURNEY: e2e-community-and-live-chat } }
+      - runFlow: ../chat/e2e-community-and-live-chat.yaml   # its own launchApp starts the measured process
+      - runFlow: end-run.yaml

package/examples/farm/flows/perflab/send-markers.js

@@ -0,0 +1,123 @@
+// Posts the step markers step.js recorded during the iteration, after it ended (end-run.yaml), so sending them never
+// changes the test's pace. Farm mode only: POST <api>/v1/markers with the marker's own run token as Bearer (local mode
+// posts at once from step.js). ES5 only (older Maestro builds run Rhino). Must not throw.
+// One request per token carries all its markers ({markers: [...]}, at most 500 each), so a long journey stays far
+// under the API's per-run rate limit; a request that fails on the network, 429 or 5xx is tried 3 times (Retry-After
+// honoured, else 1 s then 2 s). An API from before batches answers 400 without per-item results: the markers then go
+// one by one, as they used to.
+// Clock round trips (plan 51 G1.4): each answer carries the API's receive/send times; that trip rides with the next
+// request of the same token, and what is left goes to <api>/v1/clock at the end, as a short chain of CLOCK_PROBES
+// requests whose answers are trips too, so a token still reports several round trips although its markers now go in
+// one request. A trip whose POST failed or came back without a clock (an older API) stays pending, so nothing
+// measured is dropped.
+try {
+  var g = typeof globalThis !== 'undefined' ? globalThis : this;
+  var pick = function (name, dflt) {
+    var names = [name, 'MAESTRO_' + name];
+    for (var i = 0; i < names.length; i++) {
+      var v = g[names[i]];
+      if (typeof v === 'string' && (v !== '' || names[i].indexOf('KEEPSNAPPY_') >= 0)) return v;
+    }
+    return dflt;
+  };
+  var MAX_SAMPLES = 16;
+  var PER_REQUEST = 500;
+  var TRIES = 3;
+  var RETRY_CAP_MS = 30000;
+  var CLOCK_PROBES = 4;
+  var out = typeof output !== 'undefined' && output ? output : {};
+  var list = out.perflabMarkers || [];
+  out.perflabMarkers = [];
+  var api = pick('KEEPSNAPPY_API_URL', typeof out.perflabApi === 'string' ? out.perflabApi : '').replace(/\/+$/, '');
+  var wait = function (ms) {
+    try {
+      java.lang.Thread.sleep(ms);
+      return;
+    } catch (e0) {
+      // no Java bridge: wait on the clock
+    }
+    var until = Date.now() + ms;
+    while (Date.now() < until) {
+      // nothing
+    }
+  };
+  var header = function (res, name) {
+    var h = res && res.headers;
+    if (!h) return null;
+    var v = h[name] !== undefined ? h[name] : h[name.toLowerCase()];
+    return v === undefined || v === null ? null : String(v);
+  };
+  // One POST: the answer's status and parsed body, the clock trip when the answer has one; null when it threw.
+  var postOnce = function (path, token, body) {
+    var t0 = Date.now();
+    var res = http.post(api + path, {
+      headers: { 'Content-Type': 'application/json', Authorization: 'Bearer ' + token },
+      body: JSON.stringify(body),
+    });
+    var t3 = Date.now();
+    var parsed = null;
+    try {
+      parsed = res && res.body ? JSON.parse(res.body) : null;
+    } catch (e1) {
+      // not JSON
+    }
+    var c = parsed ? parsed.clock : null;
+    var trip = c && typeof c.recv_ms === 'number' && typeof c.send_ms === 'number' ? { t0: t0, t1: c.recv_ms, t2: c.send_ms, t3: t3 } : null;
+    return { status: res && typeof res.status === 'number' ? res.status : null, body: parsed, trip: trip, retryAfter: Number(header(res, 'Retry-After')) };
+  };
+  var postRetry = function (path, token, body) {
+    var a = null;
+    for (var attempt = 0; attempt < TRIES; attempt++) {
+      if (attempt > 0) wait(Math.min(a && a.retryAfter > 0 ? a.retryAfter * 1000 : 1000 * Math.pow(2, attempt - 1), RETRY_CAP_MS));
+      try {
+        a = postOnce(path, token, body);
+      } catch (e2) {
+        a = null;
+      }
+      if (a && a.status !== 429 && !(a.status >= 500)) return a;
+    }
+    return a;
+  };
+  var pending = {};
+  var tokens = [];
+  var byToken = {};
+  for (var k = 0; k < list.length && api !== ''; k++) {
+    var m = list[k];
+    if (!m || typeof m.token !== 'string' || m.token === '') continue;
+    if (!byToken[m.token]) {
+      byToken[m.token] = [];
+      pending[m.token] = [];
+      tokens.push(m.token);
+    }
+    byToken[m.token].push({ step: m.step, phase: m.phase, t_host: m.t_host });
+  }
+  var send = function (token, body) {
+    if (pending[token].length) body.clock = pending[token].slice(-MAX_SAMPLES);
+    var a = postRetry('/v1/markers', token, body);
+    if (a && a.trip) pending[token] = [a.trip];
+    return a;
+  };
+  for (var t = 0; t < tokens.length; t++) {
+    var mine = byToken[tokens[t]];
+    for (var i = 0; i < mine.length; i += PER_REQUEST) {
+      var chunk = mine.slice(i, i + PER_REQUEST);
+      var a = send(tokens[t], { markers: chunk });
+      if (!a || a.status !== 400 || (a.body && a.body.results)) continue;
+      for (var j = 0; j < chunk.length; j++) send(tokens[t], chunk[j]);
+    }
+  }
+  for (var p = 0; p < tokens.length; p++) {
+    for (var n = 0; n < CLOCK_PROBES && pending[tokens[p]].length; n++) {
+      try {
+        var probe = postOnce('/v1/clock', tokens[p], { source: 'host', samples: pending[tokens[p]].slice(-MAX_SAMPLES) });
+        if (!probe.trip) break;
+        pending[tokens[p]] = [probe.trip];
+      } catch (e3) {
+        // an older API has no /v1/clock
+        break;
+      }
+    }
+  }
+} catch (e) {
+  // swallowed on purpose
+}

package/examples/farm/flows/perflab/step-markers.yaml

@@ -0,0 +1,13 @@
+# Declared steps in farm mode (plan 36 M2, G4). Copy apps/agent/maestro/perflab/step.yaml and step.js next to this file
+# (e2e/flows/perflab/); send-markers.js is already here, the same file as maestro/perflab/send-markers.js. In farm mode
+# step.js only records the marker with the iteration's token (`output.perflabToken`, taken by begin-run.yaml); send-markers.js in end-run.yaml posts them to
+# <output.perflabApi>/v1/markers once the iteration ended, so the test never waits on the network between actions and
+# no CLI listens on the farm host. Without send-markers.js in end-run.yaml no farm marker is ever sent.
+# A journey that failed half-way drops out of the statistics because it never posted its set's completion marker and
+# `keepsnappy farm close` marks it invalid. Its step markers still reach KeepSnappy: run-perflab.yaml sends what is left from
+# onFlowComplete, for diagnosis. Inside the journey, around the part to measure:
+appId: com.gigaverse.appdev
+---
+- runFlow: { file: ../perflab/step.yaml, env: { STEP: chat.open, PHASE: start } }
+- tapOn: { id: chat-open }
+- runFlow: { file: ../perflab/step.yaml, env: { STEP: chat.open, PHASE: end } }

package/examples/farm/flows/perflab/tokens.js

@@ -0,0 +1,2 @@
+// Replaced by `perflab farm open` for one upload. Never commit real tokens.
+output.perflabTokens = {};

package/examples/farm/workflows/perf-device-run.fragment.yml

@@ -0,0 +1,22 @@
+# Fragment for .github/workflows/perf-device-run.yml (plan 36 D7): KeepSnappy takes the React profiler's slot, last in the
+# chain, on the same eas:<id> the baseline and gigaload measured. Add `perflab` to the `prepare` options parsing
+# (perflab=on|off, on by default; refuse baseline=off gigaload=off perflab=off) and its output, then this job:
+
+jobs:
+  # Last, in the slot the React profiler was built for: the same eas:<id> the baseline and gigaload measured, one
+  # BrowserStack session, no tunnel, no load fleet. It runs whatever the perf jobs concluded and never fails the night
+  # on a KeepSnappy result (exit 1 only when nothing could be judged).
+  perflab:
+    needs: [prepare, baseline-report, gigaload]
+    if: >-
+      always() && !cancelled() && needs.prepare.result == 'success'
+      && needs.prepare.outputs.perflab == 'on'
+      && needs.prepare.outputs.drive == 'device'
+      && inputs.platform == 'ios'
+    uses: ./.github/workflows/perflab-measure.yml
+    secrets: inherit
+    with:
+      platform: ${{ inputs.platform }}
+      device: ${{ needs.prepare.outputs.device }}
+      app: ${{ needs.prepare.outputs.app }}
+      maestro: ${{ needs.prepare.outputs.maestro }}

package/examples/farm/workflows/perflab-measure.yml

@@ -0,0 +1,117 @@
+# .github/workflows/perflab-measure.yml (plan 36 D8): KeepSnappy on BrowserStack, called last in perf-device-run.yml.
+#
+# The CLI never touches the device. `farm open` makes the run set and one KeepSnappy run per journey per iteration, and
+# writes their run tokens into perflab-tokens.js. BrowserStack caps env values at 100 characters, so the tokens ride
+# inside the uploaded suite: browserstack-run.mjs --suite-overlay writes that file to e2e/flows/perflab/tokens.js for
+# this one upload. The app, activated per iteration with its token, pushes its windows to the KeepSnappy API itself.
+# `farm close` waits until no batch has arrived for --settle-seconds, finishes every run (the one a failed session
+# broke is marked invalid; iterations that never ran show as "no data"), closes the set and prints the verdict.
+#
+# Exit codes of `keepsnappy farm close`: 0 for any result (also "More work"), 1 when nothing could be judged (Blocked: no
+# iteration sent data) or the API failed, 2 for a configuration problem, 3 with --fail-on-worse on "More work".
+# Re-running close is safe: finished runs are left alone and the same result is printed again.
+#
+# Files in $OUT_DIR after the job (uploaded below): perflab-farm.json (state: run set, runs, result; no tokens),
+# perflab-result.json, browserstack.ios.json. perflab-tokens.js holds live run tokens (valid for hours): close puts the
+# empty stub back even when it fails, and the job deletes the file before the upload whatever happened.
+
+name: KeepSnappy measure (reusable)
+
+on:
+  workflow_call:
+    inputs:
+      platform: { type: string, required: true }
+      device: { type: string, default: '' }
+      app: { type: string, required: true }        # eas:<id> resolved once by perf-device-run's prepare
+      maestro: { type: string, default: '2.6.1' }
+
+permissions:
+  contents: read
+
+jobs:
+  measure:
+    runs-on: ubuntu-latest
+    timeout-minutes: 120
+    env:
+      BROWSERSTACK_USERNAME: ${{ secrets.BROWSERSTACK_USERNAME }}
+      BROWSERSTACK_ACCESS_KEY: ${{ secrets.BROWSERSTACK_ACCESS_KEY }}
+      KEEPSNAPPY_KEY: ${{ secrets.KEEPSNAPPY_KEY }}                  # run scope; never leaves this runner
+      KEEPSNAPPY_API: https://perflab-api-864539138788.europe-west1.run.app
+      KEEPSNAPPY_CLI: '@keepsnappy/agent@0.1.0-alpha.1'           # first version with `farm` (not published yet)
+      OUT_DIR: ${{ github.workspace }}/farm-run
+      RUN_ID: perflab-${{ inputs.platform }}-${{ github.run_id }}-${{ github.run_attempt }}
+      JOURNEYS: e2e-community-and-live-chat                    # = the JOURNEY values in run-perflab.yaml
+      REPEAT: '5'                                              # = repeat.times in run-perflab.yaml
+    steps:
+      - uses: actions/checkout@v5
+      - uses: actions/setup-node@v4
+        with:
+          node-version: '22'
+
+      - name: Resolve the app
+        id: app
+        env:
+          EXPO_TOKEN: ${{ secrets.EXPO_TOKEN }}
+          APP_SOURCE: ${{ inputs.app }}
+          PLATFORM: ${{ inputs.platform }}
+        run: |
+          mkdir -p "$OUT_DIR"
+          node scripts/farm/resolve-app.mjs --platform "$PLATFORM" --source "$APP_SOURCE" \
+            --profile e2e --out "$OUT_DIR"
+
+      - name: Wait for a free BrowserStack slot
+        timeout-minutes: 65
+        run: node scripts/farm/preflight.mjs --sessions 1 --wait-minutes 60
+
+      # Masks every run token in this job's log (::add-mask::) and sets the outputs run_set_id, dashboard_url, state,
+      # tokens_js, runs.
+      - name: Open the KeepSnappy run set
+        id: open
+        env:
+          APP_COMMIT: ${{ steps.app.outputs.app_commit }}
+        run: |
+          [ -n "$APP_COMMIT" ] || { echo '::error::the artifact carries no commit'; exit 1; }
+          npx --yes "$KEEPSNAPPY_CLI" farm open \
+            --api "$KEEPSNAPPY_API" --branch main --commit "$APP_COMMIT" \
+            --device-model 'iPhone 15 Pro' --device-os 17 --device-provider browserstack \
+            --journeys "$JOURNEYS" --repeat "$REPEAT" \
+            --tokens-js "$OUT_DIR/perflab-tokens.js" --state "$OUT_DIR/perflab-farm.json"
+
+      - name: Run the KeepSnappy orchestrator on the device
+        id: device
+        continue-on-error: true
+        env:
+          APP: ${{ steps.app.outputs.app }}
+          APP_CUSTOM_ID: ${{ steps.app.outputs.app_custom_id }}
+          DEVICE: ${{ inputs.device || 'iPhone 15 Pro-17' }}
+          MAESTRO: ${{ inputs.maestro }}
+          PLATFORM: ${{ inputs.platform }}
+        run: |
+          args=(--platform "$PLATFORM" --device "$DEVICE" --app "$APP" --run-id "$RUN_ID"
+                --label perflab --maestro-version "$MAESTRO" --out "$OUT_DIR" --timeout-minutes 80
+                --execute flows/perflab/run-perflab.yaml
+                --suite-overlay "flows/perflab/tokens.js:$OUT_DIR/perflab-tokens.js")
+          [ -n "$APP_CUSTOM_ID" ] && args+=(--custom-id "$APP_CUSTOM_ID")
+          node scripts/farm/browserstack-run.mjs "${args[@]}"
+
+      # Runs whatever the device step did: a failed session still closes the set with what arrived. Writes the verdict
+      # and the dashboard link to $GITHUB_STEP_SUMMARY.
+      - name: Close the run set and print the verdict
+        if: always() && hashFiles('farm-run/perflab-farm.json') != ''
+        run: |
+          npx --yes "$KEEPSNAPPY_CLI" farm close \
+            --state "$OUT_DIR/perflab-farm.json" \
+            --bs-build "$OUT_DIR/browserstack.${{ inputs.platform }}.json" --settle-seconds 60 --wait
+
+      # Run tokens never go into the artifact, also when open or close failed half-way.
+      - name: Remove the run tokens
+        if: always()
+        run: rm -f "$OUT_DIR/perflab-tokens.js"
+
+      - name: Upload the run
+        if: always()
+        uses: actions/upload-artifact@v4
+        with:
+          name: perflab-${{ inputs.platform }}-${{ github.run_id }}
+          path: ${{ env.OUT_DIR }}
+          retention-days: 30

package/examples/github-actions.yml

@@ -0,0 +1,77 @@
+# .github/workflows/keepsnappy.yml: measure every pull request against main, and grow main's history on every merge.
+#
+# Needs: a perf build of your app (built with PERFLAB=1, so the KeepSnappy SDK writes its data), Maestro flows, a
+# keepsnappy.yml in the repo root (see examples/keepsnappy.yml), and a project key with `run` scope stored as the repository
+# secret KEEPSNAPPY_KEY. The key never appears in logs; keepsnappy reads it from the environment variable keepsnappy.yml names.
+#
+# What you get: on main, the runs join the history of each journey (one journey per Maestro flow file). On a pull
+# request, each journey is compared with main's recent history; the verdict ("More work", "Less work", "No change",
+# "Not enough data yet") is printed in the log and written to the job summary with a link to the comparison page.
+# The job does not fail on "More work" (no blocking checks for now); add --fail-on-worse to make it exit 3 instead.
+# Exit 2 = configuration problem (keepsnappy.yml, flags), exit 1 = infrastructure (device log, upload).
+
+name: perflab
+
+on:
+  pull_request:
+  push:
+    branches: [main]
+
+concurrency:
+  group: perflab-${{ github.ref }}
+  cancel-in-progress: true
+
+jobs:
+  measure:
+    runs-on: macos-15
+    timeout-minutes: 60
+    steps:
+      - uses: actions/checkout@v4
+
+      # Your own build step. It must produce the simulator .app of the perf build.
+      - name: Build the perf build
+        run: ./scripts/build-perf-simulator.sh   # e.g. expo prebuild + xcodebuild with PERFLAB=1 -> build/MyApp.app
+
+      - name: Boot a simulator and install the app
+        run: |
+          xcrun simctl boot "iPhone 16" || true
+          xcrun simctl bootstatus "iPhone 16" -b
+          xcrun simctl install booted build/MyApp.app
+
+      - name: Install Maestro
+        run: |
+          curl -fsSL "https://get.maestro.mobile.dev" | bash
+          echo "$HOME/.maestro/bin" >> "$GITHUB_PATH"
+
+      - name: Install perflab
+        run: npm install -g @keepsnappy/agent   # the KeepSnappy CLI (`perflab`)
+
+      # perflab picks the branch and commit from the GitHub environment (GITHUB_HEAD_REF on a pull request, else
+      # GITHUB_REF_NAME; GITHUB_SHA). On a pull request GITHUB_SHA is the merge commit, so the head commit is passed.
+      - name: Measure, upload and wait for the verdict
+        env:
+          KEEPSNAPPY_KEY: ${{ secrets.KEEPSNAPPY_KEY }}
+          PR_HEAD_SHA: ${{ github.event.pull_request.head.sha }}
+          PR_BASE_SHA: ${{ github.event.pull_request.base.sha }}
+        run: |
+          args=(run --upload --wait)
+          if [ -n "$PR_HEAD_SHA" ]; then args+=(--commit "$PR_HEAD_SHA" --base-commit "$PR_BASE_SHA"); fi
+          perflab "${args[@]}"
+          # perflab appends the verdict and the dashboard link to $GITHUB_STEP_SUMMARY itself, and writes
+          # perflab-out/perflab-result.json ({run_set_id, dashboard_url, state, summary}) for later steps.
+
+      # When the measuring step failed before a verdict, still point the summary at the dashboard if a run set exists.
+      - name: Link the dashboard
+        if: failure()
+        run: |
+          if [ -f perflab-out/perflab-run.json ]; then
+            echo "KeepSnappy did not finish; runs uploaded so far are on the dashboard (run set $(jq -r '.run_set_id // "none"' perflab-out/perflab-run.json))." >> "$GITHUB_STEP_SUMMARY"
+          fi
+
+      - name: Keep the raw results
+        if: always()
+        uses: actions/upload-artifact@v4
+        with:
+          name: perflab-out
+          path: perflab-out
+          retention-days: 14

package/examples/keepsnappy.yml

@@ -0,0 +1,36 @@
+# keepsnappy.yml: the only file you maintain for KeepSnappy. Run it with `keepsnappy run`.
+
+project:
+  key_env: KEEPSNAPPY_KEY            # NAME of the env var holding the project key (a CI secret), never the key itself
+  ingest_url: https://ingest.example.com   # optional; only used with `keepsnappy run --upload`
+
+app:
+  bundle_id: com.example.app      # the app under test; its perf-lab data is read from the device after every run
+
+platform: ios-sim                 # ios-sim | ios-device
+device: booted                    # simulator UDID or "booted"; required (UDID) for ios-device
+
+repetitions: 10                   # how many times the whole flow set runs
+baseline_branch: main             # the branch your baseline comes from (CI passes --baseline <its out dir>)
+
+flows:
+  runner: maestro                 # maestro: build `maestro test ...` from this file | command: run flows.command
+  maestro_version: 2.6.1          # note only: printed at the start, so a drifting Maestro is visible in logs
+  tags: [perf]                    # maestro --include-tags=perf
+  exclude_tags: [flaky]           # maestro --exclude-tags=flaky
+  paths:                          # files, directories or globs (*, ?, **); default "." when only tags are given
+    - e2e/flows/**/*.yaml
+    # - path: e2e/flows/chat/open.yaml  # one flow file with its dashboard title (else its `name:` / opening comment)
+    #   title: Open the chat
+    #   description: Community screen -> chat sheet, first message visible
+  # command: bun run e2e          # runner: command. Anything that exits 0 on success (Appium, Detox, ...)
+
+steps:
+  rename:                         # stable names in history; keys are window/step names as they appear in metrics.csv
+    "screen:(app)/community/[handle]/(tabs)": community.open
+  pin: [community.open]           # always listed in the summary, even without a change
+
+output:
+  dir: perflab-out                # runs.ndjson, metrics.csv, <run>/ logs, verdict (compare/verdict.json)
+
+timeout_seconds: 600              # per run of the command; optional

package/examples/maestro-steps/e2e-community-and-live-chat.yaml

@@ -0,0 +1,161 @@
+# Gigaverse chat message lifecycle (send -> edit -> delete), with two declared KeepSnappy steps:
+#   chat.open  tap the chat button .. composer visible
+#   chat.send  tap send .. the sent message is visible
+# Copied from gigaverse-mobile-perflab/e2e/flows/chat/e2e-community-and-live-chat.yaml; only the paths to
+# the shared elements/scripts/subflows (sibling checkout) and the four step.yaml calls differ.
+# Run: see README.md in this folder.
+appId: com.gigaverse.appdev
+---
+# Community chat message lifecycle: send → edit → delete, in the community-v2
+# chat sheet. This surface had no V1 equivalent, so nothing was carried over
+# when the screen was rebuilt — it is the largest untested area of the app.
+#
+# Attachments are deliberately out of scope here. Picking an image means the
+# native photo picker, which is its own fragility; the text lifecycle lands
+# first. Worth adding later, because a failed upload resolves rather than
+# rejecting, so the composer drops the image and sends the message without it
+# — silently.
+#
+# Self-cleaning: the message it sends is the message it deletes, so the
+# channel is left as it was found.
+#
+# Prerequisites:
+#   - signed-in platform QA account, member of its platform community
+#   - QA account may edit and delete its own messages (default for an owner)
+
+# Suite gate — abort in ms if the `login` gate failed; undefined (standalone
+# local run) passes.
+- assertTrue:
+    condition: ${output.loginSucceeded !== false}
+    label: Aborted — the login gate failed, no QA session
+- launchApp
+- runScript:
+    file: ../../../../../gigaverse-mobile-perflab/e2e/elements/home.js
+- runScript:
+    file: ../../../../../gigaverse-mobile-perflab/e2e/elements/community.js
+- runScript:
+    file: ../../../../../gigaverse-mobile-perflab/e2e/elements/community-chat.js
+- runScript:
+    file: ../../../../../gigaverse-mobile-perflab/e2e/scripts/generate-test-values.js
+
+- runFlow: ../../../../../gigaverse-mobile-perflab/e2e/subflows/open-qa-community.yaml
+
+# 1) Open the chat sheet. The chat button sits beside the destination bar,
+# not inside it — it is not one of the nav destinations.
+- runFlow:
+    file: ../../maestro/perflab/step.yaml
+    env: { STEP: chat.open, PHASE: start }
+- tapOn:
+    id: ${output.elements.communityChat.open}
+- extendedWaitUntil:
+    visible:
+      id: ${output.elements.communityChat.composerInput}
+    timeout: 30000
+- runFlow:
+    file: ../../maestro/perflab/step.yaml
+    env: { STEP: chat.open, PHASE: end }
+
+# 2) Send a message. Every assertion below pins it by id + text rather than by
+# index: the channel is live and another member's message can land mid-run.
+- tapOn:
+    id: ${output.elements.communityChat.composerInput}
+- waitForAnimationToEnd
+- inputText: ${output.testChatMessage}
+# Assert the text reached the field before sending — Android adb typing races
+# field focus and drops input silently, and an empty send is a no-op that
+# would only surface two steps later as a missing message.
+- extendedWaitUntil:
+    visible:
+      id: ${output.elements.communityChat.composerInput}
+      text: .*${output.testChatMessage}.*
+    timeout: 10000
+- runFlow:
+    file: ../../maestro/perflab/step.yaml
+    env: { STEP: chat.send, PHASE: start }
+- tapOn:
+    id: ${output.elements.communityChat.send}
+- extendedWaitUntil:
+    visible:
+      id: ${output.elements.communityChat.message}
+    timeout: 20000
+- runFlow:
+    file: ../../maestro/perflab/step.yaml
+    env: { STEP: chat.send, PHASE: end }
+- extendedWaitUntil:
+    visible:
+      text: .*${output.testChatMessage}.*
+    timeout: 20000
+    label: chat.send.appears
+
+# 3) Edit it. Long-press opens the actions sheet; Edit puts the composer into
+# editing mode with the draft pre-filled, which is why the erase is required —
+# a focused input never re-selects on tap, so a bare inputText would append.
+#
+# The plain tap before the long-press is what makes this deterministic, and it
+# is not a retry in disguise. Sending does NOT blur the composer, so the
+# keyboard is still up, and the actions sheet will not present while the
+# keyboard is being torn down — measured: the long-press dismisses the keyboard
+# and no sheet appears. Retrying papers over that; removing the precondition
+# ends it. The message row is a Touchable with no onPress, so a short tap on it
+# blurs the composer and does nothing else, and the long-press that follows
+# lands with no keyboard to dismiss.
+- tapOn:
+    text: .*${output.testChatMessage}.*
+- waitForAnimationToEnd:
+    timeout: 3000
+- longPressOn:
+    text: .*${output.testChatMessage}.*
+- extendedWaitUntil:
+    visible:
+      id: ${output.elements.communityChat.actions.edit}
+    timeout: 15000
+    label: chat.actions.long-press-opens
+- tapOn:
+    id: ${output.elements.communityChat.actions.edit}
+- extendedWaitUntil:
+    visible:
+      id: ${output.elements.communityChat.confirmEdit}
+    timeout: 15000
+- tapOn:
+    id: ${output.elements.communityChat.composerInput}
+- eraseText: 50
+- inputText: ${output.testChatMessageEdited}
+- tapOn:
+    id: ${output.elements.communityChat.confirmEdit}
+- extendedWaitUntil:
+    visible:
+      id: ${output.elements.communityChat.message}
+    timeout: 20000
+- extendedWaitUntil:
+    visible:
+      text: .*${output.testChatMessageEdited}.*
+    timeout: 20000
+    label: chat.edit.replaces
+
+# 4) Delete it, and prove it is gone. extendedWaitUntil rather than a bare
+# assertNotVisible: the row leaves on the next Stream event, not on the tap.
+# Same precondition as above: confirming an edit leaves the composer focused.
+- tapOn:
+    text: .*${output.testChatMessageEdited}.*
+- waitForAnimationToEnd:
+    timeout: 3000
+- longPressOn:
+    text: .*${output.testChatMessageEdited}.*
+- extendedWaitUntil:
+    visible:
+      id: ${output.elements.communityChat.actions.delete}
+    timeout: 15000
+- tapOn:
+    id: ${output.elements.communityChat.actions.delete}
+- extendedWaitUntil:
+    visible:
+      id: ${output.elements.communityChat.deleteConfirm}
+    timeout: 15000
+- tapOn:
+    id: ${output.elements.communityChat.deleteConfirm}
+- extendedWaitUntil:
+    notVisible:
+      text: .*${output.testChatMessageEdited}.*
+    timeout: 20000
+    label: chat.delete.removes
+    optional: true