From 66ed2c4084343c09f355bbbf4c263e923df5b07a Mon Sep 17 00:00:00 2001 From: Titus Date: Thu, 19 Nov 2026 10:47:32 +0100 Subject: [PATCH 1/2] carry_of: the map-space profile's frame reading, staged for the child map's frame serial Where a point on a child Map lies on its parent and on each Map above it: rules 13 and 14 of the map-space page, x_parent_frame read, the point carried one level at a time in 64-bit floats in the page's order, the walk's stop named. Not yet run on its cases: the serial is unpublished, and its fixture lands with the pin. Co-Authored-By: Claude Opus 5.5 --- src/onlyworlds/__init__.py | 6 ++ src/onlyworlds/carry.py | 152 +++++++++++++++++++++++++++++++++++++ tests/test_carry.py | 90 ++++++++++++++++++++++ 3 files changed, 248 insertions(+) create mode 100644 src/onlyworlds/carry.py create mode 100644 tests/test_carry.py diff --git a/src/onlyworlds/__init__.py b/src/onlyworlds/__init__.py index db2eae8..25a38b9 100644 --- a/src/onlyworlds/__init__.py +++ b/src/onlyworlds/__init__.py @@ -34,6 +34,7 @@ parse_ow_link, read_ow_link_at, ) +from .carry import CarryLint, CarryOf, CarryPoint, CarryStop, carry_of from .charter import ( SKILL_MAX, CharterHub, @@ -201,6 +202,10 @@ "AroundLayout", "AroundPoint", "BulkResult", + "CarryLint", + "CarryOf", + "CarryPoint", + "CarryStop", "ChangeWalk", "CharterHub", "CharterPacket", @@ -274,6 +279,7 @@ "WriteReport", "__version__", "apply_checks", + "carry_of", "charter_of", "check_kinds", "date_of", diff --git a/src/onlyworlds/carry.py b/src/onlyworlds/carry.py new file mode 100644 index 0000000..ae66c0d --- /dev/null +++ b/src/onlyworlds/carry.py @@ -0,0 +1,152 @@ +"""The map-space profile's frame reading (schema-dist ``profiles/map-space.md``, rules 13 and 14): where a point on a +child Map lies on its parent, and on each Map above it. A child Map says where it lies on the Map its ``parent_map`` +names with ``x_parent_frame``, a box ``[x0, y0, x1, y1]`` in the parent's pixels. The profile's ``frame_cases`` are +the test. ``map_space`` and ``layout_of`` do not read the key. + +Every number is read as a 64-bit float before any arithmetic: Python's exact integers would otherwise round +differently from every other reader past 2**53.""" + +from __future__ import annotations + +import math +from collections.abc import Mapping, Sequence +from typing import Any, Literal, TypedDict + +CarryStop = Literal["top", "dangling", "cycle", "no_frame", "no_carry"] +CarryLint = Literal["no_parent", "not_four_numbers", "not_a_box"] + + +class CarryPoint(TypedDict): + """A point on one Map: its id and the point in its pixels, from its bottom left.""" + + map: str + x: float + y: float + + +class CarryOf(TypedDict): + """One Map's frame reading. ``parent_frame`` is the key as written when it is a parent frame, else None; + ``lint`` names what is wrong with this Map's own key; ``points`` is the point as given, then on each Map it is + carried to up ``parent_map``; ``stop`` says why the walk ended (None only for a row that is no Map).""" + + parent_frame: list[Any] | None + lint: CarryLint | None + points: list[CarryPoint] + stop: CarryStop | None + + +def _id(value: Any) -> str | None: + """An id or a link: a string that is not empty; anything else reads as none (reading H).""" + return value if isinstance(value, str) and value != "" else None + + +def _map_id(row: Any) -> str | None: + """A Map row: ``type`` exactly ``map`` (reading K) and a non-empty string id (reading H).""" + return _id(row.get("id")) if isinstance(row, Mapping) and row.get("type") == "map" else None + + +def _float(value: Any) -> float | None: + """A number as rule 13 reads one: a JSON number held as a finite 64-bit float, else None. A bool, a string, null, + a list, an object, and an integer too large for a 64-bit float are none.""" + if isinstance(value, bool) or not isinstance(value, (int, float)): + return None + try: + f = float(value) + except OverflowError: + return None + return f if math.isfinite(f) else None + + +def _carry_size(value: Any) -> float | None: + """A size a carry may divide by: a whole number above 0, by value (reading K: 100.0 reads as 100).""" + f = _float(value) + return f if f is not None and f.is_integer() and f > 0 else None + + +def _frame_of(row: Mapping[str, Any]) -> tuple[list[Any] | None, CarryLint | None]: + """This Map's own parent frame (as written) and lint (rule 13).""" + key = row.get("x_parent_frame") + present = key is not None + if _id(row.get("parent_map")) is None: + return None, ("no_parent" if present else None) + if not present: + return None, None + if not isinstance(key, list) or len(key) != 4: + return None, "not_four_numbers" + nums = [_float(v) for v in key] + if any(n is None for n in nums): + return None, "not_four_numbers" + x0, y0, x1, y1 = (n for n in nums if n is not None) + if not (x0 < x1) or not (y0 < y1): + return None, "not_a_box" + return key, None + + +def carry_of(map: Any, point: Sequence[float], maps: Sequence[Any]) -> CarryOf: + """One Map's frame reading: ``{parent_frame, lint, points, stop}``, every key always present. + + ``map`` is the Map read, ``point`` is ``[x, y]`` on it (two finite numbers in its pixels from its bottom left), + ``maps`` the Maps the reader is served: rows of any other type are skipped, a row whose ``type`` is not exactly + ``map`` or that has no non-empty string id is no Map, and of two rows with one id the last served is read. A + ``map`` that is no Map answers ``{parent_frame: None, lint: None, points: [], stop: None}``. + + The point is carried one level at a time up ``parent_map``, by each level's own frame, as + ``x0 + ((x * (x1 - x0)) / width)`` and ``y0 + ((y * (y1 - y0)) / height)`` in 64-bit floats in that order, + never through one product of the levels' ratios. The walk ends at a Map with no ``parent_map`` (``top``), one + whose parent is not served (``dangling``), one whose parent the walk has already reached, itself included + (``cycle``), one with no parent frame (``no_frame``), or one whose written ``width`` or ``height`` is not a whole + number above 0 (``no_carry``). A point outside the child is carried as written; ``z`` is not carried. Pure.""" + if not isinstance(map, Mapping): + raise TypeError("carry_of: map is one Map element.") + if isinstance(point, (str, bytes)) or not isinstance(point, Sequence) or len(point) != 2: + raise TypeError(f"carry_of: point is [x, y], two finite numbers; got {point!r}.") + px, py = _float(point[0]), _float(point[1]) + if px is None or py is None: + raise TypeError(f"carry_of: point is [x, y], two finite numbers; got {point!r}.") + if isinstance(maps, (str, bytes)) or not isinstance(maps, Sequence): + raise TypeError("carry_of: maps is a list of Map elements.") + mid = _map_id(map) + if mid is None: + return {"parent_frame": None, "lint": None, "points": [], "stop": None} + + served: dict[str, Mapping[str, Any]] = {} + for m in maps: + sid = _map_id(m) + if sid is not None: + served[sid] = m + + own_frame, own_lint = _frame_of(map) + # The point as given is the first entry; every carried one is a 64-bit float. + points: list[CarryPoint] = [{"map": mid, "x": point[0], "y": point[1]}] + x, y = px, py + reached = {mid} + at: Mapping[str, Any] = map + frame = own_frame + stop: CarryStop + while True: + parent_id = _id(at.get("parent_map")) + if parent_id is None: + stop = "top" + break + parent = served.get(parent_id) + if parent is None: + stop = "dangling" + break + if parent_id in reached: + stop = "cycle" + break + if frame is None: + stop = "no_frame" + break + width, height = _carry_size(at.get("width")), _carry_size(at.get("height")) + if width is None or height is None: + stop = "no_carry" + break + x0, y0, x1, y1 = (float(v) for v in frame) + x = x0 + ((x * (x1 - x0)) / width) + y = y0 + ((y * (y1 - y0)) / height) + points.append({"map": parent_id, "x": x, "y": y}) + reached.add(parent_id) + at = parent + frame = _frame_of(parent)[0] + return {"parent_frame": own_frame, "lint": own_lint, "points": points, "stop": stop} diff --git a/tests/test_carry.py b/tests/test_carry.py new file mode 100644 index 0000000..fd99a05 --- /dev/null +++ b/tests/test_carry.py @@ -0,0 +1,90 @@ +"""The map-space profile's frame reading (schema-dist ``profiles/map-space.md``, rules 13 and 14): every case under +``frame_cases`` in ``codegen/schema-dist/profiles/map-space.fixture.json``, vendored with the distribution, each its own +test, through ``carry_of``. The Map read is the last Map row served with the case's id (or each row ``map_index`` +lists); ``maps`` is every row of the case. A number in ``parent_frame`` and ``points`` compares as a 64-bit float, +exactly, with no tolerance; every other part as written, key order included. A missing fixture fails, never skips.""" + +from __future__ import annotations + +import json +from pathlib import Path +from typing import Any + +import pytest + +from onlyworlds import carry_of, map_space + +REPO = Path(__file__).resolve().parent.parent +FIXTURE = REPO / "codegen" / "schema-dist" / "profiles" / "map-space.fixture.json" +FRAME_CASES_IN_FIXTURE = 66 + + +def load_fixture() -> dict[str, Any]: + assert FIXTURE.is_file(), f"no map-space fixture at {FIXTURE}" + doc: dict[str, Any] = json.loads(FIXTURE.read_text(encoding="utf-8")) + assert doc["profile"] == "map-space" + return doc + + +CASES: list[dict[str, Any]] = load_fixture().get("frame_cases", []) + + +def rows_read(case: dict[str, Any]) -> list[Any]: + if "map_index" in case: + assert "map" not in case, f"{case['name']}: both map and map_index" + return [case["elements"][i] for i in case["map_index"]] + rows = [e for e in case["elements"] if e.get("type") == "map" and e.get("id") == case["map"]] + assert rows, f"{case['name']}: no Map row with the case's id" + return [rows[-1]] + + +def same(got: Any, want: Any, path: str) -> None: + """Exactly equal: a number as a 64-bit float (a bool is no number), the rest as written, key order held.""" + if isinstance(want, (int, float)) and not isinstance(want, bool): + assert isinstance(got, (int, float)) and not isinstance(got, bool), f"{path}: a number, got {got!r}" + assert float(got) == float(want), f"{path}: {got!r} is not {want!r}" + return + if isinstance(want, list): + assert isinstance(got, list) and len(got) == len(want), f"{path}: {got!r} is not {want!r}" + for i, (g, w) in enumerate(zip(got, want, strict=True)): + same(g, w, f"{path}[{i}]") + return + if isinstance(want, dict): + assert isinstance(got, dict), f"{path}: an object" + assert list(got) == list(want), f"{path}: keys {list(got)} are not {list(want)}" + for k in want: + same(got[k], want[k], f"{path}.{k}") + return + assert got == want and type(got) is type(want), f"{path}: {got!r} is not {want!r}" + + +def test_the_fixture_holds_every_frame_case() -> None: + assert len(CASES) == FRAME_CASES_IN_FIXTURE + assert len({c["name"] for c in CASES}) == FRAME_CASES_IN_FIXTURE + + +@pytest.mark.parametrize("case", CASES, ids=lambda c: c["name"]) +def test_carry_of(case: dict[str, Any]) -> None: + for row in rows_read(case): + same(carry_of(row, case["point"], case["elements"]), case["want"], "answer") + + +def test_every_carried_number_is_a_float() -> None: + """Every point past the first is carried in 64-bit floats, whatever the fixture's numbers were written as.""" + for case in CASES: + for row in rows_read(case): + for p in carry_of(row, case["point"], case["elements"])["points"][1:]: + assert type(p["x"]) is float and type(p["y"]) is float, case["name"] + + +def test_map_space_carries_no_frame_key() -> None: + for case in CASES: + for m in map_space(case["elements"])["maps"]: + assert "parent_frame" not in m and "x_parent_frame" not in m, case["name"] + + +@pytest.mark.parametrize("bad", [[1], [1, 2, 3], ["1", 2], [1, float("nan")], [1, float("inf")], [True, 2], None, "12"]) +def test_a_point_that_is_not_two_finite_numbers_is_refused(bad: Any) -> None: + m = {"type": "map", "id": "a", "width": 10, "height": 10} + with pytest.raises(TypeError): + carry_of(m, bad, [m]) From 1a4345510e56956e0bc747e30825e28160e7958a Mon Sep 17 00:00:00 2001 From: Titus Date: Thu, 19 Nov 2026 14:11:51 +0100 Subject: [PATCH 2/2] 0.137.0: schema-dist serial 139; carry_of, the map-space profile's frame reading Co-Authored-By: Claude Opus 5.5 --- CHANGELOG.md | 5 + codegen/schema-dist/MANIFEST.json | 8 +- codegen/schema-dist/README.md | 2 +- codegen/schema-dist/VERSION | 2 +- .../profiles/map-space.fixture.json | 3290 +++++++++++++++++ codegen/schema-dist/profiles/map-space.md | 18 +- codegen/schema-pin.json | 13 +- src/onlyworlds/_schema.py | 8 +- src/onlyworlds/_version.py | 2 +- 9 files changed, 3329 insertions(+), 19 deletions(-) diff --git a/CHANGELOG.md b/CHANGELOG.md index cb0d498..4985d7b 100644 --- a/CHANGELOG.md +++ b/CHANGELOG.md @@ -4,6 +4,11 @@ The package version runs on its own semver; the schema it is generated from is ` ## Unreleased +## 0.137.0 (2026-11-19) + +- **`carry_of(map, point, maps)`, the map-space profile's frame reading** (schema-dist serial 139, rules 13 and 14), the TypeScript SDK's `carryOf` with the same answer. A child Map says where it lies on the Map its `parent_map` names with `x_parent_frame`, a box `[x0, y0, x1, y1]` in the parent's pixels; `carry_of` carries a point on a Map up that chain, one level at a time by each level's own frame, in 64-bit floats, and answers `{parent_frame, lint, points, stop}`: the Map's own frame as written or None, what is wrong with it (`no_parent`, `not_four_numbers`, `not_a_box`), the point on each Map it reaches, and why the walk ended (`top`, `dangling`, `cycle`, `no_frame`, `no_carry`). Its types are `CarryOf`, `CarryPoint`, `CarryStop` and `CarryLint`. `map_space` and `layout_of` do not read the key. +- **The schema pin moves to `v0.34.1-dist.139`** (canonical 00.34.01 unchanged, no schema file moved, `_schema.py` changes only its provenance lines): the map-space page's rules 13 and 14 and the fixture's 66 `frame_cases`, which `carry_of` answers as published; the map-space reading's own cases are unchanged. + ## 0.136.0 (2026-11-19) - **The schema pin moves to `v0.34.1-dist.138`** (serials 137 and 138; canonical 00.34.01 unchanged, no schema file moved, `_schema.py` changes only its provenance lines). Serial 137 publishes the `by-links-3d` method on the layout profile's page, with its fixture (116 cases) and directions table, adds four map-space cases (a Map's `width` or `height` that is a whole number, 0 and under 0 included, is answered as written; a slot measured on a Map with no placed point of its own is None), three layout-reading cases and two `unplaced` cases. Serial 138 adds cases to the lens (246), charter (16 design) and report (9 talk) fixtures. Every case passes as published. diff --git a/codegen/schema-dist/MANIFEST.json b/codegen/schema-dist/MANIFEST.json index 7bafa95..abe085c 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": "eef4348884994c5e99fffa81c4ad5b9a8f26f722d72e9a896db5214ae44dcb13", "profiles/lens.md": "ee1f46c6ef7d2626c3c47230d4f99315dd03da91cf429c1015b10b263d7cb5da", - "profiles/map-space.fixture.json": "40c2152f28e74f6d9518698fda6508ffedf05199f4695c0d124dd79e75d8fd57", - "profiles/map-space.md": "1d2e3626170a90c3d7cea5e78809ac43d25588f726d7537fed9a4e520a3ba05c", + "profiles/map-space.fixture.json": "f1d832d63b9b0d071bd1bc1c2d16a97b3b9db405a9e01a63451ca74ef0cec657", + "profiles/map-space.md": "f3c6b7f69da6b3ef9e27ef81699d910b17f4757bac173a08b8118d5df9ec7222", "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": "f0847e0633639df9c66952bd1ce0c4330379dbcdd0ee854c8eb62e9e8b7c509a", + "README.md": "6739b4b60bffc9102335e1153b35b84b0641e1b3bf3e07f6be8b77f6e4862dea", "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": "8ca53fe26df015f876768a285e03bc7f0c20fd15d460eed65514e083dc8e0f20", + "VERSION": "a5be0891b9dbfde6084151366e6568ef639d2f13e5f94ebe826a1e2ce4e0acbc", "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 d56fbc6..ad72304 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; `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; `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 1594fce..f3d1a01 100644 --- a/codegen/schema-dist/VERSION +++ b/codegen/schema-dist/VERSION @@ -1,3 +1,3 @@ canonical: 00.34.01 -serial: 138 +serial: 139 published: 2026-11-19 diff --git a/codegen/schema-dist/profiles/map-space.fixture.json b/codegen/schema-dist/profiles/map-space.fixture.json index 4dccceb..1b097a6 100644 --- a/codegen/schema-dist/profiles/map-space.fixture.json +++ b/codegen/schema-dist/profiles/map-space.fixture.json @@ -10952,5 +10952,3295 @@ "hand": [] } } + ], + "frame_cases": [ + { + "name": "frame-places-a-point", + "claim": "a point on the child is carried onto its parent by the frame, each axis by its own ratio, y from the bottom: (20, 10) on a 100 by 50 child framed by [100, 200, 300, 300] is (140, 220)", + "map": "019a9200-0000-7000-8000-00000000aa02", + "point": [ + 20, + 10 + ], + "elements": [ + { + "type": "map", + "id": "019a9200-0000-7000-8000-00000000aa01", + "name": "land", + "width": 1000, + "height": 800 + }, + { + "type": "map", + "id": "019a9200-0000-7000-8000-00000000aa02", + "name": "town", + "width": 100, + "height": 50, + "parent_map": "019a9200-0000-7000-8000-00000000aa01", + "x_parent_frame": [ + 100, + 200, + 300, + 300 + ] + } + ], + "want": { + "parent_frame": [ + 100, + 200, + 300, + 300 + ], + "lint": null, + "points": [ + { + "map": "019a9200-0000-7000-8000-00000000aa02", + "x": 20, + "y": 10 + }, + { + "map": "019a9200-0000-7000-8000-00000000aa01", + "x": 140.0, + "y": 220.0 + } + ], + "stop": "top" + } + }, + { + "name": "frame-a-stretch", + "claim": "a box of another shape than the child's is a stretch, not a fault: a 100 by 50 child on a box 20 wide and 100 tall carries y by 100 / 50 and x by 20 / 100, never by the width's ratio alone", + "map": "019a9200-0000-7000-8000-00000000aa02", + "point": [ + 50, + 25 + ], + "elements": [ + { + "type": "map", + "id": "019a9200-0000-7000-8000-00000000aa01", + "name": "land", + "width": 1000, + "height": 800 + }, + { + "type": "map", + "id": "019a9200-0000-7000-8000-00000000aa02", + "name": "town", + "width": 100, + "height": 50, + "parent_map": "019a9200-0000-7000-8000-00000000aa01", + "x_parent_frame": [ + 10, + 20, + 30, + 120 + ] + } + ], + "want": { + "parent_frame": [ + 10, + 20, + 30, + 120 + ], + "lint": null, + "points": [ + { + "map": "019a9200-0000-7000-8000-00000000aa02", + "x": 50, + "y": 25 + }, + { + "map": "019a9200-0000-7000-8000-00000000aa01", + "x": 20.0, + "y": 70.0 + } + ], + "stop": "top" + } + }, + { + "name": "frame-a-box-the-child-turned-is-a-stretch", + "claim": "no turn: a box of the child's shape turned on its side is a stretch, and x stays x", + "map": "019a9200-0000-7000-8000-00000000aa02", + "point": [ + 80, + 10 + ], + "elements": [ + { + "type": "map", + "id": "019a9200-0000-7000-8000-00000000aa01", + "name": "land", + "width": 1000, + "height": 800 + }, + { + "type": "map", + "id": "019a9200-0000-7000-8000-00000000aa02", + "name": "town", + "width": 100, + "height": 50, + "parent_map": "019a9200-0000-7000-8000-00000000aa01", + "x_parent_frame": [ + 0, + 0, + 50, + 100 + ] + } + ], + "want": { + "parent_frame": [ + 0, + 0, + 50, + 100 + ], + "lint": null, + "points": [ + { + "map": "019a9200-0000-7000-8000-00000000aa02", + "x": 80, + "y": 10 + }, + { + "map": "019a9200-0000-7000-8000-00000000aa01", + "x": 40.0, + "y": 20.0 + } + ], + "stop": "top" + } + }, + { + "name": "frame-a-point-outside-the-child", + "claim": "a point outside the child's rectangle is carried as written, never clipped", + "map": "019a9200-0000-7000-8000-00000000aa02", + "point": [ + -10, + 70 + ], + "elements": [ + { + "type": "map", + "id": "019a9200-0000-7000-8000-00000000aa01", + "name": "land", + "width": 1000, + "height": 800 + }, + { + "type": "map", + "id": "019a9200-0000-7000-8000-00000000aa02", + "name": "town", + "width": 100, + "height": 50, + "parent_map": "019a9200-0000-7000-8000-00000000aa01", + "x_parent_frame": [ + 100, + 200, + 300, + 300 + ] + } + ], + "want": { + "parent_frame": [ + 100, + 200, + 300, + 300 + ], + "lint": null, + "points": [ + { + "map": "019a9200-0000-7000-8000-00000000aa02", + "x": -10, + "y": 70 + }, + { + "map": "019a9200-0000-7000-8000-00000000aa01", + "x": 80.0, + "y": 340.0 + } + ], + "stop": "top" + } + }, + { + "name": "frame-a-box-past-the-parent-edge", + "claim": "a box that runs past the parent's edges is a frame as written: the reader reports, it does not fix", + "map": "019a9200-0000-7000-8000-00000000aa02", + "point": [ + 100, + 50 + ], + "elements": [ + { + "type": "map", + "id": "019a9200-0000-7000-8000-00000000aa01", + "name": "land", + "width": 1000, + "height": 800 + }, + { + "type": "map", + "id": "019a9200-0000-7000-8000-00000000aa02", + "name": "town", + "width": 100, + "height": 50, + "parent_map": "019a9200-0000-7000-8000-00000000aa01", + "x_parent_frame": [ + -50, + 700, + 150, + 900 + ] + } + ], + "want": { + "parent_frame": [ + -50, + 700, + 150, + 900 + ], + "lint": null, + "points": [ + { + "map": "019a9200-0000-7000-8000-00000000aa02", + "x": 100, + "y": 50 + }, + { + "map": "019a9200-0000-7000-8000-00000000aa01", + "x": 150.0, + "y": 900.0 + } + ], + "stop": "top" + } + }, + { + "name": "frame-whole-numbers-written-with-a-fraction-part", + "claim": "the parent frame is answered as written; `100.0` and `100` are one number, and a whole `width` written `100.0` is a whole number above 0, so the point is carried", + "map": "019a9200-0000-7000-8000-00000000aa02", + "point": [ + 20, + 10 + ], + "elements": [ + { + "type": "map", + "id": "019a9200-0000-7000-8000-00000000aa01", + "name": "land", + "width": 1000, + "height": 800 + }, + { + "type": "map", + "id": "019a9200-0000-7000-8000-00000000aa02", + "name": "town", + "width": 100.0, + "height": 50, + "parent_map": "019a9200-0000-7000-8000-00000000aa01", + "x_parent_frame": [ + 100.0, + 200, + 300.0, + 300 + ] + } + ], + "want": { + "parent_frame": [ + 100.0, + 200, + 300.0, + 300 + ], + "lint": null, + "points": [ + { + "map": "019a9200-0000-7000-8000-00000000aa02", + "x": 20, + "y": 10 + }, + { + "map": "019a9200-0000-7000-8000-00000000aa01", + "x": 140.0, + "y": 220.0 + } + ], + "stop": "top" + } + }, + { + "name": "frame-on-a-map-with-no-parent", + "claim": "a frame on a Map with no `parent_map` is not read: `parent_frame` null, lint `no_parent`, the point stays", + "map": "019a9200-0000-7000-8000-00000000aa02", + "point": [ + 20, + 10 + ], + "elements": [ + { + "type": "map", + "id": "019a9200-0000-7000-8000-00000000aa01", + "name": "land", + "width": 1000, + "height": 800 + }, + { + "type": "map", + "id": "019a9200-0000-7000-8000-00000000aa02", + "name": "town", + "width": 100, + "height": 50, + "x_parent_frame": [ + 100, + 200, + 300, + 300 + ] + } + ], + "want": { + "parent_frame": null, + "lint": "no_parent", + "points": [ + { + "map": "019a9200-0000-7000-8000-00000000aa02", + "x": 20, + "y": 10 + } + ], + "stop": "top" + } + }, + { + "name": "frame-with-an-empty-parent-link", + "claim": "a `parent_map` that is an empty string is no link (reading H), so the frame is not read", + "map": "019a9200-0000-7000-8000-00000000aa02", + "point": [ + 20, + 10 + ], + "elements": [ + { + "type": "map", + "id": "019a9200-0000-7000-8000-00000000aa01", + "name": "land", + "width": 1000, + "height": 800 + }, + { + "type": "map", + "id": "019a9200-0000-7000-8000-00000000aa02", + "name": "town", + "width": 100, + "height": 50, + "parent_map": "", + "x_parent_frame": [ + 100, + 200, + 300, + 300 + ] + } + ], + "want": { + "parent_frame": null, + "lint": "no_parent", + "points": [ + { + "map": "019a9200-0000-7000-8000-00000000aa02", + "x": 20, + "y": 10 + } + ], + "stop": "top" + } + }, + { + "name": "frame-malformed-on-a-map-with-no-parent", + "claim": "with no `parent_map` the frame is not read at all: its lint is `no_parent`, whatever its shape", + "map": "019a9200-0000-7000-8000-00000000aa02", + "point": [ + 20, + 10 + ], + "elements": [ + { + "type": "map", + "id": "019a9200-0000-7000-8000-00000000aa01", + "name": "land", + "width": 1000, + "height": 800 + }, + { + "type": "map", + "id": "019a9200-0000-7000-8000-00000000aa02", + "name": "town", + "width": 100, + "height": 50, + "x_parent_frame": [ + 30, + 20, + 10 + ] + } + ], + "want": { + "parent_frame": null, + "lint": "no_parent", + "points": [ + { + "map": "019a9200-0000-7000-8000-00000000aa02", + "x": 20, + "y": 10 + } + ], + "stop": "top" + } + }, + { + "name": "frame-absent", + "claim": "a child with a `parent_map` and no frame has `parent_frame` null and no lint, and its point is carried no further, though its Location has a Pin on the parent", + "map": "019a9200-0000-7000-8000-00000000aa02", + "point": [ + 20, + 10 + ], + "elements": [ + { + "type": "map", + "id": "019a9200-0000-7000-8000-00000000aa01", + "name": "land", + "width": 1000, + "height": 800 + }, + { + "type": "map", + "id": "019a9200-0000-7000-8000-00000000aa02", + "name": "town", + "width": 100, + "height": 50, + "parent_map": "019a9200-0000-7000-8000-00000000aa01", + "location": "019a9200-0000-7000-8000-0000000e0001" + }, + { + "type": "location", + "id": "019a9200-0000-7000-8000-0000000e0001", + "name": "place" + }, + { + "type": "pin", + "id": "019a9200-0000-7000-8000-0000000d0001", + "name": "place", + "map": "019a9200-0000-7000-8000-00000000aa01", + "element_type": "location", + "element_id": "019a9200-0000-7000-8000-0000000e0001", + "x": 400, + "y": 300 + } + ], + "want": { + "parent_frame": null, + "lint": null, + "points": [ + { + "map": "019a9200-0000-7000-8000-00000000aa02", + "x": 20, + "y": 10 + } + ], + "stop": "no_frame" + } + }, + { + "name": "frame-null", + "claim": "an `x_parent_frame` of null is no frame, as an absent one, with no lint", + "map": "019a9200-0000-7000-8000-00000000aa02", + "point": [ + 20, + 10 + ], + "elements": [ + { + "type": "map", + "id": "019a9200-0000-7000-8000-00000000aa01", + "name": "land", + "width": 1000, + "height": 800 + }, + { + "type": "map", + "id": "019a9200-0000-7000-8000-00000000aa02", + "name": "town", + "width": 100, + "height": 50, + "parent_map": "019a9200-0000-7000-8000-00000000aa01", + "x_parent_frame": null + } + ], + "want": { + "parent_frame": null, + "lint": null, + "points": [ + { + "map": "019a9200-0000-7000-8000-00000000aa02", + "x": 20, + "y": 10 + } + ], + "stop": "no_frame" + } + }, + { + "name": "frame-three-numbers", + "claim": "an `x_parent_frame` that is three numbers is no frame, with the lint `not_four_numbers`", + "map": "019a9200-0000-7000-8000-00000000aa02", + "point": [ + 50, + 25 + ], + "elements": [ + { + "type": "map", + "id": "019a9200-0000-7000-8000-00000000aa01", + "name": "land", + "width": 1000, + "height": 800 + }, + { + "type": "map", + "id": "019a9200-0000-7000-8000-00000000aa02", + "name": "town", + "width": 100, + "height": 50, + "parent_map": "019a9200-0000-7000-8000-00000000aa01", + "x_parent_frame": [ + 10, + 20, + 30 + ] + } + ], + "want": { + "parent_frame": null, + "lint": "not_four_numbers", + "points": [ + { + "map": "019a9200-0000-7000-8000-00000000aa02", + "x": 50, + "y": 25 + } + ], + "stop": "no_frame" + } + }, + { + "name": "frame-five-numbers", + "claim": "an `x_parent_frame` that is five numbers is no frame (its first four are never read), with the lint `not_four_numbers`", + "map": "019a9200-0000-7000-8000-00000000aa02", + "point": [ + 50, + 25 + ], + "elements": [ + { + "type": "map", + "id": "019a9200-0000-7000-8000-00000000aa01", + "name": "land", + "width": 1000, + "height": 800 + }, + { + "type": "map", + "id": "019a9200-0000-7000-8000-00000000aa02", + "name": "town", + "width": 100, + "height": 50, + "parent_map": "019a9200-0000-7000-8000-00000000aa01", + "x_parent_frame": [ + 10, + 20, + 30, + 40, + 50 + ] + } + ], + "want": { + "parent_frame": null, + "lint": "not_four_numbers", + "points": [ + { + "map": "019a9200-0000-7000-8000-00000000aa02", + "x": 50, + "y": 25 + } + ], + "stop": "no_frame" + } + }, + { + "name": "frame-numbers-as-strings", + "claim": "an `x_parent_frame` that is numbers written as strings is no frame, with the lint `not_four_numbers`", + "map": "019a9200-0000-7000-8000-00000000aa02", + "point": [ + 50, + 25 + ], + "elements": [ + { + "type": "map", + "id": "019a9200-0000-7000-8000-00000000aa01", + "name": "land", + "width": 1000, + "height": 800 + }, + { + "type": "map", + "id": "019a9200-0000-7000-8000-00000000aa02", + "name": "town", + "width": 100, + "height": 50, + "parent_map": "019a9200-0000-7000-8000-00000000aa01", + "x_parent_frame": [ + "10", + "20", + "30", + "40" + ] + } + ], + "want": { + "parent_frame": null, + "lint": "not_four_numbers", + "points": [ + { + "map": "019a9200-0000-7000-8000-00000000aa02", + "x": 50, + "y": 25 + } + ], + "stop": "no_frame" + } + }, + { + "name": "frame-a-string-among-numbers", + "claim": "an `x_parent_frame` that is one string among four is no frame, with the lint `not_four_numbers`", + "map": "019a9200-0000-7000-8000-00000000aa02", + "point": [ + 50, + 25 + ], + "elements": [ + { + "type": "map", + "id": "019a9200-0000-7000-8000-00000000aa01", + "name": "land", + "width": 1000, + "height": 800 + }, + { + "type": "map", + "id": "019a9200-0000-7000-8000-00000000aa02", + "name": "town", + "width": 100, + "height": 50, + "parent_map": "019a9200-0000-7000-8000-00000000aa01", + "x_parent_frame": [ + 10, + "20", + 30, + 40 + ] + } + ], + "want": { + "parent_frame": null, + "lint": "not_four_numbers", + "points": [ + { + "map": "019a9200-0000-7000-8000-00000000aa02", + "x": 50, + "y": 25 + } + ], + "stop": "no_frame" + } + }, + { + "name": "frame-a-boolean-among-numbers", + "claim": "an `x_parent_frame` that is a boolean among four (true is no 1) is no frame, with the lint `not_four_numbers`", + "map": "019a9200-0000-7000-8000-00000000aa02", + "point": [ + 50, + 25 + ], + "elements": [ + { + "type": "map", + "id": "019a9200-0000-7000-8000-00000000aa01", + "name": "land", + "width": 1000, + "height": 800 + }, + { + "type": "map", + "id": "019a9200-0000-7000-8000-00000000aa02", + "name": "town", + "width": 100, + "height": 50, + "parent_map": "019a9200-0000-7000-8000-00000000aa01", + "x_parent_frame": [ + 0, + 0, + true, + 40 + ] + } + ], + "want": { + "parent_frame": null, + "lint": "not_four_numbers", + "points": [ + { + "map": "019a9200-0000-7000-8000-00000000aa02", + "x": 50, + "y": 25 + } + ], + "stop": "no_frame" + } + }, + { + "name": "frame-null-among-numbers", + "claim": "an `x_parent_frame` that is a null among four is no frame, with the lint `not_four_numbers`", + "map": "019a9200-0000-7000-8000-00000000aa02", + "point": [ + 50, + 25 + ], + "elements": [ + { + "type": "map", + "id": "019a9200-0000-7000-8000-00000000aa01", + "name": "land", + "width": 1000, + "height": 800 + }, + { + "type": "map", + "id": "019a9200-0000-7000-8000-00000000aa02", + "name": "town", + "width": 100, + "height": 50, + "parent_map": "019a9200-0000-7000-8000-00000000aa01", + "x_parent_frame": [ + 10, + null, + 30, + 40 + ] + } + ], + "want": { + "parent_frame": null, + "lint": "not_four_numbers", + "points": [ + { + "map": "019a9200-0000-7000-8000-00000000aa02", + "x": 50, + "y": 25 + } + ], + "stop": "no_frame" + } + }, + { + "name": "frame-a-list-among-numbers", + "claim": "an `x_parent_frame` that is a list among four is no frame, with the lint `not_four_numbers`", + "map": "019a9200-0000-7000-8000-00000000aa02", + "point": [ + 50, + 25 + ], + "elements": [ + { + "type": "map", + "id": "019a9200-0000-7000-8000-00000000aa01", + "name": "land", + "width": 1000, + "height": 800 + }, + { + "type": "map", + "id": "019a9200-0000-7000-8000-00000000aa02", + "name": "town", + "width": 100, + "height": 50, + "parent_map": "019a9200-0000-7000-8000-00000000aa01", + "x_parent_frame": [ + 10, + [ + 20 + ], + 30, + 40 + ] + } + ], + "want": { + "parent_frame": null, + "lint": "not_four_numbers", + "points": [ + { + "map": "019a9200-0000-7000-8000-00000000aa02", + "x": 50, + "y": 25 + } + ], + "stop": "no_frame" + } + }, + { + "name": "frame-a-string", + "claim": "an `x_parent_frame` that is a string is no frame, with the lint `not_four_numbers`", + "map": "019a9200-0000-7000-8000-00000000aa02", + "point": [ + 50, + 25 + ], + "elements": [ + { + "type": "map", + "id": "019a9200-0000-7000-8000-00000000aa01", + "name": "land", + "width": 1000, + "height": 800 + }, + { + "type": "map", + "id": "019a9200-0000-7000-8000-00000000aa02", + "name": "town", + "width": 100, + "height": 50, + "parent_map": "019a9200-0000-7000-8000-00000000aa01", + "x_parent_frame": "10 20 30 40" + } + ], + "want": { + "parent_frame": null, + "lint": "not_four_numbers", + "points": [ + { + "map": "019a9200-0000-7000-8000-00000000aa02", + "x": 50, + "y": 25 + } + ], + "stop": "no_frame" + } + }, + { + "name": "frame-an-object", + "claim": "an `x_parent_frame` that is an object of four corners is no frame, with the lint `not_four_numbers`", + "map": "019a9200-0000-7000-8000-00000000aa02", + "point": [ + 50, + 25 + ], + "elements": [ + { + "type": "map", + "id": "019a9200-0000-7000-8000-00000000aa01", + "name": "land", + "width": 1000, + "height": 800 + }, + { + "type": "map", + "id": "019a9200-0000-7000-8000-00000000aa02", + "name": "town", + "width": 100, + "height": 50, + "parent_map": "019a9200-0000-7000-8000-00000000aa01", + "x_parent_frame": { + "x0": 10, + "y0": 20, + "x1": 30, + "y1": 40 + } + } + ], + "want": { + "parent_frame": null, + "lint": "not_four_numbers", + "points": [ + { + "map": "019a9200-0000-7000-8000-00000000aa02", + "x": 50, + "y": 25 + } + ], + "stop": "no_frame" + } + }, + { + "name": "frame-an-empty-list", + "claim": "an `x_parent_frame` that is an empty list is no frame, with the lint `not_four_numbers`", + "map": "019a9200-0000-7000-8000-00000000aa02", + "point": [ + 50, + 25 + ], + "elements": [ + { + "type": "map", + "id": "019a9200-0000-7000-8000-00000000aa01", + "name": "land", + "width": 1000, + "height": 800 + }, + { + "type": "map", + "id": "019a9200-0000-7000-8000-00000000aa02", + "name": "town", + "width": 100, + "height": 50, + "parent_map": "019a9200-0000-7000-8000-00000000aa01", + "x_parent_frame": [] + } + ], + "want": { + "parent_frame": null, + "lint": "not_four_numbers", + "points": [ + { + "map": "019a9200-0000-7000-8000-00000000aa02", + "x": 50, + "y": 25 + } + ], + "stop": "no_frame" + } + }, + { + "name": "frame-mirrored-in-x", + "claim": "a frame with x0 above x1 (a mirrored box, never normalised) is no frame, with the lint `not_a_box`", + "map": "019a9200-0000-7000-8000-00000000aa02", + "point": [ + 50, + 25 + ], + "elements": [ + { + "type": "map", + "id": "019a9200-0000-7000-8000-00000000aa01", + "name": "land", + "width": 1000, + "height": 800 + }, + { + "type": "map", + "id": "019a9200-0000-7000-8000-00000000aa02", + "name": "town", + "width": 100, + "height": 50, + "parent_map": "019a9200-0000-7000-8000-00000000aa01", + "x_parent_frame": [ + 30, + 20, + 10, + 40 + ] + } + ], + "want": { + "parent_frame": null, + "lint": "not_a_box", + "points": [ + { + "map": "019a9200-0000-7000-8000-00000000aa02", + "x": 50, + "y": 25 + } + ], + "stop": "no_frame" + } + }, + { + "name": "frame-mirrored-in-y", + "claim": "a frame with y0 above y1 is no frame, with the lint `not_a_box`", + "map": "019a9200-0000-7000-8000-00000000aa02", + "point": [ + 50, + 25 + ], + "elements": [ + { + "type": "map", + "id": "019a9200-0000-7000-8000-00000000aa01", + "name": "land", + "width": 1000, + "height": 800 + }, + { + "type": "map", + "id": "019a9200-0000-7000-8000-00000000aa02", + "name": "town", + "width": 100, + "height": 50, + "parent_map": "019a9200-0000-7000-8000-00000000aa01", + "x_parent_frame": [ + 10, + 40, + 30, + 20 + ] + } + ], + "want": { + "parent_frame": null, + "lint": "not_a_box", + "points": [ + { + "map": "019a9200-0000-7000-8000-00000000aa02", + "x": 50, + "y": 25 + } + ], + "stop": "no_frame" + } + }, + { + "name": "frame-with-no-width", + "claim": "a frame with x0 equal to x1 (a box with no width) is no frame, with the lint `not_a_box`", + "map": "019a9200-0000-7000-8000-00000000aa02", + "point": [ + 50, + 25 + ], + "elements": [ + { + "type": "map", + "id": "019a9200-0000-7000-8000-00000000aa01", + "name": "land", + "width": 1000, + "height": 800 + }, + { + "type": "map", + "id": "019a9200-0000-7000-8000-00000000aa02", + "name": "town", + "width": 100, + "height": 50, + "parent_map": "019a9200-0000-7000-8000-00000000aa01", + "x_parent_frame": [ + 10, + 20, + 10, + 40 + ] + } + ], + "want": { + "parent_frame": null, + "lint": "not_a_box", + "points": [ + { + "map": "019a9200-0000-7000-8000-00000000aa02", + "x": 50, + "y": 25 + } + ], + "stop": "no_frame" + } + }, + { + "name": "frame-with-no-height", + "claim": "a frame with y0 equal to y1, `20` and `20.0` being one number is no frame, with the lint `not_a_box`", + "map": "019a9200-0000-7000-8000-00000000aa02", + "point": [ + 50, + 25 + ], + "elements": [ + { + "type": "map", + "id": "019a9200-0000-7000-8000-00000000aa01", + "name": "land", + "width": 1000, + "height": 800 + }, + { + "type": "map", + "id": "019a9200-0000-7000-8000-00000000aa02", + "name": "town", + "width": 100, + "height": 50, + "parent_map": "019a9200-0000-7000-8000-00000000aa01", + "x_parent_frame": [ + 10, + 20, + 30, + 20.0 + ] + } + ], + "want": { + "parent_frame": null, + "lint": "not_a_box", + "points": [ + { + "map": "019a9200-0000-7000-8000-00000000aa02", + "x": 50, + "y": 25 + } + ], + "stop": "no_frame" + } + }, + { + "name": "no-size-no-carry", + "claim": "a child with no `width` or `height` of its own has its frame and no carry: the extent its points measure (rule 2) is never the size a frame divides by", + "map": "019a9200-0000-7000-8000-00000000aa02", + "point": [ + 50, + 25 + ], + "elements": [ + { + "type": "map", + "id": "019a9200-0000-7000-8000-00000000aa01", + "name": "land", + "width": 1000, + "height": 800 + }, + { + "type": "map", + "id": "019a9200-0000-7000-8000-00000000aa02", + "name": "town", + "parent_map": "019a9200-0000-7000-8000-00000000aa01", + "x_parent_frame": [ + 100, + 200, + 300, + 300 + ] + }, + { + "type": "pin", + "id": "019a9200-0000-7000-8000-0000000d0011", + "name": "corner", + "map": "019a9200-0000-7000-8000-00000000aa02", + "x": 80, + "y": 40 + }, + { + "type": "marker", + "id": "019a9200-0000-7000-8000-0000000c0011", + "name": "corner", + "map": "019a9200-0000-7000-8000-00000000aa02", + "zone": "019a9200-0000-7000-8000-0000000b0011", + "x": 60, + "y": 45 + }, + { + "type": "zone", + "id": "019a9200-0000-7000-8000-0000000b0011", + "name": "yard" + } + ], + "want": { + "parent_frame": [ + 100, + 200, + 300, + 300 + ], + "lint": null, + "points": [ + { + "map": "019a9200-0000-7000-8000-00000000aa02", + "x": 50, + "y": 25 + } + ], + "stop": "no_carry" + } + }, + { + "name": "no-height-no-carry", + "claim": "a child with a `width` and no `height` has its frame and no carry", + "map": "019a9200-0000-7000-8000-00000000aa02", + "point": [ + 50, + 25 + ], + "elements": [ + { + "type": "map", + "id": "019a9200-0000-7000-8000-00000000aa01", + "name": "land", + "width": 1000, + "height": 800 + }, + { + "type": "map", + "id": "019a9200-0000-7000-8000-00000000aa02", + "name": "town", + "width": 100, + "parent_map": "019a9200-0000-7000-8000-00000000aa01", + "x_parent_frame": [ + 100, + 200, + 300, + 300 + ] + }, + { + "type": "pin", + "id": "019a9200-0000-7000-8000-0000000d0011", + "name": "corner", + "map": "019a9200-0000-7000-8000-00000000aa02", + "x": 80, + "y": 40 + }, + { + "type": "marker", + "id": "019a9200-0000-7000-8000-0000000c0011", + "name": "corner", + "map": "019a9200-0000-7000-8000-00000000aa02", + "zone": "019a9200-0000-7000-8000-0000000b0011", + "x": 60, + "y": 45 + }, + { + "type": "zone", + "id": "019a9200-0000-7000-8000-0000000b0011", + "name": "yard" + } + ], + "want": { + "parent_frame": [ + 100, + 200, + 300, + 300 + ], + "lint": null, + "points": [ + { + "map": "019a9200-0000-7000-8000-00000000aa02", + "x": 50, + "y": 25 + } + ], + "stop": "no_carry" + } + }, + { + "name": "width-zero-no-carry", + "claim": "a child with a `width` of 0 has its frame and no carry: rule 2 answers the size as written, and the frame divides only by a whole number above 0", + "map": "019a9200-0000-7000-8000-00000000aa02", + "point": [ + 50, + 25 + ], + "elements": [ + { + "type": "map", + "id": "019a9200-0000-7000-8000-00000000aa01", + "name": "land", + "width": 1000, + "height": 800 + }, + { + "type": "map", + "id": "019a9200-0000-7000-8000-00000000aa02", + "name": "town", + "width": 0, + "height": 50, + "parent_map": "019a9200-0000-7000-8000-00000000aa01", + "x_parent_frame": [ + 100, + 200, + 300, + 300 + ] + } + ], + "want": { + "parent_frame": [ + 100, + 200, + 300, + 300 + ], + "lint": null, + "points": [ + { + "map": "019a9200-0000-7000-8000-00000000aa02", + "x": 50, + "y": 25 + } + ], + "stop": "no_carry" + } + }, + { + "name": "width-under-zero-no-carry", + "claim": "a child with a `width` under 0 has its frame and no carry: rule 2 answers the size as written, and the frame divides only by a whole number above 0", + "map": "019a9200-0000-7000-8000-00000000aa02", + "point": [ + 50, + 25 + ], + "elements": [ + { + "type": "map", + "id": "019a9200-0000-7000-8000-00000000aa01", + "name": "land", + "width": 1000, + "height": 800 + }, + { + "type": "map", + "id": "019a9200-0000-7000-8000-00000000aa02", + "name": "town", + "width": -100, + "height": 50, + "parent_map": "019a9200-0000-7000-8000-00000000aa01", + "x_parent_frame": [ + 100, + 200, + 300, + 300 + ] + } + ], + "want": { + "parent_frame": [ + 100, + 200, + 300, + 300 + ], + "lint": null, + "points": [ + { + "map": "019a9200-0000-7000-8000-00000000aa02", + "x": 50, + "y": 25 + } + ], + "stop": "no_carry" + } + }, + { + "name": "height-under-zero-no-carry", + "claim": "a child with a `height` under 0 has its frame and no carry: rule 2 answers the size as written, and the frame divides only by a whole number above 0", + "map": "019a9200-0000-7000-8000-00000000aa02", + "point": [ + 50, + 25 + ], + "elements": [ + { + "type": "map", + "id": "019a9200-0000-7000-8000-00000000aa01", + "name": "land", + "width": 1000, + "height": 800 + }, + { + "type": "map", + "id": "019a9200-0000-7000-8000-00000000aa02", + "name": "town", + "width": 100, + "height": -50, + "parent_map": "019a9200-0000-7000-8000-00000000aa01", + "x_parent_frame": [ + 100, + 200, + 300, + 300 + ] + } + ], + "want": { + "parent_frame": [ + 100, + 200, + 300, + 300 + ], + "lint": null, + "points": [ + { + "map": "019a9200-0000-7000-8000-00000000aa02", + "x": 50, + "y": 25 + } + ], + "stop": "no_carry" + } + }, + { + "name": "width-with-a-fraction-no-carry", + "claim": "a child with a `width` of 99.6 (never rounded to 100) has its frame and no carry: rule 2 answers the size as written, and the frame divides only by a whole number above 0", + "map": "019a9200-0000-7000-8000-00000000aa02", + "point": [ + 50, + 25 + ], + "elements": [ + { + "type": "map", + "id": "019a9200-0000-7000-8000-00000000aa01", + "name": "land", + "width": 1000, + "height": 800 + }, + { + "type": "map", + "id": "019a9200-0000-7000-8000-00000000aa02", + "name": "town", + "width": 99.6, + "height": 50, + "parent_map": "019a9200-0000-7000-8000-00000000aa01", + "x_parent_frame": [ + 100, + 200, + 300, + 300 + ] + } + ], + "want": { + "parent_frame": [ + 100, + 200, + 300, + 300 + ], + "lint": null, + "points": [ + { + "map": "019a9200-0000-7000-8000-00000000aa02", + "x": 50, + "y": 25 + } + ], + "stop": "no_carry" + } + }, + { + "name": "width-a-string-no-carry", + "claim": "a child with a `width` written as the string \"100\" has its frame and no carry: rule 2 answers the size as written, and the frame divides only by a whole number above 0", + "map": "019a9200-0000-7000-8000-00000000aa02", + "point": [ + 50, + 25 + ], + "elements": [ + { + "type": "map", + "id": "019a9200-0000-7000-8000-00000000aa01", + "name": "land", + "width": 1000, + "height": 800 + }, + { + "type": "map", + "id": "019a9200-0000-7000-8000-00000000aa02", + "name": "town", + "width": "100", + "height": 50, + "parent_map": "019a9200-0000-7000-8000-00000000aa01", + "x_parent_frame": [ + 100, + 200, + 300, + 300 + ] + } + ], + "want": { + "parent_frame": [ + 100, + 200, + 300, + 300 + ], + "lint": null, + "points": [ + { + "map": "019a9200-0000-7000-8000-00000000aa02", + "x": 50, + "y": 25 + } + ], + "stop": "no_carry" + } + }, + { + "name": "width-a-boolean-no-carry", + "claim": "a child with a `width` of true has its frame and no carry: rule 2 answers the size as written, and the frame divides only by a whole number above 0", + "map": "019a9200-0000-7000-8000-00000000aa02", + "point": [ + 50, + 25 + ], + "elements": [ + { + "type": "map", + "id": "019a9200-0000-7000-8000-00000000aa01", + "name": "land", + "width": 1000, + "height": 800 + }, + { + "type": "map", + "id": "019a9200-0000-7000-8000-00000000aa02", + "name": "town", + "width": true, + "height": 50, + "parent_map": "019a9200-0000-7000-8000-00000000aa01", + "x_parent_frame": [ + 100, + 200, + 300, + 300 + ] + } + ], + "want": { + "parent_frame": [ + 100, + 200, + 300, + 300 + ], + "lint": null, + "points": [ + { + "map": "019a9200-0000-7000-8000-00000000aa02", + "x": 50, + "y": 25 + } + ], + "stop": "no_carry" + } + }, + { + "name": "decimals-in-the-written-order-x", + "claim": "the carried x is x0 + ((x * (x1 - x0)) / width) in 64-bit floats, in that order: the step per pixel first, the fraction first, a centre-based order and exact rationals each give another last bit", + "map": "019a9200-0000-7000-8000-00000000aa02", + "point": [ + 364.08, + 450.558682673927 + ], + "elements": [ + { + "type": "map", + "id": "019a9200-0000-7000-8000-00000000aa01", + "name": "land", + "width": 4096, + "height": 4096 + }, + { + "type": "map", + "id": "019a9200-0000-7000-8000-00000000aa02", + "name": "town", + "width": 450, + "height": 600, + "parent_map": "019a9200-0000-7000-8000-00000000aa01", + "x_parent_frame": [ + 269.61, + 1774.12, + 454.23, + 1812.92 + ] + } + ], + "want": { + "parent_frame": [ + 269.61, + 1774.12, + 454.23, + 1812.92 + ], + "lint": null, + "points": [ + { + "map": "019a9200-0000-7000-8000-00000000aa02", + "x": 364.08, + "y": 450.558682673927 + }, + { + "map": "019a9200-0000-7000-8000-00000000aa01", + "x": 418.97988799999996, + "y": 1803.2561281462472 + } + ], + "stop": "top" + } + }, + { + "name": "decimals-in-the-written-order-y", + "claim": "the carried y is y0 + ((y * (y1 - y0)) / height), in that order, in 64-bit floats", + "map": "019a9200-0000-7000-8000-00000000aa02", + "point": [ + 622.92, + 1041.15 + ], + "elements": [ + { + "type": "map", + "id": "019a9200-0000-7000-8000-00000000aa01", + "name": "land", + "width": 4096, + "height": 4096 + }, + { + "type": "map", + "id": "019a9200-0000-7000-8000-00000000aa02", + "name": "town", + "width": 800, + "height": 1366, + "parent_map": "019a9200-0000-7000-8000-00000000aa01", + "x_parent_frame": [ + 299.633, + 640.3, + 456.374964, + 693.817 + ] + } + ], + "want": { + "parent_frame": [ + 299.633, + 640.3, + 456.374964, + 693.817 + ], + "lint": null, + "points": [ + { + "map": "019a9200-0000-7000-8000-00000000aa02", + "x": 622.92, + "y": 1041.15 + }, + { + "map": "019a9200-0000-7000-8000-00000000aa01", + "x": 421.6801302686, + "y": 681.0900618960468 + } + ], + "stop": "top" + } + }, + { + "name": "nesting-three-levels", + "claim": "a point on a plan framed on a town map framed on the land is carried by the plan's frame, then the town's: each level carries the point the level below gave, in 64-bit floats, never a product of the levels' ratios", + "map": "019a9200-0000-7000-8000-00000000aa03", + "point": [ + 797.461665, + 98.264319 + ], + "elements": [ + { + "type": "map", + "id": "019a9200-0000-7000-8000-00000000aa01", + "name": "land", + "width": 8000, + "height": 5700 + }, + { + "type": "map", + "id": "019a9200-0000-7000-8000-00000000aa02", + "name": "town", + "width": 1366, + "height": 1024, + "parent_map": "019a9200-0000-7000-8000-00000000aa01", + "x_parent_frame": [ + 719.6, + 179.92, + 907.61, + 399.46 + ] + }, + { + "type": "map", + "id": "019a9200-0000-7000-8000-00000000aa03", + "name": "plan", + "width": 800, + "height": 450, + "parent_map": "019a9200-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": "019a9200-0000-7000-8000-00000000aa03", + "x": 797.461665, + "y": 98.264319 + }, + { + "map": "019a9200-0000-7000-8000-00000000aa02", + "x": 310.0160267548, + "y": 605.79209896012 + }, + { + "map": "019a9200-0000-7000-8000-00000000aa01", + "x": 762.2691897439018, + "y": 309.79851309150854 + } + ], + "stop": "top" + } + }, + { + "name": "nesting-four-levels", + "claim": "four levels compose as three do, one level at a time, up to the Map with no `parent_map`", + "map": "019a9200-0000-7000-8000-00000000aa04", + "point": [ + 38.437, + 25.456 + ], + "elements": [ + { + "type": "map", + "id": "019a9200-0000-7000-8000-00000000aa01", + "name": "land", + "width": 8000, + "height": 5700 + }, + { + "type": "map", + "id": "019a9200-0000-7000-8000-00000000aa02", + "name": "town", + "width": 1366, + "height": 1024, + "parent_map": "019a9200-0000-7000-8000-00000000aa01", + "x_parent_frame": [ + 719.6, + 179.92, + 907.61, + 399.46 + ] + }, + { + "type": "map", + "id": "019a9200-0000-7000-8000-00000000aa03", + "name": "plan", + "width": 800, + "height": 450, + "parent_map": "019a9200-0000-7000-8000-00000000aa02", + "x_parent_frame": [ + 160.795, + 546.164, + 310.491, + 819.23 + ] + }, + { + "type": "map", + "id": "019a9200-0000-7000-8000-00000000aa04", + "name": "room", + "width": 40, + "height": 30, + "parent_map": "019a9200-0000-7000-8000-00000000aa03", + "x_parent_frame": [ + 580.24, + 320.2, + 599.25, + 347.144 + ] + } + ], + "want": { + "parent_frame": [ + 580.24, + 320.2, + 599.25, + 347.144 + ], + "lint": null, + "points": [ + { + "map": "019a9200-0000-7000-8000-00000000aa04", + "x": 38.437, + "y": 25.456 + }, + { + "map": "019a9200-0000-7000-8000-00000000aa03", + "x": 598.50718425, + "y": 343.06288213333335 + }, + { + "map": "019a9200-0000-7000-8000-00000000aa02", + "x": 272.78766431686, + "y": 754.3391310502684 + }, + { + "map": "019a9200-0000-7000-8000-00000000aa01", + "x": 757.1452480001558, + "y": 341.64618440505456 + } + ], + "stop": "top" + } + }, + { + "name": "nesting-a-level-with-no-frame", + "claim": "where one level has no frame the point is carried no further: a plan framed on a town that has a `parent_map` and no frame stops on the town", + "map": "019a9200-0000-7000-8000-00000000aa03", + "point": [ + 10, + 5 + ], + "elements": [ + { + "type": "map", + "id": "019a9200-0000-7000-8000-00000000aa01", + "name": "land", + "width": 1000, + "height": 800 + }, + { + "type": "map", + "id": "019a9200-0000-7000-8000-00000000aa02", + "name": "town", + "width": 100, + "height": 50, + "parent_map": "019a9200-0000-7000-8000-00000000aa01" + }, + { + "type": "map", + "id": "019a9200-0000-7000-8000-00000000aa03", + "name": "plan", + "width": 40, + "height": 20, + "parent_map": "019a9200-0000-7000-8000-00000000aa02", + "x_parent_frame": [ + 10, + 10, + 50, + 30 + ] + } + ], + "want": { + "parent_frame": [ + 10, + 10, + 50, + 30 + ], + "lint": null, + "points": [ + { + "map": "019a9200-0000-7000-8000-00000000aa03", + "x": 10, + "y": 5 + }, + { + "map": "019a9200-0000-7000-8000-00000000aa02", + "x": 20.0, + "y": 15.0 + } + ], + "stop": "no_frame" + } + }, + { + "name": "nesting-a-level-with-a-mirrored-frame", + "claim": "a level whose frame is no frame stops the walk as one with none: the read Map's lint is its own", + "map": "019a9200-0000-7000-8000-00000000aa03", + "point": [ + 10, + 5 + ], + "elements": [ + { + "type": "map", + "id": "019a9200-0000-7000-8000-00000000aa01", + "name": "land", + "width": 1000, + "height": 800 + }, + { + "type": "map", + "id": "019a9200-0000-7000-8000-00000000aa02", + "name": "town", + "width": 100, + "height": 50, + "parent_map": "019a9200-0000-7000-8000-00000000aa01", + "x_parent_frame": [ + 300, + 200, + 100, + 300 + ] + }, + { + "type": "map", + "id": "019a9200-0000-7000-8000-00000000aa03", + "name": "plan", + "width": 40, + "height": 20, + "parent_map": "019a9200-0000-7000-8000-00000000aa02", + "x_parent_frame": [ + 10, + 10, + 50, + 30 + ] + } + ], + "want": { + "parent_frame": [ + 10, + 10, + 50, + 30 + ], + "lint": null, + "points": [ + { + "map": "019a9200-0000-7000-8000-00000000aa03", + "x": 10, + "y": 5 + }, + { + "map": "019a9200-0000-7000-8000-00000000aa02", + "x": 20.0, + "y": 15.0 + } + ], + "stop": "no_frame" + } + }, + { + "name": "nesting-a-level-with-no-carry", + "claim": "a level with a frame and no carry stops the walk on that level", + "map": "019a9200-0000-7000-8000-00000000aa03", + "point": [ + 10, + 5 + ], + "elements": [ + { + "type": "map", + "id": "019a9200-0000-7000-8000-00000000aa01", + "name": "land", + "width": 1000, + "height": 800 + }, + { + "type": "map", + "id": "019a9200-0000-7000-8000-00000000aa02", + "name": "town", + "height": 50, + "parent_map": "019a9200-0000-7000-8000-00000000aa01", + "x_parent_frame": [ + 100, + 200, + 300, + 300 + ] + }, + { + "type": "map", + "id": "019a9200-0000-7000-8000-00000000aa03", + "name": "plan", + "width": 40, + "height": 20, + "parent_map": "019a9200-0000-7000-8000-00000000aa02", + "x_parent_frame": [ + 10, + 10, + 50, + 30 + ] + } + ], + "want": { + "parent_frame": [ + 10, + 10, + 50, + 30 + ], + "lint": null, + "points": [ + { + "map": "019a9200-0000-7000-8000-00000000aa03", + "x": 10, + "y": 5 + }, + { + "map": "019a9200-0000-7000-8000-00000000aa02", + "x": 20.0, + "y": 15.0 + } + ], + "stop": "no_carry" + } + }, + { + "name": "nesting-a-top-with-a-stray-frame", + "claim": "the walk ends on a Map with no `parent_map`, whatever it carries: a frame there is not read", + "map": "019a9200-0000-7000-8000-00000000aa02", + "point": [ + 20, + 10 + ], + "elements": [ + { + "type": "map", + "id": "019a9200-0000-7000-8000-00000000aa01", + "name": "land", + "width": 1000, + "height": 800, + "x_parent_frame": [ + 0, + 0, + 10, + 10 + ] + }, + { + "type": "map", + "id": "019a9200-0000-7000-8000-00000000aa02", + "name": "town", + "width": 100, + "height": 50, + "parent_map": "019a9200-0000-7000-8000-00000000aa01", + "x_parent_frame": [ + 100, + 200, + 300, + 300 + ] + } + ], + "want": { + "parent_frame": [ + 100, + 200, + 300, + 300 + ], + "lint": null, + "points": [ + { + "map": "019a9200-0000-7000-8000-00000000aa02", + "x": 20, + "y": 10 + }, + { + "map": "019a9200-0000-7000-8000-00000000aa01", + "x": 140.0, + "y": 220.0 + } + ], + "stop": "top" + } + }, + { + "name": "parent-not-served", + "claim": "a `parent_map` that names a Map the reader is not served ends the walk, `dangling`; the child's own parent frame is still reported", + "map": "019a9200-0000-7000-8000-00000000aa02", + "point": [ + 20, + 10 + ], + "elements": [ + { + "type": "map", + "id": "019a9200-0000-7000-8000-00000000aa02", + "name": "town", + "width": 100, + "height": 50, + "parent_map": "019a9200-0000-7000-8000-00000000aa09", + "x_parent_frame": [ + 100, + 200, + 300, + 300 + ] + } + ], + "want": { + "parent_frame": [ + 100, + 200, + 300, + 300 + ], + "lint": null, + "points": [ + { + "map": "019a9200-0000-7000-8000-00000000aa02", + "x": 20, + "y": 10 + } + ], + "stop": "dangling" + } + }, + { + "name": "parent-not-served-and-frame-malformed", + "claim": "served-ness before shape: a child whose parent is not served and whose frame is no frame stops `dangling`, its lint still `not_four_numbers`", + "map": "019a9200-0000-7000-8000-00000000aa02", + "point": [ + 20, + 10 + ], + "elements": [ + { + "type": "map", + "id": "019a9200-0000-7000-8000-00000000aa02", + "name": "town", + "width": 100, + "height": 50, + "parent_map": "019a9200-0000-7000-8000-00000000aa09", + "x_parent_frame": [ + 1, + 2, + 3 + ] + } + ], + "want": { + "parent_frame": null, + "lint": "not_four_numbers", + "points": [ + { + "map": "019a9200-0000-7000-8000-00000000aa02", + "x": 20, + "y": 10 + } + ], + "stop": "dangling" + } + }, + { + "name": "parent-whose-type-is-Map-is-not-served", + "claim": "a row whose `type` is `Map` is no Map (reading K): a parent served only so is not served", + "map": "019a9200-0000-7000-8000-00000000aa02", + "point": [ + 20, + 10 + ], + "elements": [ + { + "type": "Map", + "id": "019a9200-0000-7000-8000-00000000aa01", + "name": "land", + "width": 1000, + "height": 800 + }, + { + "type": "map", + "id": "019a9200-0000-7000-8000-00000000aa02", + "name": "town", + "width": 100, + "height": 50, + "parent_map": "019a9200-0000-7000-8000-00000000aa01", + "x_parent_frame": [ + 100, + 200, + 300, + 300 + ] + } + ], + "want": { + "parent_frame": [ + 100, + 200, + 300, + 300 + ], + "lint": null, + "points": [ + { + "map": "019a9200-0000-7000-8000-00000000aa02", + "x": 20, + "y": 10 + } + ], + "stop": "dangling" + } + }, + { + "name": "parent-names-itself", + "claim": "a Map whose `parent_map` names itself is a ring of one: the walk stops at once, `cycle`, and the parent frame is reported as written", + "map": "019a9200-0000-7000-8000-00000000aa02", + "point": [ + 20, + 10 + ], + "elements": [ + { + "type": "map", + "id": "019a9200-0000-7000-8000-00000000aa02", + "name": "town", + "width": 100, + "height": 50, + "parent_map": "019a9200-0000-7000-8000-00000000aa02", + "x_parent_frame": [ + 100, + 200, + 300, + 300 + ] + } + ], + "want": { + "parent_frame": [ + 100, + 200, + 300, + 300 + ], + "lint": null, + "points": [ + { + "map": "019a9200-0000-7000-8000-00000000aa02", + "x": 20, + "y": 10 + } + ], + "stop": "cycle" + } + }, + { + "name": "two-maps-in-a-ring", + "claim": "a ring of two: the point is carried onto the other Map once, and the walk stops before it reaches a Map it has passed", + "map": "019a9200-0000-7000-8000-00000000aa02", + "point": [ + 20, + 10 + ], + "elements": [ + { + "type": "map", + "id": "019a9200-0000-7000-8000-00000000aa02", + "name": "town", + "width": 100, + "height": 50, + "parent_map": "019a9200-0000-7000-8000-00000000aa01", + "x_parent_frame": [ + 100, + 200, + 300, + 300 + ] + }, + { + "type": "map", + "id": "019a9200-0000-7000-8000-00000000aa01", + "name": "land", + "width": 1000, + "height": 800, + "parent_map": "019a9200-0000-7000-8000-00000000aa02", + "x_parent_frame": [ + 0, + 0, + 50, + 40 + ] + } + ], + "want": { + "parent_frame": [ + 100, + 200, + 300, + 300 + ], + "lint": null, + "points": [ + { + "map": "019a9200-0000-7000-8000-00000000aa02", + "x": 20, + "y": 10 + }, + { + "map": "019a9200-0000-7000-8000-00000000aa01", + "x": 140.0, + "y": 220.0 + } + ], + "stop": "cycle" + } + }, + { + "name": "a-ring-above-the-read-map", + "claim": "a ring above the read Map: the walk climbs into it and stops before a Map it has passed", + "map": "019a9200-0000-7000-8000-00000000aa02", + "point": [ + 20, + 10 + ], + "elements": [ + { + "type": "map", + "id": "019a9200-0000-7000-8000-00000000aa02", + "name": "town", + "width": 100, + "height": 50, + "parent_map": "019a9200-0000-7000-8000-00000000aa01", + "x_parent_frame": [ + 100, + 200, + 300, + 300 + ] + }, + { + "type": "map", + "id": "019a9200-0000-7000-8000-00000000aa01", + "name": "land", + "width": 1000, + "height": 800, + "parent_map": "019a9200-0000-7000-8000-00000000aa05", + "x_parent_frame": [ + 0, + 0, + 500, + 400 + ] + }, + { + "type": "map", + "id": "019a9200-0000-7000-8000-00000000aa05", + "name": "other", + "width": 500, + "height": 400, + "parent_map": "019a9200-0000-7000-8000-00000000aa01", + "x_parent_frame": [ + 0, + 0, + 1000, + 800 + ] + } + ], + "want": { + "parent_frame": [ + 100, + 200, + 300, + 300 + ], + "lint": null, + "points": [ + { + "map": "019a9200-0000-7000-8000-00000000aa02", + "x": 20, + "y": 10 + }, + { + "map": "019a9200-0000-7000-8000-00000000aa01", + "x": 140.0, + "y": 220.0 + }, + { + "map": "019a9200-0000-7000-8000-00000000aa05", + "x": 70.0, + "y": 110.0 + } + ], + "stop": "cycle" + } + }, + { + "name": "repeated-map-last-row-wins", + "claim": "two rows of one Map: the last served wins (reading I), for the Map read and for its parent", + "map": "019a9200-0000-7000-8000-00000000aa02", + "point": [ + 20, + 10 + ], + "elements": [ + { + "type": "map", + "id": "019a9200-0000-7000-8000-00000000aa01", + "name": "land", + "width": 10, + "height": 10 + }, + { + "type": "map", + "id": "019a9200-0000-7000-8000-00000000aa01", + "name": "land", + "width": 1000, + "height": 800 + }, + { + "type": "map", + "id": "019a9200-0000-7000-8000-00000000aa02", + "name": "town", + "width": 100, + "height": 50, + "parent_map": "019a9200-0000-7000-8000-00000000aa01", + "x_parent_frame": [ + 0, + 0, + 1, + 1 + ] + }, + { + "type": "map", + "id": "019a9200-0000-7000-8000-00000000aa02", + "name": "town", + "width": 100, + "height": 50, + "parent_map": "019a9200-0000-7000-8000-00000000aa01", + "x_parent_frame": [ + 100, + 200, + 300, + 300 + ] + } + ], + "want": { + "parent_frame": [ + 100, + 200, + 300, + 300 + ], + "lint": null, + "points": [ + { + "map": "019a9200-0000-7000-8000-00000000aa02", + "x": 20, + "y": 10 + }, + { + "map": "019a9200-0000-7000-8000-00000000aa01", + "x": 140.0, + "y": 220.0 + } + ], + "stop": "top" + } + }, + { + "name": "map-row-without-a-string-id", + "claim": "a Map row with no non-empty string id is no Map (reading H): nothing it carries is read", + "map_index": [ + 1, + 2 + ], + "point": [ + 20, + 10 + ], + "elements": [ + { + "type": "map", + "id": "019a9200-0000-7000-8000-00000000aa01", + "name": "land", + "width": 1000, + "height": 800 + }, + { + "type": "map", + "name": "town", + "width": 100, + "height": 50, + "parent_map": "019a9200-0000-7000-8000-00000000aa01", + "x_parent_frame": [ + 100, + 200, + 300, + 300 + ] + }, + { + "type": "map", + "id": "", + "name": "town", + "width": 100, + "height": 50, + "parent_map": "019a9200-0000-7000-8000-00000000aa01", + "x_parent_frame": [ + 100, + 200, + 300, + 300 + ] + } + ], + "want": { + "parent_frame": null, + "lint": null, + "points": [], + "stop": null + } + }, + { + "name": "scale-is-not-read", + "claim": "the frame places and a scale measures: two `x_metres_per_pixel` that disagree with the frame move no carried point, and the reading reports no scale", + "map": "019a9200-0000-7000-8000-00000000aa02", + "point": [ + 20, + 10 + ], + "elements": [ + { + "type": "map", + "id": "019a9200-0000-7000-8000-00000000aa01", + "name": "land", + "width": 1000, + "height": 800, + "x_metres_per_pixel": 10.0 + }, + { + "type": "map", + "id": "019a9200-0000-7000-8000-00000000aa02", + "name": "town", + "width": 100, + "height": 50, + "parent_map": "019a9200-0000-7000-8000-00000000aa01", + "x_parent_frame": [ + 100, + 200, + 300, + 300 + ], + "x_metres_per_pixel": 0.5 + } + ], + "want": { + "parent_frame": [ + 100, + 200, + 300, + 300 + ], + "lint": null, + "points": [ + { + "map": "019a9200-0000-7000-8000-00000000aa02", + "x": 20, + "y": 10 + }, + { + "map": "019a9200-0000-7000-8000-00000000aa01", + "x": 140.0, + "y": 220.0 + } + ], + "stop": "top" + } + }, + { + "name": "a-layout-map-is-read-as-any-map", + "claim": "the reading reads a layout map's frame as any Map's; what a tool places from it is rule 11's", + "map": "019a9200-0000-7000-8000-00000000aa02", + "point": [ + 20, + 10 + ], + "elements": [ + { + "type": "map", + "id": "019a9200-0000-7000-8000-00000000aa01", + "name": "land", + "width": 1000, + "height": 800 + }, + { + "type": "map", + "id": "019a9200-0000-7000-8000-00000000aa02", + "name": "town", + "width": 100, + "height": 50, + "parent_map": "019a9200-0000-7000-8000-00000000aa01", + "x_parent_frame": [ + 100, + 200, + 300, + 300 + ], + "x_layout": { + "method": "hand" + } + } + ], + "want": { + "parent_frame": [ + 100, + 200, + 300, + 300 + ], + "lint": null, + "points": [ + { + "map": "019a9200-0000-7000-8000-00000000aa02", + "x": 20, + "y": 10 + }, + { + "map": "019a9200-0000-7000-8000-00000000aa01", + "x": 140.0, + "y": 220.0 + } + ], + "stop": "top" + } + }, + { + "name": "top-map-without-a-key", + "claim": "a Map with no `parent_map` and no `x_parent_frame`, the commonest input of all, has no lint", + "map": "019a9200-0000-7000-8000-00000000aa01", + "point": [ + 20, + 10 + ], + "elements": [ + { + "type": "map", + "id": "019a9200-0000-7000-8000-00000000aa01", + "name": "land", + "width": 1000, + "height": 800 + }, + { + "type": "map", + "id": "019a9200-0000-7000-8000-00000000aa02", + "name": "town", + "width": 100, + "height": 50, + "parent_map": "019a9200-0000-7000-8000-00000000aa01", + "x_parent_frame": [ + 100, + 200, + 300, + 300 + ] + } + ], + "want": { + "parent_frame": null, + "lint": null, + "points": [ + { + "map": "019a9200-0000-7000-8000-00000000aa01", + "x": 20, + "y": 10 + } + ], + "stop": "top" + } + }, + { + "name": "top-map-with-a-null-key", + "claim": "a Map with no `parent_map` whose `x_parent_frame` is null has no lint: a null key is no key", + "map": "019a9200-0000-7000-8000-00000000aa01", + "point": [ + 20, + 10 + ], + "elements": [ + { + "type": "map", + "id": "019a9200-0000-7000-8000-00000000aa01", + "name": "land", + "width": 1000, + "height": 800, + "x_parent_frame": null + }, + { + "type": "map", + "id": "019a9200-0000-7000-8000-00000000aa02", + "name": "town", + "width": 100, + "height": 50, + "parent_map": "019a9200-0000-7000-8000-00000000aa01", + "x_parent_frame": [ + 100, + 200, + 300, + 300 + ] + } + ], + "want": { + "parent_frame": null, + "lint": null, + "points": [ + { + "map": "019a9200-0000-7000-8000-00000000aa01", + "x": 20, + "y": 10 + } + ], + "stop": "top" + } + }, + { + "name": "parent-names-itself-with-no-parent-frame", + "claim": "a ring comes before the shape: a Map that names itself and has no parent frame stops `cycle`, not `no_frame`", + "map": "019a9200-0000-7000-8000-00000000aa02", + "point": [ + 20, + 10 + ], + "elements": [ + { + "type": "map", + "id": "019a9200-0000-7000-8000-00000000aa02", + "name": "town", + "width": 100, + "height": 50, + "parent_map": "019a9200-0000-7000-8000-00000000aa02" + } + ], + "want": { + "parent_frame": null, + "lint": null, + "points": [ + { + "map": "019a9200-0000-7000-8000-00000000aa02", + "x": 20, + "y": 10 + } + ], + "stop": "cycle" + } + }, + { + "name": "parent-names-itself-with-no-width", + "claim": "a ring comes before the carry: a Map that names itself, with a parent frame and no `width`, stops `cycle`, not `no_carry`", + "map": "019a9200-0000-7000-8000-00000000aa02", + "point": [ + 20, + 10 + ], + "elements": [ + { + "type": "map", + "id": "019a9200-0000-7000-8000-00000000aa02", + "name": "town", + "height": 50, + "parent_map": "019a9200-0000-7000-8000-00000000aa02", + "x_parent_frame": [ + 100, + 200, + 300, + 300 + ] + } + ], + "want": { + "parent_frame": [ + 100, + 200, + 300, + 300 + ], + "lint": null, + "points": [ + { + "map": "019a9200-0000-7000-8000-00000000aa02", + "x": 20, + "y": 10 + } + ], + "stop": "cycle" + } + }, + { + "name": "no-parent-frame-and-no-width", + "claim": "no parent frame comes before no carry: a child with a served parent, no `x_parent_frame` and no `width` stops `no_frame`", + "map": "019a9200-0000-7000-8000-00000000aa02", + "point": [ + 20, + 10 + ], + "elements": [ + { + "type": "map", + "id": "019a9200-0000-7000-8000-00000000aa01", + "name": "land", + "width": 1000, + "height": 800 + }, + { + "type": "map", + "id": "019a9200-0000-7000-8000-00000000aa02", + "name": "town", + "height": 50, + "parent_map": "019a9200-0000-7000-8000-00000000aa01" + } + ], + "want": { + "parent_frame": null, + "lint": null, + "points": [ + { + "map": "019a9200-0000-7000-8000-00000000aa02", + "x": 20, + "y": 10 + } + ], + "stop": "no_frame" + } + }, + { + "name": "row-read-whose-type-is-Map", + "claim": "a row read whose `type` is `Map` is no Map (reading K): nothing it carries is read", + "map_index": [ + 1 + ], + "point": [ + 20, + 10 + ], + "elements": [ + { + "type": "map", + "id": "019a9200-0000-7000-8000-00000000aa01", + "name": "land", + "width": 1000, + "height": 800 + }, + { + "type": "Map", + "id": "019a9200-0000-7000-8000-00000000aa02", + "name": "town", + "width": 100, + "height": 50, + "parent_map": "019a9200-0000-7000-8000-00000000aa01", + "x_parent_frame": [ + 100, + 200, + 300, + 300 + ] + } + ], + "want": { + "parent_frame": null, + "lint": null, + "points": [], + "stop": null + } + }, + { + "name": "parent-map-a-list", + "claim": "a `parent_map` that is a list holding a served Map's id is no link (reading H): the Map is a top, and its parent frame is not read, with the lint `no_parent`", + "map": "019a9200-0000-7000-8000-00000000aa02", + "point": [ + 20, + 10 + ], + "elements": [ + { + "type": "map", + "id": "019a9200-0000-7000-8000-00000000aa01", + "name": "land", + "width": 1000, + "height": 800 + }, + { + "type": "map", + "id": "019a9200-0000-7000-8000-00000000aa02", + "name": "town", + "width": 100, + "height": 50, + "parent_map": [ + "019a9200-0000-7000-8000-00000000aa01" + ], + "x_parent_frame": [ + 100, + 200, + 300, + 300 + ] + } + ], + "want": { + "parent_frame": null, + "lint": "no_parent", + "points": [ + { + "map": "019a9200-0000-7000-8000-00000000aa02", + "x": 20, + "y": 10 + } + ], + "stop": "top" + } + }, + { + "name": "parent-map-a-number", + "claim": "a `parent_map` that is a number is no link (reading H): the Map is a top, and its parent frame is not read, with the lint `no_parent`", + "map": "019a9200-0000-7000-8000-00000000aa02", + "point": [ + 20, + 10 + ], + "elements": [ + { + "type": "map", + "id": "019a9200-0000-7000-8000-00000000aa01", + "name": "land", + "width": 1000, + "height": 800 + }, + { + "type": "map", + "id": "019a9200-0000-7000-8000-00000000aa02", + "name": "town", + "width": 100, + "height": 50, + "parent_map": 7, + "x_parent_frame": [ + 100, + 200, + 300, + 300 + ] + } + ], + "want": { + "parent_frame": null, + "lint": "no_parent", + "points": [ + { + "map": "019a9200-0000-7000-8000-00000000aa02", + "x": 20, + "y": 10 + } + ], + "stop": "top" + } + }, + { + "name": "parent-map-a-boolean", + "claim": "a `parent_map` that is true is no link (reading H): the Map is a top, and its parent frame is not read, with the lint `no_parent`", + "map": "019a9200-0000-7000-8000-00000000aa02", + "point": [ + 20, + 10 + ], + "elements": [ + { + "type": "map", + "id": "019a9200-0000-7000-8000-00000000aa01", + "name": "land", + "width": 1000, + "height": 800 + }, + { + "type": "map", + "id": "019a9200-0000-7000-8000-00000000aa02", + "name": "town", + "width": 100, + "height": 50, + "parent_map": true, + "x_parent_frame": [ + 100, + 200, + 300, + 300 + ] + } + ], + "want": { + "parent_frame": null, + "lint": "no_parent", + "points": [ + { + "map": "019a9200-0000-7000-8000-00000000aa02", + "x": 20, + "y": 10 + } + ], + "stop": "top" + } + }, + { + "name": "parent-map-an-object", + "claim": "a `parent_map` that is an object holding a served Map's id is no link (reading H): the Map is a top, and its parent frame is not read, with the lint `no_parent`", + "map": "019a9200-0000-7000-8000-00000000aa02", + "point": [ + 20, + 10 + ], + "elements": [ + { + "type": "map", + "id": "019a9200-0000-7000-8000-00000000aa01", + "name": "land", + "width": 1000, + "height": 800 + }, + { + "type": "map", + "id": "019a9200-0000-7000-8000-00000000aa02", + "name": "town", + "width": 100, + "height": 50, + "parent_map": { + "id": "019a9200-0000-7000-8000-00000000aa01" + }, + "x_parent_frame": [ + 100, + 200, + 300, + 300 + ] + } + ], + "want": { + "parent_frame": null, + "lint": "no_parent", + "points": [ + { + "map": "019a9200-0000-7000-8000-00000000aa02", + "x": 20, + "y": 10 + } + ], + "stop": "top" + } + }, + { + "name": "frame-a-number", + "claim": "an `x_parent_frame` that is a number is no frame, with the lint `not_four_numbers`", + "map": "019a9200-0000-7000-8000-00000000aa02", + "point": [ + 50, + 25 + ], + "elements": [ + { + "type": "map", + "id": "019a9200-0000-7000-8000-00000000aa01", + "name": "land", + "width": 1000, + "height": 800 + }, + { + "type": "map", + "id": "019a9200-0000-7000-8000-00000000aa02", + "name": "town", + "width": 100, + "height": 50, + "parent_map": "019a9200-0000-7000-8000-00000000aa01", + "x_parent_frame": 40 + } + ], + "want": { + "parent_frame": null, + "lint": "not_four_numbers", + "points": [ + { + "map": "019a9200-0000-7000-8000-00000000aa02", + "x": 50, + "y": 25 + } + ], + "stop": "no_frame" + } + }, + { + "name": "frame-a-boolean", + "claim": "an `x_parent_frame` that is true is no frame, with the lint `not_four_numbers`", + "map": "019a9200-0000-7000-8000-00000000aa02", + "point": [ + 50, + 25 + ], + "elements": [ + { + "type": "map", + "id": "019a9200-0000-7000-8000-00000000aa01", + "name": "land", + "width": 1000, + "height": 800 + }, + { + "type": "map", + "id": "019a9200-0000-7000-8000-00000000aa02", + "name": "town", + "width": 100, + "height": 50, + "parent_map": "019a9200-0000-7000-8000-00000000aa01", + "x_parent_frame": true + } + ], + "want": { + "parent_frame": null, + "lint": "not_four_numbers", + "points": [ + { + "map": "019a9200-0000-7000-8000-00000000aa02", + "x": 50, + "y": 25 + } + ], + "stop": "no_frame" + } + }, + { + "name": "frame-an-empty-string", + "claim": "an `x_parent_frame` that is an empty string is a value, not an absent key: no frame, with the lint `not_four_numbers`", + "map": "019a9200-0000-7000-8000-00000000aa02", + "point": [ + 50, + 25 + ], + "elements": [ + { + "type": "map", + "id": "019a9200-0000-7000-8000-00000000aa01", + "name": "land", + "width": 1000, + "height": 800 + }, + { + "type": "map", + "id": "019a9200-0000-7000-8000-00000000aa02", + "name": "town", + "width": 100, + "height": 50, + "parent_map": "019a9200-0000-7000-8000-00000000aa01", + "x_parent_frame": "" + } + ], + "want": { + "parent_frame": null, + "lint": "not_four_numbers", + "points": [ + { + "map": "019a9200-0000-7000-8000-00000000aa02", + "x": 50, + "y": 25 + } + ], + "stop": "no_frame" + } + }, + { + "name": "frame-false", + "claim": "an `x_parent_frame` that is false is a value, not an absent key: no frame, with the lint `not_four_numbers`", + "map": "019a9200-0000-7000-8000-00000000aa02", + "point": [ + 50, + 25 + ], + "elements": [ + { + "type": "map", + "id": "019a9200-0000-7000-8000-00000000aa01", + "name": "land", + "width": 1000, + "height": 800 + }, + { + "type": "map", + "id": "019a9200-0000-7000-8000-00000000aa02", + "name": "town", + "width": 100, + "height": 50, + "parent_map": "019a9200-0000-7000-8000-00000000aa01", + "x_parent_frame": false + } + ], + "want": { + "parent_frame": null, + "lint": "not_four_numbers", + "points": [ + { + "map": "019a9200-0000-7000-8000-00000000aa02", + "x": 50, + "y": 25 + } + ], + "stop": "no_frame" + } + }, + { + "name": "top-map-with-an-empty-string-key", + "claim": "on a Map with no `parent_map`, a key that is an empty string is present and not null: not read, with the lint `no_parent`", + "map": "019a9200-0000-7000-8000-00000000aa01", + "point": [ + 20, + 10 + ], + "elements": [ + { + "type": "map", + "id": "019a9200-0000-7000-8000-00000000aa01", + "name": "land", + "width": 1000, + "height": 800, + "x_parent_frame": "" + }, + { + "type": "map", + "id": "019a9200-0000-7000-8000-00000000aa02", + "name": "town", + "width": 100, + "height": 50, + "parent_map": "019a9200-0000-7000-8000-00000000aa01", + "x_parent_frame": [ + 100, + 200, + 300, + 300 + ] + } + ], + "want": { + "parent_frame": null, + "lint": "no_parent", + "points": [ + { + "map": "019a9200-0000-7000-8000-00000000aa01", + "x": 20, + "y": 10 + } + ], + "stop": "top" + } + } ] } diff --git a/codegen/schema-dist/profiles/map-space.md b/codegen/schema-dist/profiles/map-space.md index c300697..738dc67 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. 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. 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. @@ -18,6 +18,8 @@ 10. **A hand Pin.** On a layout map, a Pin with `x_hand: true` was placed by hand: a method that lays the map out again keeps it where it is and lays the rest around it. Only `true` is the mark; absent, `false` or any other value (`"true"`, `1`) reads as placed by the method. On a board every Pin is placed by hand, marked or not: nothing lays a board out again. A writer that places or moves a Pin by hand on a layout map sets the mark (a drag, a place at a tap); on a Map that is not a layout map it writes nothing, since every Pin there is placed by hand already. A method never sets it. Removing it hands the Pin back to the method's next lay-out. A writer that gives a Map with Pins a method other than `hand` marks every Pin on it `x_hand: true` first, then writes `x_layout`, or refuses: an act cut short leaves marks a plain map ignores, never unmarked Pins under a method. The order binds a Map that held Pins before the method, not a Map written new in one act with its method (a folder writer may write its Pins before its `x_layout`). On a Pin of a Map that is not a layout map, `x_hand` means nothing: a reader ignores it, and a writer need not clear it, so a Map whose `x_layout` is removed reads plain with its marks still on. 11. **Picking a Map.** Which Map stands for the world's space when a world has several stays the tool's (below). One thing is ruled: a layout map is no candidate. A tool that picks a Map for the world's space, by whatever rule of its own (no `parent_map`, the most Pins, a picture, a name, the order read), reads each Map's layout first (rule 8) and leaves out every Map that is a layout map. And a Pin on a layout map says where its element stands in that drawing, drawn over a ground or not (rule 9), and a Marker there where its Zone's outline runs in it, never where either is in the world: a tool that measures between elements or places an element in the world reads no Pin and no Marker of a layout map. A world whose every Map is a layout map has no Map for its space, and a tool says so; a tool that shows layout maps still opens one as what it is. The map-space reading and the layout reading answer a layout map as before, its Pins and its Markers with it; this rule is on the tool that picks or places from them. 12. **Who writes the mark.** The writer that knows what the Map is. A tool that lays Pins out by a method writes `x_layout` with that method; a tool that imports a surface its source holds as a board (cards placed by hand on no map of a place) writes `{"method": "hand"}`; a tool that makes a Map a person names, for whatever they mean by it, writes nothing, and may offer the person a control that says "this is a board". The test is what the Map is, never the source's word for it: an importer that meets a board holding a map of a real place marks nothing, and that Map is a plain Map (a ground when a layout names it). A method that places every Pin where its element is in the world and names no ground makes a place, not a drawing, and writes no mark: the Map is the world's space, whatever placed its Pins, and nothing on the standard's side lays it out again (the tool keeps its own recipe in its own namespace). +13. **A child Map's parent frame.** A Map's `x_parent_frame`, its parent frame, is a list of four numbers `[x0, y0, x1, y1]`: two corners of a box in the pixels of the Map its `parent_map` names, counted as a Pin on that Map counts them, from its bottom left (rule 1). The child's own rectangle, from (0, 0) to (`width`, `height`), lies on that box, each axis by its own ratio: a box of another shape than the child's is a stretch, not a fault, with no threshold and no refusal, and neither axis takes the other's ratio. Nothing turns: the child's axes are the parent's, a plan drawn turned carries its turn inside its picture, and the key says no rotation and a reader reads none. The parent frame places and a scale measures: a reader reports both as the world holds them, takes no scale from a parent frame and no parent frame from a scale (rule 3), and reconciles neither with the other. The key is read only on a Map with a `parent_map` (a link as reading H reads one); on a Map with none, a key that is present and not null is not read, with the lint `no_parent`, whatever it holds. It is a parent frame when it is a list of exactly four numbers with x0 less than x1 and y0 less than y1, the four compared as 64-bit floats. A number here is a JSON number a reader holds as a finite 64-bit float: a string, a boolean, null, a list and an object are none, and so is a number too large for a 64-bit float. A value that is not a list of exactly four numbers (a list of another length, one that holds anything that is no number, or no list at all) is no parent frame, with the lint `not_four_numbers`, and its first four are never read; a box with x0 not less than x1, or y0 not less than y1 (mirrored, or with no width or no height), is no parent frame, with the lint `not_a_box`, and is never normalised. A key that is absent or null is no parent frame, with no lint. A Map with a `parent_map` and no parent frame has no place on its parent: a tool may still go into it by the Pin of its `location` on the parent, or by a layout file of its own, and that is a way in, not a place. A child whose `width` or `height` is not a whole number above 0 (by value, as reading K reads one) has its parent frame and no carry: the parent frame is reported, and no point is carried through it. The size a parent frame divides by is the written one, never the extent rule 2 measures from the child's points (that extent moves whenever a Pin is added, and every carried point with it); 0 and a size under 0, which rule 2 answers as written, divide by nothing or turn the box over. +14. **Carrying a point.** A point (x, y), two numbers whole or not, on a child with a parent frame and a carry is, on its parent, `x0 + ((x * (x1 - x0)) / width)` and `y0 + ((y * (y1 - y0)) / height)`, in 64-bit binary floating point: the point, the four numbers and the two sizes each read as a 64-bit float, and each step taken in the order the parentheses write, the difference, then the product, then the quotient, then the sum. Sixty-four bits alone is not the rule; the order is: the step per pixel taken first, the fraction taken first, a carry from the box's centre, and exact rationals rounded once each give another last bit on some points, and two readers that keep this order give the same bits. Nesting composes: a point on a plan framed on a town map framed on the land is carried by the plan's parent frame onto the town map, and that point, as the carry gave it, by the town map's parent frame onto the land, one level at a time up the `parent_map` chain, never through one product of the levels' ratios. At each Map the walk reaches, the first of these that holds ends it, served-ness before shape as in reading A: the Map has no `parent_map` (`top`); its `parent_map` names a Map the reader is not served (`dangling`); it names a Map the walk has already reached, the Map itself included (`cycle`), so no point is carried onto a Map twice; the Map has no parent frame (`no_frame`); or it has one and no carry (`no_carry`). A point outside the child's rectangle is carried as written and never clipped. `z` is not carried: a parent frame says nothing of `depth`. A reader that keeps a point in 32 bits carries it in 64 and rounds once, when it draws or stores it; that rounding is the reader's own and outside what the fixture compares. The small plates of the default layouts page's `by-links-3d` stand at a Map's `location` and read no parent frame: they are a drawing, not where a child lies, and this rule does not move them. **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. @@ -26,12 +28,20 @@ A Pin whose element the reader cannot see is still a Pin and is listed when it qualifies. A method's own `settings` are not returned or ruled here, the ground apart. The map-space reading is unchanged by rules 8 to 10: its answer carries no layout key. +**The frame reading.** `carryOf(map, point, maps)` (`carry_of` in Python), from the fixture's `frame_cases`. `map` is one Map, `point` is `[x, y]` on it (two finite numbers in its pixels from its bottom left, as a Pin's `x` and `y` or a tap gives them), and `maps` the Maps the reader is served; the reader reads a Map row as the map-space reading does (K: `type` exactly `map`; I: the last row served for an id wins; H: a link that is not a non-empty string is no link, and a Map row without a non-empty string id is no Map; a row that is no Map by K or H answers `{parent_frame: null, lint: null, points: [], stop: null}`, whatever it carries). The answer is `{parent_frame, lint, points, stop}`, in that order, every key always present: +- `parent_frame`: the Map's `x_parent_frame` as written when it is a parent frame (rule 13), else `null`; also on a Map whose parent is not served or closes a ring, which ends the walk and leaves the parent frame its own. +- `lint`: `no_parent`, `not_four_numbers` or `not_a_box` when this Map's own key is one (rule 13), else `null`. A Map further up the chain is read for its own lint by its own reading. +- `points`: each `{map, x, y}`, first the point on this Map as given, then the point on each Map it is carried to, in order up the chain (rule 14), each `x` and `y` the 64-bit float the carry gives. +- `stop`: why the last point in `points` is carried no further: `top`, `dangling`, `cycle`, `no_frame` or `no_carry` (rule 14). + +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. + **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 reader that wants those builds them on this page's answer. +**What stays the tool's**, said so nobody ports it as a rule: which Map stands for the world's space when a world has several, among those rule 11 leaves; a default scale when none is given (the C# takes 0.05); hull, area and room roles read from `role` or `x_` keys; doors as Objects with Pins, their widths and wall snaps; a lift factor on z; cameras and looks; how a layout method places where no page rules it, and its own `settings`; what a layout method does with a layout map's Markers; a way into a child Map that has no parent frame (the Pin of its `location` on the parent, a layout file beside the world), which is never a place; how a child's picture is drawn on its parent's. A reader that wants those builds them on this page's answer. -**The fixture** `map-space.fixture.json`: each case is the elements as one reader is served them, and a `want` that holds the whole answer, keys in order. The cases cover: `order` then id, and a Zone with no `order` at all; a repeated corner kept; `polygon`, `line`, absent and a stray value for `shape`; a Zone with Markers on two Maps; a Marker whose `zone` is not served, and one whose `map` is not; a Pin with no element, and one whose element is not served; `z` present and absent, and a `z` past the Map's `depth`; a Marker whose `x` is not a whole number; an `order` of `"2"` and of `1.5`; a Pin with one of its two keys; a Map without `width`; a Map with `x_metres_per_pixel` and one without; a hidden Zone, read as the owner and as a visitor (the visitor's input lacks it, the answer has no outline for it, and nothing in `out` names it); ids above U+FFFF for the code point order; a layout map with a Zone's Markers and a Pin on it, beside a plain Map with a Pin, read as any Map (rule 11); an empty string as a link: a Pin's `map`, a Marker's `zone`, a Map's `parent_map` and `location`, and a Pin's `element_type` and `element_id` together; a written size of 0 and under 0, and a `depth` of 0 and under 0, a `height` as a `width`; a `width` and a `depth` that are null, `1.5`, `"100"` and `true`; each of the seven links the reading reads (a Map's `location` and `parent_map`, a Pin's `map`, `element_id` and `element_type`, a Marker's `map` and `zone`) as a list, a number, a boolean and an object, the values ones a careless reader would take; and a Map measured with no point of its own. Its `layout_cases`, beside `cases`, are the layout reading's: each case is the elements as one reader is served them and `map`, the id of the Map read (the reader's `map` is that row, `maps` the case's Map rows, `pins` its Pin rows; a case that reads a Map row with no non-empty string id cannot name it, so it has `map_index` instead, a list of positions in `elements`, and the answer is the case's `want` for each row read), with a `want` that holds the whole answer, keys in order. They cover: `x_layout` absent, null, a string, an object without `method` but with a ground, `method` `""`, and a `method` that is not a string; a board with two unmarked Pins and one marked; a known method with `x_hand` as `true`, `"true"`, `1`, `false` and absent; a marked Pin served with its element link null; a method no page names; a ground naming a served Map, a Map not served, no `map`, a `map` that is an empty string, and the layout Map itself; a plain Map whose Pins keep their marks after `x_layout` is removed; a Map with three Pins that gains a method, as the writer leaves it; Pins held out of id order, and a Pin on another Map; two Pin ids that a UTF-16 comparison and a code point comparison put in different orders; a Pin id repeated, marked in its first row and not its last, and the reverse; a Pin row with no `id`, one whose `id` is a number, and one whose `id` is an empty string; a Map row with no `id`, and one whose `id` is a number, each carrying a method, a served ground and marked Pins, one of them with no `map`; a Map row whose `id` is an empty string, a board with a Pin whose `map` is an empty string too; a layout Map and its ground, neither with a `parent_map`, the layout holding three Pins and the ground one, each read in turn (a missing parent and a Pin count neither make nor unmake a layout); a Map whose Pins a method drew, marked with that method; a Map with no `x_layout` whose Pins a tool placed at their true positions by a recipe in its own namespace; and a board of a real place, imported with supertype `Board` and no mark; and a ground whose `map` is a number beside a Map whose id is its text, a list holding a served Map's id, and an object holding one: each no ground (reading H). +**The fixture** `map-space.fixture.json`: each case is the elements as one reader is served them, and a `want` that holds the whole answer, keys in order. The cases cover: `order` then id, and a Zone with no `order` at all; a repeated corner kept; `polygon`, `line`, absent and a stray value for `shape`; a Zone with Markers on two Maps; a Marker whose `zone` is not served, and one whose `map` is not; a Pin with no element, and one whose element is not served; `z` present and absent, and a `z` past the Map's `depth`; a Marker whose `x` is not a whole number; an `order` of `"2"` and of `1.5`; a Pin with one of its two keys; a Map without `width`; a Map with `x_metres_per_pixel` and one without; a hidden Zone, read as the owner and as a visitor (the visitor's input lacks it, the answer has no outline for it, and nothing in `out` names it); ids above U+FFFF for the code point order; a layout map with a Zone's Markers and a Pin on it, beside a plain Map with a Pin, read as any Map (rule 11); an empty string as a link: a Pin's `map`, a Marker's `zone`, a Map's `parent_map` and `location`, and a Pin's `element_type` and `element_id` together; a written size of 0 and under 0, and a `depth` of 0 and under 0, a `height` as a `width`; a `width` and a `depth` that are null, `1.5`, `"100"` and `true`; each of the seven links the reading reads (a Map's `location` and `parent_map`, a Pin's `map`, `element_id` and `element_type`, a Marker's `map` and `zone`) as a list, a number, a boolean and an object, the values ones a careless reader would take; and a Map measured with no point of its own. Its `layout_cases`, beside `cases`, are the layout reading's: each case is the elements as one reader is served them and `map`, the id of the Map read (the reader's `map` is that row, `maps` the case's Map rows, `pins` its Pin rows; a case that reads a Map row with no non-empty string id cannot name it, so it has `map_index` instead, a list of positions in `elements`, and the answer is the case's `want` for each row read), with a `want` that holds the whole answer, keys in order. They cover: `x_layout` absent, null, a string, an object without `method` but with a ground, `method` `""`, and a `method` that is not a string; a board with two unmarked Pins and one marked; a known method with `x_hand` as `true`, `"true"`, `1`, `false` and absent; a marked Pin served with its element link null; a method no page names; a ground naming a served Map, a Map not served, no `map`, a `map` that is an empty string, and the layout Map itself; a plain Map whose Pins keep their marks after `x_layout` is removed; a Map with three Pins that gains a method, as the writer leaves it; Pins held out of id order, and a Pin on another Map; two Pin ids that a UTF-16 comparison and a code point comparison put in different orders; a Pin id repeated, marked in its first row and not its last, and the reverse; a Pin row with no `id`, one whose `id` is a number, and one whose `id` is an empty string; a Map row with no `id`, and one whose `id` is a number, each carrying a method, a served ground and marked Pins, one of them with no `map`; a Map row whose `id` is an empty string, a board with a Pin whose `map` is an empty string too; a layout Map and its ground, neither with a `parent_map`, the layout holding three Pins and the ground one, each read in turn (a missing parent and a Pin count neither make nor unmake a layout); a Map whose Pins a method drew, marked with that method; a Map with no `x_layout` whose Pins a tool placed at their true positions by a recipe in its own namespace; and a board of a real place, imported with supertype `Board` and no mark; and a ground whose `map` is a number beside a Map whose id is its text, a list holding a served Map's id, and an object holding one: each no ground (reading H). Its `frame_cases` are the frame reading's: each case is the elements as one reader is served them, `map`, the id of the Map read (or `map_index`, as in a layout case: a list of positions in `elements`, and the answer is the case's `want` for each row read), and `point`, with a `want` that holds the whole answer, keys in order. The reader's `map` is the row read (for an id, the last Map row served with it) and its `maps` every row of the case, of which it keeps the Maps by reading K. A number in `parent_frame` and in `points` compares as a 64-bit float, exactly equal and with no tolerance (`100.0` and `100` are one number); every other part compares as written. They cover: a point carried, each axis by its own ratio and y from the bottom; a stretch; a box the child's shape turned; a point outside the child; a box past the parent's edges; a parent frame and a `width` written with a fraction part of 0; a parent frame on a Map with no `parent_map`, with one that is an empty string, with one that is a list, a number, a boolean and an object, and a malformed one with none; a Map with no `parent_map` and no key, and one whose key is null; a parent frame absent, beside a Pin of the child's `location` on the parent, and one null; three numbers, five, numbers as strings, a string, a boolean, a null and a list among four, a string, an object, a number, a boolean and an empty list; an empty string and `false` as the key of a child, and an empty string as the key of a Map with no `parent_map`; a box mirrored in x and in y, and one with no width and no height; a child with no size, and with no `height`, each beside points that would measure one; a `width` of 0, under 0, of 99.6, `"100"` and `true`, and a `height` under 0; decimals on which the per-pixel order, the fraction-first order, a centre-based order and exact rationals each differ from the written order, one case for x and one for y; three levels and four, with decimals on which a product of the levels' ratios differs; a level with no parent frame, a mirrored one and one with no carry, and a top Map that carries a parent frame; a parent not served, alone and beside a malformed parent frame, and a parent served only as a row whose `type` is `Map`; a Map that names itself, with a parent frame, with none, and with no `width`; two in a ring, and a ring above the Map read; a child with a served parent and neither a parent frame nor a `width`; a Map and its parent each served twice; a Map row with no `id` and one whose `id` is an empty string, and a row read whose `type` is `Map`; two scales that disagree with the parent frame; and a layout map with a parent frame. **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. +**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. diff --git a/codegen/schema-pin.json b/codegen/schema-pin.json index 7cc1bc2..6a5a4b4 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.138", - "commit": "a4793840199570607bdd06fc54d472af6093dd20", - "manifest_sha256": "60c6f68fcd5ca63b02a0e99ea0c2b586159bb68ade38106aa890c823a6a6fca1", + "tag": "v0.34.1-dist.139", + "commit": "fc466572b978ea23d62e900161f5670ea363b58c", + "manifest_sha256": "65a3ded94dfce624e823c664c7bcfc317530a872213a217d8e3a63215fe9f4e5", "canonical_version": "00.34.01", - "dist_serial": 138, + "dist_serial": 139, "published": "2026-11-19", "pinned_at": "2026-11-19", "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.138", + "manifest_sha256": "60c6f68fcd5ca63b02a0e99ea0c2b586159bb68ade38106aa890c823a6a6fca1", + "note": "superseded by v0.34.1-dist.139 (serial 139, canonical 00.34.01 unchanged: the child Map frame, the map-space page's rules 13 and 14 and the fixture's 66 frame_cases)" + }, { "tag": "v0.34.1-dist.136", "manifest_sha256": "9a1f31d1135a17ffa0facca587ba354a90821bdb28dc46a4a7335cbfe7acfa91", diff --git a/src/onlyworlds/_schema.py b/src/onlyworlds/_schema.py index bac0761..b637132 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.138 (a4793840199570607bdd06fc54d472af6093dd20) +# Source: https://github.com/OnlyWorlds/schema-dist @ v0.34.1-dist.139 (fc466572b978ea23d62e900161f5670ea363b58c) """Schema provenance, the 22 element types and their fields, from the pinned schema distribution.""" -SCHEMA_DIST_TAG = "v0.34.1-dist.138" +SCHEMA_DIST_TAG = "v0.34.1-dist.139" SCHEMA_VERSION = "00.34.01" -SCHEMA_DIST_SERIAL = 138 -SCHEMA_MANIFEST_SHA256 = "60c6f68fcd5ca63b02a0e99ea0c2b586159bb68ade38106aa890c823a6a6fca1" +SCHEMA_DIST_SERIAL = 139 +SCHEMA_MANIFEST_SHA256 = "65a3ded94dfce624e823c664c7bcfc317530a872213a217d8e3a63215fe9f4e5" # Canonical order, as the walk declares it. ELEMENT_TYPES: tuple[str, ...] = ( diff --git a/src/onlyworlds/_version.py b/src/onlyworlds/_version.py index dd2dfb4..da56c9c 100644 --- a/src/onlyworlds/_version.py +++ b/src/onlyworlds/_version.py @@ -1 +1 @@ -__version__ = "0.136.0" +__version__ = "0.137.0"