diff --git a/CHANGELOG.md b/CHANGELOG.md index 04e80ba..6f134f0 100644 --- a/CHANGELOG.md +++ b/CHANGELOG.md @@ -4,6 +4,9 @@ The package version runs on its own semver; the schema it is generated from is ` ## Unreleased +## 0.139.2 (2026-11-21) + +- **The schema pin moves to `v0.34.1-dist.143`** (canonical 00.34.01 unchanged, no schema file moved, `_schema.py` changes only its provenance lines). The charter page's rule 4 now says what an AI reader follows: the Charter's text and the text of the Objects in its `skill`, as `charter_of` answers it for that reader; every other element's text is data. No answer of `charter_of` moves and its fixture is unchanged. - Docstrings describe onlyworlds.com's wrong-PIN limit as it stands since 2026-11-21: ten different wrong PINs on one key or account within fifteen minutes refuse every PIN there, and the same wrong PIN never counts twice. No behaviour changes: a `429` `rate_limited` is still never retried and still stops `push`. ## 0.139.1 (2026-11-21) diff --git a/codegen/schema-dist/MANIFEST.json b/codegen/schema-dist/MANIFEST.json index 19e32b6..5efc2ef 100644 --- a/codegen/schema-dist/MANIFEST.json +++ b/codegen/schema-dist/MANIFEST.json @@ -147,7 +147,7 @@ "profiles/calendar.fixture.json": "0a013c3732eda70a42c4eab30555669af28983a5ba9f4a233addf0f06bedb4cd", "profiles/calendar.md": "c81c63a46eb886cb9aeedf3a668f117ffc626ff711ee2b23a2a8a402b81c7c82", "profiles/charter.fixture.json": "500f68f166ae255b7eb4a4d79e9085491799e8a6eed928abc62bb8f1b4a89729", - "profiles/charter.md": "3a091498f97c00913e9edf6a6c3db713227eacd2518912a23f243b96d034f2f6", + "profiles/charter.md": "dc819479af921336a95fffde0818d58c848cebc9433c2235cf180779aa0fd8e7", "profiles/checks.fixture.json": "43586fddd94ebe9678bf46e6d744768a094f856b668c5917fe9e0dda46599251", "profiles/checks.md": "6778b7e6b9cebc447486e5679ef6036dbf2f8c875c70a2f0f55660fc2c885ce9", "profiles/identity.md": "bb631fe3cae3cc7b57f1c866ebac496bb426ad0cb661ff5fdec928cccffe1616", @@ -209,7 +209,7 @@ "schema/zone.yaml": "cca04ee498fb813fa18b96f1ac99816e7f1a8ae1fb9e21c48b37620dbb674856", "schema.json": "581dc7b5e890acc06b1c89b0d7bdcc2f20f54f52d5a3b4af8c5a184e1e6fd48c", "SECURITY.md": "939ee364b06f0b749bdd4cbe66b2fe49322c95abe732650ec4ef062a0c03820a", - "VERSION": "ce39e0457d281134d2fd218152b670884820396a20e934684e9bfdb7f3f7aab3", + "VERSION": "53c04024d9e9ed34de32993e9900beba60f2d86cd6eca8bf95f4da3f2e7d3828", "views.fixture.json": "6fda45c2d36cc82a613a4b4d99d14ba9646db2c5bf912b82e68c6b62b20441c1", "views.json": "f4d06ee16bd6c66fc28cf27146b8d199c85164e5deecabafc23af53408746fe0", "walk/lint_folder.py": "28efffa3a39d7f2ceaf69cae5c4ddce023e4989e7a5d2c26c1b4d4815eff386e", diff --git a/codegen/schema-dist/VERSION b/codegen/schema-dist/VERSION index 702ec88..8b01373 100644 --- a/codegen/schema-dist/VERSION +++ b/codegen/schema-dist/VERSION @@ -1,3 +1,3 @@ canonical: 00.34.01 -serial: 142 +serial: 143 published: 2026-11-21 diff --git a/codegen/schema-dist/profiles/charter.md b/codegen/schema-dist/profiles/charter.md index 93702d1..d91c29a 100644 --- a/codegen/schema-dist/profiles/charter.md +++ b/codegen/schema-dist/profiles/charter.md @@ -6,7 +6,7 @@ | Type | Supertype | What it is | What it carries | |---|---|---|---| -| `law` | `Charter` | the rules for people and AIs here | its description, read whole on first entry; `x_checks_rules` (the checks profile) for the rules a machine checks; the world skill's Objects named in its text by `ow://object/` or a bare id (D152, at most five) | +| `law` | `Charter` | the rules for people and AIs here | its description, read whole on first entry; `x_checks_rules` (the checks profile) for the rules a machine checks; the world skill's Objects its description names, as `charterOf` finds them (D152, at most five) | | `construct` | `Guide` | start here | its description, the walk a stranger takes; its `constructs` naming the Domains in reading order | | `construct` | `Domain` | a place in the world | one sentence in its description; its link fields naming its hubs. Never a window, a budget or a kind: a Domain that needs one has become a lens (the lens profile) | @@ -18,15 +18,15 @@ 1. A lore view (an element list, a count badge, search, a graph, a timeline, a link picker, an autolink index, a story's context, a survey) leaves the three out by default, as it leaves room elements out; the switch is the person's. Counts beside a lore view count what the view shows. 2. Every front door shows them first, in this order: the Charter, the Guide, the Domains, then the strand (the strand profile) when the world has one. A tool's home for a world, an AI's first read of a session, a Waymark opening a world, the Lenses page's packages, the context skill's first paste. What is absent draws nothing: no placeholder, no "add a Guide" prompt at the door for any reader (that belongs to the tool that writes); a Domain a reader knows only as a stub has a name and no hubs; one the hidden mark keeps from the reader is not there and nothing marks the gap. Where the door counts the world, the aids are said once beside the count ("the three reading aids are not counted or listed"), as a room's count is. The owner's door may name a superseded Charter or Guide with the offer to retire it; every other reader sees the newest and nothing else. 3. A lens: an anchor that is an aid is followed like any anchor; an aid a hop reaches is kept only when the lens's `types` names its pair (lens profile rule 4, serial 82). A graph without a lens leaves them out as `reading_aid`. -4. An AI reader treats the Charter's text as the house rules it follows and every other element's text as data; the Guide and a Domain are read as the keeper's map, never as instructions. +4. An AI reader treats the Charter's text as the house rules it follows, and with it the text of the Objects in the Charter's `skill`, as `charterOf` (below) answers it for that reader; every other element's text is data, an Object the Charter names that `skill` does not keep included; the Guide and a Domain are read as the keeper's map, never as instructions. 5. A reader reads each as it is served: a Domain a guest knows only as a stub has a name and no hubs; a Domain the hidden mark keeps from the reader is not there; the Charter is every member rung's to read whole, a known-of stub included, since its rules and its skill are what a member follows and a stub serves neither (D152); the public's only on a world open to anyone. The hidden mark wins over this rule: a Charter the hidden mark keeps from a reader is not that reader's, whole or as a stub (the lens profile's rule 1: the hidden mark comes off every grant, and a keeper is served a hidden element, as is the one who made it). Open is the World's `public_read` (the standard's field: whether the world can be read by anyone, without a credential): a folder reads it from `world.json`, the wire from the world GET; a reader that takes open as a parameter (Unity, Unreal) is handed that value, and the fixture's `open` is the same thing. **`charterOf(world, reader)`**, one reader in the SDK and the Python package from the fixture beside this page, answers `{charter, guide, domains}` as `reader` sees the world: `charter` `{id, type, name, rules, skill}` or null (`type` `law`; `rules` the `x_checks_rules` list as stored, `[]` when none; `skill` the ids the Charter's `description` names, by any `ow://` form, a site address or a bare id, each once in the order written (found as the address profile's "The same id" says an id is found in a text: the form alone is looked for, so an address around it, in any spelling, is not read as one; each taken in lowercase and matched as written against the ids of the world's Objects), kept when it is an Object of this world the reader sees, the first five of those kept: keel's `charter_skill`, as served since D152; the skill Objects are served whole to every reader who reads the Charter, and a skill Object the hidden mark keeps from the reader is not served, not even as a stub, and not kept; every id in `skill` is an Object's, fetched as one); `guide` `{id, type, name}` or null, `type` `construct`; `domains` a list of `{id, type, name, sentence, hubs}` in the order above, `type` `construct`, `sentence` the description with White_Space (the room profile's set) trimmed from both ends, cut at its first line break (a carriage return or a line feed), and trimmed again: its first line that holds something, trimmed, or an empty string when the description holds nothing, `hubs` the distinct `{type, id}` its link fields name, itself excluded, that the reader sees, in the schema's field order: a hub is an element of the kind its link field links to, in the reader's view, and its `type` is that kind; an id in a link field that names no element of that kind in the reader's view names no hub. Each `type` is a type's name as the API's routes and a folder's directories write it, singular and lowercase; on the Charter, the Guide and a Domain it is the pair's own word in the table above, whatever spelling the element's type is stored in. The packet is handed to a reader that may hold nothing else of the world, and an id is fetched by its type. **`domainsOf(world, reader)`** is the list alone. **`isCharterElement(element)`** is the pair-and-mark test. **`readingAidOf(element)`** (Python `reading_aid_of`) answers `'charter'`, `'guide'`, `'domain'` or null from the type and supertype alone, trimmed and folded as the pairs above, the whole word, the mark ignored: an unmarked Law with supertype Charter answers `'charter'`, which is what a tool offering to mark one needs; whether an element is a reading aid stays `isCharterElement`'s question. Keel serves the same packet to a key as `reading_aids` beside `front_door` on `GET /me` and the join reply (`front_door.charter` and `charter_skill` stay as served; a removal is a dated notice), and at the world's door on the site. -**What a writer must do.** A keeper (the owner or a co-builder) writes the pair and the mark together, the mark the id of the world the element is in, byte for byte like every extension field. The server refuses `x_charter_of` set or changed by any other key, by name, before anything is written (a guest's own Law must never become what every AI reads first). A tool never writes the mark on lore on its own; it may offer a keeper "Mark this as the world's Charter" (or Guide, or a Domain) on a Law or Construct the keeper names, one write that sets the pair and the mark together, which is how a world that never met a server (a folder, a browser world) keeps its door. A tool that offers supertype suggestions may still offer these words, since the mark, not the word, makes the aid. One Charter and one Guide at a time: a tool that makes a new one offers to retire the old. A Domain's hubs are its links and its sentence its description; a tool that proposes Domains (from a world's own link counts) writes them as proposed (the review profile) or not at all, never silently. +**What a writer must do.** A keeper (the owner or a co-builder) writes the pair and the mark together, the mark the id of the world the element is in, byte for byte like every extension field. The server refuses `x_charter_of` set or changed by any other key, by name, before anything is written (a guest's own Law must never become what every AI reads first). Rule 4 has an AI follow the Charter's text and that of the Objects in its `skill`, so who may change that text is the host's to rule: keel lets only a keeper change it; a folder has no such hand, and there it is written by whoever can write the folder. A tool never writes the mark on lore on its own; it may offer a keeper "Mark this as the world's Charter" (or Guide, or a Domain) on a Law or Construct the keeper names, one write that sets the pair and the mark together, which is how a world that never met a server (a folder, a browser world) keeps its door. A tool that offers supertype suggestions may still offer these words, since the mark, not the word, makes the aid. One Charter and one Guide at a time: a tool that makes a new one offers to retire the old. A Domain's hubs are its links and its sentence its description; a tool that proposes Domains (from a world's own link counts) writes them as proposed (the review profile) or not at all, never silently. **Health, measured, never promised.** How many of the world's elements the Domains reach in one hop; a Domain or Guide entry that names a hidden or deleted element (a leak bound: the page warns at save, the doctor flags on its cadence, two checks that each fail alone); a hub carrying more links than any Domain names; two marked Charters. The doctor reports these; nothing here prevents them. **Where the list is read from.** The SDK and the Python package export the three pairs, `isCharterElement`, `readingAidOf`, `charterOf` and `domainsOf`; a tool with its own charter lookup (Atlas's `findCharter`, the doctor's Charter rule, keel's front door) replaces it with this selection the release after the packages carry it. The conformance fixture beside this page, `charter.fixture.json`, holds the cases every reader must agree on; its second list, `design_cases`, holds, of a world and one reader, the design parts that reader reads, each `{type, id, state}`, its `type` a type's name as the packet writes one (`object` or `construct`, whatever spelling the element's type is stored in), compared as a set. -**Ruled**: Skeld, 2026-10-28, serial 83 (the reading aids by pair and mark were ruled in the lens and room profiles on serial 82; this page gathers them and adds the selection, the packet and the writer's rule); Skeld, 2026-10-28, serial 85: what retiring writes, and `readingAidOf`. Skeld, 2026-10-30, serial 94: three readings found by porting the reader, ruled and cased: a proposed aid, skill Object or hub is in no reader's view, the owner's included; a member reads the Charter whole from a stub; a skill id compares as a UUID, whatever its case. Serial 100 (2026-10-31): the order names the strand fourth; keel's reading_aids packet carries it as strand, the strand profile's reading. Serial 107 (2026-11-03): open is the World's `public_read`, named where an engine port could not settle it from the page; no fixture change. 2026-11-13, serial 122: a skill id found in the Charter's `description` is taken in lowercase and matched as written against the world's Objects, wherever it stands in the text, and a `created_at` is read as the message profile reads one, one that cannot be read sorting as the oldest; seven more cases in the fixture. 2026-11-14, serial 126: an `x_charter_of` that is an empty list or an empty object is no mark, as the review profile reads an empty mark, so an aid reads the same in its full and its compact form; three more cases in the fixture, two packets whose newer Law carries an empty mark and `false` as a mark. 2026-11-16, serial 133: the Charter, the Guide and each Domain in the packet carry `type` beside `id`, the pair's own word (`law`, `construct`, `construct`) whatever spelling the element's type is stored in, since a reader handed the packet alone fetches an id by its type; a hub is an element of the kind its link field links to, in the reader's view, so an id of another kind, or of no element, in a link field names no hub; wherever the page compares an element's type to a kind (a pair, a hub's kind, a skill's being an Object), the type is trimmed and compared without regard to case, as the room profile defines it; rule 2's stub Domain has a name and no hubs, as rule 5 has it; the Charter, the Guide, each Domain and each hub carry the key (`skill` stays a list of Object ids), and six more cases in the fixture: a Domain whose `characters` names a Location and an id of no element, a Charter whose type is stored as ` Law `, a Domain whose type is stored as `CONSTRUCT`, a hub Location whose type is stored as ` Location `, a skill Object whose type is stored as `Object`, and one world whose Domains and hubs are typed so that only the room profile's own trim and fold reads them right. 2026-11-18, serial 135: the design state of an Object or a Construct is its `subtype` when that is `in design` or `locked`, trimmed and folded as the room profile defines it, read only from an element the reader is served whole (a known-of stub has none, though it is served its subtype), and only in a world where `charterOf` finds a Charter for the reader, so a story's world that keeps a marked Charter has design states, and a reader for whom `charterOf` finds no Charter reads none where another reader of the same world does; rule 5's Charter for every member rung yields to the hidden mark, so a Charter the hidden mark keeps from a reader is not that reader's; carrying it makes the element a design part, whatever its supertype, and no other subtype or type has one; nothing is under a Construct by this page; a design part's `type` is written as the packet writes a type, whatever spelling the element's type is stored in; thirteen cases in the fixture's new list, `design_cases`: a locked Object, a Construct in design and a workshop's spec in design (a room element: no kind is excluded), a subtype stored as `In Design `, a Construct that is `deprecated`, a Law that is `accepted` and a Law that is `locked`, which are no parts, a locked Object in a world whose only Charter has no mark, and an Object whose subtype is `locked` followed by U+001F, which is no White_Space by the room profile, so it has no design state, a locked Object a guest holds only as a known-of stub, which has none, and one world whose Charter carries the hidden mark, read twice: its owner reads a locked Object as a design part, a contributor reads none, and a locked Object whose type is stored as ` Object `, written `object`; the fixture's note on what a stub holds now names its supertype, subtype, image_url and its type's public fields, as the lens profile serves a stub. 2026-11-19, serial 138: rule 5's exception names a keeper and the one who made a hidden element, where it named the owner alone, as the lens profile's rule 1 now does, so a Charter the hidden mark keeps from other readers is still a keeper's and its maker's; three more cases in `design_cases`: a locked Object the hidden mark keeps from a contributor, which is no part for it, a hidden Charter made by a contributor, which opens the gate for that contributor, and a Charter a guest holds only as a known-of stub, which opens the gate, since a member reads the Charter whole from a stub (rule 5); the fixture's note on its worlds says a contributor's whole as the lens fixture's does. 2026-11-19, serial 141: folded names are compared by code point, as written, never by UTF-16 unit, a collation or a locale, and nothing is normalized before or after the fold, so a decomposed and a precomposed spelling are two names; the fixture's note on the order says the same; a name is trimmed and folded as the room profile defines it, where the ties named its fold alone, and the fixture's note on the order says the same; ten more cases in the fixture, each a world whose Domains no Guide orders: names beyond U+FFFF beside full-width ones, which code point and UTF-16 order two ways, a sharp s beside the capital sharp s that folds to it, a decomposed and a precomposed name, four names equal once trimmed and folded, ordered by id, a name after a byte order mark and one before U+001F, which no White_Space trim takes, names with U+0085 or U+3000 at an end, which it takes, three names equal once trimmed and folded whose `created_at` follow neither their ids' order nor its reverse, ordered by id, a name that is the start of another, which comes first, and two names equal once folded whose ids, one of them in upper case, order one way as written and the other way folded, ordered by the ids as written, and a name that is the start of another that continues with U+0001, which comes first; three more cases in `design_cases`: a locked Object with U+0085 before and after its subtype, which is White_Space by the room profile, so it is locked, a locked Object after a byte order mark, which is not, so it has no design state, and a Construct in design written with a long s, which folds to s. +**Ruled**: Skeld, 2026-10-28, serial 83 (the reading aids by pair and mark were ruled in the lens and room profiles on serial 82; this page gathers them and adds the selection, the packet and the writer's rule); Skeld, 2026-10-28, serial 85: what retiring writes, and `readingAidOf`. Skeld, 2026-10-30, serial 94: three readings found by porting the reader, ruled and cased: a proposed aid, skill Object or hub is in no reader's view, the owner's included; a member reads the Charter whole from a stub; a skill id compares as a UUID, whatever its case. Serial 100 (2026-10-31): the order names the strand fourth; keel's reading_aids packet carries it as strand, the strand profile's reading. Serial 107 (2026-11-03): open is the World's `public_read`, named where an engine port could not settle it from the page; no fixture change. 2026-11-13, serial 122: a skill id found in the Charter's `description` is taken in lowercase and matched as written against the world's Objects, wherever it stands in the text, and a `created_at` is read as the message profile reads one, one that cannot be read sorting as the oldest; seven more cases in the fixture. 2026-11-14, serial 126: an `x_charter_of` that is an empty list or an empty object is no mark, as the review profile reads an empty mark, so an aid reads the same in its full and its compact form; three more cases in the fixture, two packets whose newer Law carries an empty mark and `false` as a mark. 2026-11-16, serial 133: the Charter, the Guide and each Domain in the packet carry `type` beside `id`, the pair's own word (`law`, `construct`, `construct`) whatever spelling the element's type is stored in, since a reader handed the packet alone fetches an id by its type; a hub is an element of the kind its link field links to, in the reader's view, so an id of another kind, or of no element, in a link field names no hub; wherever the page compares an element's type to a kind (a pair, a hub's kind, a skill's being an Object), the type is trimmed and compared without regard to case, as the room profile defines it; rule 2's stub Domain has a name and no hubs, as rule 5 has it; the Charter, the Guide, each Domain and each hub carry the key (`skill` stays a list of Object ids), and six more cases in the fixture: a Domain whose `characters` names a Location and an id of no element, a Charter whose type is stored as ` Law `, a Domain whose type is stored as `CONSTRUCT`, a hub Location whose type is stored as ` Location `, a skill Object whose type is stored as `Object`, and one world whose Domains and hubs are typed so that only the room profile's own trim and fold reads them right. 2026-11-18, serial 135: the design state of an Object or a Construct is its `subtype` when that is `in design` or `locked`, trimmed and folded as the room profile defines it, read only from an element the reader is served whole (a known-of stub has none, though it is served its subtype), and only in a world where `charterOf` finds a Charter for the reader, so a story's world that keeps a marked Charter has design states, and a reader for whom `charterOf` finds no Charter reads none where another reader of the same world does; rule 5's Charter for every member rung yields to the hidden mark, so a Charter the hidden mark keeps from a reader is not that reader's; carrying it makes the element a design part, whatever its supertype, and no other subtype or type has one; nothing is under a Construct by this page; a design part's `type` is written as the packet writes a type, whatever spelling the element's type is stored in; thirteen cases in the fixture's new list, `design_cases`: a locked Object, a Construct in design and a workshop's spec in design (a room element: no kind is excluded), a subtype stored as `In Design `, a Construct that is `deprecated`, a Law that is `accepted` and a Law that is `locked`, which are no parts, a locked Object in a world whose only Charter has no mark, and an Object whose subtype is `locked` followed by U+001F, which is no White_Space by the room profile, so it has no design state, a locked Object a guest holds only as a known-of stub, which has none, and one world whose Charter carries the hidden mark, read twice: its owner reads a locked Object as a design part, a contributor reads none, and a locked Object whose type is stored as ` Object `, written `object`; the fixture's note on what a stub holds now names its supertype, subtype, image_url and its type's public fields, as the lens profile serves a stub. 2026-11-19, serial 138: rule 5's exception names a keeper and the one who made a hidden element, where it named the owner alone, as the lens profile's rule 1 now does, so a Charter the hidden mark keeps from other readers is still a keeper's and its maker's; three more cases in `design_cases`: a locked Object the hidden mark keeps from a contributor, which is no part for it, a hidden Charter made by a contributor, which opens the gate for that contributor, and a Charter a guest holds only as a known-of stub, which opens the gate, since a member reads the Charter whole from a stub (rule 5); the fixture's note on its worlds says a contributor's whole as the lens fixture's does. 2026-11-19, serial 141: folded names are compared by code point, as written, never by UTF-16 unit, a collation or a locale, and nothing is normalized before or after the fold, so a decomposed and a precomposed spelling are two names; the fixture's note on the order says the same; a name is trimmed and folded as the room profile defines it, where the ties named its fold alone, and the fixture's note on the order says the same; ten more cases in the fixture, each a world whose Domains no Guide orders: names beyond U+FFFF beside full-width ones, which code point and UTF-16 order two ways, a sharp s beside the capital sharp s that folds to it, a decomposed and a precomposed name, four names equal once trimmed and folded, ordered by id, a name after a byte order mark and one before U+001F, which no White_Space trim takes, names with U+0085 or U+3000 at an end, which it takes, three names equal once trimmed and folded whose `created_at` follow neither their ids' order nor its reverse, ordered by id, a name that is the start of another, which comes first, and two names equal once folded whose ids, one of them in upper case, order one way as written and the other way folded, ordered by the ids as written, and a name that is the start of another that continues with U+0001, which comes first; three more cases in `design_cases`: a locked Object with U+0085 before and after its subtype, which is White_Space by the room profile, so it is locked, a locked Object after a byte order mark, which is not, so it has no design state, and a Construct in design written with a long s, which folds to s. 2026-11-21, serial 143: rule 4 names what an AI reader follows with the Charter's text, the text of the Objects in the Charter's `skill` as `charterOf` answers it for that reader; every other element's text stays data, an Object the Charter names that `skill` does not keep included; the table's Charter row names the skill Objects as `charterOf` finds them, where it named two of the forms; the writer's paragraph says that who may change the text rule 4 has an AI follow is the host's to rule: on keel only a keeper, and in a folder whoever can write the folder; no answer moves and no fixture change. diff --git a/codegen/schema-pin.json b/codegen/schema-pin.json index 7a22526..4dd93c4 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.142", - "commit": "5d5a8beffe1d17abfb5cd279034702f0ec38ca2a", - "manifest_sha256": "59d21a4b7a3210bf4cb7cc8c59aece3600681e864fb2e9825e3d592e8b1f6e4e", + "tag": "v0.34.1-dist.143", + "commit": "e03cd70f9cac6e591e62fcccb047074ac95d9d38", + "manifest_sha256": "c054efbf5ce23c6ccc7ba80bcc5a5f2bb55ca3561574ce0f94621006c88507cf", "canonical_version": "00.34.01", - "dist_serial": 142, + "dist_serial": 143, "published": "2026-11-21", "pinned_at": "2026-11-21", "pinned_by": "The maintainer: tree from `git archive` of the tag in a schema-dist checkout (216 files: the 215 the MANIFEST lists, and MANIFEST.json itself); files re-hashed against MANIFEST.json by verify_dist.py; MANIFEST self-hash matched against the raw file GitHub serves at the tag, whose ref resolves to the commit above.", "previous_pins": [ + { + "tag": "v0.34.1-dist.142", + "manifest_sha256": "59d21a4b7a3210bf4cb7cc8c59aece3600681e864fb2e9825e3d592e8b1f6e4e", + "note": "superseded by v0.34.1-dist.143 (the charter page's rule 4: what an AI reader follows; no answer moves)" + }, { "tag": "v0.34.1-dist.141", "manifest_sha256": "417be97794478dd39b1ba580c3316a6daf64953ab9ea7cf7ac9eb24f34548c92", diff --git a/src/onlyworlds/_schema.py b/src/onlyworlds/_schema.py index 6126f24..ddc0429 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.142 (5d5a8beffe1d17abfb5cd279034702f0ec38ca2a) +# Source: https://github.com/OnlyWorlds/schema-dist @ v0.34.1-dist.143 (e03cd70f9cac6e591e62fcccb047074ac95d9d38) """Schema provenance, the 22 element types and their fields, from the pinned schema distribution.""" -SCHEMA_DIST_TAG = "v0.34.1-dist.142" +SCHEMA_DIST_TAG = "v0.34.1-dist.143" SCHEMA_VERSION = "00.34.01" -SCHEMA_DIST_SERIAL = 142 -SCHEMA_MANIFEST_SHA256 = "59d21a4b7a3210bf4cb7cc8c59aece3600681e864fb2e9825e3d592e8b1f6e4e" +SCHEMA_DIST_SERIAL = 143 +SCHEMA_MANIFEST_SHA256 = "c054efbf5ce23c6ccc7ba80bcc5a5f2bb55ca3561574ce0f94621006c88507cf" # Canonical order, as the walk declares it. ELEMENT_TYPES: tuple[str, ...] = ( diff --git a/src/onlyworlds/_version.py b/src/onlyworlds/_version.py index 727efd8..d4bf641 100644 --- a/src/onlyworlds/_version.py +++ b/src/onlyworlds/_version.py @@ -1 +1 @@ -__version__ = "0.139.1" +__version__ = "0.139.2"