Back to results
Explore the library298 guides total · goals, work & tasks
By goal

Choose what you want to achieve.

By work or interest

Choose a setting you work or spend time in.

By task

Choose the kind of help you want.

Counts show all available guides. Filters combine to narrow your results.

Make life easierWorkflow

Keep game-night scores with corrections and ties

Build a small local score ledger that rejects bad entries, recomputes totals and can undo a correction or reset.

Illustrative resourceNot tool-testedBeginners turning an explicit tabletop scoring rule into an inspectable local scorekeeper
What you’re working towards

A real self-contained HTML ledger for the fixed Pebble Pair sample, with exact turn scores, totals 33/29/27, explicit Edit/Undo, reversible reset and joint winners. A separate source, answer sheet and read-only local harness make the behavior checkable; actual browser checks remain a separate gate.

Download playbook .md

Your choice also saves this guide’s current worked-example checkmarks. Only this browser; no account or sync. View saved guides

Saving needs JavaScript. Reading and downloading this guide does not save it.

Included example · illustrative HTML file

Download the editable local scorekeeper

Self-contained HTML for the fixed three-player, three-round sample; Add, explicit corrections, Undo, cancelable reset and honest ties. No saved history after reload.

Not tool-tested. Review and adapt before using it for a real project.

Source files to work with

Make a start

One step at a time.

5 steps

Start with the synthetic worked example or other non-sensitive inputs. Run one prompt at a time in your chosen AI tool. Replace any bracketed placeholders with the requested material, check each reply, and supply the source or earlier outputs that step needs. Paste them again if the tool lacks that context.

Set up the worked example

Open

Open a fresh text/code-AI chat and a plain-text editor. Use only the fictional sample first. HTML is a page saved as a .html file; JavaScript supplies its controls. A local browser check means you open that saved file on your computer. A VM is a code simulation, not a browser. This scorekeeper forgets scores and Undo history on reload or return through page history, so write down any result you need before leaving.

Add the sample

Replace step 1’s placeholder with all of ‘The starting point’ (Synthetic input), including rules, nine turns and interaction limits; pebble-pair-rules.md and pebble-pair-source.json are the downloadable source. Keep ‘The intended result’ (Illustrative output), pebble-pair-worked-scores.md and the CSV as separate answers. Save the approved contract and independently calculated score sheet as text. For step 2 paste the entire approved contract, including turns. Ask for complete HTML from <!doctype html> through </html>; save only that code as my-pebble-pair.html, without chat fences or a .txt suffix, and reopen it in the editor before checking it. For step 3 explicitly paste the complete reopened HTML, original source and independent score sheet, or attach those exact files if supported; the AI cannot see local files merely because you name them. For step 4 provide that same saved file, expected results and which actual browser/tools are available. The supplied downloadable HTML is a separate comparison edition; a pass on it does not test your generated file. Step 5 is optional: use the separate own-input route for a new synthetic game contract, rather than pretending the sample controls change rules. Return to this sample chat for the original advanced exercise and provide the complete sample rules/turns, exact saved HTML, independent references, test source/results and available tools again. In a new chat, supply that whole set; leave missing execution checks pending.

Start with the synthetic example, then adapt each prompt to your task.

01

Write the game contract before asking for code

Start with the complete rules and fictional turns. Decide which scores win and what makes the game complete; a game name alone is not enough. Keep the answer sheet separate so it can check the tool.

Your starting prompt
Review this complete owner-supplied game brief. Extract fixed player aliases, exact round schema, allowed input type and minimum/maximum for each field, scoring formula, higher-or-lower winning direction, completion rule and tie rule. Identify anything missing rather than guessing it. For Pebble Pair, keep three fixed aliases, three rounds each, each die an integer 1–6, sum plus 5 only for a double, highest total wins and all tied leaders joint winners. No final winner until all nine turns exist. Produce an independent worked score sheet separately from the runnable app. Do not add gambling, prizes, real personal data or a universal rules engine.

COMPLETE BRIEF AND TURNS:
[paste the source input]
Expect

A complete fixed-game contract and a separate worked score sheet, with missing facts raised before code.

Check

Ari, Bea and Cleo each have three turns. Each face is a single digit 1–6; doubles add 5. Highest total wins, all tied leaders share it, and nine valid records are required. Recalculate the nine scores yourself: 9/7/17, 7/15/7 and 13/3/11; totals 33/29/27.

If it differs

If a rule or answer differs, point to the exact original line or turn and ask for a corrected complete contract/reference. Do not change the supplied rules to fit a plausible total. Save the reviewed versions before requesting the HTML.

02

Build the real local ledger with explicit changes

Ask for the complete self-contained HTML and open a new copy. Make Add and Edit different actions so an accidental duplicate cannot replace a score. Store the original faces and derive totals from them.

Your starting prompt
Create one complete inspectable HTML scorekeeper from the approved contract. Start empty with an unsaved warning. Add only fills a blank player/round; duplicate Add must fail without changing state. Edit explicitly selects a recorded turn and locks its identity. Save correction commits, Cancel edit preserves the record, and saving unchanged faces creates no history. Recompute totals, completeness and every tied winner from the original records. Undo restores the previous committed ledger, including a reset, and discards any unsaved draft. Reset must offer Keep this game and Yes, clear scores; cancellation preserves the draft too. Reload/page-show starts fresh. Use native labeled controls, readable errors, visible focus, a JavaScript-off explanation and text-only output. No form, network, remote asset, account, storage, import or permission. Include exact script/style CSP hashes and no unsafe-inline. Deliver the whole file, not a screenshot or partial snippet.

APPROVED CONTRACT:
[paste]
Expect

One complete local-only HTML file, saved and reopened, with an initially empty ledger, an unsaved warning and explicit Add/Edit/Undo/reset controls.

Check

Inspect the whole saved source. It should preserve original faces and derive totals, prevent duplicate Add, lock identity during Edit, and make reset confirmable and undoable. No account, network, storage or import belongs here. CSP hashes are fingerprints of the exact inline code/style bytes; they must match after any edit.

If it differs

If given snippets or a screenshot, ask for the entire file and save/reopen it. If it opens as source text, check the .html extension. If code or CSP needs repair, request a complete corrected copy with recalculated hashes; never remove CSP or add unsafe-inline to make it run. Code inspection alone does not show that controls worked.

03

Challenge inputs and check the independent totals

A total can look plausible while a blank is treated as zero or a correction is added twice. Test each die separately and compare the original recorded faces as well as the totals.

Your starting prompt
Read the original source, independent score reference and complete HTML. Build read-only local tests that do not overwrite any source or install anything. For the sample verify all 36 ordered dice pairs, exact round scores 9/7/17, 7/15/7 and 13/3/11, final totals 33/29/27, arbitrary entry order and no winner for every incomplete prefix. Independently reject blank, whitespace-only, nonfinite text, decimal 1.0/1.5, exponent, sign, negative, 0, 7 and markup in either field; no clamping. Test duplicate Add and invalid turn identity. Correct Bea round 3 to 5,6: joint winners Ari/Bea at 33; Undo restores original faces and totals. Include a three-way tie, unchanged edit, Cancel edit, empty Undo, reset/cancel/confirm/Undo and snapshot mutation. Assert state invariants across repeated operations. Inspect network/storage/HTML-insertion APIs and recompute inline hashes. Record runtime, actual counts and failures; do not label a VM a browser.

SOURCE, REFERENCES AND HTML:
[provide]
Expect

A clearly scoped arithmetic/state audit of your actual saved HTML, plus test source and observed results only where execution was available.

Check

Compare faces as well as totals. Editing Bea round 3 to 5,6 must produce 33/33/27 and both Ari and Bea; Undo must restore 4,3 and 33/29/27. Check every invalid face separately, incomplete states, duplicate Add, cancel/no-op edits, three-way ties and reset recovery. Read a test script before running it; the bundled node pebble-pair-tests.mjs command reads its named sibling sample files only.

If it differs

Keep an exact failing case before changing code. If checking your generated file, obtain a complete harness explicitly targeting that file and your separate references; do not run the bundled harness on a different file and transfer its pass. With no compatible already-installed runtime, keep execution not run. Historical reports bind their recorded revision. The supplied current pebble-pair-scorekeeper.html has SHA-256 097decb519cbe7a346761da75fe3915edd8cba30ea62dd80837a8c8ef3a58cf5; a newly generated file has its own hash and needs its own checks.

04

Try the downloaded file in an actual browser

Use the keyboard and deliberately make mistakes. Test the file you downloaded, not just a web preview. Keep each observed result separate from checks that still need doing.

Your starting prompt
Prepare and execute only the actual-browser checks available in this environment on the exact local HTML. Record browser/version, date and file SHA-256. Enter all nine turns with keyboard only; observe labels, visible focus, errors and the correct completed result. Exercise Add/Edit/Save/Cancel, duplicate Add, both tie cases, Undo, reset cancellation with an unsaved edit, confirmed reset and recovery. Check narrow width at 320 CSS px, enlarged text, reload and back/forward fresh-state behavior, and the readable JavaScript-off explanation. Open the downloaded file offline and inspect requests; an HTTP-only check is not evidence of local offline opening. Note console/CSP issues. If a browser action is unavailable, mark it not run. Do not claim accessibility certification, human usability approval or an AI-provider benchmark from code tests.

HTML AND EXPECTED RESULTS:
[provide]
Expect

A separate actual-browser checklist with observations for the exact saved file, or explicit not-run entries when those tools are unavailable.

Check

Open my-pebble-pair.html directly in the permitted browser. Choose Player and round, type First die face and Second die face, then Add turn. Use a recorded row’s Edit, Save correction or Cancel edit; use Undo last change and both reset choices. Observe keyboard focus, errors, 320 CSS px/enlarged text, reload/back-forward fresh state, JavaScript-off text and local offline opening. Record browser/version, file hash and date.

If it differs

If you cannot perform a check, leave it not run; source or VM output cannot fill it. If the actual file fails, record the steps/error, provide the complete saved source to the AI and request a new complete revision. Save/reopen it and repeat affected arithmetic and browser checks. Do not reload expecting Undo recovery.

05

Adapt only after the sample checks agree

The fixed controls edit scores, not the rules. A different game needs a newly approved contract and new independent answers. Changing the JSON alone does not update the HTML.

Your starting prompt
Compare my proposed new scoring contract with the fixed Pebble Pair sample. List every affected input bound, player/round mapping, formula, scoring direction, tie/completion rule, UI label and test oracle. Ask for missing rules instead of deriving them from the game name. Work on a new copy and keep the original unchanged. If the changes are bounded and approved, return complete source, independent worked references and complete HTML; regenerate exact inline CSP hashes after code/style changes. Preserve local-only behavior, explicit corrections, reversible reset, no winner while incomplete and all tied aliases. Rerun the independent arithmetic/state tests and actual browser checks for this version. Do not grow a universal rules engine, add storage/services or imply the old test results certify a new game.

NEW APPROVED CONTRACT:
[paste]
Expect

For a deliberately supplied new synthetic contract, a change list and a complete new edition with its own references and fresh checks; otherwise this optional adaptation stays pending.

Check

Changing the JSON does not update the sample HTML. Every changed alias, round, bound, formula, winning direction and tie/completion rule needs matching code, labels and independent answers. Old test reports never certify the new edition. Keep this bounded and local-only.

If it differs

If no new contract is supplied, stop with the sample result instead of inventing a game. If a rule is missing or the adaptation is unbounded, hold it. Keep the original sample and failed new versions; use the own-input route below when ready.

Optional: improve the result

Separate rule correctness from history correctness

Challenge the arithmetic oracle and the state transitions independently. An app can calculate a turn correctly yet restore the wrong prior game.

