diff --git a/CHANGELOG.md b/CHANGELOG.md index 5d4a50e..40150b2 100644 --- a/CHANGELOG.md +++ b/CHANGELOG.md @@ -4,6 +4,10 @@ The package version runs on its own semver; the schema it is generated from is ` ## Unreleased +## 0.138.1 (2026-11-21) + +- **The schema pin moves to `v0.34.1-dist.142`** (canonical 00.34.01 unchanged, no schema file moved, `_schema.py` changes only its provenance lines). The map-space page gains a note at the end of rule 14: where a Zone has an outline on a child Map and on its parent, no reading joins the two outlines or adds a point on the edge of the child's rectangle or of its parent frame, and what a tool draws there is the tool's; rule 4 now says one outline per Map the Zone has placed Markers on. Three new cases (46 in all) hold it: a Zone on a child Map and on its parent, a Zone placed on a parent and only unplaced on its child, and a Zone outlined on a child alone. `map_space` already answered all three; no answer on an earlier case moved. + ## 0.138.0 (2026-11-20) - **`world_graph` reads a co-builder as a keeper** (schema-dist serial 140). The flags `hidden` and `proposed` may be asked by a co-builder, and by the owner reading `as` one, where they were the owner's alone; a co-builder's graph without a lens is answered as the owner's is on the same input, the hidden and proposed elements it leaves out counted in `cut` and `edges_cut`. `not_visible` and `anchor_not_visible` stay the owner's, and a contributor, a guest and the public reader answer as before. A refused flag's `ValueError` now says it is a keeper's. diff --git a/codegen/schema-dist/MANIFEST.json b/codegen/schema-dist/MANIFEST.json index 797c1ef..19e32b6 100644 --- a/codegen/schema-dist/MANIFEST.json +++ b/codegen/schema-dist/MANIFEST.json @@ -162,8 +162,8 @@ "profiles/layout.md": "ffbf41c331b704db8dbddd2887e70787df894b5c7c9555ba5321f31349c44685", "profiles/lens.fixture.json": "9b3694d4190e77848f0ad8d26ffc8d587ed84a7a58a316a5df5a4d2aaa364b23", "profiles/lens.md": "2874a53dac8e0548e53d2414f957d60c7157384579658d2c6b17d0fa62cb92bf", - "profiles/map-space.fixture.json": "f1d832d63b9b0d071bd1bc1c2d16a97b3b9db405a9e01a63451ca74ef0cec657", - "profiles/map-space.md": "f3c6b7f69da6b3ef9e27ef81699d910b17f4757bac173a08b8118d5df9ec7222", + "profiles/map-space.fixture.json": "4ebec65d75b6de4e9a2eb9e1723c8978edef6191ba7fb783d978f882ae3f26f6", + "profiles/map-space.md": "5f629e6722beb3977acd0a42a8fbd5deb393b1d9acfa8e8bdc058168a72e7558", "profiles/message.fixture.json": "418964e564db054c8e969a157f6e29e82499c04180d10bea8c55ac9f5bf5e279", "profiles/message.md": "768e09ef6370deb2af331da8d665128746553498da2cb6e065bbdcaa326d6d2c", "profiles/names.fixture.json": "7d012081b5df7bab3e2223333f87a347417c3061c62b38947fc952e8c4d2377a", @@ -209,7 +209,7 @@ "schema/zone.yaml": "cca04ee498fb813fa18b96f1ac99816e7f1a8ae1fb9e21c48b37620dbb674856", "schema.json": "581dc7b5e890acc06b1c89b0d7bdcc2f20f54f52d5a3b4af8c5a184e1e6fd48c", "SECURITY.md": "939ee364b06f0b749bdd4cbe66b2fe49322c95abe732650ec4ef062a0c03820a", - "VERSION": "697aa14b3b3c37ed4892ae27f89726c8dfefaf7d0b541fb3d2500ade6bc32c48", + "VERSION": "ce39e0457d281134d2fd218152b670884820396a20e934684e9bfdb7f3f7aab3", "views.fixture.json": "6fda45c2d36cc82a613a4b4d99d14ba9646db2c5bf912b82e68c6b62b20441c1", "views.json": "f4d06ee16bd6c66fc28cf27146b8d199c85164e5deecabafc23af53408746fe0", "walk/lint_folder.py": "28efffa3a39d7f2ceaf69cae5c4ddce023e4989e7a5d2c26c1b4d4815eff386e", diff --git a/codegen/schema-dist/VERSION b/codegen/schema-dist/VERSION index fef0357..702ec88 100644 --- a/codegen/schema-dist/VERSION +++ b/codegen/schema-dist/VERSION @@ -1,3 +1,3 @@ canonical: 00.34.01 -serial: 141 -published: 2026-11-20 +serial: 142 +published: 2026-11-21 diff --git a/codegen/schema-dist/profiles/map-space.fixture.json b/codegen/schema-dist/profiles/map-space.fixture.json index 1b097a6..70f5dc5 100644 --- a/codegen/schema-dist/profiles/map-space.fixture.json +++ b/codegen/schema-dist/profiles/map-space.fixture.json @@ -9595,6 +9595,377 @@ "no_point": 1 } } + }, + { + "name": "zone-on-a-child-and-its-parent", + "claim": "rule 4 and the note under rule 14: a Zone drawn as a line on a parent Map and on its child; the parent's line enters the child's parent frame, has a Marker inside it and leaves it. Each Map's outline holds that Map's own Markers as written: nothing is joined, no point is added on the parent frame's edge and none inside it is taken out", + "elements": [ + { + "type": "map", + "id": "019a9420-0000-7000-8000-00000000aa01", + "name": "land", + "width": 1000, + "height": 800 + }, + { + "type": "map", + "id": "019a9420-0000-7000-8000-00000000aa02", + "name": "town", + "width": 100, + "height": 50, + "parent_map": "019a9420-0000-7000-8000-00000000aa01", + "x_parent_frame": [ + 100, + 200, + 300, + 300 + ] + }, + { + "type": "zone", + "id": "019a9420-0000-7000-8000-0000000b0001", + "name": "river", + "shape": "line" + }, + { + "type": "marker", + "id": "019a9420-0000-7000-8000-0000000c0001", + "name": "river: land 1", + "map": "019a9420-0000-7000-8000-00000000aa01", + "zone": "019a9420-0000-7000-8000-0000000b0001", + "x": 40, + "y": 210, + "order": 0 + }, + { + "type": "marker", + "id": "019a9420-0000-7000-8000-0000000c0002", + "name": "river: land 2", + "map": "019a9420-0000-7000-8000-00000000aa01", + "zone": "019a9420-0000-7000-8000-0000000b0001", + "x": 160, + "y": 230, + "order": 1 + }, + { + "type": "marker", + "id": "019a9420-0000-7000-8000-0000000c0005", + "name": "river: land 3", + "map": "019a9420-0000-7000-8000-00000000aa01", + "zone": "019a9420-0000-7000-8000-0000000b0001", + "x": 440, + "y": 250, + "order": 2 + }, + { + "type": "marker", + "id": "019a9420-0000-7000-8000-0000000c0003", + "name": "river: town 1", + "map": "019a9420-0000-7000-8000-00000000aa02", + "zone": "019a9420-0000-7000-8000-0000000b0001", + "x": 0, + "y": 10, + "order": 0 + }, + { + "type": "marker", + "id": "019a9420-0000-7000-8000-0000000c0004", + "name": "river: town 2", + "map": "019a9420-0000-7000-8000-00000000aa02", + "zone": "019a9420-0000-7000-8000-0000000b0001", + "x": 20, + "y": 10, + "order": 1 + } + ], + "want": { + "maps": [ + { + "id": "019a9420-0000-7000-8000-00000000aa01", + "width": 1000, + "height": 800, + "depth": null, + "z_max": 0, + "scale": null, + "location": null, + "parent_map": null + }, + { + "id": "019a9420-0000-7000-8000-00000000aa02", + "width": 100, + "height": 50, + "depth": null, + "z_max": 0, + "scale": null, + "location": null, + "parent_map": "019a9420-0000-7000-8000-00000000aa01" + } + ], + "zones": [ + { + "zone": "019a9420-0000-7000-8000-0000000b0001", + "map": "019a9420-0000-7000-8000-00000000aa01", + "shape": "line", + "points": [ + [ + 40, + 210, + 0 + ], + [ + 160, + 230, + 0 + ], + [ + 440, + 250, + 0 + ] + ] + }, + { + "zone": "019a9420-0000-7000-8000-0000000b0001", + "map": "019a9420-0000-7000-8000-00000000aa02", + "shape": "line", + "points": [ + [ + 0, + 10, + 0 + ], + [ + 20, + 10, + 0 + ] + ] + } + ], + "pins": [], + "out": {} + } + }, + { + "name": "zone-placed-on-a-parent-and-not-on-its-child", + "claim": "rule 4: a Zone with placed Markers on a parent Map and one Marker on its child whose x is not a whole number has an outline on the parent only; the child has none, not one with no points, and the Marker is counted no_point", + "elements": [ + { + "type": "map", + "id": "019a9421-0000-7000-8000-00000000aa01", + "name": "land", + "width": 1000, + "height": 800 + }, + { + "type": "map", + "id": "019a9421-0000-7000-8000-00000000aa02", + "name": "town", + "width": 100, + "height": 50, + "parent_map": "019a9421-0000-7000-8000-00000000aa01", + "x_parent_frame": [ + 100, + 200, + 300, + 300 + ] + }, + { + "type": "zone", + "id": "019a9421-0000-7000-8000-0000000b0001", + "name": "marsh" + }, + { + "type": "marker", + "id": "019a9421-0000-7000-8000-0000000c0001", + "name": "marsh: land 1", + "map": "019a9421-0000-7000-8000-00000000aa01", + "zone": "019a9421-0000-7000-8000-0000000b0001", + "x": 40, + "y": 210, + "order": 0 + }, + { + "type": "marker", + "id": "019a9421-0000-7000-8000-0000000c0002", + "name": "marsh: land 2", + "map": "019a9421-0000-7000-8000-00000000aa01", + "zone": "019a9421-0000-7000-8000-0000000b0001", + "x": 160, + "y": 230, + "order": 1 + }, + { + "type": "marker", + "id": "019a9421-0000-7000-8000-0000000c0003", + "name": "marsh: town 1", + "map": "019a9421-0000-7000-8000-00000000aa02", + "zone": "019a9421-0000-7000-8000-0000000b0001", + "x": 1.5, + "y": 10, + "order": 0 + } + ], + "want": { + "maps": [ + { + "id": "019a9421-0000-7000-8000-00000000aa01", + "width": 1000, + "height": 800, + "depth": null, + "z_max": 0, + "scale": null, + "location": null, + "parent_map": null + }, + { + "id": "019a9421-0000-7000-8000-00000000aa02", + "width": 100, + "height": 50, + "depth": null, + "z_max": null, + "scale": null, + "location": null, + "parent_map": "019a9421-0000-7000-8000-00000000aa01" + } + ], + "zones": [ + { + "zone": "019a9421-0000-7000-8000-0000000b0001", + "map": "019a9421-0000-7000-8000-00000000aa01", + "shape": "polygon", + "points": [ + [ + 40, + 210, + 0 + ], + [ + 160, + 230, + 0 + ] + ] + } + ], + "pins": [], + "out": { + "no_point": 1 + } + } + }, + { + "name": "zone-outlined-on-a-child-alone", + "claim": "rule 4: a Zone with placed Markers on a child Map with a parent frame and none on its parent has an outline on the child only; the parent has none, and the child's points are not carried up to make one", + "elements": [ + { + "type": "map", + "id": "019a9422-0000-7000-8000-00000000aa01", + "name": "land", + "width": 1000, + "height": 800 + }, + { + "type": "map", + "id": "019a9422-0000-7000-8000-00000000aa02", + "name": "town", + "width": 100, + "height": 50, + "parent_map": "019a9422-0000-7000-8000-00000000aa01", + "x_parent_frame": [ + 100, + 200, + 300, + 300 + ] + }, + { + "type": "zone", + "id": "019a9422-0000-7000-8000-0000000b0001", + "name": "pond" + }, + { + "type": "marker", + "id": "019a9422-0000-7000-8000-0000000c0001", + "name": "pond 1", + "map": "019a9422-0000-7000-8000-00000000aa02", + "zone": "019a9422-0000-7000-8000-0000000b0001", + "x": 20, + "y": 10, + "order": 0 + }, + { + "type": "marker", + "id": "019a9422-0000-7000-8000-0000000c0002", + "name": "pond 2", + "map": "019a9422-0000-7000-8000-00000000aa02", + "zone": "019a9422-0000-7000-8000-0000000b0001", + "x": 40, + "y": 30, + "order": 1 + }, + { + "type": "marker", + "id": "019a9422-0000-7000-8000-0000000c0003", + "name": "pond 3", + "map": "019a9422-0000-7000-8000-00000000aa02", + "zone": "019a9422-0000-7000-8000-0000000b0001", + "x": 20, + "y": 30, + "order": 2 + } + ], + "want": { + "maps": [ + { + "id": "019a9422-0000-7000-8000-00000000aa01", + "width": 1000, + "height": 800, + "depth": null, + "z_max": null, + "scale": null, + "location": null, + "parent_map": null + }, + { + "id": "019a9422-0000-7000-8000-00000000aa02", + "width": 100, + "height": 50, + "depth": null, + "z_max": 0, + "scale": null, + "location": null, + "parent_map": "019a9422-0000-7000-8000-00000000aa01" + } + ], + "zones": [ + { + "zone": "019a9422-0000-7000-8000-0000000b0001", + "map": "019a9422-0000-7000-8000-00000000aa02", + "shape": "polygon", + "points": [ + [ + 20, + 10, + 0 + ], + [ + 40, + 30, + 0 + ], + [ + 20, + 30, + 0 + ] + ] + } + ], + "pins": [], + "out": {} + } } ], "layout_cases": [ diff --git a/codegen/schema-dist/profiles/map-space.md b/codegen/schema-dist/profiles/map-space.md index 738dc67..80932eb 100644 --- a/codegen/schema-dist/profiles/map-space.md +++ b/codegen/schema-dist/profiles/map-space.md @@ -9,7 +9,7 @@ 1. **Coordinates.** `x` and `y` count from the bottom left of the Map, in the Map's pixels; `z` is in the same pixels, upward, and the Map's `depth` is the z extent. `z` is a point's elevation, never a height: a Marker at z 300 sits 300 pixels up, and a zone's height, where a tool wants one, is the tool's own key (the first folder read against this page had written a room's height into every Marker's z, and its reader read it back as wall height; both moved the same day). All are whole numbers as the standard says. A missing `x` or `y` on a Marker or Pin, or one that is not a whole number, leaves that row out, counted `no_point`; a `z` that is missing or not a whole number reads as 0. A reader holds a whole number within the range it holds exactly and reads a value past it as not whole: a value a parse had to round is not whole, so a reader whose JSON numbers are doubles holds whole numbers to 2^53 and reads past it as not whole; the fixture keeps every number within 2^53, so every reader answers alike. A `z` past the Map's `depth` is kept as written and never clipped: the reader reports, it does not fix (the Map entry carries `z_max`, the largest z among its points, beside `depth`, so a tool sees the overrun). 2. **Maps.** One entry per Map the reader is served: `{id, width, height, depth, z_max, scale, location, parent_map}`. A Map without `width` or `height` reports the extent of its own placed Markers and Pins (the largest x and y among those with a whole x and y that name the Map; a dangling or unplaced point measures nothing) in that slot, with `extent: "points"` beside it, so a drawing tool knows the frame was measured, not authored. A `width` or `height` that is a whole number is answered as that number, 0 and a number under 0 included; any other value, or none, is measured. A slot measured on a Map with no placed point of its own answers null, still with `extent: "points"`. A `depth` that is a whole number is answered as that number too; any other value, or none, reads null and is never measured. 3. **Scale.** `scale` is metres per pixel: the Map's `x_metres_per_pixel` when it carries one (a decimal; the convention this page reads, as the lens profile read `x_lens`, until a scale field reaches the standard by motion), else `null`; a number passed through as given, with no byte guarantee across languages (a `1.0` prints as `1` in one and `1.0` in another; its decimals never had one). The World's `length_unit` is not a map scale and this page does not read it as one. A tool with no scale draws in pixels. -4. **A Zone's outline.** The Markers whose `zone` names the Zone and whose `map` names one Map, in `order` ascending, ties and missing `order` by id in code point order (an `order` that is not a whole number reads as missing). Id order is the one answer a folder and a server give alike; it is the making order only when ids are uuidv7, and this page does not claim it otherwise; one outline per Map the Zone has Markers on, as `{zone, map, shape, points}` with each point `[x, y, z]`. A repeated point is kept as written. `shape` is the Zone's own `shape` when it is `polygon` or `line`; empty, absent or any other value reads as `polygon`, as the field's description says. A Zone with no placed Marker has no outline and is counted `no_markers`, each of its unplaced Markers under its own reason; a Marker whose `zone` or `map` is not served is counted `dangling`. +4. **A Zone's outline.** The Markers whose `zone` names the Zone and whose `map` names one Map, in `order` ascending, ties and missing `order` by id in code point order (an `order` that is not a whole number reads as missing). Id order is the one answer a folder and a server give alike; it is the making order only when ids are uuidv7, and this page does not claim it otherwise; one outline per Map the Zone has placed Markers on, as `{zone, map, shape, points}` with each point `[x, y, z]`. A repeated point is kept as written. `shape` is the Zone's own `shape` when it is `polygon` or `line`; empty, absent or any other value reads as `polygon`, as the field's description says. A Zone with no placed Marker has no outline and is counted `no_markers`, each of its unplaced Markers under its own reason; a Marker whose `zone` or `map` is not served is counted `dangling`. 5. **A Pin's point.** One entry per Pin whose `map` is served: `{pin, map, element_type, element_id, x, y, z}`. The element is the generic link as the wire serves it and a folder writes it, `element_type` and `element_id`; a Pin with neither, or with only one of the two, is still a point (a place with a name and nothing it stands for), with both null. A Pin whose element is not served keeps its ids: the reader may know the id without the row. 6. **Out.** `out` counts what the reading left aside by reason: `no_point`, `no_markers`, `dangling`, `no_map`. A reason with nothing counted is absent. 7. **A stable order.** `maps`, `zones` and `pins` by id in code point order (outlines by zone id, then map id); the same input gives the same answer, byte for byte. @@ -19,7 +19,7 @@ 11. **Picking a Map.** Which Map stands for the world's space when a world has several stays the tool's (below). One thing is ruled: a layout map is no candidate. A tool that picks a Map for the world's space, by whatever rule of its own (no `parent_map`, the most Pins, a picture, a name, the order read), reads each Map's layout first (rule 8) and leaves out every Map that is a layout map. And a Pin on a layout map says where its element stands in that drawing, drawn over a ground or not (rule 9), and a Marker there where its Zone's outline runs in it, never where either is in the world: a tool that measures between elements or places an element in the world reads no Pin and no Marker of a layout map. A world whose every Map is a layout map has no Map for its space, and a tool says so; a tool that shows layout maps still opens one as what it is. The map-space reading and the layout reading answer a layout map as before, its Pins and its Markers with it; this rule is on the tool that picks or places from them. 12. **Who writes the mark.** The writer that knows what the Map is. A tool that lays Pins out by a method writes `x_layout` with that method; a tool that imports a surface its source holds as a board (cards placed by hand on no map of a place) writes `{"method": "hand"}`; a tool that makes a Map a person names, for whatever they mean by it, writes nothing, and may offer the person a control that says "this is a board". The test is what the Map is, never the source's word for it: an importer that meets a board holding a map of a real place marks nothing, and that Map is a plain Map (a ground when a layout names it). A method that places every Pin where its element is in the world and names no ground makes a place, not a drawing, and writes no mark: the Map is the world's space, whatever placed its Pins, and nothing on the standard's side lays it out again (the tool keeps its own recipe in its own namespace). 13. **A child Map's parent frame.** A Map's `x_parent_frame`, its parent frame, is a list of four numbers `[x0, y0, x1, y1]`: two corners of a box in the pixels of the Map its `parent_map` names, counted as a Pin on that Map counts them, from its bottom left (rule 1). The child's own rectangle, from (0, 0) to (`width`, `height`), lies on that box, each axis by its own ratio: a box of another shape than the child's is a stretch, not a fault, with no threshold and no refusal, and neither axis takes the other's ratio. Nothing turns: the child's axes are the parent's, a plan drawn turned carries its turn inside its picture, and the key says no rotation and a reader reads none. The parent frame places and a scale measures: a reader reports both as the world holds them, takes no scale from a parent frame and no parent frame from a scale (rule 3), and reconciles neither with the other. The key is read only on a Map with a `parent_map` (a link as reading H reads one); on a Map with none, a key that is present and not null is not read, with the lint `no_parent`, whatever it holds. It is a parent frame when it is a list of exactly four numbers with x0 less than x1 and y0 less than y1, the four compared as 64-bit floats. A number here is a JSON number a reader holds as a finite 64-bit float: a string, a boolean, null, a list and an object are none, and so is a number too large for a 64-bit float. A value that is not a list of exactly four numbers (a list of another length, one that holds anything that is no number, or no list at all) is no parent frame, with the lint `not_four_numbers`, and its first four are never read; a box with x0 not less than x1, or y0 not less than y1 (mirrored, or with no width or no height), is no parent frame, with the lint `not_a_box`, and is never normalised. A key that is absent or null is no parent frame, with no lint. A Map with a `parent_map` and no parent frame has no place on its parent: a tool may still go into it by the Pin of its `location` on the parent, or by a layout file of its own, and that is a way in, not a place. A child whose `width` or `height` is not a whole number above 0 (by value, as reading K reads one) has its parent frame and no carry: the parent frame is reported, and no point is carried through it. The size a parent frame divides by is the written one, never the extent rule 2 measures from the child's points (that extent moves whenever a Pin is added, and every carried point with it); 0 and a size under 0, which rule 2 answers as written, divide by nothing or turn the box over. -14. **Carrying a point.** A point (x, y), two numbers whole or not, on a child with a parent frame and a carry is, on its parent, `x0 + ((x * (x1 - x0)) / width)` and `y0 + ((y * (y1 - y0)) / height)`, in 64-bit binary floating point: the point, the four numbers and the two sizes each read as a 64-bit float, and each step taken in the order the parentheses write, the difference, then the product, then the quotient, then the sum. Sixty-four bits alone is not the rule; the order is: the step per pixel taken first, the fraction taken first, a carry from the box's centre, and exact rationals rounded once each give another last bit on some points, and two readers that keep this order give the same bits. Nesting composes: a point on a plan framed on a town map framed on the land is carried by the plan's parent frame onto the town map, and that point, as the carry gave it, by the town map's parent frame onto the land, one level at a time up the `parent_map` chain, never through one product of the levels' ratios. At each Map the walk reaches, the first of these that holds ends it, served-ness before shape as in reading A: the Map has no `parent_map` (`top`); its `parent_map` names a Map the reader is not served (`dangling`); it names a Map the walk has already reached, the Map itself included (`cycle`), so no point is carried onto a Map twice; the Map has no parent frame (`no_frame`); or it has one and no carry (`no_carry`). A point outside the child's rectangle is carried as written and never clipped. `z` is not carried: a parent frame says nothing of `depth`. A reader that keeps a point in 32 bits carries it in 64 and rounds once, when it draws or stores it; that rounding is the reader's own and outside what the fixture compares. The small plates of the default layouts page's `by-links-3d` stand at a Map's `location` and read no parent frame: they are a drawing, not where a child lies, and this rule does not move them. +14. **Carrying a point.** A point (x, y), two numbers whole or not, on a child with a parent frame and a carry is, on its parent, `x0 + ((x * (x1 - x0)) / width)` and `y0 + ((y * (y1 - y0)) / height)`, in 64-bit binary floating point: the point, the four numbers and the two sizes each read as a 64-bit float, and each step taken in the order the parentheses write, the difference, then the product, then the quotient, then the sum. Sixty-four bits alone is not the rule; the order is: the step per pixel taken first, the fraction taken first, a carry from the box's centre, and exact rationals rounded once each give another last bit on some points, and two readers that keep this order give the same bits. Nesting composes: a point on a plan framed on a town map framed on the land is carried by the plan's parent frame onto the town map, and that point, as the carry gave it, by the town map's parent frame onto the land, one level at a time up the `parent_map` chain, never through one product of the levels' ratios. At each Map the walk reaches, the first of these that holds ends it, served-ness before shape as in reading A: the Map has no `parent_map` (`top`); its `parent_map` names a Map the reader is not served (`dangling`); it names a Map the walk has already reached, the Map itself included (`cycle`), so no point is carried onto a Map twice; the Map has no parent frame (`no_frame`); or it has one and no carry (`no_carry`). A point outside the child's rectangle is carried as written and never clipped. `z` is not carried: a parent frame says nothing of `depth`. A reader that keeps a point in 32 bits carries it in 64 and rounds once, when it draws or stores it; that rounding is the reader's own and outside what the fixture compares. The small plates of the default layouts page's `by-links-3d` stand at a Map's `location` and read no parent frame: they are a drawing, not where a child lies, and this rule does not move them. Where a Zone has an outline on a child Map and on its parent (rule 4), no reading on this page joins the two outlines, or adds a point on the edge of the child's rectangle or of its parent frame. What a tool draws of the Zone inside the parent frame and past it, and whether it shows the parent's outline through the parent frame, is the tool's. **The layout reading.** `layoutOf(map, maps, pins)`, one reader in the SDK and the Python package (`layout_of`), from the fixture's `layout_cases`. `map` is one Map, `maps` the Maps the reader is served, `pins` every Pin the caller holds, of any Map, as served; the reader itself keeps the Pins whose `map` names this Map's id, and reads a row as the map-space reading does (H: a row without a non-empty string id is no Pin, and a Map row without one is no Map, so the reading answers `{layout: null, ground: null, hand: []}` for it, whatever it carries; I: the last row served for an id wins). The answer is `{layout, ground, hand}`, in that order, every key always present: - `layout`: the `method` string when the Map is a layout map (rule 8), else `null`. A method no page names answers itself. @@ -38,10 +38,10 @@ The point on the parent is `points[1]` where there is one; the point on the top **Readings ruled on the fixture** (2026-11-02): A, a Marker that is both dangling and without a point counts once, as `dangling` (served-ness before shape). B, a Marker without a whole `order` sorts after every ordered one, then by id (where the ids are uuidv7, as keel mints them, that is the order they were made in): a stated order outranks an unstated one. C, a Pin with one of its two keys reads both null. D, a `width` or `height` that is missing or not a whole number is measured from that Map's own Markers and Pins only, and with no placed one of them it is null. E, `scale` is set only when `x_metres_per_pixel` is a positive number, else null. F, `extent: "points"` appears only when a slot was measured. G, a `z` past `depth` is kept. H, a row without a non-empty string id is no element: ignored, never counted (an element is its id; what has none was never served); a link whose value is not a non-empty string is no link and is read as an absent one: an empty string, a list, a number, a boolean, an object, as an id that is empty is no id (a Pin left with one of its two element keys then reads both null, rule 5). I, two rows of one type with one id: the last row served wins, for every type (a reader holds one row per id). J, reading A reaches Pins: a Pin with neither a served map nor a point counts once, as `no_map`. K, `type` and `shape` are read case-exactly: `Map` is no Map and `Line` is a polygon, as the field's own sentence says lowercase. And a whole number is a JSON number with no fractional part, whatever its spelling: `2.0` reads as 2, `1.5` and `"2"` do not read; a reader in a language that keeps the spelling converts, never refuses, on the value. -**What stays the tool's**, said so nobody ports it as a rule: which Map stands for the world's space when a world has several, among those rule 11 leaves; a default scale when none is given (the C# takes 0.05); hull, area and room roles read from `role` or `x_` keys; doors as Objects with Pins, their widths and wall snaps; a lift factor on z; cameras and looks; how a layout method places where no page rules it, and its own `settings`; what a layout method does with a layout map's Markers; a way into a child Map that has no parent frame (the Pin of its `location` on the parent, a layout file beside the world), which is never a place; how a child's picture is drawn on its parent's. A reader that wants those builds them on this page's answer. +**What stays the tool's**, said so nobody ports it as a rule: which Map stands for the world's space when a world has several, among those rule 11 leaves; a default scale when none is given (the C# takes 0.05); hull, area and room roles read from `role` or `x_` keys; doors as Objects with Pins, their widths and wall snaps; a lift factor on z; cameras and looks; how a layout method places where no page rules it, and its own `settings`; what a layout method does with a layout map's Markers; a way into a child Map that has no parent frame (the Pin of its `location` on the parent, a layout file beside the world), which is never a place; how a child's picture is drawn on its parent's, and what is drawn of a Zone outlined on both (rule 14). A reader that wants those builds them on this page's answer. -**The fixture** `map-space.fixture.json`: each case is the elements as one reader is served them, and a `want` that holds the whole answer, keys in order. The cases cover: `order` then id, and a Zone with no `order` at all; a repeated corner kept; `polygon`, `line`, absent and a stray value for `shape`; a Zone with Markers on two Maps; a Marker whose `zone` is not served, and one whose `map` is not; a Pin with no element, and one whose element is not served; `z` present and absent, and a `z` past the Map's `depth`; a Marker whose `x` is not a whole number; an `order` of `"2"` and of `1.5`; a Pin with one of its two keys; a Map without `width`; a Map with `x_metres_per_pixel` and one without; a hidden Zone, read as the owner and as a visitor (the visitor's input lacks it, the answer has no outline for it, and nothing in `out` names it); ids above U+FFFF for the code point order; a layout map with a Zone's Markers and a Pin on it, beside a plain Map with a Pin, read as any Map (rule 11); an empty string as a link: a Pin's `map`, a Marker's `zone`, a Map's `parent_map` and `location`, and a Pin's `element_type` and `element_id` together; a written size of 0 and under 0, and a `depth` of 0 and under 0, a `height` as a `width`; a `width` and a `depth` that are null, `1.5`, `"100"` and `true`; each of the seven links the reading reads (a Map's `location` and `parent_map`, a Pin's `map`, `element_id` and `element_type`, a Marker's `map` and `zone`) as a list, a number, a boolean and an object, the values ones a careless reader would take; and a Map measured with no point of its own. Its `layout_cases`, beside `cases`, are the layout reading's: each case is the elements as one reader is served them and `map`, the id of the Map read (the reader's `map` is that row, `maps` the case's Map rows, `pins` its Pin rows; a case that reads a Map row with no non-empty string id cannot name it, so it has `map_index` instead, a list of positions in `elements`, and the answer is the case's `want` for each row read), with a `want` that holds the whole answer, keys in order. They cover: `x_layout` absent, null, a string, an object without `method` but with a ground, `method` `""`, and a `method` that is not a string; a board with two unmarked Pins and one marked; a known method with `x_hand` as `true`, `"true"`, `1`, `false` and absent; a marked Pin served with its element link null; a method no page names; a ground naming a served Map, a Map not served, no `map`, a `map` that is an empty string, and the layout Map itself; a plain Map whose Pins keep their marks after `x_layout` is removed; a Map with three Pins that gains a method, as the writer leaves it; Pins held out of id order, and a Pin on another Map; two Pin ids that a UTF-16 comparison and a code point comparison put in different orders; a Pin id repeated, marked in its first row and not its last, and the reverse; a Pin row with no `id`, one whose `id` is a number, and one whose `id` is an empty string; a Map row with no `id`, and one whose `id` is a number, each carrying a method, a served ground and marked Pins, one of them with no `map`; a Map row whose `id` is an empty string, a board with a Pin whose `map` is an empty string too; a layout Map and its ground, neither with a `parent_map`, the layout holding three Pins and the ground one, each read in turn (a missing parent and a Pin count neither make nor unmake a layout); a Map whose Pins a method drew, marked with that method; a Map with no `x_layout` whose Pins a tool placed at their true positions by a recipe in its own namespace; and a board of a real place, imported with supertype `Board` and no mark; and a ground whose `map` is a number beside a Map whose id is its text, a list holding a served Map's id, and an object holding one: each no ground (reading H). Its `frame_cases` are the frame reading's: each case is the elements as one reader is served them, `map`, the id of the Map read (or `map_index`, as in a layout case: a list of positions in `elements`, and the answer is the case's `want` for each row read), and `point`, with a `want` that holds the whole answer, keys in order. The reader's `map` is the row read (for an id, the last Map row served with it) and its `maps` every row of the case, of which it keeps the Maps by reading K. A number in `parent_frame` and in `points` compares as a 64-bit float, exactly equal and with no tolerance (`100.0` and `100` are one number); every other part compares as written. They cover: a point carried, each axis by its own ratio and y from the bottom; a stretch; a box the child's shape turned; a point outside the child; a box past the parent's edges; a parent frame and a `width` written with a fraction part of 0; a parent frame on a Map with no `parent_map`, with one that is an empty string, with one that is a list, a number, a boolean and an object, and a malformed one with none; a Map with no `parent_map` and no key, and one whose key is null; a parent frame absent, beside a Pin of the child's `location` on the parent, and one null; three numbers, five, numbers as strings, a string, a boolean, a null and a list among four, a string, an object, a number, a boolean and an empty list; an empty string and `false` as the key of a child, and an empty string as the key of a Map with no `parent_map`; a box mirrored in x and in y, and one with no width and no height; a child with no size, and with no `height`, each beside points that would measure one; a `width` of 0, under 0, of 99.6, `"100"` and `true`, and a `height` under 0; decimals on which the per-pixel order, the fraction-first order, a centre-based order and exact rationals each differ from the written order, one case for x and one for y; three levels and four, with decimals on which a product of the levels' ratios differs; a level with no parent frame, a mirrored one and one with no carry, and a top Map that carries a parent frame; a parent not served, alone and beside a malformed parent frame, and a parent served only as a row whose `type` is `Map`; a Map that names itself, with a parent frame, with none, and with no `width`; two in a ring, and a ring above the Map read; a child with a served parent and neither a parent frame nor a `width`; a Map and its parent each served twice; a Map row with no `id` and one whose `id` is an empty string, and a row read whose `type` is `Map`; two scales that disagree with the parent frame; and a layout map with a parent frame. +**The fixture** `map-space.fixture.json`: each case is the elements as one reader is served them, and a `want` that holds the whole answer, keys in order. The cases cover: `order` then id, and a Zone with no `order` at all; a repeated corner kept; `polygon`, `line`, absent and a stray value for `shape`; a Zone with Markers on two Maps; a Marker whose `zone` is not served, and one whose `map` is not; a Pin with no element, and one whose element is not served; `z` present and absent, and a `z` past the Map's `depth`; a Marker whose `x` is not a whole number; an `order` of `"2"` and of `1.5`; a Pin with one of its two keys; a Map without `width`; a Map with `x_metres_per_pixel` and one without; a hidden Zone, read as the owner and as a visitor (the visitor's input lacks it, the answer has no outline for it, and nothing in `out` names it); ids above U+FFFF for the code point order; a layout map with a Zone's Markers and a Pin on it, beside a plain Map with a Pin, read as any Map (rule 11); an empty string as a link: a Pin's `map`, a Marker's `zone`, a Map's `parent_map` and `location`, and a Pin's `element_type` and `element_id` together; a written size of 0 and under 0, and a `depth` of 0 and under 0, a `height` as a `width`; a `width` and a `depth` that are null, `1.5`, `"100"` and `true`; each of the seven links the reading reads (a Map's `location` and `parent_map`, a Pin's `map`, `element_id` and `element_type`, a Marker's `map` and `zone`) as a list, a number, a boolean and an object, the values ones a careless reader would take; a Map measured with no point of its own; a Zone with Markers on a child Map with a parent frame and on its parent, the parent's line entering the parent frame, with a Marker inside it, and leaving it; a Zone with placed Markers on a parent and only an unplaced one on its child; and a Zone with placed Markers on a child with a parent frame and none on its parent. Its `layout_cases`, beside `cases`, are the layout reading's: each case is the elements as one reader is served them and `map`, the id of the Map read (the reader's `map` is that row, `maps` the case's Map rows, `pins` its Pin rows; a case that reads a Map row with no non-empty string id cannot name it, so it has `map_index` instead, a list of positions in `elements`, and the answer is the case's `want` for each row read), with a `want` that holds the whole answer, keys in order. They cover: `x_layout` absent, null, a string, an object without `method` but with a ground, `method` `""`, and a `method` that is not a string; a board with two unmarked Pins and one marked; a known method with `x_hand` as `true`, `"true"`, `1`, `false` and absent; a marked Pin served with its element link null; a method no page names; a ground naming a served Map, a Map not served, no `map`, a `map` that is an empty string, and the layout Map itself; a plain Map whose Pins keep their marks after `x_layout` is removed; a Map with three Pins that gains a method, as the writer leaves it; Pins held out of id order, and a Pin on another Map; two Pin ids that a UTF-16 comparison and a code point comparison put in different orders; a Pin id repeated, marked in its first row and not its last, and the reverse; a Pin row with no `id`, one whose `id` is a number, and one whose `id` is an empty string; a Map row with no `id`, and one whose `id` is a number, each carrying a method, a served ground and marked Pins, one of them with no `map`; a Map row whose `id` is an empty string, a board with a Pin whose `map` is an empty string too; a layout Map and its ground, neither with a `parent_map`, the layout holding three Pins and the ground one, each read in turn (a missing parent and a Pin count neither make nor unmake a layout); a Map whose Pins a method drew, marked with that method; a Map with no `x_layout` whose Pins a tool placed at their true positions by a recipe in its own namespace; and a board of a real place, imported with supertype `Board` and no mark; and a ground whose `map` is a number beside a Map whose id is its text, a list holding a served Map's id, and an object holding one: each no ground (reading H). Its `frame_cases` are the frame reading's: each case is the elements as one reader is served them, `map`, the id of the Map read (or `map_index`, as in a layout case: a list of positions in `elements`, and the answer is the case's `want` for each row read), and `point`, with a `want` that holds the whole answer, keys in order. The reader's `map` is the row read (for an id, the last Map row served with it) and its `maps` every row of the case, of which it keeps the Maps by reading K. A number in `parent_frame` and in `points` compares as a 64-bit float, exactly equal and with no tolerance (`100.0` and `100` are one number); every other part compares as written. They cover: a point carried, each axis by its own ratio and y from the bottom; a stretch; a box the child's shape turned; a point outside the child; a box past the parent's edges; a parent frame and a `width` written with a fraction part of 0; a parent frame on a Map with no `parent_map`, with one that is an empty string, with one that is a list, a number, a boolean and an object, and a malformed one with none; a Map with no `parent_map` and no key, and one whose key is null; a parent frame absent, beside a Pin of the child's `location` on the parent, and one null; three numbers, five, numbers as strings, a string, a boolean, a null and a list among four, a string, an object, a number, a boolean and an empty list; an empty string and `false` as the key of a child, and an empty string as the key of a Map with no `parent_map`; a box mirrored in x and in y, and one with no width and no height; a child with no size, and with no `height`, each beside points that would measure one; a `width` of 0, under 0, of 99.6, `"100"` and `true`, and a `height` under 0; decimals on which the per-pixel order, the fraction-first order, a centre-based order and exact rationals each differ from the written order, one case for x and one for y; three levels and four, with decimals on which a product of the levels' ratios differs; a level with no parent frame, a mirrored one and one with no carry, and a top Map that carries a parent frame; a parent not served, alone and beside a malformed parent frame, and a parent served only as a row whose `type` is `Map`; a Map that names itself, with a parent frame, with none, and with no `width`; two in a ring, and a ring above the Map read; a child with a served parent and neither a parent frame nor a `width`; a Map and its parent each served twice; a Map row with no `id` and one whose `id` is an empty string, and a row read whose `type` is `Map`; two scales that disagree with the parent frame; and a layout map with a parent frame. **Where it shows.** Any tool that draws a world's maps: Atlas's map view, the Shell's Deck, the Unity package, the visuals engine. Keel draws nothing with it today. -**Ruled**: 2026-11-02, on the visuals round's four drafts in one evening: the Pin's two keys as the wire serves them, id order for an unstated `order`, z as elevation and never a height (the plan of record moved its room heights out of z the same hour), eight fixture readings (A to H), a whole number by value. A map scale is read from `x_metres_per_pixel` as a convention until a scale field reaches the standard by motion. 2026-11-02, serial 106: three engine ports found one parity difference and six silences; readings I to K, placed points for a measured frame, a non-whole z as 0, `no_markers` as no placed Marker, and the platform range sentence. 2026-11-03, serial 107: a reader's integer range is what it holds exactly, and a JSON reader whose numbers are doubles holds whole numbers to 2^53 (found by the SDK's and a game engine's readers); no fixture change. 2026-11-10: the layout keys, rules 8 to 10 (`x_layout` as the mark and the recipe, its ground, `x_hand` on a Pin and the writer's order), and the layout reading with its own fixture section; the map-space reading and its cases do not change. 2026-11-10, serial 111: four layout cases, twenty-one in all, the first ports found missing (code point order, a repeated Pin id, a Pin row without a string id, a Map row without one); reading H holds for the Map row of the layout reading; no rule change. 2026-11-12, serial 119: rule 11, a layout map is no candidate when a tool picks a world's Map, and a Pin or a Marker on one is never a place in the world; two layout cases, twenty-three in all (a layout Map and its ground, neither with a `parent_map`), and one map-space case, a layout map read as any Map; no reader's answer moves. 2026-11-14, serial 126: a link whose value is an empty string is no link, read as null, as an empty id is no id; reading H has said a non-empty string id since serial 119, which that serial's entry did not say; seven cases, four map-space cases (an empty `map`, `zone`, `parent_map` with `location`, and element pair) and three layout cases (an empty Map id, Pin id and ground `map`), twenty-six layout cases in all; the SDK's and the Python package's readers already answer every one. 2026-11-14, serial 127: the layout mark has one meaning, the Map is a drawing of its elements and not a place in the world (rule 8), and rule 12 says who writes it: a tool that lays Pins out by a method, a tool that imports a board, never a tool for a Map a person names, and never a method that places every Pin at its element's place in the world with no ground, the test being what the Map is and never the source's word for it; rule 10's writer order binds a Map that held Pins before its method, not one written new in one act; three layout cases, twenty-nine in all, none of which moves a reader. 2026-11-16, serial 132: rule 8 names the default layouts page (`profiles/layout.md`) as the page of the method words `by-kind` and `around`; a method's page may be a section on one, and a method word is read whole; the stored Pins are the layout and a tool that draws a stored Pin draws it where it stands; no tool draws an element the Map has no Pin for as though the Map placed it, or another picture as this Map, and what any tool draws beside the stored Pins without saving is the tool's; reading or drawing a layout map adds, changes or removes none of its Pins or Markers and leaves its frame and its `x_layout` as they are, and laying it out again, or placing on it the elements it does not place, is a write like any other and never a side effect of reading or drawing the Map; a write a tool makes by itself as a Map is opened or drawn is such a side effect, whatever setting ordered it; a tool that tells how many, or which, elements the method would place that the Map does not place uses the reading on the method's page where there is one (`unplaced`); how a layout method places stays the tool's where no page rules it, and so do a method's own `settings`; no case and no reader moves. 2026-11-16, serial 137: on the default layouts page's third method, which reads Maps through this reading: a `width` or `height` that is a whole number is answered as that number, 0 and under 0 included, and any other value is measured as a missing one is; a slot measured with no placed point is null and still says it was measured; a `depth` that is a whole number is answered as that number, any other is null, and none is measured; a link whose value is not a non-empty string is no link, a list, a number, a boolean and an object like the empty string; rule 8 names `by-links-3d` among the default layouts page's words; four cases, and three layout cases for a layout's ground. 2026-11-18, serial 139: where a child Map lies on its parent (rule 13), `x_parent_frame`, two corners in the parent's pixels counted from its bottom left as a Pin's are; the child's rectangle lies on that box, each axis by its own ratio, a box of another shape being a stretch with no threshold; no turn; the parent frame places and a scale measures, and neither is read from the other; a Map with a `parent_map` and no parent frame has no place on its parent, and a Pin of its place there is a way in. 2026-11-19, serial 139: nesting composes, one level at a time, and a level with no parent frame or no carry carries the point no further; a value that is not a list of exactly four numbers, or a box with x0 not less than x1 or y0 not less than y1, is no parent frame, with a lint, and is never normalised or cut to four; a key present and not null on a Map with no `parent_map` is not read, with a lint; a child whose `width` or `height` is not a whole number above 0 as written (by value) has its parent frame and no carry, and a measured extent is never the size a parent frame divides by; the carry is written out in its order in 64-bit floats, the fixture compares it exactly and names no tolerance, and a reader that holds 32 bits rounds once, outside the compare; a walk ends at a Map it has already reached (rule 14); the frame reading, `carryOf`, with its own fixture section, `frame_cases`, sixty-six cases; the map-space reading and its forty-three cases do not change. +**Ruled**: 2026-11-02, on the visuals round's four drafts in one evening: the Pin's two keys as the wire serves them, id order for an unstated `order`, z as elevation and never a height (the plan of record moved its room heights out of z the same hour), eight fixture readings (A to H), a whole number by value. A map scale is read from `x_metres_per_pixel` as a convention until a scale field reaches the standard by motion. 2026-11-02, serial 106: three engine ports found one parity difference and six silences; readings I to K, placed points for a measured frame, a non-whole z as 0, `no_markers` as no placed Marker, and the platform range sentence. 2026-11-03, serial 107: a reader's integer range is what it holds exactly, and a JSON reader whose numbers are doubles holds whole numbers to 2^53 (found by the SDK's and a game engine's readers); no fixture change. 2026-11-10: the layout keys, rules 8 to 10 (`x_layout` as the mark and the recipe, its ground, `x_hand` on a Pin and the writer's order), and the layout reading with its own fixture section; the map-space reading and its cases do not change. 2026-11-10, serial 111: four layout cases, twenty-one in all, the first ports found missing (code point order, a repeated Pin id, a Pin row without a string id, a Map row without one); reading H holds for the Map row of the layout reading; no rule change. 2026-11-12, serial 119: rule 11, a layout map is no candidate when a tool picks a world's Map, and a Pin or a Marker on one is never a place in the world; two layout cases, twenty-three in all (a layout Map and its ground, neither with a `parent_map`), and one map-space case, a layout map read as any Map; no reader's answer moves. 2026-11-14, serial 126: a link whose value is an empty string is no link, read as null, as an empty id is no id; reading H has said a non-empty string id since serial 119, which that serial's entry did not say; seven cases, four map-space cases (an empty `map`, `zone`, `parent_map` with `location`, and element pair) and three layout cases (an empty Map id, Pin id and ground `map`), twenty-six layout cases in all; the SDK's and the Python package's readers already answer every one. 2026-11-14, serial 127: the layout mark has one meaning, the Map is a drawing of its elements and not a place in the world (rule 8), and rule 12 says who writes it: a tool that lays Pins out by a method, a tool that imports a board, never a tool for a Map a person names, and never a method that places every Pin at its element's place in the world with no ground, the test being what the Map is and never the source's word for it; rule 10's writer order binds a Map that held Pins before its method, not one written new in one act; three layout cases, twenty-nine in all, none of which moves a reader. 2026-11-16, serial 132: rule 8 names the default layouts page (`profiles/layout.md`) as the page of the method words `by-kind` and `around`; a method's page may be a section on one, and a method word is read whole; the stored Pins are the layout and a tool that draws a stored Pin draws it where it stands; no tool draws an element the Map has no Pin for as though the Map placed it, or another picture as this Map, and what any tool draws beside the stored Pins without saving is the tool's; reading or drawing a layout map adds, changes or removes none of its Pins or Markers and leaves its frame and its `x_layout` as they are, and laying it out again, or placing on it the elements it does not place, is a write like any other and never a side effect of reading or drawing the Map; a write a tool makes by itself as a Map is opened or drawn is such a side effect, whatever setting ordered it; a tool that tells how many, or which, elements the method would place that the Map does not place uses the reading on the method's page where there is one (`unplaced`); how a layout method places stays the tool's where no page rules it, and so do a method's own `settings`; no case and no reader moves. 2026-11-16, serial 137: on the default layouts page's third method, which reads Maps through this reading: a `width` or `height` that is a whole number is answered as that number, 0 and under 0 included, and any other value is measured as a missing one is; a slot measured with no placed point is null and still says it was measured; a `depth` that is a whole number is answered as that number, any other is null, and none is measured; a link whose value is not a non-empty string is no link, a list, a number, a boolean and an object like the empty string; rule 8 names `by-links-3d` among the default layouts page's words; four cases, and three layout cases for a layout's ground. 2026-11-18, serial 139: where a child Map lies on its parent (rule 13), `x_parent_frame`, two corners in the parent's pixels counted from its bottom left as a Pin's are; the child's rectangle lies on that box, each axis by its own ratio, a box of another shape being a stretch with no threshold; no turn; the parent frame places and a scale measures, and neither is read from the other; a Map with a `parent_map` and no parent frame has no place on its parent, and a Pin of its place there is a way in. 2026-11-19, serial 139: nesting composes, one level at a time, and a level with no parent frame or no carry carries the point no further; a value that is not a list of exactly four numbers, or a box with x0 not less than x1 or y0 not less than y1, is no parent frame, with a lint, and is never normalised or cut to four; a key present and not null on a Map with no `parent_map` is not read, with a lint; a child whose `width` or `height` is not a whole number above 0 as written (by value) has its parent frame and no carry, and a measured extent is never the size a parent frame divides by; the carry is written out in its order in 64-bit floats, the fixture compares it exactly and names no tolerance, and a reader that holds 32 bits rounds once, outside the compare; a walk ends at a Map it has already reached (rule 14); the frame reading, `carryOf`, with its own fixture section, `frame_cases`, sixty-six cases; the map-space reading and its forty-three cases do not change. 2026-11-20, serial 142: where a Zone has an outline on a child Map and on its parent, no reading on this page joins the two outlines or adds a point on the edge of the child's rectangle or of its parent frame, and what a tool draws of the Zone inside the parent frame and past it, the parent's outline through it among them, is the tool's (a note under rule 14); rule 4 says one outline per Map the Zone has placed Markers on, where it said Markers, as rule 1 already read, which leaves a Marker without a whole `x` and `y` out; three map-space cases, forty-six in all: a parent's line through the child's parent frame, with a Marker inside it, a Zone placed on a parent and not on its child, which has no outline there, and a Zone placed on a child and not on its parent, which has no outline on the parent; no reader's answer moves. diff --git a/codegen/schema-pin.json b/codegen/schema-pin.json index c11da3d..7a22526 100644 --- a/codegen/schema-pin.json +++ b/codegen/schema-pin.json @@ -2,15 +2,20 @@ "_what": "The recorded pin for the vendored OnlyWorlds schema distribution (codegen/schema-dist/, copied byte-exact). Do not edit by hand; re-vendor from the pinned tag and review the diff. Kept equal to the npm SDK's pin (github.com/OnlyWorlds/sdk, codegen/schema-pin.json) on purpose: two clients, one schema.", "_why_manifest_sha256": "Verifying the tree against its own MANIFEST.json only proves internal consistency. If the tag moved, the manifest moved with it. The hash recorded here is the one first accepted, which is what makes a moved tag visible.", "repo": "https://github.com/OnlyWorlds/schema-dist", - "tag": "v0.34.1-dist.141", - "commit": "f87f9abde92a427379c20d0cc60befde6ff06e44", - "manifest_sha256": "417be97794478dd39b1ba580c3316a6daf64953ab9ea7cf7ac9eb24f34548c92", + "tag": "v0.34.1-dist.142", + "commit": "5d5a8beffe1d17abfb5cd279034702f0ec38ca2a", + "manifest_sha256": "59d21a4b7a3210bf4cb7cc8c59aece3600681e864fb2e9825e3d592e8b1f6e4e", "canonical_version": "00.34.01", - "dist_serial": 141, - "published": "2026-11-20", - "pinned_at": "2026-11-20", + "dist_serial": 142, + "published": "2026-11-21", + "pinned_at": "2026-11-21", "pinned_by": "The maintainer: tree from `git archive` of the tag in a schema-dist checkout (216 files: the 215 the MANIFEST lists, and MANIFEST.json itself); files re-hashed against MANIFEST.json by verify_dist.py; MANIFEST self-hash matched against the raw file GitHub serves at the tag, whose ref resolves to the commit above.", "previous_pins": [ + { + "tag": "v0.34.1-dist.141", + "manifest_sha256": "417be97794478dd39b1ba580c3316a6daf64953ab9ea7cf7ac9eb24f34548c92", + "note": "superseded by v0.34.1-dist.142 (map-space: the note under rule 14, rule 4 says placed Markers, three cases; no answer moved)" + }, { "tag": "v0.34.1-dist.139", "manifest_sha256": "65a3ded94dfce624e823c664c7bcfc317530a872213a217d8e3a63215fe9f4e5", diff --git a/src/onlyworlds/_schema.py b/src/onlyworlds/_schema.py index ed25621..6126f24 100644 --- a/src/onlyworlds/_schema.py +++ b/src/onlyworlds/_schema.py @@ -1,13 +1,13 @@ # GENERATED by codegen/generate_schema.py from the vendored schema distribution. Do not hand-edit. # Regenerate: python codegen/generate_schema.py (CI/test: --check) -# Source: https://github.com/OnlyWorlds/schema-dist @ v0.34.1-dist.141 (f87f9abde92a427379c20d0cc60befde6ff06e44) +# Source: https://github.com/OnlyWorlds/schema-dist @ v0.34.1-dist.142 (5d5a8beffe1d17abfb5cd279034702f0ec38ca2a) """Schema provenance, the 22 element types and their fields, from the pinned schema distribution.""" -SCHEMA_DIST_TAG = "v0.34.1-dist.141" +SCHEMA_DIST_TAG = "v0.34.1-dist.142" SCHEMA_VERSION = "00.34.01" -SCHEMA_DIST_SERIAL = 141 -SCHEMA_MANIFEST_SHA256 = "417be97794478dd39b1ba580c3316a6daf64953ab9ea7cf7ac9eb24f34548c92" +SCHEMA_DIST_SERIAL = 142 +SCHEMA_MANIFEST_SHA256 = "59d21a4b7a3210bf4cb7cc8c59aece3600681e864fb2e9825e3d592e8b1f6e4e" # Canonical order, as the walk declares it. ELEMENT_TYPES: tuple[str, ...] = ( diff --git a/src/onlyworlds/_version.py b/src/onlyworlds/_version.py index 354f1bc..473bba8 100644 --- a/src/onlyworlds/_version.py +++ b/src/onlyworlds/_version.py @@ -1 +1 @@ -__version__ = "0.138.0" +__version__ = "0.138.1" diff --git a/tests/test_map_space.py b/tests/test_map_space.py index a90b17a..3865347 100644 --- a/tests/test_map_space.py +++ b/tests/test_map_space.py @@ -17,7 +17,7 @@ REPO = Path(__file__).resolve().parent.parent FIXTURE = REPO / "codegen" / "schema-dist" / "profiles" / "map-space.fixture.json" -CASES_IN_FIXTURE = 43 +CASES_IN_FIXTURE = 46 def load_fixture() -> dict[str, Any]: