AGENT SKILL

toybox-visual-parity

Proves a built Pocket Arcade screen matches its Toybox design screenshot (light/dark, en/fa) and drives the fixes: capture, element gates, sheets, sign-off. Use when any screen is built or changed, or for visual parity, design match, screenshot compare. Not for building screens (toybox-screens).

License 许可
MIT
最近更新
2026-11-05
Stars
★ 0
Forks
0

01 前言 Front Matter

name
toybox-visual-parity
description
Proves a built Pocket Arcade screen matches its Toybox design screenshot (light/dark, en/fa) and drives the fixes: capture, element gates, sheets, sign-off. Use when any screen is built or changed, or for visual parity, design match, screenshot compare. Not for building screens (toybox-screens).

02 资源文件 500

03 SKILL.md 正文

Toybox visual parity

Makes the owner's rule true: every built screen is compared with its Toybox design screenshot, in light and dark and in English and Persian, and fixed until it matches. Machines check geometry, text, colour, type and shape per element; Claude checks the rest by looking at side-by-side sheets; check-signoff.mjs proves both happened for the current build.

Rules that must hold

  1. No screen is done until it passes parity in light and dark x en and fa (plus de and ckb before a release), at every scroll offset run-parity.mjs plans for a tall screen, against the reference its game's facts pick. That full set is what check-signoff.mjs checks by default; --themes and --langs may narrow a run while fixing, but a narrowed check prints narrowed: not a sign-off and fails. Dark mode and right-to-left are where screens break; one passing variant proves little. The test-only S15 debug menu is no exception: it is a design frame and is signed off like every other screen (its labels stay English in fa, its digits follow the language).
  2. The committed references are the authority. Never edit, re-render or replace anything in assets/reference/, assets/reference-android/, assets/design/, assets/frames.json or assets/device/ to make a screen pass. They change only after the owner (or the lead, for the owner) changes the design on purpose; every such change is an entry in the reference manifest's referenceChanges log, never a waiver, and the report names it.
  3. The game's facts pick the reference; nobody guesses. Three facts, hasMusic, winLine and hasHints, live in parity/game-facts.json, which a test pins to the game module. s11-settings, s6-pause, s7-result-win and s14-reset-all-progress have design-derived variants (no music, the score line, no hint key), and the variants a game's facts match compose (Line Siege: s6-pause--no-music--no-hints). A missing fact or a mismatched facts file stops every script with exit 2; a missing Music row or hint key is never waived.
  4. Never widen a tolerance, add a mask or skip a gate to get a pass. Every number is a measured noise floor (text-ink centres per type role), and the self-test pins both sides of it. What the app truly cannot fix gets a waiver: one element, one rule, its class (platform, platform-text-shaping naming the glyphs, or design-artefact quoting the mockup CSS), the reason, the date the owner was told.
  5. Capture the real app with capture-app.mjs on this session's own parity simulator (an e07-parity[-<key>] iPhone 16 Pro on iOS 26.5, Release test build, launch arguments straight into the frame). Every Maestro call names that simulator's UDID and this run's own driver port (--device <udid> --driver-host-port <port> before the command), every launch carries a nonce the hierarchy dump must contain, and a dump without it stops the capture ("hierarchy from another simulator"). The references are rendered at exactly that device's geometry; any other device, a Debug build, a deep link or a hand-made screenshot compares nothing. On Android (--platform android on run-parity.mjs, capture-app.mjs and check-signoff.mjs) the same holds on this session's own e07-android-parity[-<key>] emulator (402 x 874 dp at 3.0, like the iPhone 16 Pro): every adb call names its serial, the run is judged only against assets/reference-android/ and only by Android waivers and ledger entries ("platform": "android"), and no gate number changes.
  6. Machine gates first, then the look. check-parity.mjs must pass, then Claude reads every sheet image and records the seven eye checks in parity/signoff.json. The gates have tolerances; icons, drawings, shadow feel, wrapping and mirroring need eyes.
  7. Fix the app, one gate at a time, in the printed order: screen reached, scroll, missing, bounds, text, fill, border, text-ink, structure. Read the element's crop before changing code. If the same failure survives three fixes, stop and report it with the sheet.
  8. testIDs exactly as the shared map says, on the accessible element; bounds only for what Maestro can list. The gates key everything by testID, and Maestro's hierarchy is the accessibility tree: it never lists the children of an accessible element or a part hidden from VoiceOver. So the map marks those parts crop-only (parent, or a11yHidden for decorative art the components hide) with checks: ["crop"] and a coveredBy ancestor whose aligned crop judges their pixels; they are never reported missing. The root testID sits on the screen's outer view. Never un-hide a decorative part to make it measurable: VoiceOver comes first.
  9. The parity harness is the shipped templates, test-only. Copy templates/packages/shell/src/app/parity/ and parity-startup.tsx; never hand-write the fixture, the ports or the startup (a hand-written fixture kept Premium on across frames). It is reached only through TEST_ONLY, so store builds never contain it. Each frame state is opened by the model hook that owns it, motion freezes through the one isParityMotionFrozen() switch that useReduceMotion() honours, and the Game frames draw the design's numbers (parityGameFixture()) with the game's own board masked; check-harness.mjs proves all of it is complete, wired and unchanged.
  10. Pixel identity is never promised. Anti-aliasing and 1/3 pt rounding always differ; the whole-screen difference is printed for information and never decides anything.