Advanced prompt
Audit this fixed scorekeeper without adding features. Independently enumerate all 36 valid dice pairs and construct incomplete, sole-winner, two-way and three-way tie fixtures. Then test add/correct/reset/undo against a separate reference ledger across deterministic repeated operations. Include rejected and no-op actions and prove they do not alter Undo history. Try mutating returned snapshots and invalid turn-selector values. In disposable in-memory code copies, remove the double bonus, allow overwrite or announce a winner early and confirm the checks fail; preserve every source file. Inspect text-only rendering and recalculate each inline CSP hash. Finally observe the actual local file with keyboard, narrow view, JavaScript off and no external requests. Report exact run environments and unperformed checks. Do not turn this into a universal rules engine, accept real data, install packages or claim security/accessibility certification.

SOURCE, FILES AND AVAILABLE CHECKING ENVIRONMENT:
[provide]
Optional: use your own input

Make a separate scorekeeper for your own synthetic game

Start a separate chat with the prompt below. Use fictional adult aliases and invented test turns, not players’ personal information, gambling or prizes. Resolve missing rules and calculate a separate answer sheet from the approved contract before code. Save both as my-game-contract.txt and my-game-reference.txt. Then send:
“Create one complete self-contained HTML scorekeeper for MY APPROVED CONTRACT. Keep the exact aliases, round mapping, input grammar/bounds, scoring formula, winning direction, completion and tie rules. Store original turn inputs and recompute totals and winners. Start empty; Add must not overwrite, Edit must lock turn identity, explicit Save commits, Cancel preserves records, unchanged saves add no history. Undo restores the last committed ledger including reset and discards unsaved input. Reset offers cancel preserving drafts or confirm as one undoable change. Reload/page-show starts fresh. Include native labelled controls, visible focus, errors and a readable JavaScript-off explanation. No network, account, install, storage, import, form or remote asset. Include matching exact-hash CSP without unsafe-inline. Return the complete HTML, not patches. COMPLETE APPROVED CONTRACT: [paste all rules and synthetic turns].”
Save only the returned code as my-game.html; reopen it in the text editor. Then send:
“Audit MY ORIGINAL CONTRACT, SEPARATE ANSWERS AND COMPLETE SAVED HTML. Independently derive expected scores from my rules; test valid boundaries, invalid/blank input, arbitrary entry order, duplicates, incomplete records, all tied leaders, explicit edit/save/cancel, unchanged save, Undo and reset cancellation/confirmation/recovery. Use my supplied correction and tie cases and calculate any additional synthetic cases from my rule; do not reuse another game’s answers. Check no rejected/no-op action changes history, snapshots cannot mutate state, text-only rendering and exact CSP hashes. Return complete read-only test source targeting my exact saved filename and references. Run only if a compatible already-installed authorized runtime exists; record environment and actual failures, otherwise mark not run. COMPLETE CONTRACT, INDEPENDENT ANSWERS AND REOPENED HTML: [paste or attach full files if supported]. AVAILABLE TOOLS: [list or none].”
Read the test source before any permitted run. Preserve failures, save/reopen complete corrections under a new name, and rerun tests on that exact revision. Then send:
“Prepare actual-browser checks for MY SAVED HTML and my independent expected results. Cover keyboard-only entry, labels/focus/errors, correction/cancel/no-op/Undo, every tied leader, reset with an unsaved draft, narrow/enlarged text, reload/back-forward fresh state, JavaScript off and actual local-file offline opening with request checks. Record browser/version, date and file hash only for checks actually observed; keep unavailable checks not run. A VM is not a browser or accessibility certification. COMPLETE SAVED HTML, CONTRACT, EXPECTED RESULTS AND ACTUAL CODE-TEST RESULTS: [provide]. AVAILABLE BROWSER TOOLS: [list or none].”
Open the saved HTML yourself in a permitted browser when that route is available; follow the checklist and keep actual observations. Write down any scores needed before closing or reloading. For a later rule change, send:
“Compare MY ORIGINAL CONTRACT and PROPOSED REVISED CONTRACT. Identify every affected rule, alias/round mapping, input bound, UI label, arithmetic oracle and history invariant. Ask about gaps; do not invent rules or broaden into a universal engine. After my review, deliver complete revised contract, independent answers and HTML in a new edition, with new exact CSP hashes. Reuse the source/state and actual-browser check procedure on this new saved file, leaving unrun checks pending; never inherit an old pass. ORIGINAL CONTRACT, COMPLETE SAVED HTML AND CHECK RESULTS: [provide]. PROPOSED REVISED CONTRACT: [provide, or keep this stage pending].”
All answers must be recalculated from your own synthetic contract. An AI needs the actual full files to review them, not local path names. Return to the original sample chat for the original advanced prompt, with the full sample source, exact sample HTML, references and test results; do not mix its fixed dice expectations into this route.

