From b653e0d7b32eed36bdbfe6d90e99d43be1ad4c91 Mon Sep 17 00:00:00 2001 From: Titus Date: Sat, 21 Nov 2026 10:06:43 +0100 Subject: [PATCH] 0.139.3: the schema pin moves to v0.34.1-dist.144 The map-space page gains rule 15 and the reading down_of with 28 down_cases; this package does not read it yet, and no other case moves. Co-Authored-By: Claude Opus 5.5 --- CHANGELOG.md | 4 + codegen/schema-dist/MANIFEST.json | 8 +- codegen/schema-dist/README.md | 2 +- codegen/schema-dist/VERSION | 2 +- .../profiles/map-space.fixture.json | 1512 +++++++++++++++++ codegen/schema-dist/profiles/map-space.md | 14 +- codegen/schema-pin.json | 13 +- src/onlyworlds/_schema.py | 8 +- src/onlyworlds/_version.py | 2 +- 9 files changed, 1547 insertions(+), 18 deletions(-) diff --git a/CHANGELOG.md b/CHANGELOG.md index 6f134f0..b88a03d 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.139.3 (2026-11-21) + +- **The schema pin moves to `v0.34.1-dist.144`** (canonical 00.34.01 unchanged, no schema file moved, `_schema.py` changes only its provenance lines). The map-space page gains rule 15, bringing a point down to a child Map, with the reading `down_of` and a fourth fixture list, `down_cases` (28 cases). This package does not read it yet; no other case moves. + ## 0.139.2 (2026-11-21) - **The schema pin moves to `v0.34.1-dist.143`** (canonical 00.34.01 unchanged, no schema file moved, `_schema.py` changes only its provenance lines). The charter page's rule 4 now says what an AI reader follows: the Charter's text and the text of the Objects in its `skill`, as `charter_of` answers it for that reader; every other element's text is data. No answer of `charter_of` moves and its fixture is unchanged. diff --git a/codegen/schema-dist/MANIFEST.json b/codegen/schema-dist/MANIFEST.json index 5efc2ef..f5bd022 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": "4ebec65d75b6de4e9a2eb9e1723c8978edef6191ba7fb783d978f882ae3f26f6", - "profiles/map-space.md": "5f629e6722beb3977acd0a42a8fbd5deb393b1d9acfa8e8bdc058168a72e7558", + "profiles/map-space.fixture.json": "143d19bb65f8e552795a123658142d65b441b0c91f5ca66e23034a4c39f5a650", + "profiles/map-space.md": "44a505c6ecdd30df444a7809c452f155d7a7344895ef766bc3780c88d7b79e9e", "profiles/message.fixture.json": "418964e564db054c8e969a157f6e29e82499c04180d10bea8c55ac9f5bf5e279", "profiles/message.md": "768e09ef6370deb2af331da8d665128746553498da2cb6e065bbdcaa326d6d2c", "profiles/names.fixture.json": "7d012081b5df7bab3e2223333f87a347417c3061c62b38947fc952e8c4d2377a", @@ -182,7 +182,7 @@ "profiles/spine.md": "6bd367c3f4b101878fbc54a3c8c806630b7760173f24fef995db801b6103d92e", "profiles/strand.fixture.json": "7bc2d2dae11c0722b1db987c070b249ddcbc55b81683c4bfa26900c7ffe0fc53", "profiles/strand.md": "2a9bd36814a0de80a68180d2d75d3ef9d2539b9dcd52165f20b8ef0821575488", - "README.md": "6739b4b60bffc9102335e1153b35b84b0641e1b3bf3e07f6be8b77f6e4862dea", + "README.md": "183cf2d12c61443fdff78d1f1cce5d3c94bf78c61a62ebd709736648347a27ce", "schema/ability.yaml": "af185b2d22a5985ac323e6227a95df287fffaae0e5fca502976a02c2754f71b2", "schema/base_properties.yaml": "ec3724ceb2faca973e431a2e2ff946e55bfb55b6b8d78689b6b22d0cfb7c9a2e", "schema/character.yaml": "dc291b206121bd23c69cb89e01a0523eb2f71b4a247116dd6a1fa4bc227ff145", @@ -209,7 +209,7 @@ "schema/zone.yaml": "cca04ee498fb813fa18b96f1ac99816e7f1a8ae1fb9e21c48b37620dbb674856", "schema.json": "581dc7b5e890acc06b1c89b0d7bdcc2f20f54f52d5a3b4af8c5a184e1e6fd48c", "SECURITY.md": "939ee364b06f0b749bdd4cbe66b2fe49322c95abe732650ec4ef062a0c03820a", - "VERSION": "53c04024d9e9ed34de32993e9900beba60f2d86cd6eca8bf95f4da3f2e7d3828", + "VERSION": "391011bb4091fa2a9b8c6dcd48c890956f30e207b80242830d26ebd124766778", "views.fixture.json": "6fda45c2d36cc82a613a4b4d99d14ba9646db2c5bf912b82e68c6b62b20441c1", "views.json": "f4d06ee16bd6c66fc28cf27146b8d199c85164e5deecabafc23af53408746fe0", "walk/lint_folder.py": "28efffa3a39d7f2ceaf69cae5c4ddce023e4989e7a5d2c26c1b4d4815eff386e", diff --git a/codegen/schema-dist/README.md b/codegen/schema-dist/README.md index ad72304..a00d261 100644 --- a/codegen/schema-dist/README.md +++ b/codegen/schema-dist/README.md @@ -17,7 +17,7 @@ Each serial (one numbered publication of these files, tagged `v- | `presentation.json` | default colour group and icon per type (`family` names the group by its colour: `blue`, `green`, `pink`, `amber`, a visual aid for drawing the 22 types, not part of the standard), and the four colours as light/dark pairs. Defaults: tools may override them. The colours were checked for colour-vision deficiency, so re-run that check before changing one. Each type also lists its `public` fields: what the platform shows of an element a reader knows of but does not see whole, beside its name and description | | `pairs.json` | the link a drag between two types writes, for the pairs of the 22 types a tool may offer (same-kind pairs and fields that name a role are absent by ruling). Each key names the pair by its two type slugs in alphabetical order (`ability+character`); `on` is the type that carries the field, `field` the field's name, and `holds` whether the drop puts the dragged element inside the target (one square under the other) or only draws a line. Presentation, as `presentation.json` is, not part of the standard: a tool that offers drags reads this file and offers nothing else, and a pair absent here draws no line | | `views.json` | how an element is shown, by its kind: for a report, a charter, a message and a line in a room, which field gives the one sentence a card or a list row shows, which fields lead the page, which fold, and which layout draws it; and the marks shown at the head of any element's page. A kind with no row draws as its type draws today. Presentation, as `presentation.json` is, not part of the standard: each tool keeps its own drawing and reads the row. `views.fixture.json` holds the cases a reader replays (the row that wins, the sentence, the marks in order) and a cite for every field a row names | -| `profiles/` | extension profiles: one page per named extension field or convention that tools agree to read the same way (`x_identity_key`, one being in several worlds; `atlas_calendar`, a world's own calendar; `x_packet_*`, a work item's elements with a reason each; `x_review_*`, proposed and checked marks; `room`, a convention profile: the ten type-and-supertype pairs a world's working layer holds (a parlor's lines and boards, work items, reports), and the rule that a lore view leaves them out; `message`, a convention profile: a message between a world's members (a Narrative with supertype Message), to whom it is addressed, whether its sender is proved, and each reader's read mark; `checks`, machine-checkable house rules on a world's Charter; `x_names`, a world's own words for the 22 types, on the World; `map-space`, a convention profile: how a reader turns Map, Marker, Pin and Zone rows into geometry (a Map's frame, a Zone's outline in marker order, a Pin's point; z an elevation, never a height), and the layout keys: `x_layout` on a Map (the Map is a drawing of its elements: how it was drawn, and the ground it stands on), `x_hand` on a Pin (placed by hand, kept by a new lay-out), and a small layout reading of one Map; and `x_parent_frame` on a child Map, the box on its parent where it lies, each axis by its own ratio, with a small reading that carries a point on it up its parents; `spine`, a world that maps a software ecosystem: a closed list of kinds as supertypes, eleven `x_spine_*` keys, a day count from a stated day 0; `import-map`, per source tool, from that tool's own tags to the 22 types, which an import offers the user and never applies silently, LegendKeeper first; `address`, a convention profile: one element's three spellings, the site's address and the two `ow://` text forms, with an optional moment and lens, the rule that a field holding one is public text, never resolved, and when two ids are the same id; `lens`, a convention profile: a saved way of reading a world (a Construct with supertype Lens), its links the anchors, `x_lens` the recipe (how far, which types, how far back, how much), and the one resolution every reader agrees on; `charter`, a convention profile: a world's reading aids, the Charter (the rules for people and AIs here), the Guide (start here) and the Domains (the places in the world), each marked with `x_charter_of`, and the one packet every tool shows first at a world's door; `strand`, a convention profile: one story in a world in miniature, a Narrative, one of its Events, that Event's place, the story's protagonist and where the hero is now, named on the World by `x_strand`'s three ids and read through four existing links, never one slot filled from another; `record`, a convention profile: one run of a game kept in the world its Characters live in, an Event marked by `x_record` (the game, when it was played, and optionally the engine's version, the seed, the outcome and each Character's seat) with its chronicle and each Character's stories as Narratives, and a character's records read from the Event's `characters` and the stories' `protagonist` or `narrator`, never a field on the Character; `landing`, a convention profile: a world's first picture at a door, read from the lens profile's graph, its most-linked Characters each with what it links, the nodes no head reaches, and a small world's gaps (an orphan, a near-orphan, a Character with no place, a Location nobody is in), each an invitation to make the world bigger, with nothing stored; `report`, a convention profile: work done, left in the world by a stretch of work or a closed talk, a Narrative with supertype Report and the room's mark, handed in by the reporter's AI with its own text and completed by the world's keeper with a summary, a link to every element it touched and a line per change in `consequences`, the work items it answers named in `x_report_answers`; `layout`, a convention profile: the default layouts, three ways to draw a world nobody has laid out, `by-kind` (the whole graph, read from the graph alone, each kind round a circle, the same points to the last bit in every tool), `around` (one element and what links to it, on rings, read from the graph alone) and `by-links-3d` (the whole graph in three dimensions by its links, with the world's Maps and Pins as a plate its pinned elements stand on), the method words a layout map names under map-space's rule 8, and `unplaced`, the one reading of which elements a saved layout map does not place). What it holds, how a reader reads it, what a writer must keep. A profile may carry a data file beside its page (`import-map.json`, the table a door loads). A profile with a `.fixture.json` beside it has a conformance fixture: cases a reader must pass; the report profile has a second, `report-lines.fixture.json`, the lines of its `consequences`, and the layouts profile has a second, `layout-by-links-3d.fixture.json`, with the directions table `layout-by-links-3d.directions.json` it names by its sha256 | +| `profiles/` | extension profiles: one page per named extension field or convention that tools agree to read the same way (`x_identity_key`, one being in several worlds; `atlas_calendar`, a world's own calendar; `x_packet_*`, a work item's elements with a reason each; `x_review_*`, proposed and checked marks; `room`, a convention profile: the ten type-and-supertype pairs a world's working layer holds (a parlor's lines and boards, work items, reports), and the rule that a lore view leaves them out; `message`, a convention profile: a message between a world's members (a Narrative with supertype Message), to whom it is addressed, whether its sender is proved, and each reader's read mark; `checks`, machine-checkable house rules on a world's Charter; `x_names`, a world's own words for the 22 types, on the World; `map-space`, a convention profile: how a reader turns Map, Marker, Pin and Zone rows into geometry (a Map's frame, a Zone's outline in marker order, a Pin's point; z an elevation, never a height), and the layout keys: `x_layout` on a Map (the Map is a drawing of its elements: how it was drawn, and the ground it stands on), `x_hand` on a Pin (placed by hand, kept by a new lay-out), and a small layout reading of one Map; and `x_parent_frame` on a child Map, the box on its parent where it lies, each axis by its own ratio, with a small reading that carries a point on it up its parents and one that brings a point down to it; `spine`, a world that maps a software ecosystem: a closed list of kinds as supertypes, eleven `x_spine_*` keys, a day count from a stated day 0; `import-map`, per source tool, from that tool's own tags to the 22 types, which an import offers the user and never applies silently, LegendKeeper first; `address`, a convention profile: one element's three spellings, the site's address and the two `ow://` text forms, with an optional moment and lens, the rule that a field holding one is public text, never resolved, and when two ids are the same id; `lens`, a convention profile: a saved way of reading a world (a Construct with supertype Lens), its links the anchors, `x_lens` the recipe (how far, which types, how far back, how much), and the one resolution every reader agrees on; `charter`, a convention profile: a world's reading aids, the Charter (the rules for people and AIs here), the Guide (start here) and the Domains (the places in the world), each marked with `x_charter_of`, and the one packet every tool shows first at a world's door; `strand`, a convention profile: one story in a world in miniature, a Narrative, one of its Events, that Event's place, the story's protagonist and where the hero is now, named on the World by `x_strand`'s three ids and read through four existing links, never one slot filled from another; `record`, a convention profile: one run of a game kept in the world its Characters live in, an Event marked by `x_record` (the game, when it was played, and optionally the engine's version, the seed, the outcome and each Character's seat) with its chronicle and each Character's stories as Narratives, and a character's records read from the Event's `characters` and the stories' `protagonist` or `narrator`, never a field on the Character; `landing`, a convention profile: a world's first picture at a door, read from the lens profile's graph, its most-linked Characters each with what it links, the nodes no head reaches, and a small world's gaps (an orphan, a near-orphan, a Character with no place, a Location nobody is in), each an invitation to make the world bigger, with nothing stored; `report`, a convention profile: work done, left in the world by a stretch of work or a closed talk, a Narrative with supertype Report and the room's mark, handed in by the reporter's AI with its own text and completed by the world's keeper with a summary, a link to every element it touched and a line per change in `consequences`, the work items it answers named in `x_report_answers`; `layout`, a convention profile: the default layouts, three ways to draw a world nobody has laid out, `by-kind` (the whole graph, read from the graph alone, each kind round a circle, the same points to the last bit in every tool), `around` (one element and what links to it, on rings, read from the graph alone) and `by-links-3d` (the whole graph in three dimensions by its links, with the world's Maps and Pins as a plate its pinned elements stand on), the method words a layout map names under map-space's rule 8, and `unplaced`, the one reading of which elements a saved layout map does not place). What it holds, how a reader reads it, what a writer must keep. A profile may carry a data file beside its page (`import-map.json`, the table a door loads). A profile with a `.fixture.json` beside it has a conformance fixture: cases a reader must pass; the report profile has a second, `report-lines.fixture.json`, the lines of its `consequences`, and the layouts profile has a second, `layout-by-links-3d.fixture.json`, with the directions table `layout-by-links-3d.directions.json` it names by its sha256 | | `walk/schema_walk.py` | the reference decoder, in Python: reads the YAML and returns each type's fields. `schema.json` is its output. One module; its only dependency is PyYAML | | `walk/rulings.yaml` | rulings the YAML cannot carry (nullability, empty strings, extension fields). Code in any language should follow these rows | | `walk/lint_folder.py` | the folder check: run it on a world folder and it names every key that is not a field of its type, every link that does not resolve or points at the wrong type, every value of the wrong shape, and a `world.json` that carries an `api` block while git tracks it (a linked folder is never committed, folder spec 4.6 d). The example world passes it at every publish | diff --git a/codegen/schema-dist/VERSION b/codegen/schema-dist/VERSION index 8b01373..0975de4 100644 --- a/codegen/schema-dist/VERSION +++ b/codegen/schema-dist/VERSION @@ -1,3 +1,3 @@ canonical: 00.34.01 -serial: 143 +serial: 144 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 70f5dc5..fdb6387 100644 --- a/codegen/schema-dist/profiles/map-space.fixture.json +++ b/codegen/schema-dist/profiles/map-space.fixture.json @@ -14613,5 +14613,1517 @@ "stop": "top" } } + ], + "down_cases": [ + { + "name": "down-the-frame-corner-to-the-origin", + "claim": "a point on the parent at the parent frame's corner (x0, y0) comes down to the child's origin: the point on `from` as given, then the point on `map`, and `stop` null; `parent_frame` is the child's own", + "map": "019a9300-0000-7000-8000-00000000aa02", + "from": "019a9300-0000-7000-8000-00000000aa01", + "point": [ + 7011.9, + 1282.2 + ], + "elements": [ + { + "type": "map", + "id": "019a9300-0000-7000-8000-00000000aa01", + "name": "land", + "width": 8000, + "height": 6000 + }, + { + "type": "map", + "id": "019a9300-0000-7000-8000-00000000aa02", + "name": "town", + "width": 2400, + "height": 1800, + "parent_map": "019a9300-0000-7000-8000-00000000aa01", + "x_parent_frame": [ + 7011.9, + 1282.2, + 7164.3, + 1396.6 + ] + } + ], + "want": { + "parent_frame": [ + 7011.9, + 1282.2, + 7164.3, + 1396.6 + ], + "lint": null, + "points": [ + { + "map": "019a9300-0000-7000-8000-00000000aa01", + "x": 7011.9, + "y": 1282.2 + }, + { + "map": "019a9300-0000-7000-8000-00000000aa02", + "x": 0.0, + "y": 0.0 + } + ], + "stop": null + } + }, + { + "name": "down-the-far-corner-to-the-size", + "claim": "the parent frame's corner (x1, y1) comes down to the child's (`width`, `height`)", + "map": "019a9300-0000-7000-8000-00000000aa02", + "from": "019a9300-0000-7000-8000-00000000aa01", + "point": [ + 7164.3, + 1396.6 + ], + "elements": [ + { + "type": "map", + "id": "019a9300-0000-7000-8000-00000000aa01", + "name": "land", + "width": 8000, + "height": 6000 + }, + { + "type": "map", + "id": "019a9300-0000-7000-8000-00000000aa02", + "name": "town", + "width": 2400, + "height": 1800, + "parent_map": "019a9300-0000-7000-8000-00000000aa01", + "x_parent_frame": [ + 7011.9, + 1282.2, + 7164.3, + 1396.6 + ] + } + ], + "want": { + "parent_frame": [ + 7011.9, + 1282.2, + 7164.3, + 1396.6 + ], + "lint": null, + "points": [ + { + "map": "019a9300-0000-7000-8000-00000000aa01", + "x": 7164.3, + "y": 1396.6 + }, + { + "map": "019a9300-0000-7000-8000-00000000aa02", + "x": 2400.0, + "y": 1800.0 + } + ], + "stop": null + } + }, + { + "name": "down-a-carried-point-does-not-come-back", + "claim": "no round trip is promised: (1234.5, 987.25) on the child is carried up by rule 14 to this point, and brought down it is not (1234.5, 987.25); in y the fraction taken first gives another last bit", + "map": "019a9300-0000-7000-8000-00000000aa02", + "from": "019a9300-0000-7000-8000-00000000aa01", + "point": [ + 7090.29075, + 1344.9452222222221 + ], + "elements": [ + { + "type": "map", + "id": "019a9300-0000-7000-8000-00000000aa01", + "name": "land", + "width": 8000, + "height": 6000 + }, + { + "type": "map", + "id": "019a9300-0000-7000-8000-00000000aa02", + "name": "town", + "width": 2400, + "height": 1800, + "parent_map": "019a9300-0000-7000-8000-00000000aa01", + "x_parent_frame": [ + 7011.9, + 1282.2, + 7164.3, + 1396.6 + ] + } + ], + "want": { + "parent_frame": [ + 7011.9, + 1282.2, + 7164.3, + 1396.6 + ], + "lint": null, + "points": [ + { + "map": "019a9300-0000-7000-8000-00000000aa01", + "x": 7090.29075, + "y": 1344.9452222222221 + }, + { + "map": "019a9300-0000-7000-8000-00000000aa02", + "x": 1234.5000000000032, + "y": 987.249999999999 + } + ], + "stop": null + } + }, + { + "name": "down-a-point-outside-the-parent-frame", + "claim": "a point on the parent left of the parent frame is brought down as written and never clipped: it lands left of the child's rectangle", + "map": "019a9300-0000-7000-8000-00000000aa02", + "from": "019a9300-0000-7000-8000-00000000aa01", + "point": [ + 6968.0215, + 1353.0008888888888 + ], + "elements": [ + { + "type": "map", + "id": "019a9300-0000-7000-8000-00000000aa01", + "name": "land", + "width": 8000, + "height": 6000 + }, + { + "type": "map", + "id": "019a9300-0000-7000-8000-00000000aa02", + "name": "town", + "width": 2400, + "height": 1800, + "parent_map": "019a9300-0000-7000-8000-00000000aa01", + "x_parent_frame": [ + 7011.9, + 1282.2, + 7164.3, + 1396.6 + ] + } + ], + "want": { + "parent_frame": [ + 7011.9, + 1282.2, + 7164.3, + 1396.6 + ], + "lint": null, + "points": [ + { + "map": "019a9300-0000-7000-8000-00000000aa01", + "x": 6968.0215, + "y": 1353.0008888888888 + }, + { + "map": "019a9300-0000-7000-8000-00000000aa02", + "x": -690.9999999999944, + "y": 1113.9999999999986 + } + ], + "stop": null + } + }, + { + "name": "down-decimals-in-the-written-order", + "claim": "each axis is ((X - x0) * width) / (x1 - x0) in 64-bit floats, in that order: the difference, then the product, then the quotient; in y the fraction taken first gives another last bit", + "map": "019a9300-0000-7000-8000-00000000aa02", + "from": "019a9300-0000-7000-8000-00000000aa01", + "point": [ + 7011.906349999999, + 1282.244488888889 + ], + "elements": [ + { + "type": "map", + "id": "019a9300-0000-7000-8000-00000000aa01", + "name": "land", + "width": 8000, + "height": 6000 + }, + { + "type": "map", + "id": "019a9300-0000-7000-8000-00000000aa02", + "name": "town", + "width": 2400, + "height": 1800, + "parent_map": "019a9300-0000-7000-8000-00000000aa01", + "x_parent_frame": [ + 7011.9, + 1282.2, + 7164.3, + 1396.6 + ] + } + ], + "want": { + "parent_frame": [ + 7011.9, + 1282.2, + 7164.3, + 1396.6 + ], + "lint": null, + "points": [ + { + "map": "019a9300-0000-7000-8000-00000000aa01", + "x": 7011.906349999999, + "y": 1282.244488888889 + }, + { + "map": "019a9300-0000-7000-8000-00000000aa02", + "x": 0.09999999999459137, + "y": 0.7000000000011768 + } + ], + "stop": null + } + }, + { + "name": "down-from-the-map-itself", + "claim": "when `from` is `map` there is a way down of no level: `points` holds the point as given, alone, and `stop` is null", + "map": "019a9300-0000-7000-8000-00000000aa02", + "from": "019a9300-0000-7000-8000-00000000aa02", + "point": [ + 1.5, + 2.5 + ], + "elements": [ + { + "type": "map", + "id": "019a9300-0000-7000-8000-00000000aa01", + "name": "land", + "width": 8000, + "height": 6000 + }, + { + "type": "map", + "id": "019a9300-0000-7000-8000-00000000aa02", + "name": "town", + "width": 2400, + "height": 1800, + "parent_map": "019a9300-0000-7000-8000-00000000aa01", + "x_parent_frame": [ + 7011.9, + 1282.2, + 7164.3, + 1396.6 + ] + } + ], + "want": { + "parent_frame": [ + 7011.9, + 1282.2, + 7164.3, + 1396.6 + ], + "lint": null, + "points": [ + { + "map": "019a9300-0000-7000-8000-00000000aa02", + "x": 1.5, + "y": 2.5 + } + ], + "stop": null + } + }, + { + "name": "down-two-levels", + "claim": "a point on the land comes down onto the town by the town's parent frame, and that point, as it came down, onto the plan by the plan's: one level at a time, never through one product of the levels' ratios, which gives other bits here", + "map": "019a9300-0000-7000-8000-00000000aa03", + "from": "019a9300-0000-7000-8000-00000000aa01", + "point": [ + 745.0, + 300.0 + ], + "elements": [ + { + "type": "map", + "id": "019a9300-0000-7000-8000-00000000aa01", + "name": "land", + "width": 8000, + "height": 5700 + }, + { + "type": "map", + "id": "019a9300-0000-7000-8000-00000000aa02", + "name": "town", + "width": 1366, + "height": 1024, + "parent_map": "019a9300-0000-7000-8000-00000000aa01", + "x_parent_frame": [ + 719.6, + 179.92, + 907.61, + 399.46 + ] + }, + { + "type": "map", + "id": "019a9300-0000-7000-8000-00000000aa03", + "name": "plan", + "width": 800, + "height": 450, + "parent_map": "019a9300-0000-7000-8000-00000000aa02", + "x_parent_frame": [ + 160.795, + 546.164, + 310.491, + 819.23 + ] + } + ], + "want": { + "parent_frame": [ + 160.795, + 546.164, + 310.491, + 819.23 + ], + "lint": null, + "points": [ + { + "map": "019a9300-0000-7000-8000-00000000aa01", + "x": 745.0, + "y": 300.0 + }, + { + "map": "019a9300-0000-7000-8000-00000000aa02", + "x": 184.54550289878185, + "y": 560.0889131821082 + }, + { + "map": "019a9300-0000-7000-8000-00000000aa03", + "x": 126.92658667583295, + "y": 22.947605824045038 + } + ], + "stop": null + } + }, + { + "name": "down-one-level-of-two", + "claim": "`from` may be any Map the walk from `map` reaches: from the town, one level down onto the plan, and the land is not read", + "map": "019a9300-0000-7000-8000-00000000aa03", + "from": "019a9300-0000-7000-8000-00000000aa02", + "point": [ + 250.125, + 600.5 + ], + "elements": [ + { + "type": "map", + "id": "019a9300-0000-7000-8000-00000000aa01", + "name": "land", + "width": 8000, + "height": 5700 + }, + { + "type": "map", + "id": "019a9300-0000-7000-8000-00000000aa02", + "name": "town", + "width": 1366, + "height": 1024, + "parent_map": "019a9300-0000-7000-8000-00000000aa01", + "x_parent_frame": [ + 719.6, + 179.92, + 907.61, + 399.46 + ] + }, + { + "type": "map", + "id": "019a9300-0000-7000-8000-00000000aa03", + "name": "plan", + "width": 800, + "height": 450, + "parent_map": "019a9300-0000-7000-8000-00000000aa02", + "x_parent_frame": [ + 160.795, + 546.164, + 310.491, + 819.23 + ] + } + ], + "want": { + "parent_frame": [ + 160.795, + 546.164, + 310.491, + 819.23 + ], + "lint": null, + "points": [ + { + "map": "019a9300-0000-7000-8000-00000000aa02", + "x": 250.125, + "y": 600.5 + }, + { + "map": "019a9300-0000-7000-8000-00000000aa03", + "x": 477.39418554938015, + "y": 89.54318736129727 + } + ], + "stop": null + } + }, + { + "name": "down-from-a-map-below", + "claim": "the walk from the land ends at once, `top`, without reaching the town below it: no way down, and `points` holds the point on `from` as given, alone", + "map": "019a9300-0000-7000-8000-00000000aa01", + "from": "019a9300-0000-7000-8000-00000000aa02", + "point": [ + 15, + 15 + ], + "elements": [ + { + "type": "map", + "id": "019a9300-0000-7000-8000-00000000aa01", + "name": "land", + "width": 8000, + "height": 6000 + }, + { + "type": "map", + "id": "019a9300-0000-7000-8000-00000000aa02", + "name": "town", + "width": 2400, + "height": 1800, + "parent_map": "019a9300-0000-7000-8000-00000000aa01", + "x_parent_frame": [ + 7011.9, + 1282.2, + 7164.3, + 1396.6 + ] + } + ], + "want": { + "parent_frame": null, + "lint": null, + "points": [ + { + "map": "019a9300-0000-7000-8000-00000000aa02", + "x": 15, + "y": 15 + } + ], + "stop": "top" + } + }, + { + "name": "down-from-a-map-beside", + "claim": "a harbour beside the town on the land is not on the walk from the town, which reaches the top: no way down, `top`, and the given point alone", + "map": "019a9300-0000-7000-8000-00000000aa02", + "from": "019a9300-0000-7000-8000-00000000aa04", + "point": [ + 15, + 15 + ], + "elements": [ + { + "type": "map", + "id": "019a9300-0000-7000-8000-00000000aa01", + "name": "land", + "width": 8000, + "height": 6000 + }, + { + "type": "map", + "id": "019a9300-0000-7000-8000-00000000aa02", + "name": "town", + "width": 2400, + "height": 1800, + "parent_map": "019a9300-0000-7000-8000-00000000aa01", + "x_parent_frame": [ + 7011.9, + 1282.2, + 7164.3, + 1396.6 + ] + }, + { + "type": "map", + "id": "019a9300-0000-7000-8000-00000000aa04", + "name": "harbour", + "width": 600, + "height": 400, + "parent_map": "019a9300-0000-7000-8000-00000000aa01", + "x_parent_frame": [ + 7200, + 1300, + 7260, + 1340 + ] + } + ], + "want": { + "parent_frame": [ + 7011.9, + 1282.2, + 7164.3, + 1396.6 + ], + "lint": null, + "points": [ + { + "map": "019a9300-0000-7000-8000-00000000aa04", + "x": 15, + "y": 15 + } + ], + "stop": "top" + } + }, + { + "name": "down-from-a-parent-not-served", + "claim": "`from` is the Map the town's `parent_map` names, and it is not served: the walk ends `dangling`, and the given point stands alone", + "map": "019a9300-0000-7000-8000-00000000aa02", + "from": "019a9300-0000-7000-8000-00000000aa09", + "point": [ + 7100, + 1300 + ], + "elements": [ + { + "type": "map", + "id": "019a9300-0000-7000-8000-00000000aa02", + "name": "town", + "width": 2400, + "height": 1800, + "parent_map": "019a9300-0000-7000-8000-00000000aa09", + "x_parent_frame": [ + 7011.9, + 1282.2, + 7164.3, + 1396.6 + ] + } + ], + "want": { + "parent_frame": [ + 7011.9, + 1282.2, + 7164.3, + 1396.6 + ], + "lint": null, + "points": [ + { + "map": "019a9300-0000-7000-8000-00000000aa09", + "x": 7100, + "y": 1300 + } + ], + "stop": "dangling" + } + }, + { + "name": "down-through-a-ring", + "claim": "the town and the land name each other: the walk from the town carries onto the land once and ends `cycle`, never reaching the sea, so there is no way down from it", + "map": "019a9300-0000-7000-8000-00000000aa02", + "from": "019a9300-0000-7000-8000-00000000aa05", + "point": [ + 15, + 15 + ], + "elements": [ + { + "type": "map", + "id": "019a9300-0000-7000-8000-00000000aa05", + "name": "sea", + "width": 9000, + "height": 9000 + }, + { + "type": "map", + "id": "019a9300-0000-7000-8000-00000000aa01", + "name": "land", + "width": 8000, + "height": 6000, + "parent_map": "019a9300-0000-7000-8000-00000000aa02", + "x_parent_frame": [ + 0, + 0, + 10, + 10 + ] + }, + { + "type": "map", + "id": "019a9300-0000-7000-8000-00000000aa02", + "name": "town", + "width": 2400, + "height": 1800, + "parent_map": "019a9300-0000-7000-8000-00000000aa01", + "x_parent_frame": [ + 7011.9, + 1282.2, + 7164.3, + 1396.6 + ] + } + ], + "want": { + "parent_frame": [ + 7011.9, + 1282.2, + 7164.3, + 1396.6 + ], + "lint": null, + "points": [ + { + "map": "019a9300-0000-7000-8000-00000000aa05", + "x": 15, + "y": 15 + } + ], + "stop": "cycle" + } + }, + { + "name": "down-past-a-level-with-no-frame", + "claim": "the plan has a `parent_map` and no parent frame: the walk from it ends `no_frame` on the plan, though the town is framed on the land; no point is brought part of the way, onto the town", + "map": "019a9300-0000-7000-8000-00000000aa03", + "from": "019a9300-0000-7000-8000-00000000aa01", + "point": [ + 745.0, + 300.0 + ], + "elements": [ + { + "type": "map", + "id": "019a9300-0000-7000-8000-00000000aa01", + "name": "land", + "width": 8000, + "height": 5700 + }, + { + "type": "map", + "id": "019a9300-0000-7000-8000-00000000aa02", + "name": "town", + "width": 1366, + "height": 1024, + "parent_map": "019a9300-0000-7000-8000-00000000aa01", + "x_parent_frame": [ + 719.6, + 179.92, + 907.61, + 399.46 + ] + }, + { + "type": "map", + "id": "019a9300-0000-7000-8000-00000000aa03", + "name": "plan", + "width": 800, + "height": 450, + "parent_map": "019a9300-0000-7000-8000-00000000aa02" + } + ], + "want": { + "parent_frame": null, + "lint": null, + "points": [ + { + "map": "019a9300-0000-7000-8000-00000000aa01", + "x": 745.0, + "y": 300.0 + } + ], + "stop": "no_frame" + } + }, + { + "name": "down-past-a-level-with-no-carry", + "claim": "the plan has a parent frame and no `width`: the walk from it ends `no_carry`, and no point is brought part of the way; the plan's own parent frame is reported", + "map": "019a9300-0000-7000-8000-00000000aa03", + "from": "019a9300-0000-7000-8000-00000000aa01", + "point": [ + 745.0, + 300.0 + ], + "elements": [ + { + "type": "map", + "id": "019a9300-0000-7000-8000-00000000aa01", + "name": "land", + "width": 8000, + "height": 5700 + }, + { + "type": "map", + "id": "019a9300-0000-7000-8000-00000000aa02", + "name": "town", + "width": 1366, + "height": 1024, + "parent_map": "019a9300-0000-7000-8000-00000000aa01", + "x_parent_frame": [ + 719.6, + 179.92, + 907.61, + 399.46 + ] + }, + { + "type": "map", + "id": "019a9300-0000-7000-8000-00000000aa03", + "name": "plan", + "height": 450, + "parent_map": "019a9300-0000-7000-8000-00000000aa02", + "x_parent_frame": [ + 160.795, + 546.164, + 310.491, + 819.23 + ] + } + ], + "want": { + "parent_frame": [ + 160.795, + 546.164, + 310.491, + 819.23 + ], + "lint": null, + "points": [ + { + "map": "019a9300-0000-7000-8000-00000000aa01", + "x": 745.0, + "y": 300.0 + } + ], + "stop": "no_carry" + } + }, + { + "name": "down-below-a-level-that-ends-the-walk", + "claim": "the walk from the town carries onto the land, so there is a way down from the land; the land's parent is not served, and the walk is not followed past `from`, so that fault is never met", + "map": "019a9300-0000-7000-8000-00000000aa02", + "from": "019a9300-0000-7000-8000-00000000aa01", + "point": [ + 7090.29075, + 1344.9452222222221 + ], + "elements": [ + { + "type": "map", + "id": "019a9300-0000-7000-8000-00000000aa01", + "name": "land", + "width": 8000, + "height": 6000, + "parent_map": "019a9300-0000-7000-8000-00000000aa09", + "x_parent_frame": [ + 0, + 0, + 10, + 10 + ] + }, + { + "type": "map", + "id": "019a9300-0000-7000-8000-00000000aa02", + "name": "town", + "width": 2400, + "height": 1800, + "parent_map": "019a9300-0000-7000-8000-00000000aa01", + "x_parent_frame": [ + 7011.9, + 1282.2, + 7164.3, + 1396.6 + ] + } + ], + "want": { + "parent_frame": [ + 7011.9, + 1282.2, + 7164.3, + 1396.6 + ], + "lint": null, + "points": [ + { + "map": "019a9300-0000-7000-8000-00000000aa01", + "x": 7090.29075, + "y": 1344.9452222222221 + }, + { + "map": "019a9300-0000-7000-8000-00000000aa02", + "x": 1234.5000000000032, + "y": 987.249999999999 + } + ], + "stop": null + } + }, + { + "name": "down-below-a-ring", + "claim": "the walk from the plan carries onto the town, so there is a way down from the town, though the land above it names the town back: the walk is followed only until it reaches `from`", + "map": "019a9300-0000-7000-8000-00000000aa03", + "from": "019a9300-0000-7000-8000-00000000aa02", + "point": [ + 250.125, + 600.5 + ], + "elements": [ + { + "type": "map", + "id": "019a9300-0000-7000-8000-00000000aa01", + "name": "land", + "width": 8000, + "height": 5700, + "parent_map": "019a9300-0000-7000-8000-00000000aa02", + "x_parent_frame": [ + 0, + 0, + 10, + 10 + ] + }, + { + "type": "map", + "id": "019a9300-0000-7000-8000-00000000aa02", + "name": "town", + "width": 1366, + "height": 1024, + "parent_map": "019a9300-0000-7000-8000-00000000aa01", + "x_parent_frame": [ + 719.6, + 179.92, + 907.61, + 399.46 + ] + }, + { + "type": "map", + "id": "019a9300-0000-7000-8000-00000000aa03", + "name": "plan", + "width": 800, + "height": 450, + "parent_map": "019a9300-0000-7000-8000-00000000aa02", + "x_parent_frame": [ + 160.795, + 546.164, + 310.491, + 819.23 + ] + } + ], + "want": { + "parent_frame": [ + 160.795, + 546.164, + 310.491, + 819.23 + ], + "lint": null, + "points": [ + { + "map": "019a9300-0000-7000-8000-00000000aa02", + "x": 250.125, + "y": 600.5 + }, + { + "map": "019a9300-0000-7000-8000-00000000aa03", + "x": 477.39418554938015, + "y": 89.54318736129727 + } + ], + "stop": null + } + }, + { + "name": "down-from-the-map-itself-on-a-broken-walk", + "claim": "when `from` is `map` there is a way down of no level, whatever the walk from `map` would meet: the town's parent is not served, and the point as given stands alone with `stop` null", + "map": "019a9300-0000-7000-8000-00000000aa02", + "from": "019a9300-0000-7000-8000-00000000aa02", + "point": [ + 1.5, + 2.5 + ], + "elements": [ + { + "type": "map", + "id": "019a9300-0000-7000-8000-00000000aa02", + "name": "town", + "width": 2400, + "height": 1800, + "parent_map": "019a9300-0000-7000-8000-00000000aa09", + "x_parent_frame": [ + 7011.9, + 1282.2, + 7164.3, + 1396.6 + ] + } + ], + "want": { + "parent_frame": [ + 7011.9, + 1282.2, + 7164.3, + 1396.6 + ], + "lint": null, + "points": [ + { + "map": "019a9300-0000-7000-8000-00000000aa02", + "x": 1.5, + "y": 2.5 + } + ], + "stop": null + } + }, + { + "name": "down-from-a-row-whose-type-is-Map", + "claim": "`from` is read by its id alone: the town's parent is served only as a row whose `type` is `Map`, so the walk ends `dangling` (reading K), and no row under `from`'s id is read for it", + "map": "019a9300-0000-7000-8000-00000000aa02", + "from": "019a9300-0000-7000-8000-00000000aa01", + "point": [ + 7100, + 1300 + ], + "elements": [ + { + "type": "Map", + "id": "019a9300-0000-7000-8000-00000000aa01", + "name": "land", + "width": 8000, + "height": 6000 + }, + { + "type": "map", + "id": "019a9300-0000-7000-8000-00000000aa02", + "name": "town", + "width": 2400, + "height": 1800, + "parent_map": "019a9300-0000-7000-8000-00000000aa01", + "x_parent_frame": [ + 7011.9, + 1282.2, + 7164.3, + 1396.6 + ] + } + ], + "want": { + "parent_frame": [ + 7011.9, + 1282.2, + 7164.3, + 1396.6 + ], + "lint": null, + "points": [ + { + "map": "019a9300-0000-7000-8000-00000000aa01", + "x": 7100, + "y": 1300 + } + ], + "stop": "dangling" + } + }, + { + "name": "down-a-map-that-is-no-map-from-itself", + "claim": "a `map` that is no Map answers the empty reading before anything else, `from` naming the same id included", + "map_index": [ + 1 + ], + "from": "019a9300-0000-7000-8000-00000000aa02", + "point": [ + 1.5, + 2.5 + ], + "elements": [ + { + "type": "map", + "id": "019a9300-0000-7000-8000-00000000aa01", + "name": "land", + "width": 8000, + "height": 6000 + }, + { + "type": "Map", + "id": "019a9300-0000-7000-8000-00000000aa02", + "name": "town", + "width": 2400, + "height": 1800, + "parent_map": "019a9300-0000-7000-8000-00000000aa01", + "x_parent_frame": [ + 7011.9, + 1282.2, + 7164.3, + 1396.6 + ] + } + ], + "want": { + "parent_frame": null, + "lint": null, + "points": [], + "stop": null + } + }, + { + "name": "down-from-an-empty-string", + "claim": "a `from` that is an empty string is no Map's id (reading H): the walk from the town never reaches it and ends `top`, so there is no way down, and the one point carries `from` as given", + "map": "019a9300-0000-7000-8000-00000000aa02", + "from": "", + "point": [ + 7100, + 1300 + ], + "elements": [ + { + "type": "map", + "id": "019a9300-0000-7000-8000-00000000aa01", + "name": "land", + "width": 8000, + "height": 6000 + }, + { + "type": "map", + "id": "019a9300-0000-7000-8000-00000000aa02", + "name": "town", + "width": 2400, + "height": 1800, + "parent_map": "019a9300-0000-7000-8000-00000000aa01", + "x_parent_frame": [ + 7011.9, + 1282.2, + 7164.3, + 1396.6 + ] + } + ], + "want": { + "parent_frame": [ + 7011.9, + 1282.2, + 7164.3, + 1396.6 + ], + "lint": null, + "points": [ + { + "map": "", + "x": 7100, + "y": 1300 + } + ], + "stop": "top" + } + }, + { + "name": "down-from-null", + "claim": "a `from` that is null is no Map's id (reading H): the walk from the town ends `dangling` on its parent not served, so there is no way down, and the one point carries `from` as given", + "map": "019a9300-0000-7000-8000-00000000aa02", + "from": null, + "point": [ + 7100, + 1300 + ], + "elements": [ + { + "type": "map", + "id": "019a9300-0000-7000-8000-00000000aa02", + "name": "town", + "width": 2400, + "height": 1800, + "parent_map": "019a9300-0000-7000-8000-00000000aa09", + "x_parent_frame": [ + 7011.9, + 1282.2, + 7164.3, + 1396.6 + ] + } + ], + "want": { + "parent_frame": [ + 7011.9, + 1282.2, + 7164.3, + 1396.6 + ], + "lint": null, + "points": [ + { + "map": null, + "x": 7100, + "y": 1300 + } + ], + "stop": "dangling" + } + }, + { + "name": "down-from-an-id-served-nowhere", + "claim": "a `from` that is an id no Map is served under, and not the parent the walk names, is not reached: the walk from the town ends `top`, its own word, and the given point stands alone", + "map": "019a9300-0000-7000-8000-00000000aa02", + "from": "019a9300-0000-7000-8000-00000000aa77", + "point": [ + 7100, + 1300 + ], + "elements": [ + { + "type": "map", + "id": "019a9300-0000-7000-8000-00000000aa01", + "name": "land", + "width": 8000, + "height": 6000 + }, + { + "type": "map", + "id": "019a9300-0000-7000-8000-00000000aa02", + "name": "town", + "width": 2400, + "height": 1800, + "parent_map": "019a9300-0000-7000-8000-00000000aa01", + "x_parent_frame": [ + 7011.9, + 1282.2, + 7164.3, + 1396.6 + ] + } + ], + "want": { + "parent_frame": [ + 7011.9, + 1282.2, + 7164.3, + 1396.6 + ], + "lint": null, + "points": [ + { + "map": "019a9300-0000-7000-8000-00000000aa77", + "x": 7100, + "y": 1300 + } + ], + "stop": "top" + } + }, + { + "name": "down-a-map-with-its-own-lint", + "claim": "`lint` is `map`'s own: the land carries a parent frame and no `parent_map`, so its lint is `no_parent`, and the walk from it ends `top` without reaching the town below it", + "map": "019a9300-0000-7000-8000-00000000aa01", + "from": "019a9300-0000-7000-8000-00000000aa02", + "point": [ + 15, + 15 + ], + "elements": [ + { + "type": "map", + "id": "019a9300-0000-7000-8000-00000000aa01", + "name": "land", + "width": 8000, + "height": 6000, + "x_parent_frame": [ + 0, + 0, + 10, + 10 + ] + }, + { + "type": "map", + "id": "019a9300-0000-7000-8000-00000000aa02", + "name": "town", + "width": 2400, + "height": 1800, + "parent_map": "019a9300-0000-7000-8000-00000000aa01", + "x_parent_frame": [ + 7011.9, + 1282.2, + 7164.3, + 1396.6 + ] + } + ], + "want": { + "parent_frame": null, + "lint": "no_parent", + "points": [ + { + "map": "019a9300-0000-7000-8000-00000000aa02", + "x": 15, + "y": 15 + } + ], + "stop": "top" + } + }, + { + "name": "down-past-a-mirrored-parent-frame", + "claim": "the town's key is a box mirrored in x, no parent frame, with the lint `not_a_box`: the walk from the town ends `no_frame` before it reaches the land", + "map": "019a9300-0000-7000-8000-00000000aa02", + "from": "019a9300-0000-7000-8000-00000000aa01", + "point": [ + 7100, + 1300 + ], + "elements": [ + { + "type": "map", + "id": "019a9300-0000-7000-8000-00000000aa01", + "name": "land", + "width": 8000, + "height": 6000 + }, + { + "type": "map", + "id": "019a9300-0000-7000-8000-00000000aa02", + "name": "town", + "width": 2400, + "height": 1800, + "parent_map": "019a9300-0000-7000-8000-00000000aa01", + "x_parent_frame": [ + 7164.3, + 1282.2, + 7011.9, + 1396.6 + ] + } + ], + "want": { + "parent_frame": null, + "lint": "not_a_box", + "points": [ + { + "map": "019a9300-0000-7000-8000-00000000aa01", + "x": 7100, + "y": 1300 + } + ], + "stop": "no_frame" + } + }, + { + "name": "down-from-a-parent-not-served-past-a-mirrored-frame", + "claim": "served-ness before shape: the town's parent is not served and its key is a mirrored box, so the walk from it ends `dangling`, not `no_frame`, its lint still `not_a_box`", + "map": "019a9300-0000-7000-8000-00000000aa02", + "from": "019a9300-0000-7000-8000-00000000aa09", + "point": [ + 7100, + 1300 + ], + "elements": [ + { + "type": "map", + "id": "019a9300-0000-7000-8000-00000000aa02", + "name": "town", + "width": 2400, + "height": 1800, + "parent_map": "019a9300-0000-7000-8000-00000000aa09", + "x_parent_frame": [ + 7164.3, + 1282.2, + 7011.9, + 1396.6 + ] + } + ], + "want": { + "parent_frame": null, + "lint": "not_a_box", + "points": [ + { + "map": "019a9300-0000-7000-8000-00000000aa09", + "x": 7100, + "y": 1300 + } + ], + "stop": "dangling" + } + }, + { + "name": "down-a-map-served-twice", + "claim": "the town is served twice with two parent frames: the last row served wins (reading I), and the point comes down by the parent frame the walk checked at the town, never by the first row's", + "map": "019a9300-0000-7000-8000-00000000aa02", + "from": "019a9300-0000-7000-8000-00000000aa01", + "point": [ + 7100, + 1300 + ], + "elements": [ + { + "type": "map", + "id": "019a9300-0000-7000-8000-00000000aa01", + "name": "land", + "width": 8000, + "height": 6000 + }, + { + "type": "map", + "id": "019a9300-0000-7000-8000-00000000aa02", + "name": "town", + "width": 2400, + "height": 1800, + "parent_map": "019a9300-0000-7000-8000-00000000aa01", + "x_parent_frame": [ + 7000, + 1200, + 7200, + 1400 + ] + }, + { + "type": "map", + "id": "019a9300-0000-7000-8000-00000000aa02", + "name": "town", + "width": 2400, + "height": 1800, + "parent_map": "019a9300-0000-7000-8000-00000000aa01", + "x_parent_frame": [ + 7011.9, + 1282.2, + 7164.3, + 1396.6 + ] + } + ], + "want": { + "parent_frame": [ + 7011.9, + 1282.2, + 7164.3, + 1396.6 + ], + "lint": null, + "points": [ + { + "map": "019a9300-0000-7000-8000-00000000aa01", + "x": 7100, + "y": 1300 + }, + { + "map": "019a9300-0000-7000-8000-00000000aa02", + "x": 1387.4015748031504, + "y": 280.0699300699297 + } + ], + "stop": null + } + }, + { + "name": "down-from-the-map-itself-with-its-own-lint", + "claim": "when `from` is `map` the lint is still `map`'s own: the land carries a key and no `parent_map`, so its lint is `no_parent`, with the point as given alone and `stop` null", + "map": "019a9300-0000-7000-8000-00000000aa01", + "from": "019a9300-0000-7000-8000-00000000aa01", + "point": [ + 15, + 15 + ], + "elements": [ + { + "type": "map", + "id": "019a9300-0000-7000-8000-00000000aa01", + "name": "land", + "width": 8000, + "height": 6000, + "x_parent_frame": [ + 0, + 0, + 10, + 10 + ] + } + ], + "want": { + "parent_frame": null, + "lint": "no_parent", + "points": [ + { + "map": "019a9300-0000-7000-8000-00000000aa01", + "x": 15, + "y": 15 + } + ], + "stop": null + } + }, + { + "name": "down-a-row-that-is-no-map", + "claim": "a row read whose `type` is `Map`, and one with no `id`, are no Map (readings K and H): each answers the empty reading, `points` empty and `stop` null", + "map_index": [ + 1, + 2 + ], + "from": "019a9300-0000-7000-8000-00000000aa01", + "point": [ + 7100, + 1300 + ], + "elements": [ + { + "type": "map", + "id": "019a9300-0000-7000-8000-00000000aa01", + "name": "land", + "width": 8000, + "height": 6000 + }, + { + "type": "Map", + "id": "019a9300-0000-7000-8000-00000000aa02", + "name": "town", + "width": 2400, + "height": 1800, + "parent_map": "019a9300-0000-7000-8000-00000000aa01", + "x_parent_frame": [ + 7011.9, + 1282.2, + 7164.3, + 1396.6 + ] + }, + { + "type": "map", + "name": "town", + "width": 2400, + "height": 1800, + "parent_map": "019a9300-0000-7000-8000-00000000aa01", + "x_parent_frame": [ + 7011.9, + 1282.2, + 7164.3, + 1396.6 + ] + } + ], + "want": { + "parent_frame": null, + "lint": null, + "points": [], + "stop": null + } + } ] } diff --git a/codegen/schema-dist/profiles/map-space.md b/codegen/schema-dist/profiles/map-space.md index 80932eb..4ba1d77 100644 --- a/codegen/schema-dist/profiles/map-space.md +++ b/codegen/schema-dist/profiles/map-space.md @@ -1,7 +1,7 @@ # Convention profile: map space -**What it is.** How a reader turns the standard's four map-space types into geometry: a Map's frame, a Zone's outline from its Markers, a Pin's point. The standard already says every part of it in its field descriptions (coordinates from the bottom left, `order` for the sequence, `shape` for how markers join, `depth` for z); two readers (the Unity package's C#, the Shell's `model.js`) carry the same rules with no page to replay against, and an engine would be the third copy. This page states the rules once, with a fixture. The geometry adds nothing to the world: no field, no mark, nothing stored. Two marks are a layout tool's, and rules 8 to 10 say how every tool reads them: `x_layout` on a Map (the Map is a drawing of its elements, and how it was drawn) and `x_hand` on a Pin (placed by hand); a second, small reading answers them for one Map. Rule 11 says what a tool that picks a Map, or measures or places by one, does with a layout map, and rule 12 when a writer marks one. Rule 13 says where a child Map lies on its parent (`x_parent_frame` on the child), and rule 14 how a point on the child is carried up to its parent and on; a third small reading answers both for one Map. Looks, cameras, lifts, doors, walls and rooms are a drawing tool's and are not here. +**What it is.** How a reader turns the standard's four map-space types into geometry: a Map's frame, a Zone's outline from its Markers, a Pin's point. The standard already says every part of it in its field descriptions (coordinates from the bottom left, `order` for the sequence, `shape` for how markers join, `depth` for z); two readers (the Unity package's C#, the Shell's `model.js`) carry the same rules with no page to replay against, and an engine would be the third copy. This page states the rules once, with a fixture. The geometry adds nothing to the world: no field, no mark, nothing stored. Two marks are a layout tool's, and rules 8 to 10 say how every tool reads them: `x_layout` on a Map (the Map is a drawing of its elements, and how it was drawn) and `x_hand` on a Pin (placed by hand); a second, small reading answers them for one Map. Rule 11 says what a tool that picks a Map, or measures or places by one, does with a layout map, and rule 12 when a writer marks one. Rule 13 says where a child Map lies on its parent (`x_parent_frame` on the child), and rule 14 how a point on the child is carried up to its parent and on; a third small reading answers both for one Map. Rule 15 brings a point on a Map down into the pixels of a Map below it, and a fourth small reading answers it. Looks, cameras, lifts, doors, walls and rooms are a drawing tool's and are not here. **The reading.** `mapSpace(elements)`, one reader in the SDK and the Python package (`map_space`), from the fixture beside this page. `elements` are the elements as the reader is served them (the folder's rows, or the API's), so visibility is already applied: a hidden Zone and its Markers are not in a member's or a visitor's input, and this page never brings them back. The answer is `{maps, zones, pins, out}`, in that order, every key always present. Everything is keyed by id and holds integers in the Map's pixels; a tool converts to its own units from the scale this page reports. @@ -20,6 +20,7 @@ 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. 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. +15. **Bringing a point down.** A point (X, Y), two numbers whole or not, on a Map is said in the pixels of a Map below it, or of that Map itself, by rule 14's walk, run from the Map below and reversed. The walk is rule 14's, from the Map the point lands on, with its stops in their order, and it is followed only until it carries a point onto the Map the point is on: what lies past that Map is never asked. When it does, or the two are one Map (whatever the walk from it would meet), there is a way down: the point is brought down the same Maps in reverse, one level at a time, the point each level gave brought down by the next, never through one product of the levels' ratios. Each level is, on the child, `((X - x0) * width) / (x1 - x0)` and `((Y - y0) * height) / (y1 - y0)`, with that child's own parent frame and its own written `width` and `height`, the ones the walk checked at that child and never the size of the Map the point is leaving, read as rule 14 reads them, in 64-bit binary floating point, each step in the order the parentheses write: the difference, then the product, then the quotient (the fraction taken first gives another last bit on some points). When the walk ends without reaching it, there is no way down, and `stop` is the word the walk ended on (`top` is the walk's own: the top reached with that Map not on the way); no point is brought part of the way. A point outside the parent frame is brought down as written and never clipped. `z` is not brought down: a parent frame says nothing of `depth`. No round trip is promised: a point carried up by rule 14 and brought down again is not, on every point, the point it was to the last bit. **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. @@ -36,12 +37,19 @@ A Pin whose element the reader cannot see is still a Pin and is listed when it q The point on the parent is `points[1]` where there is one; the point on the top of the chain is the last when `stop` is `top`; a tool that wants one Map above reads the entry with that Map's id, and finds none when the walk stopped below it. `parent_frame` and `lint` are this Map's own and do not depend on `point`. The reading reports no scale and takes none from a parent frame, and it reads a layout map as any Map: rule 11 is on the tool that places from one. The map-space reading is unchanged by rules 13 and 14: its Map entries carry no parent frame. +**The reading down.** `downOf(map, from, point, maps)` (`down_of` in Python), from the fixture's `down_cases`. `map` is the Map the point lands on, `from` the id of the Map it is given on, read by its id alone (the reading reads nothing of a row served under it; whether the walk reaches it is the walk's own, and a parent not served as a Map ends the walk `dangling`; a `from` that is not a non-empty string is no Map's id (reading H), which the walk never reaches and which is never `map`, so there is no way down), `point` is `[x, y]` on `from` (two finite numbers in its pixels from its bottom left), and `maps` the Maps the reader is served, each row read as the frame reading reads one. The answer is the frame reading's four keys, `{parent_frame, lint, points, stop}`, in that order, every key always present: +- `parent_frame` and `lint`: `map`'s own, as the frame reading answers them for `map`. +- `points`: each `{map, x, y}`, first the point on `from` as given; then, when there is a way down (rule 15), the point on each Map down the chain, the last on `map`, each `x` and `y` the 64-bit float the way down gives. When there is none, or `from` is `map`, the point on `from` stands alone. +- `stop`: `null` when there is a way down, else the word the walk from `map` ended on (rule 14). + +A `map` row that is no Map by K or H answers `{parent_frame: null, lint: null, points: [], stop: null}`, as the frame reading does, before anything else is read, `from` naming the same id included: a `stop` of `null` with `points` empty is no Map, and with `points` not empty a way down. Where there is no way down, the one point is `{map, x, y}` with `from` as given and the point as given. A tool that wants the point on a Map between asks for that Map as `map`. The reading reports no scale, and the map-space reading is unchanged by rule 15. + **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, 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; 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. +**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. Its `down_cases` are the reading down's, each in the form of a frame case with `from` beside `map` (or `map_index`) and `point`, and compared as a frame case is. They cover: a parent frame's two corners brought down to the child's origin and to its size; a point carried up from the child and brought down to other bits, on which the fraction taken first differs in y; decimals on which it differs again; a point left of the parent frame; `from` the Map itself; two levels, on which a product of the levels' ratios differs in both axes, and one level of the two; `from` below the Map read and beside it, each `top`; `from` the parent named and not served; a ring the walk ends in before it reaches `from`; a level with no parent frame and one with no carry, each below a level that carries; a walk that reaches `from` below a parent not served, and one that reaches it below a ring, neither followed past `from`, so neither fault is met; `from` the Map itself, on a Map whose parent is not served; `from` the parent named and served only as a row whose `type` is `Map`; a `map` whose `type` is `Map`, with `from` its own id; `from` an empty string on a walk that ends `top`, and `from` null on one that ends `dangling`; `from` an id no Map is served under and not the parent named, `top`; a `map` with its own lint, `no_parent`, and one whose key is a mirrored box, `not_a_box`, ending `no_frame`; a parent not served above a mirrored box, `dangling` before `no_frame`; a Map served twice with two parent frames, brought down by the last row's; `from` the Map itself on a Map with its own lint; and a row whose `type` is `Map` and one with no `id`. **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. 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. +**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. 2026-11-21, serial 144: rule 15, a point on a Map brought down into the pixels of a Map below it by rule 14's walk from the Map below, followed only until it reaches the Map the point is on, and reversed: the same Maps in reverse, one level at a time, each by the child's own parent frame and written size, `((X - x0) * width) / (x1 - x0)` and its y in 64-bit floats in that order, the difference, the product, the quotient; when the walk ends first, no way down, the word it ended on, and no point brought part of the way; a point outside the parent frame never clipped, `z` not brought down, and no round trip promised; the reading down, `downOf`, answering the frame reading's four keys, `from` read by its id alone, a `from` that is not a non-empty string being no Map's id, and a `map` that is no Map answered first, with its own fixture section, `down_cases`, twenty-eight cases; no reader's answer on an existing case moves. diff --git a/codegen/schema-pin.json b/codegen/schema-pin.json index 4dd93c4..343ade2 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.143", - "commit": "e03cd70f9cac6e591e62fcccb047074ac95d9d38", - "manifest_sha256": "c054efbf5ce23c6ccc7ba80bcc5a5f2bb55ca3561574ce0f94621006c88507cf", + "tag": "v0.34.1-dist.144", + "commit": "35a12a0c05bc158008d3cca8261c71b3cc68e855", + "manifest_sha256": "ebf8c6b472cb6cdd9494d244efdafe743cdefce0a83f4468ce59fdf05d6e3a89", "canonical_version": "00.34.01", - "dist_serial": 143, + "dist_serial": 144, "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.143", + "manifest_sha256": "c054efbf5ce23c6ccc7ba80bcc5a5f2bb55ca3561574ce0f94621006c88507cf", + "note": "superseded by v0.34.1-dist.144 (map-space rule 15, downOf and 28 down_cases; no other case moves)" + }, { "tag": "v0.34.1-dist.142", "manifest_sha256": "59d21a4b7a3210bf4cb7cc8c59aece3600681e864fb2e9825e3d592e8b1f6e4e", diff --git a/src/onlyworlds/_schema.py b/src/onlyworlds/_schema.py index ddc0429..6a29eaa 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.143 (e03cd70f9cac6e591e62fcccb047074ac95d9d38) +# Source: https://github.com/OnlyWorlds/schema-dist @ v0.34.1-dist.144 (35a12a0c05bc158008d3cca8261c71b3cc68e855) """Schema provenance, the 22 element types and their fields, from the pinned schema distribution.""" -SCHEMA_DIST_TAG = "v0.34.1-dist.143" +SCHEMA_DIST_TAG = "v0.34.1-dist.144" SCHEMA_VERSION = "00.34.01" -SCHEMA_DIST_SERIAL = 143 -SCHEMA_MANIFEST_SHA256 = "c054efbf5ce23c6ccc7ba80bcc5a5f2bb55ca3561574ce0f94621006c88507cf" +SCHEMA_DIST_SERIAL = 144 +SCHEMA_MANIFEST_SHA256 = "ebf8c6b472cb6cdd9494d244efdafe743cdefce0a83f4468ce59fdf05d6e3a89" # Canonical order, as the walk declares it. ELEMENT_TYPES: tuple[str, ...] = ( diff --git a/src/onlyworlds/_version.py b/src/onlyworlds/_version.py index d4bf641..0f8f149 100644 --- a/src/onlyworlds/_version.py +++ b/src/onlyworlds/_version.py @@ -1 +1 @@ -__version__ = "0.139.2" +__version__ = "0.139.3"