Workflow

  1. Tooling, once per session. The scripts load pngjs, pixelmatch and playwright from a tooling folder (exact pins, no browser download: the installed Google Chrome renders). By default that is the skill's own scripts/ (npm ci --prefix ${CLAUDE_SKILL_DIR}/scripts). When the skill folder must stay read-only or other sessions share it, install into the app repo instead: mkdir -p .parity/tooling && cp ${CLAUDE_SKILL_DIR}/scripts/package.json ${CLAUDE_SKILL_DIR}/scripts/package-lock.json .parity/tooling/ && npm ci --prefix .parity/tooling, then pass --tooling .parity/tooling to every script, selftest.mjs and check-testids.mjs included (or export PARITY_TOOLING_DIR=$PWD/.parity/tooling). Every script writes only into the app repo (.parity/, parity/, reports/); only shoot-design.mjs --update-reference writes into the skill, after a design change. Run node ${CLAUDE_SKILL_DIR}/scripts/selftest.mjs --tooling .parity/tooling (no option when the packages are in the skill); it checks the folder before any case, and anything but RESULT: PASS means the tooling is broken, so stop and report. Then node ${CLAUDE_SKILL_DIR}/scripts/setup-parity-sim.mjs --appearance light --name e07-parity-<key> (it prints the UDID; read references/simulator-and-capture.md if it fails). For Android captures run node ${CLAUDE_SKILL_DIR}/scripts/setup-parity-emu.mjs --appearance light --name e07-android-parity-<key> instead (it prints the serial; --check changes nothing; it never downloads the system image) and read that reference's Android section.
  2. The harness, once per app repo. Read references/parity-harness.md. Copy templates/packages/shell/src/app/parity/ (with its tests), templates/packages/shell/src/app/parity-startup.tsx (+ test) and templates/parity/ (pre-listed waivers, an empty ledger, the game facts) into the repo, and templates/apps/__GAME_ID__/src/parity-game-facts.test.ts into every game app with PARITY_GAME_FACTS set to that app's entry of parity/game-facts.json (Line Siege: hasMusic: false, winLine: "score", hasHints: false); copy templates/packages/shell/src/app/parity-launch-marker.tsx and parity-marker.tsx (ParityMarker({ testID, label }), the centred invisible element the launch and scroll markers both draw), each with its test, which the parity root and the ModalLayer (the layer the consent cover, the dialogs, Pause and Result are drawn in) render, once per layer: the Scrim and the Result overlay inside it draw none of their own; make sure packages/shell/src/app/test-only-entry.ts and test-only-api.ts are this skill's templates/packages/shell/src/app/ copies (the one shared entry and TestOnlyApi, which already export the harness members, each tagged /** @public */; ios-simulator-build ships the same bytes); make sure start-shell calls readParityLaunch() and passes parityLaunchFor(...) to createShellApp (the rtl-and-direction template does; the composition root then runs the launch's steps in order); add .parity/ to .gitignore. For Android also copy templates/packages/shell/android/ and templates/packages/shell/src/app/parity-startup.android.test.tsx (it runs in the Android Jest project) and register io.applander.shell.ParityLaunchModule under android.modules in packages/shell/expo-module.config.json (check-harness.mjs rule harness-android-launch). Run npx jest packages/shell/src/app/parity packages/shell/src/app/parity-startup.test.tsx apps/<id>/src/parity-game-facts.test.ts --ci --selectProjects unit --coverage --collectCoverageFrom='packages/shell/src/app/parity/**/*.ts' --coverageThreshold='{}', then node ${CLAUDE_SKILL_DIR}/scripts/check-harness.mjs . until it passes (it also proves every frame state has its opener, the frozen-motion switch, the board probe and the consent hold are wired, the launch marker is drawn by the parity root and inside every modal root, every ScreenBody draws the scroll offset it reached, the facts are pinned, and component-specs.json draws the edge widths the references draw; rules for screens outside shell-slice.json print SKIP lines). In a partial Shell the harness is Shell core, because startup reads it: packages/shell/src/app/parity/ and parity-startup.tsx (with their tests) are in every Shell app whatever the slice; only the frame states of screens outside the slice wait.
  3. Before building or changing a screen, read its references: assets/reference/lineSiege/light-en/<frame>.png and dark-fa/<frame>.png (for S6, S7 win, S11 and the S14 reset dialog the variant the game's facts pick, for example s6-pause--no-music--no-hints.png), the frame's state in assets/frames.json, and its testIDs with node ${CLAUDE_SKILL_DIR}/scripts/check-testids.mjs --list <S4>. references/design-reference-set.md lists every frame and variant, its kind (phone, tall, state card) and what is masked.
  4. Build and install the Release test build on the parity simulator (the ios-simulator-build skill). After a JavaScript-only change the bundle swap in references/simulator-and-capture.md takes seconds.
  5. Run the machine side: node ${CLAUDE_SKILL_DIR}/scripts/run-parity.mjs --screen <S4> --bundle-id io.applander.linesiege --name e07-parity-<key> (every app's id is io.applander.<game id without hyphens>; read CFBundleIdentifier from the built app's Info.plist to be sure; test and store builds share it). It captures every frame of the screen in light and dark x en and fa (a tall frame at the scroll offsets that show each element whole once), checks each run and draws its sheets. It prints the reference each frame uses (the facts file picks variants), and a Game-route frame (S5 to S7) first launches once with probe=board to read and mask the game's own board. Each run takes about 10 to 20 s (launch, still screen, Maestro dump, check, sheets), so a whole screen (S12: 36 runs) can outlast a 2-minute command timeout: run it in the background or with the longest timeout, and narrow with --frame, --themes, --langs while fixing (never for the sign-off). Each session uses its own simulator (--name); run-parity.mjs picks a free Maestro driver port for its run unless --driver-port is given, and every run.json records the UDID, the port and the launch nonces (references/simulator-and-capture.md). When the session is done, shut down its simulator by UDID (xcrun simctl shutdown <udid>), never another one. On Android add --platform android and pass the emulator's AVD as --name (runs go to .parity/android/, against assets/reference-android/); stop your own emulator with adb -s <serial> emu kill.
  6. On FAIL, read references/failure-messages.md for the rule, open crops/<testID>.png in the run folder, the reference .layout.json for the design's exact style, and for a gap or pad inside an element the mockup CSS in assets/design/toybox.html (the layout has boxes, not internal gaps). Fix the first failing rule of each run in the app code, rebuild, run step 5 again. To re-check one existing run without capturing again (a waiver added, a reference fixed by the owner), run node ${CLAUDE_SKILL_DIR}/scripts/check-parity.mjs <run-dir> and then node ${CLAUDE_SKILL_DIR}/scripts/make-sheet.mjs <run-dir>, which redraws its sheets for the look pass. references/what-exact-means.md explains every gate and its numbers.
  7. On PASS, look. Follow references/signoff-and-waivers.md: read sheet.png, every zoom-*.png and every eye-*.png of every run, answer the seven eye checks, and fix every visible difference (then step 5 again). A difference the app cannot fix becomes a waiver in parity/waivers.json (its class and why), reported to the owner; the known ones (dashed edges, S9's tilted month in dark fa, S8 tile 13 mid-press, the S11b chip gap, the S14 restart card in fa) are pre-listed in templates/parity/waivers.json. A commit that changes parity/waivers.json or parity/game-facts.json carries a Gate-Change: trailer.
  8. Record and prove. For each run, node ${CLAUDE_SKILL_DIR}/scripts/check-signoff.mjs --draft <run-dir> prints the ledger entry, dated with today's local day (after a rebuild add --from-ledger to carry the recorded differences over; the eye checks open again); add it to parity/signoff.json with the answers and differences. Then run check-signoff.mjs --screen <S4> (with --platform android for the Android runs) until it prints RESULT: PASS. examples/worked-loop-s4-home.md shows the whole loop; examples/worked-loop-s8-levels.md adds a frame state, Persian digits and pre-listed waivers.
  9. Report per frame: the reference used (base or variant), the variants that pass, what was checked by eye, every waiver with its class and reason, every intended reference change check-signoff.mjs printed, open questions (every design artefact is one), and the dark fa sheet.png.
  10. Only when the owner (or the lead) changed the design: add the entry to referenceChanges in assets/reference/lineSiege/manifest.json (design-reference-set.md, last section), then import-design.mjs <new mockup>, check-testids.mjs and a full shoot-design.mjs --check: a change that does not reach the set (a design pass that adds a game) passes with a note and moves no reference; one that does reach it shows as reference-drift, and only then shoot-design.mjs --update-reference once, --check again, and say in the report that the references changed. For games or languages outside the committed set, render references with shoot-design.mjs --out .parity/design and pass --reference .parity/design.

Definition of done

  • [ ] node ${CLAUDE_SKILL_DIR}/scripts/check-harness.mjs . prints RESULT: PASS (the harness is the complete templates, wired into the startup, knows every frame, loads the fixture unchanged and stays test-only; every frame state of the slice has its opener; a parity launch clears the saved debug flags; motion freezes, the board probe and the consent hold are wired; parity/game-facts.json is pinned by each app's facts test; the component specs draw the reference edge widths).
  • [ ] run-parity.mjs passed every frame of the screen in light and dark x en and fa (never a narrowed set), at every scroll offset it plans for a tall frame, against the reference the game's facts select (composed variants included), on this session's own simulator, with no tolerance, mask or reference changed.
  • [ ] Every sheet image of every run was read; parity/signoff.json has an entry for each run's current sheet with all seven eye checks answered and no open difference.
  • [ ] Every waiver names one element, one rule and its class, gives the platform reason (the glyphs for text shaping, the mockup CSS for a design artefact) and the owner-report date, and is in the report with any design question.
  • [ ] node ${CLAUDE_SKILL_DIR}/scripts/check-signoff.mjs --screen <S4> prints RESULT: PASS

Anti-patterns

  • Judging a screen by one whole-screen pixel percentage or SSIM. Correct builds score 0.13 to 0.51 %, a wrong colour or a 1 pt shift scores the same; only the per-element gates and the look decide.
  • Regenerating the references, adding a mask or loosening a number after a failure. That turns the check into a mirror of the app. Fix the app; ask the owner if the design itself seems wrong.
  • A screenshot from the everyday simulator, a Debug build, a deep link or manual navigation. Wrong geometry, dev overlays, an "Open in ...?" alert, a state that is almost right; use capture-app.mjs (or run-parity.mjs).
  • The testID on the inner Text of a button. Maestro lists only the Pressable, so the element is missing; put it on the accessible element.
  • Removing accessibilityElementsHidden from a logo or icon tile so Maestro lists it. VoiceOver would then read decoration; the map already judges hidden parts by their cover's crop (check-testids.mjs --list S4 shows each part's coveredBy).
  • Signing off after reading only sheet.png. Icons, radii and shadows show in the zoom bands and eye pages; the ledger demands every image.
  • A waiver for "close enough". A waiver is for what iOS or React Native cannot draw; anything else is a fix.
  • A parity-only layout. The harness sets state (data, clock, dialogs, scroll); it never draws something the real screen would not, and never shows a copy of the design.
  • Fixing several rules at once. A wrong padding moves everything below it; fix the first failing element from the top, then re-run.
  • Hand-writing the harness or retyping the fixture. A session that did so spent seven files, guessed the save mapping, typed a price the premium checker refuses and kept Premium on across frames; copy the templates and call the six startup steps.
  • Nudging glyphs to pass text-ink. A per-size translate or padding breaks the text boxes that now match to the pixel; the gate already allows each type role its measured CoreText offset. Rule out a type-role mismatch first (the run's font in the layout).
  • Copying the design PNG in as app.png. check-signoff.mjs refuses it (not-a-capture), and it proves nothing.
  • Waiving the Music rows, the hint key or the moves line of a game that does not have them. The references have variants for that; fix parity/game-facts.json (its test pins it to the module) and capture again.
  • Signing off a narrowed set. --themes light --langs en is for iteration; check-signoff.mjs fails it (narrowed). The done set is light and dark x en and fa.
  • Sharing a simulator or a driver port with another session, or simctl ... booted. A hierarchy dump can then come from the other session's simulator; name your own simulator, let the scripts pick a free port, and trust the nonce check.
  • Hand-drawing or hand-editing a reference variant. Variants are derived from the rendered mockup by shoot-design.mjs (frames.json derive); a hand-made one is a mirror of the app.
  • A parity-only branch to stop a loop. Every capture freezes motion through isParityMotionFrozen(); a loop that still moves ignores useReduceMotion(), so route it through the hook.

Files in this skill

File What it is Read/run when
references/what-exact-means.md The gates, their measured tolerances, what only a look proves Workflow step 6; when a tolerance seems wrong
references/simulator-and-capture.md Parity device, simulator setup, status bar, launch arguments, screenshots, Maestro hierarchy, bundle swap Workflow steps 1 and 4; capture problems
references/design-reference-set.md How references are rendered, the 32 frames, masks, fixture values, when references may change Workflow steps 3 and 10
references/parity-harness.md The app side: the -parity contract, harness steps, frame plans, testID rules, wiring Workflow step 2; a frame not reached
references/signoff-and-waivers.md Reading the sheets, the ledger and waiver formats, the owner report Workflow steps 7 to 9
references/failure-messages.md Every rule id of every script: meaning, real cause, fix Any FAIL line
templates/packages/shell/src/app/parity/ Harness: plans, request parser and reader, fixture (JSON + loader), parityDoc, session, ads port, purchase port, start state, error view, root contexts, the scroll marker every ScreenBody draws (parity.scroll.<y>, the measured scroll); each with its test Workflow step 2 (copy)
templates/packages/shell/src/app/parity-startup.tsx The Shell's startup side: readParityLaunch, parityLaunchFor (the composition root's ShellLaunch), the held splash and the five steps it bundles Workflow step 2 (copy, then call)
templates/packages/shell/src/app/parity-startup.test.tsx Its test: normal, error and frame launches, data, ports, first route, root Workflow step 2 (copy)
templates/packages/shell/src/app/parity-startup.android.test.tsx The Android launch path's test (runs in the Android Jest project): the parity intent extra opens the frame Workflow step 2 (copy once the Android Jest project exists)
templates/packages/shell/android/src/main/java/io/applander/shell/ParityLaunchModule.kt The Expo module ParityLaunch that hands the launch intent's parity extra to the harness; register it in packages/shell/expo-module.config.json Workflow step 2 (copy, for Android)
templates/packages/shell/src/app/parity-launch-marker.tsx ParityLaunchMarker and its context: the invisible parity.launch.<nonce> element the parity root and the ModalLayer's layer draw in a capture (nothing otherwise) Workflow step 2 (copy; the parity root and ModalLayer render it)
templates/packages/shell/src/app/parity-launch-marker.test.tsx Its test Workflow step 2 (copy)
templates/packages/shell/src/app/parity-marker.tsx ParityMarker({ testID, label }): the invisible 1 x 1 pt accessible element in the middle of its parent (clear of Android's system bars) that ParityLaunchMarker and app/parity/parity-scroll-marker.tsx draw Workflow step 2 (copy)
templates/packages/shell/src/app/parity-marker.test.tsx Its test Workflow step 2 (copy)
templates/parity/ For the app repo's parity/: waivers.json with the pre-listed waivers (dashed edges of S7, S8, S9 and the disabled S12 key, S9's tilted month, S8 tile 13, the S11b chip gap, the S14 restart card in fa), an empty signoff.json, game-facts.json (the pilot's facts) Workflow step 2 (copy)
templates/apps/__GAME_ID__/src/parity-game-facts.test.ts Pins the app's game facts to its module through hasMusicOf, isScoreRatedOf and hasHintsOf Workflow step 2 (copy into every game app)
templates/packages/shell/src/app/test-only-entry.ts The one test-only entry (debug kit and harness exports, each @public, plus the sentinel); synced from the library, do not edit here Workflow step 2 (copy when the repo's copy lacks the harness)
templates/packages/shell/src/app/test-only-api.ts TestOnlyApi, the type of TEST_ONLY with the debug kit and harness members; synced from the library, do not edit here Workflow step 2 (copy with the entry)
examples/worked-loop-s4-home.md The whole loop for S4 Home, with real outputs First time through the loop
examples/worked-loop-s8-levels.md S8 in en and fa: a hook-opened frame state, frozen motion, Persian level numbers, pre-listed waivers A screen with a frame state or pre-listed waivers
scripts/run-parity.mjs Capture, check and sheet for every frame x theme x language of a screen Workflow step 5
scripts/capture-app.mjs One capture: launch into the frame, still screenshot, Maestro bounds, run.json Called by run-parity; alone to re-capture one run
scripts/check-parity.mjs The per-element gates; writes report.json Called by run-parity; alone to re-check
scripts/make-sheet.mjs sheet.png, zoom bands, failing-element crops, eye-check pages Called by run-parity; alone after a re-check
scripts/check-signoff.mjs Definition of done per screen; --draft prints a ledger entry Workflow step 8
scripts/check-harness.mjs Checks the app's parity harness (complete, wired, fixture unchanged, no typed price), the component edge widths, .gitignore, waiver and ledger files Workflow step 2 and before sign-off
scripts/setup-parity-sim.mjs Creates, boots and pins this session's parity simulator (--name e07-parity-<key>); --check Workflow step 1
scripts/setup-parity-emu.mjs Creates, boots and pins this session's Android parity emulator (--name e07-android-parity-<key>, prints the serial); --check Workflow step 1 (Android)
scripts/shoot-design.mjs Renders references (--out, --update-reference) or proves them current (--check) Workflow step 10
scripts/import-design.mjs Makes or checks the offline design copy from a new mockup Workflow step 10
scripts/check-testids.mjs Checks the shared testID map against the design; --list <S4> prints a screen's testIDs Workflow steps 3 and 10 (shared, synced)
scripts/selftest.mjs Proves every script on good and planted-defect fixtures Workflow step 1; after changing a script
scripts/lib/ Gates (with the type-role floors and the board mask), component edge widths, rendering (with variant derives), frames, facts and variants, runs, waivers and pre-listed waivers, the reference-change log, hierarchy parsing, PNG helpers, tool lookup, the platforms and the Android tools (adb by serial, emulator, avdmanager, demo mode) Never directly
scripts/check-lib.mjs Shared script helper, synced from the library (do not edit here) Never by hand
scripts/package.json Exact pins: pngjs 7.0.0, pixelmatch 7.2.0, playwright 1.63.0 Workflow step 1 (npm ci --prefix, into the skill or a --tooling folder)
scripts/package-lock.json Lockfile for npm ci Never by hand
scripts/.gitignore Keeps scripts/node_modules/ out of git Never
assets/reference/ The committed reference set: lineSiege x light, dark x en, fa, 32 frames and 6 variants, PNG + layout.json + manifest.json (with the referenceChanges log) Workflow steps 3 and 6 (read)
assets/design/toybox.html Offline copy of the Toybox mockup (local fonts) the references are rendered from Read by the scripts
assets/design/fonts/ The TTFs the app bundles, OFL texts, SOURCES.md (shared, synced) Read by the design copy
assets/frames.json Per frame: root testID, the app state it draws, settle time, reference variants (when, derive, scope), the board or picture a frame masks, sample fixes and design masks; the design's facts; the fixture values, and fixtureSave (the same player as save sections, with gameFrame) Workflow steps 2 and 3
assets/screen-testids.json The shared testID map: every element of every frame (shared, synced) Workflow step 3
assets/toybox-tokens.json The shared Toybox token file (synced): its color.games, each with its logo layers in logos.games, are the design games every script accepts Read by the scripts; a new game joins through its design pass
assets/device/iphone16pro.json Parity device: geometry, safe areas, masks, simulator name, locales, status bar Read by the scripts
assets/device/android-phone.json Android parity device: AVD e07-android-parity, system image, 402 x 874 dp at 3.0 (hw.lcd.*), status and gesture-bar insets and masks, app locales, demo-mode status bar Read by the scripts with --platform android
assets/reference-android/ The Android reference set: the same 32 frames and 6 variants x light, dark x en, fa, rendered at the Android profile's geometry; its manifest says "platform": "android" Workflow steps 3 and 6 on Android (read)
assets/shared.json Declares the shared files this skill copies in When adding a shared file
tests/fixtures/ Good and planted-defect inputs for every script, fake xcrun, maestro, adb, emulator and avdmanager When changing a script

Related skills

  • toybox-screens - builds the S1 to S15 layouts this skill checks.
  • toybox-components - the components whose testIDs and parts the gates measure.
  • toybox-design-system - tokens and fonts; a fill or text-ink failure usually points there.
  • code-drawn-art-and-icons - icons and pictures the eye checks look at.
  • rtl-and-direction - mirroring rules behind the direction eye check.
  • ios-simulator-build - the Release test build that is captured.
  • e2e-maestro - installing Maestro and Java 17.
  • architecture-and-boundaries - the test-only gate the harness hides behind.

04 同仓库更多 Skills

zakariaf
zakariaf/pocket-arcade

unit-and-component-tests

Sets up Jest and writes Pocket Arcade test code - three projects, RNTL 14 async via renderWithShell, root SDK mocks, fakes, fast-check, coverage, Stryker. Use when a test needs the Shell wrapper, a mock or a fake, or Jest fails. Not for the red-green loop (tdd-workflow) or goldens (golden-tests).

★ 0
zakariaf
zakariaf/pocket-arcade

typescript-and-lint-rules

Enforces Pocket Arcade's strict TypeScript 6 tsconfigs, ESLint 9 flat config, Prettier and size limits. Use when writing or splitting .ts/.tsx or fixing a tsc or lint error. Not for gate wiring (quality-gates), names (naming-conventions) or import zones (architecture-and-boundaries).

★ 0
zakariaf
zakariaf/pocket-arcade

demo-skill

Builds a demo. Use when testing the pitfall checker.

★ 0
zakariaf
zakariaf/pocket-arcade

demo-skill

Builds a demo. Use when testing the pitfall checker.

★ 0
zakariaf
zakariaf/pocket-arcade

troubleshooting-playbook

Diagnoses and fixes Pocket Arcade failures with a catalogue of 300+ known ones (symptom, cause, fix). Use when something errors, crashes, hangs or renders wrong, or an error or log needs explaining. Not for gate setup (quality-gates) or running builds (ios-simulator-build, ios-release-testflight).

★ 0
zakariaf
zakariaf/pocket-arcade

toybox-screens

Builds Pocket Arcade screens S1-S15 to their Toybox specs: layout, spacing, the exact screen-map testIDs, copy keys, every state, banner slots, reference images. Use when building or changing a screen, overlay or dialog. Not for components (toybox-components) or pixel compare (toybox-visual-parity).

★ 0