Your own-input prompt
Help me specify a small local scorekeeper for MY own synthetic tabletop game. First extract exact fictional adult aliases, player/round mapping, each input’s type/grammar and bounds, scoring formula, higher-or-lower winning direction, completion rule, tie rule and the supplied invented turns. Ask for missing or conflicting rules instead of deriving them from a game name. Separate raw turn inputs from calculated scores. Produce a complete reviewed contract and an independently calculated worked reference, including a correction/Undo case, incomplete state, sole winner and ties where the rules allow them. Ask before resolving any unspecified tie policy. No real personal data, gambling, prizes, universal rules engine, account, network, storage or installation. Stop for my contract/answer review before code.

MY COMPLETE SYNTHETIC GAME BRIEF
[Paste all rules listed above and the full invented turn set, with a correction case. Identify expected results you calculated separately or say they still need calculation. Mark missing rules explicitly; do not paste the sample answer sheet.]

Check your own result

  • Every expected score, total, missing state and tie follows your approved rules and original synthetic turns, not the sample’s numbers.
  • Complete saved/reopened source is handed to each audit. The script tested and actual browser file must be the same revision; a bundled sample-harness pass is not a new-game pass.
  • Bad entries, rejected duplicates, Cancel and unchanged Save leave records/history alone. Undo restores original inputs as well as recomputed totals; reset is reversible only while the page remains open.
  • Actual browser/offline/keyboard observations remain distinct from code checks. Unrun checks remain open; no persistence, security certification or usability success is inferred.
Show, then try

See the shape of the result.

This input is synthetic. The output is a written illustration of the intended result, not a verified AI-tool run.

The starting point

Synthetic input
# Pebble Pair: complete original input

This is an original fictional adult tabletop game for a teaching exercise. Ari, Bea and Cleo are fixed synthetic aliases. There is no gambling or prize. These rules are the supplied game specification, not a claim about another game.

## Rules supplied by the game owner

- Three players: Ari, Bea and Cleo. Three rounds per player; nine turns altogether.
- Each turn records two ordinary six-sided-die faces, each a whole-number digit 1–6.
- Score = first face + second face + 5 only when both faces match. Otherwise bonus = 0.
- Highest total wins. All players tied at the highest total are joint winners; do not invent a tie-break.
- The game is incomplete until all nine turns have valid entries. Do not declare a final winner early. An unrecorded turn stays missing rather than becoming a zero-score turn.
- Turns may be entered in any order. One record per player/round. Add never overwrites an existing turn.

## Complete fictional turn input

| Player | Round 1 faces | Round 2 faces | Round 3 faces |
|---|---|---|---|
| Ari | 2, 2 | 3, 4 | 6, 6 |
| Bea | 6, 1 | 5, 5 | 4, 3 |
| Cleo | 4, 4 | 1, 2 | 5, 6 |

For the correction exercise only, change Bea’s round 3 to faces 5, 6 using its explicit Edit button. Then Undo. The worked score sheet and CSV are separate answer references.

## Local interaction contract

1. Open the HTML locally. It begins empty and warns that scores are unsaved. This file needs no server, install, account, internet connection or service form.
2. Choose Player and round; type both faces; activate Add turn. Alternatively use Add beside a blank round. Each die accepts exactly one ASCII digit 1–6 after trimming surrounding spaces. Blank, nonfinite, negative, zero, 7, decimals including 1.0, exponents, signs and other text are rejected without rounding or clamping.
3. To correct a recorded turn, activate its Edit button. The turn selection is locked. Save correction commits it; Cancel edit abandons unsaved changes. Saving the same faces is not an Undo change.
4. Undo restores the previous committed ledger, including a reset. It discards any unsaved input. Empty Undo is disabled. There is no Redo.
5. Reset game asks first. Keep this game preserves the ledger, history and unsaved input. Yes, clear scores empties all nine slots as one undoable change. Empty reset is disabled.
6. Reload or a page-show event starts an empty game and clears history. This includes browser back/forward page restoration; do not navigate away expecting recovery. Browser autofill and history features exist separately from this code.

