# mass_entry v1: data bundle for the "picture as a record" page

Static data for a web page that replays two recorded experiments (pilots) with the YuCe kernel. Nothing on the page is generated live and no model is called: every picture, journal and number here was recorded on 12 November 2026 and is only shown again.

- **Vector pilot.** DeepSeek drew a house scene as 12 SVG elements, one per numbered line of `scene.md`. Each element is recorded in the kernel as a claim resting on an exact quote of its line. Withdrawing a line makes the kernel drop what stood on it; four one-line edits replace single elements; the picture of any earlier frame can be assembled again; Gemini continues the picture through the journal. Two control runs show Gemini without the kernel.
- **Raster pilot.** GPT-6 Luna painted 6 raster layers (PNG), one per line of its `scene.md`. Each layer is recorded as an element that names the layer file by its SHA-256. Journal A has one ground per layer; journal B, made from the same files without model calls, also rests roof and door on the wall line, so withdrawing the wall drops all three.

## Contents

```
README.md                    this file
steps_manifest.json          one entry per picture the page shows (initial frames, actions, controls)
verification.json            sbgk audit-verify and yuce-verify on the three journals and on every cut the page uses
SHA256SUMS.txt               SHA-256 of every other file of the bundle
verifier/yuce-verify.mjs     independent journal verifier, copied unchanged from YuCe release v0.2.1 (Apache-2.0)
verifier/README_BROWSER_API.md   how to call it in a browser
vector_scene/                scene.md, edit-1.md ... edit-5.md, pilot.wal (19 frames), the pictures (svg + png)
raster_scene/                scene.md, edit-1.md, edit-2.md, pilot_a.wal (10 frames), pilot_b.wal (5 frames),
                             the composite pictures (svg + png), L/ = the 7 layer files the composites use
```

The raster SVGs reference their layers as `L/<name>.png`, relative to `raster_scene/`. A layer's name is its SHA-256 with the digits written as the letters g to p (the reason is the number rule under "Honest limits"). Six of the seven layer files carry the C2PA Content Credentials that the image generator embedded (an AI-generated image, signed by its provider, with the signing certificate chain); they are kept as they are, because the journal pins every byte of these files.

## The actions

| # | id | journal | frame | fell | standing elements | pixels changed (outside the area) | pixel source |
|---|---|---|---|---|---|---|---|
| 1 | vector_initial | pilot.wal | 4 | 0 | 12 | — | — |
| 2 | vector_withdraw_sun | pilot.wal | 5 | 1 (sun) | 11 | 2,910 (0) | pilot report |
| 3 | vector_edit_door | pilot.wal | 8 | 1 (door) | 11 | 1,500 (0) | pilot report |
| 4 | vector_edit_roof | pilot.wal | 11 | 1 (roof) | 11 | 4,920 (0) | pilot report |
| 5 | vector_edit_crown | pilot.wal | 14 | 1 (tree crown) | 11 | 5,135 (0) | pilot report |
| 6 | vector_edit_label | pilot.wal | 17 | 1 (caption) | 11 | 1,007 (0) | pilot report |
| 7 | vector_back_to_original | pilot.wal | 4 | 0 | 12 | 0 | rechecked from PNG |
| 8 | vector_continue_gemini | pilot.wal | 19 | 0 | 12 | 2,910 (0) | pilot report |
| 9 | vector_control_scratch | none | — | — | — | 76,756 | pilot report |
| 10 | vector_control_plain_1 | none | — | — | — | — | — |
| 11 | vector_control_plain_2 | none | — | — | — | 109,878 | pilot report |
| 12 | raster_initial | pilot_a.wal | 4 | 0 | 6 | — | — |
| 13 | raster_red_sun | pilot_a.wal | 7 | 1 (sun) | 6 | 3,216 (0) | pilot report |
| 14 | raster_back_to_first | pilot_a.wal | 4 | 0 | 6 | 0 | rechecked from PNG |
| 15 | raster_wall_one_ground | pilot_a.wal | 10 | 1 (wall) | 6 | 16,205 (0) | rechecked from PNG |
| 16 | raster_b_initial | pilot_b.wal | 4 | 0 | 6 | 0 | rechecked from PNG |
| 17 | raster_b_withdraw_wall | pilot_b.wal | 5 | 3 (wall, roof, door) | 3 | 16,130 (0) | rechecked from PNG |

A frame number n is the number of journal lines: the picture of an entry is the state after the first n frames. Each entry's `pixels.compared_with` names the picture it is compared with: the journal state just before the action, which is not always the picture the page showed just before. Three cases matter:

- `vector_continue_gemini` is compared with frame 17 (after edit 4, where the sun line was already withdrawn and no sun was drawn). Its picture also carries the four DeepSeek edits.
- `raster_wall_one_ground` is compared with frame 7 (red sun). Its sun is red because edit 1 is still in force.
- The two "back" entries and `raster_b_initial` are compared with the first picture of their pilot: 0 pixels differ, same SVG and PNG SHA-256.

Each entry has `label_en`/`label_ru` (button text) and `caption_en`/`caption_ru` (the sentence under the picture).

## Where each number comes from

| field | source | checked against |
|---|---|---|
| pictures (`image_svg`, `image_png`) | made by the pilots, copied unchanged | the pilots' hash lists and `report.json`; SVG rebuilt from the kernel's answer at the frame (below) |
| `frame` | the pilot reports | for every journal entry the build cut the journal to `frame` lines, read the standing elements with `sbgk audit-read active-claims`, assembled the SVG by the pilots' rule and got the bytes of `image_svg` (`crosscheck.svg_rebuilt_from_kernel_equals_image`) |
| `standing`, `standing_count` | `sbgk audit-read active-claims` and `record` on the cut | the record per scene line in the pilots' `report.json` |
| `fallen`, `revoked_lines`, `added`, quotes, `based_on` | `sbgk audit-read fallen --since <previous frame>`, `record`, `diff --from --to` on the cut | the fallen ids in `report.json`; the withdrawal frames of the journal itself; the same query at the frame right after the withdrawal; `diff` (fell, withdrawn text SHA-256, records added) |
| quote text and `file_line` | `sbgk audit-read record` | the exact bytes of the document in this bundle at the span the kernel gives; the documents match the SHA-256 the journal's first frame records |
| `pixels.changed` | pilot reports (vector, raster red sun) or this bundle's recount (raster wall steps, "back" entries) | every count recounted from the two PNG files (RGBA compared pixel by pixel; PNG reader = the vector pilot's own, standard library only). All recounts equal the reported numbers |
| `pixels.in_element_area`, `outside_area` | vector and raster red sun: pilot reports. Raster wall steps: this bundle | pilot method: the element alone, old and new together for an edit, rendered over two plain backgrounds; its area is every pixel it paints on either. Bundle method (raster only, `box_check`): changed pixels tested against the boxes (x, y, width, height) of the layers that differ between the two composite SVGs, an upper bound of what those layers can paint. On the raster red sun both methods give 3,216 inside, 0 outside |
| `pixels.element_area_size` | pilot reports | the size of the area, not a count of changed pixels: for edit 4 the caption area is 1,014 pixels and 1,007 of them changed |
| percentages in captions | `changed / 120,000`, rounded | — |
| `frame_check`, `verification.json` | `sbgk audit-verify` (0.2.1) and `node verifier/yuce-verify.mjs journal <file> --json` on the full journals and on each cut | both tools agree on frames, SHA-256 and head; the heads equal those the pilot reports recorded where they recorded one |

`fallen` lists elements (claims). The withdrawn quote that brought them down is not in `fallen`: it is in `revoked_lines`, in each fallen record's `quotes` (status `withdrawn`) and in `kernel_diff.fell` (kind `observe`). The kernel answers "1 fell" for the sun in the same sense.

**Cross-check result:** no mismatch was found between the kernel's answers, the pilots' `report.json`, the journals' own frames and the recounted pixels. Every `crosscheck` value in the manifest is `true`.

## How to check it yourself

```
sha256sum -c SHA256SUMS.txt
node verifier/yuce-verify.mjs journal vector_scene/pilot.wal --json
sbgk audit-verify --wal vector_scene/pilot.wal
head -n 5 vector_scene/pilot.wal > cut.wal
sbgk audit-read fallen --wal cut.wal --since 4
sbgk audit-read active-claims --wal cut.wal
sbgk audit-read record --wal cut.wal --record <id>
```

The picture of a frame is assembled outside the kernel: for each numbered scene line, the standing element whose first ground is that line; if the line was withdrawn, the standing element on the edit line that replaces it; otherwise nothing. Elements in line order inside `<svg xmlns="http://www.w3.org/2000/svg" width="400" height="300">`.

## Honest limits

- **A recorded experiment.** Both pilots ran on kernel 0.2.0 (build 44d8a21c) on 12 November 2026; the journals were re-checked with release 0.2.1 for this bundle. No live generation and no live model calls on the page.
- **Pixel for pixel holds only for PNGs rendered by one renderer:** headless Chrome with fixed flags at 400×300. Another renderer draws the same SVG differently while the record stays the same. Claims about SVG files are byte for byte, by SHA-256.
- **The browser verifier checks journal integrity only (J0-J1):** well-formed frames, hash chain, seals. What fell was computed by the kernel and is recorded in the manifest; anyone can recompute it with `sbgk audit-read fallen`.
- **The journals have no seals.** The browser check says the file is internally consistent, not that it is authentic: anyone able to recompute the hashes could produce a file that passes.
- **Colours in the vector pilot are written as words or as codes with a letter, because of a kernel rule about numbers.** In a dry run the kernel refused elements with the colour `#010000`: the claim names a number its quote does not contain (refusal NO_EVIDENCE). The kernel would read a decimal such as `0.5` as a version number in the same way. The rule was made for text reports; for pictures it means colours as words or codes with a letter, and whole numbers only. The models were told this in advance, and in the recorded run the kernel refused nothing. The raster layer names spell their SHA-256 digits as letters for the same reason.
- **Only what was declared as a ground falls.** The pilots' runners declared the grounds: each element on the quote of its own line; in raster journal B roof and door also on the wall line.
- **One scene per pilot, one run, one model call per step.** These are pilots, not measurements.
- "All 12 requirements are still met" (entry 9) rests on the pilot script's rough checks: kind of element, colour by hue, rough place, 3 checks per line (36 of 36). It is not a judgement of the picture.
- In the raster pilot the script set each layer's place and size; the model painted only the content. A layer painted again from the same prompt comes out different (the pilot measured 3,070 different pixels for a second red sun), so going back is exact only for recorded layers.
- The element areas of the vector pilot were measured by the pilot's renderer; this bundle re-rendered nothing. The raster wall steps were not measured by the pilot; their area counts are this bundle's box method.
- The page's cut of a journal and the heads in this manifest come from the same files: when they match, the page reads the same bytes, which is not an external anchor.