The original faces are the only stored application data. Subtotals, totals, completion and winners are recomputed from them each time. Turn scores range from 3–17; a completed player total ranges from 9–51. These bounds follow this supplied rule, not generic dice-game advice.

## Reuse limits

The controls deliberately keep the aliases, three-round shape and scoring rule fixed. They edit turn entries, not the rules engine. The JSON source is editable text for a new version; it is not imported by the HTML. Before adapting, write your own exact authorized aliases, round schema, input bounds, scoring direction, tie/completion rules and test cases. Keep real personal data out of this sample. Use a new copy; do not overwrite this source.

The actual file has native labeled controls, text-only dynamic output, visible focus CSS and a readable JavaScript-off explanation. Local VM checks do not establish browser keyboard, layout, offline-open or assistive-technology success. Check the actual local download before relying on an adaptation. No provider plan/access or time saving is claimed.

Copies text only. For image or file tasks, use the source files named in the steps too.

Download source .txt

The intended result

Illustrative output
# Worked local scorekeeper

The main download is the complete runnable HTML, not a screenshot or a code outline. It opens with an empty ledger and an unsaved-scores warning. Ari, Bea and Cleo each have exactly three fixed round slots; enter the supplied fictional faces in any order.

## Exact answer

- Ari: 9, 7, 17 → total 33.
- Bea: 7, 15, 7 → total 29.
- Cleo: 13, 3, 11 → total 27.
- Before all nine turns are recorded: incomplete, no final winner.
- After all nine: Ari wins with 33.
- Edit Bea round 3 from faces 4,3 to 5,6 and Save correction: totals become 33/33/27, so Ari and Bea are joint winners.
- Undo restores exactly the former faces and totals 33/29/27.

The separate worked sheet and nine-row CSV show the arithmetic. They are not imported automatically. The source JSON contains the complete input and rules, without precomputed score answers.

## Meaningful editing and recovery

Add only fills a blank player/round. A duplicate Add rejects rather than overwriting. Edit preloads the existing faces and locks turn identity; only Save correction commits. Cancel edit keeps the record, and an unchanged save creates no history entry. Each committed change snapshots the original face ledger; all totals and winners are derived again, not incrementally patched.

Undo restores the previous committed ledger and discards any unsaved draft. Reset first asks; cancellation preserves scores, history and draft. Confirmation clears the game as one undoable change. Reload/page-show starts a genuinely empty ledger and clears history. There is no saved-game, import, sync or Redo feature.

## Evidence boundary

Twenty-one read-only local checks passed on Node v24.19.0 using the embedded scripts and a minimal simulated DOM. They cover all 36 valid dice pairs, independently transcribed source/CSV answers, invalid values on each face, duplicate Add, explicit correction, incomplete/tied results, reset cancellation with a draft, Undo recovery, snapshot isolation, 1,500 deterministic state operations and exact inline CSP hashes. A test caught and corrected a blank/tampered selector coercion before this version was recorded.

These are source/state checks, not observed browser rendering, keyboard events, assistive-technology, offline-open or user trials. The code requests appropriate focus and uses native labeled controls, a JavaScript-off explanation and text-only output. Actual browser checks remain unperformed in this staged package. The consumer-AI workflow was not executed; status stays illustrative_untested and time savings are unmeasured. No provider plan or access is verified.
Download result .txt
You’re the final check

Check the worked example.

These checks use the worked example and its particular facts. With your own material, check your actual names, numbers, sources and rules; do not reuse the sample’s values as the answer.

Unsaved checks stay in this tab and reset when you reload. If you choose Save guide, its current example checkmarks are kept in this browser when storage is available.

A few things to watch for.

  • Turning a blank into zero, accepting 1.0 or an exponent through broad number coercion, or silently clamping an invalid die.
  • Patching a displayed total after an edit while the underlying original turn stays wrong.
  • Declaring a winner from unequal numbers of recorded turns, or selecting only the first tied alias.
  • Making Add overwrite an existing turn or making reset irreversible despite promising Undo.
  • Treating a minimal DOM fixture as proof of keyboard focus, mobile layout, offline opening or screen-reader behavior.
  • Editing inline code without updating CSP hashes, or weakening CSP rather than correcting the hash.
  • Expecting JSON changes to import automatically or expecting this no-storage page to recover after reload.

What has been checked?

Documentation
Reviewed 2026-10-14. Source review is not workflow execution.
Included files
Scoped checks passed on 2026-10-14. Fixture checks; File parsing. See scope below.
AI workflow
Not run in a recorded consumer-AI workflow.
Time savings
Time savings not measured
Read the scope and evidence

pebble-pair-scorekeeper.html

2026-10-14 · semantic fixture · passed

Authored source/arithmetic/state and artifact consistency checks only. Actual local browser, keyboard/layout, offline-open, assistive-technology and human usability checks remain unperformed. No consumer-AI workflow or savings measurement.

  • Exact named artifact exists and SHA-256 is bound to this version
  • Complete original synthetic content; no real personal data or consumer-AI evidence
  • 21 read-only checks passed; all 36 valid rolls and exact 33/29/27 fixture
  • Invalid fields, duplicate Add, correction/Undo, complete/incomplete and tied results checked
  • Cancelable reset with draft preservation, reversible reset, snapshot isolation and 1,500 state operations checked
  • Exact CSP hashes and native label/focus/no-JavaScript source inspected; no network/storage/HTML-insertion APIs
  • Actual browser, offline opening, keyboard events, layout and assistive-technology checks not run

Environment: Node v24.19.0 on Linux; embedded scripts executed in a Node VM with a minimal simulated DOM. No actual browser.

SHA-256: 097decb519cbe7a346761da75fe3915edd8cba30ea62dd80837a8c8ef3a58cf5

pebble-pair-rules.md

2026-10-14 · parser · passed

Authored source/arithmetic/state and artifact consistency checks only. Actual local browser, keyboard/layout, offline-open, assistive-technology and human usability checks remain unperformed. No consumer-AI workflow or savings measurement.

  • Exact named artifact exists and SHA-256 is bound to this version
  • Complete original synthetic content; no real personal data or consumer-AI evidence
  • Readable source/reference/report and stated scope reviewed against the fixed fixture

Environment: Node v24.19.0 on Linux; embedded scripts executed in a Node VM with a minimal simulated DOM. No actual browser.

SHA-256: 9b7383844b99acd84c8c3114a29acf63af1800e8f275d8abf50321d743c95bb1

pebble-pair-source.json

2026-10-14 · semantic fixture · passed

Authored source/arithmetic/state and artifact consistency checks only. Actual local browser, keyboard/layout, offline-open, assistive-technology and human usability checks remain unperformed. No consumer-AI workflow or savings measurement.

  • Exact named artifact exists and SHA-256 is bound to this version
  • Complete original synthetic content; no real personal data or consumer-AI evidence
  • Exact player/round/face input and independently transcribed nine-turn scores compared by the read-only harness

Environment: Node v24.19.0 on Linux; embedded scripts executed in a Node VM with a minimal simulated DOM. No actual browser.

SHA-256: 667c9b7f0e160cf1a3a544a0c53927ccdc5256d5e34f31cc521a04bcc272a05a

pebble-pair-worked-scores.md

2026-10-14 · parser · passed

Authored source/arithmetic/state and artifact consistency checks only. Actual local browser, keyboard/layout, offline-open, assistive-technology and human usability checks remain unperformed. No consumer-AI workflow or savings measurement.

  • Exact named artifact exists and SHA-256 is bound to this version
  • Complete original synthetic content; no real personal data or consumer-AI evidence
  • Readable source/reference/report and stated scope reviewed against the fixed fixture

Environment: Node v24.19.0 on Linux; embedded scripts executed in a Node VM with a minimal simulated DOM. No actual browser.

SHA-256: e9a93e064c814f26eab6c5436f361c56a15b38ca894eaae779a84b16de3accc3

pebble-pair-score-reference.csv

2026-10-14 · semantic fixture · passed

Authored source/arithmetic/state and artifact consistency checks only. Actual local browser, keyboard/layout, offline-open, assistive-technology and human usability checks remain unperformed. No consumer-AI workflow or savings measurement.

  • Exact named artifact exists and SHA-256 is bound to this version
  • Complete original synthetic content; no real personal data or consumer-AI evidence
  • Exact player/round/face input and independently transcribed nine-turn scores compared by the read-only harness

Environment: Node v24.19.0 on Linux; embedded scripts executed in a Node VM with a minimal simulated DOM. No actual browser.

SHA-256: 5c17cd98cacb406be905eb842a8ccfab56051cfca1583bfb7cf01e74cf78d19c

pebble-pair-tests.mjs

2026-10-14 · semantic fixture · passed

Authored source/arithmetic/state and artifact consistency checks only. Actual local browser, keyboard/layout, offline-open, assistive-technology and human usability checks remain unperformed. No consumer-AI workflow or savings measurement.

  • Exact named artifact exists and SHA-256 is bound to this version
  • Complete original synthetic content; no real personal data or consumer-AI evidence
  • Executed successfully: 21 checks, including 1,500 deterministic operations
  • Harness reads only named sibling inputs; VM/minimal-DOM execution is explicitly not a browser

Environment: Node v24.19.0 on Linux; embedded scripts executed in a Node VM with a minimal simulated DOM. No actual browser.

SHA-256: ec6f0ed451e652351e8c3645db51a7d050a827b4396ec7e167497c9a8c6a96f5

pebble-pair-checks.md

2026-10-14 · parser · passed

Authored source/arithmetic/state and artifact consistency checks only. Actual local browser, keyboard/layout, offline-open, assistive-technology and human usability checks remain unperformed. No consumer-AI workflow or savings measurement.

  • Exact named artifact exists and SHA-256 is bound to this version
  • Complete original synthetic content; no real personal data or consumer-AI evidence
  • Readable source/reference/report and stated scope reviewed against the fixed fixture

Environment: Node v24.19.0 on Linux; embedded scripts executed in a Node VM with a minimal simulated DOM. No actual browser.

SHA-256: 9d088b34f8028ced41645c52c487dddfd62a791d34dc3beef12dff92f79501e4

pebble-pair-adaptation.md

2026-10-14 · parser · passed

Authored source/arithmetic/state and artifact consistency checks only. Actual local browser, keyboard/layout, offline-open, assistive-technology and human usability checks remain unperformed. No consumer-AI workflow or savings measurement.

  • Exact named artifact exists and SHA-256 is bound to this version
  • Complete original synthetic content; no real personal data or consumer-AI evidence
  • Readable source/reference/report and stated scope reviewed against the fixed fixture

Environment: Node v24.19.0 on Linux; embedded scripts executed in a Node VM with a minimal simulated DOM. No actual browser.

SHA-256: 9def8010f1129e217a12c3fbe82194035e5a8753c06d5ebc93e2a3ef4fbbf3d7

Exact inline CSP hashes ↗ (opens in a new tab)

2026-10-14 · confirmed

A hash allowlist can permit an exact inline script/style block; whitespace and capitalization matter, and the enclosing tags are excluded from the hash. This is documentation, not browser enforcement evidence.

Plain-text DOM output ↗ (opens in a new tab)

2026-10-14 · confirmed

textContent sets text content rather than parsing a string as HTML. The local fixture uses text nodes/content for its dynamic labels and results.

For context and further reading

Official documentation

Documentation reviewed: 2026-10-14. Documentation review is not tool-execution evidence. This resource remains illustrative and not tool-tested.

Copy these instructions

Your browser blocked automatic copying. Select the text below and copy it.