TSON 2026 Revision 39 — Change Log

This document records the changes accepted into Revision 39 of the TSON specification series, adjudicated from the implementation’s spec-feedback register (24 entries, renumbered from #1 against Revision 38, all raised since Revision 38 closed every entry open against Revision 37). SPEC-FEEDBACK.md remains a record against Revision 38 and is not modified by this revision; each of its entries receives a disposition here.

Provenance markers used in the disposition table:

• [settled] — the resolution was settled by the spec author inside the feedback register itself, is already implemented in the revised companion artifacts shipped with this revision, or was decided by the spec author at adjudication.
• [open] — a genuine design decision deliberately left open. Collected in §5.
• [editorial] — a sentence the revision editor had to write that no register entry dictates, or a reading the editor took where the register admits more than one. Each is the spec author’s to confirm; collected in §5 beside the open questions.

This revision does not change the lexer. [TSON-DATA] §1.3’s lexer-freeze paragraph stands as Revision 38 left it: < and > were already single-character special tokens, a qualified name was already one unquoted token, and a sibling reference (kind!, #21) is an unquoted token followed by an adjacent !, which the lexer already emits as a special token. Every change below is in what the grammars make of tokens the lexer already produces.

It does change the data grammar at four positions: < and > gain a grammar role in data values, a reference carrying an argument list being a core value (#13); ! gains a postfix role, a sibling reference (#21); a type annotation and an annotation name are qualified names (#14, #15); and the scoped-value production is gone, so a directive at a value position is a parse error (#6). It changes the document header for both document kinds: a header is an optional !!id followed by any number of !!imports, !!meta and !!schema are parse errors naming their replacement, and a document is a schema document exactly when its root is tagged !schema (#8).

What this revision changes most is the schema chain, and with it the kernel. The ladder of governing relations — !!schema → user schema → !!meta → meta-schema → meta-kernel — and the four rules that kept each document on one rung are replaced by one namespace per schema: a schema’s own entries and every entry of its import closure, in which every name resolves (#7). The two pre-loaded documents become one, meta.tn, the kernel, whose root holds the thirteen names an author writes bare and whose machinery sits under six nested schema maps named by path — meta.record, unicode.text_type, numeric.integer_type, net.iri_type, binary.bytes_type, atom.ordering (#14, #15). Three data-format libraries stand beside it, numeric.tn, temporal.tn and net.tn, each importing the kernel alone; core.tn imports the three and declares the author annotations; policy.tn imports the kernel alone. Within the kernel: an entry is a type exactly when its value is built by a constructor IS-A meta.type, and any other entry is a value (#9); namespace is a refinement of map (#9); one atom, meta.reference_type, replaces kind_type and ref_type, and an application is a value of it (#11, #12, #13); a record template is its own constructor, meta.record_template, its fields labelled (#19); a field may be typed by a sibling field of its own record, value?: type! (#21); value and value_type are gone, every facet typed by its family’s own instance (#17, #21); every count is a numeric.count, the non-negative half of int64 (#16); scoped and the scope push are gone, meta.declared being the open sum (#6); and resolution within a schema runs in a stated wait order (#4). Every bundled pin changes, and the artifact set changes shape.

1. Baseline: the revised artifacts

Eighteen of the register’s proposals arrived already implemented in the companion artifacts, and Revision 39 adopts them as its baseline. Summarising the normative effect:

• #3 — the emitter’s form at a disjoint choice. The schemaless writers quote every host string and write every number and boolean bare, so a value this implementation writes round-trips through a disjoint choice to the variant it came from. Text-only otherwise ([TSON-DATA] §2.4; [TSON-SCHEMA] §5.4).
• #4 — resolution order within a schema. Rules 1–7: reading a value against a type waits on the type being ready and on each type a part of the value is read against; a reference orders nothing; a held value orders nothing; a wait cycle is a resolver error; every order consistent with rule 1 gives one output and source order is not consulted; everything closes at load; max_wait_depth is a limit, default 64. The kernel’s one cycle is the 25 entries holding meta.record, pre-loaded; every other entry is read by the rules. The kernel’s meta.annotation is void’s alias and annotates nothing. (Part 2 §3.4, §3.4.1, §5.10.1, §6, §11.5; meta, policy.)
• #5 — ! is an instance and ^ refines under the type’s rules — implemented for construction, atom refinement, record refinement and the kernel’s own refinements of the reference and map constructors (type_ref => !field_type_ref ^ { allow_sibling: false }, identifier_ref => !type_ref ^ { of: unicode.identifier_type }, namespace => map ^ { … }). The container constructors’ tightening rules are each that constructor’s to state. (Part 2 §5.5, §5.7, §12.1; meta.)
• #6 — the scope push is gone. The kernel declares meta.declared_type => sum & {} and meta.declared => !meta.declared_type {}; scoped, scope_kind, scope_set, schema_identity, extern, dynamic, extern_of and extern_type are in no bundled schema; a directive at a value position is a parse error; the foreign-schemas limit is gone. (Part 1 §2.3, §3.3, §7.4, §9.1; Part 2 §7.1, §7.8; meta, policy.)
• #7 — one namespace per schema. A schema’s namespace is its own entries and its import closure; every name resolves there — ! heads, refinement sources, type positions, a reference’s of, a bound, an annotation. Placement, direction of service, the import-level rule, governing-target eligibility, the structure/type-name split and the sibling allowance go. core.tn imports numeric.tn, temporal.tn and net.tn and declares no copy of any kernel entry. (Part 2 §2.2.2, §2.2.3, §3, §4.2, §6, §9; all artifacts.)
• #8 — one directive, and the root says the kind. A header is [!!id] *!!import for every document; a document is a schema exactly when its root is tagged !schema; a data document imports as a schema does, several imports read under one namespace; a resolved form carries its source’s header and nothing is supplied at ingest; the kernel’s header is its !!id alone. (Part 1 §2.2, §3.3, §7.1, §7.4; Part 2 §2.2, §3.4, §7.1, §8.1, §12.1; all artifacts.)
• #9 — value entries are ordinary values; namespace refines map. namespace => meta.map ^ { key_type: meta.identifier_ref voidable?: = false }; schema => !meta.namespace { key_type: meta.type_name value_type: meta.declared }; field_map => !meta.map { key_type: text value_type: meta.record_field ordered: true }, a plain map keyed by text that no qualified name enters; an entry whose value is an instance of an ordinary type is a value, marked by nothing but its tag, and a schema may hold create_order => !operation { … }. (Part 2 §4.1, §4.2, §5.12, §7.4, §8.1; meta.)
• #10 — the alias body is meta.alias, !meta.alias { target: T }, and “reference” keeps one meaning, a name held in a slot. max_alias_chain replaces the reference-chain limit. (Part 2 §4.1, §8, §11.5, §12.1; meta, policy.)
• #11 — one reference atom. meta.reference_type => meta.atom & { of: meta.type_ref allow_sibling?: boolean ~ true } admits a name exactly when the named entry’s value, past its alias hops, has a type IS-A of; meta.ref<T> is its one spelling; a slot over a constructor holds a type’s name and any other a value’s qualified name; a constructor is an ordinary record type at every name slot; members is derived and never written. kind_type, ref_type and core’s kind are gone; type_kind and identifier_kind are meta.type_ref and meta.identifier_ref. (Part 2 §4.1, §4.2, §5.12, §7.4, §8.1; meta.)
• #12 — an application is a reference value. The type_ref and type_argument records are gone; alias.target, type_chain.parents and meta.application are typed meta.type_ref; an open application is written unquoted in resolved output, !meta.alias { target: pair<uuid B> }; identity is the parsed form. (Part 2 §4.2, §5.10, §8.1, §8.2; meta, fixtures.)
• #13 — a reference in data is grammar. core-value gains reference = qualified-name "<" ws type-args ws ">", < adjacent to the name; a quoted token is never a reference; a schemaless read keeps an application as a structured value. (Part 1 §4, §7.2.5, §7.4, §7.5; Part 2 §12.1, §12.3; Part 3 §5.6.)
• #14 — every !schema value declares, from the root. geo => !schema { … } is a schema map nested as an entry whose members are entries named by path, geo.address; every name resolves from the root; a map of one path declared by several documents is the union of their members; a tag is "!" qualified-name; synthetics mint at the root. (Part 1 §4, §7.4; Part 2 §2.2.3, §4.1, §5.12, §12.1; all artifacts.)
• #15 — the roots hold the common vocabulary. The kernel’s root: void, boolean, integer, int64, text, bytes, iri, iri_reference, regex, doc, enum, set and schema; its machinery under meta, atom, numeric, unicode, net and binary. numeric.tn, temporal.tn and net.tn each declare their instances at the root and their constructors under a map of their own name; core.tn declares the author annotations; policy.tn declares policy. An annotation name is a qualified name (@atom.ordering:TOTAL, @meta.disjoint). (Part 1 §3.1, §5.5, §5.6, §7.4; Part 2 §3.4, §4.1, §9, §13.2; all artifacts.)
• #16 — a count is a fixed 64-bit range. int64 at the kernel’s root, numeric.count => !int64 ^ { min: 0 } typing every count facet; integer_type.multiple_of and integer_size.bits are integer, positive by coherence; policy.limit => !int64 ^ { min: 1 }. (Part 1 §9.1; Part 2 §5.3, §5.10, §5.11, §9, §11.5, §13.2; meta, numeric, policy.)
• #17 — a facet is typed by its family’s instance. decimal_type’s bounds, step and members are number; float_type’s bounds are number; rational_type’s are rational; each temporal constructor’s are its own instance; the network lists are [cidr4] and [cidr6]. Nothing in the libraries names meta.value. (Part 2 §4.2, §5.2, §5.5, §7.4, §13.2; numeric, temporal, net.)
• #18 — a restated field’s type narrows by IS-A. (Part 2 §5.7, §5.8.)
• #19 — a record template is its own constructor. meta.record is closed; meta.record_template carries parameters: [meta.template_param; 1..] and fields: meta.record_template_field_map, whose fields label a whole parameter as type_param or value_param; a literal value needs a closed type; a parameter may not be spelled like a name written among an absorbed field type’s arguments. (Part 2 §1.3, §4.2, §5.7, §5.8, §5.10, §8.1, §13.2; meta.)
• #21 — dependent fields. kind! is a sibling reference, data grammar and schema grammar alike; meta.reference_type carries allow_sibling; meta.field_type_ref types a record field’s type; record_field.value?: type!. (Part 1 §2.5, §4, §7.2.5, §7.4, §7.5; Part 2 §4.2, §5.2, §5.7, §5.8, §5.11, §5.12, §8.1, §12; Part 3 §5.6, §6.1.6; meta.)

The artifacts also carry housekeeping the register did not raise, adopted here on the same footing:

• uuid, uri, uri_reference and email, with uuid_type, uri_type and email_type, are net.tn’s (net.uuid_type, net.uri_type, net.email_type), not core’s; iri_type stays the kernel’s, as net.iri_type, with net.scheme_set and net.scheme_name beside it. Part 1 §5.5’s library column follows.
• The kernel’s iri refines its iri_reference (iri => !iri_reference ^ { allow_relative: false }), so iri IS-A iri_reference as uri IS-A uri_reference.
• The classifying annotations are atom.ordering, atom.bounded, atom.exact and atom.numeric; meta.disjoint, meta.synthetic and meta.application are the kernel’s; the author annotations deprecated, title, comment, examples, read_only and write_only are core’s; doc is the kernel’s root.
• meta.declared carries no classifying annotations, being no atom.
• The resolved fixtures’ conventions note is rewritten for the new shape: a map nested and tagged !meta.schema, a record template as !meta.record_template, an application written unquoted, type_param/value_param, @meta.synthetic and @meta.application.
• policy.tn’s record of the token policy is named policy.script_policy, its field on policy.processor token_policy. Part 1 §8.2 keeps “token policy” as the policy’s name; the record’s name stands as received. [editorial]

2. Disposition summary

Counts: 24 accepted (1–24 — #2 closed by #7; #12, #13, #14, #15, #19 and #21 carry open remainders), 0 declined, and 17 open questions carried (#12’s one, #13’s one, #14’s three, #15’s four, #19’s one, #21’s seven), plus the open remainders of Revision 35’s #25 and Revision 37’s Part 3 ordered-map confirmation (§5). Revision 38’s open remainder on kind_type.of — the higher kind the series lacked — is closed by #11: meta.reference_type.of is typed meta.type_ref, a constructor being an ordinary record type, and the admitted set is derived. Revision 38’s three considered-and-not-taken items (an identity atom, allow_zone, uri_template) stand recorded. Open questions are recorded here and are NOT reflected as open text in the specification.

3. Accepted changes by target document

3.1 Part 1 — Text Data Format

1. §1.1, §1.3 — the series architecture: one directive, a chain of imports grounded in the pre-loaded kernel, a document a schema by its root’s tag; the lexer-freeze paragraph records that Revision 39 leaves the lexer alone and names the four data-grammar positions it changes (#6, #8, #13, #21).
2. §1.5 — a Class 1 processor recognises a schema document by its root’s !schema tag, past the root’s leading annotations, and rejects it with the categorised diagnostic; “preserve schema directives” becomes “preserve the header’s !!imports”; a reference with arguments and a sibling reference are kept as structured values (#8, #13, #21).
3. §2.1 — the example’s header is !!id and !!import, its shipping field loses its !!schema, and the walk-through follows (#6, #8).
4. §2.2 — the header is [id-directive] *(import-directive); kind dispatch reads the header, the root’s leading annotations and its tag; a pure-metadata document stands as before (#8).
5. §2.2.1 — the references the canonical-identity rule covers are !!import, a schema library’s keys and the TSON-Schema field (#8).
6. §2.3 — one value rule, data-value; the table’s “scoped values” column goes (#6).
7. §2.4 — after “consulted exactly once”: at a disjoint choice that consultation selects the variant, so the form an emitter chooses there is its tag, with a pointer to [TSON-SCHEMA] §5.4’s emitter sentence (#3).
8. §2.5 — the directive sentence goes (#6); a record’s field order is insignificant except that a dependent field’s free sibling is written before it (#21).
9. §2.6, §2.7 — the directive sentences go (#6).
10. §3 — directives stand in the header alone; the augmentation intro follows (#6).
11. §3.1 — annotation = "@" qualified-name [ ":" data-value ]; a dotted name resolves from the root under a schema and is kept as written schemaless; an empty segment is a parse error (#15).
12. §3.2 — type-ref = "!" qualified-name, no arguments; a type annotation names a member of a nested map by its path; the “type expression syntax is not available in data values” paragraph is restated: an argument list is data grammar at a reference value and never on a tag (#13, #14).
13. §3.3 — the closed positional set is id then import; the table has two rows; !!meta and !!schema are parse errors naming !!import (#6, #8).
14. §4, §4.1, §4.4 — a schemaless read keeps a reference with arguments, a dotted tag and a sibling reference as structured values, resolving nothing (#13, #14, #21).
15. §5.1, §5.5, §5.6 — the library column names the kernel (meta.tn) for !void, !boolean, !text, !bytes, !regex, !iri, !iri_reference, !integer and !int64; numeric for !number, !rational, !complex, the other widths and the floats; temporal for the five temporal rows; net for !uuid, !uri, !uri_reference, !email and the network rows; “a schema that imports core alone” sentences are rewritten for the four-library layout (#15).
16. §6 — the JSON reader’s binding is $import (#8).
17. §7.1 — classification reads the header, the root’s leading annotations and its tag; the identifier profile’s . sentence cites the qualified name; the media-type paragraph compares the field with !!import (#8, #14).
18. §7.2.5 — < and > join ! and @ as the characters with a grammar role in data values, the other eleven reserved; ! keeps its prefix role and gains a postfix one (#13, #21).
19. §7.4 — document = [id-directive ws] *(import-directive ws) data-value ws; scoped-value goes; core-value gains reference; reference, sibling-ref, type-args, type-arg and qualified-name as the register writes them; type-ref = "!" qualified-name; annotation = "@" qualified-name […] (#6, #8, #13, #14, #15, #21).
20. §7.5 — two rows: < (reference arguments) adjacent to the preceding unquoted token, whitespace free inside the list, >> two tokens; ! (suffix, sibling reference) adjacent to the preceding token and followed by whitespace (#13, #21).
21. §7.7 — the separator sentence cites §5.12’s qualified name as the kernel’s grammar reads it; the kernel’s profile entry is meta.identifier (#14, #15).
22. §8.1 — the parse errors gain a directive outside the header, !!meta/!!schema, < with whitespace before it, an unclosed argument list and a sibling reference not followed by whitespace; the schema-document diagnostic names the root’s tag (#6, #8, #13, #21).
23. §8.2 — the policy document is a data document of policy.processor; the token policy’s record is policy.script_policy (#16, #15).
24. §9.1 — the foreign-schemas row goes; a limit is a positive int64, a processor holding one in a narrower type capping it (#6, #16).
25. §9.3 — the one directive that selects a vocabulary is !!import (#8).
26. §10.2 — series references at /2026/39/.

3.2 Part 2 — Type System and Schema

1. §1 — the schema grammar imports the data grammar’s core-value, a reference with arguments now among its values; the “every rung” sentence is rewritten for the import chain (#8, #13).
2. §1.2 — principle 1 reads over !!import; “type reference (!name)” reads “tag” (#8, #22).
3. §1.3 — a Class 2 processor pre-loads the kernel alone and SHOULD pre-load the libraries; resolves every name in the schema’s one namespace; recognises a record template by its constructor; a resolved-output consumer never meets a !meta.template or a !meta.record_template at a closed position (#7, #15, #19).
4. §1.4 — terminology: a schema document is one whose root is tagged !schema; a schema value is a value of meta.schema; “kind” is the set a reference over a constructor admits; “namespace” is a schema’s one namespace and meta.namespace the map constructor; the meta-schema entry goes (#7, #8, #9, #11).
5. §1.5 — eleven companion artifacts: six normative, five fixtures (#15).
6. §1.6 — the example’s header and root tag; !!import on the data document (#8).
7. §2.1 — a schema document’s structure: [!!id] *!!import, annotations, !schema, the map; the !schema tag names the kernel’s root schema and classifies the document (#8, #15).
8. §2.2 — two operations; §2.2.2 retired (its number kept, marked so) (#7, #8).
9. §2.2.3 — imports for every document, every target a schema document; the level rule goes; an entry’s identity is its declaring document and its path, a synthetic’s its form; a map of one path declared by several documents is the union of its members; two pins of one identity refused; “imports populate only the type-name namespace” goes (#7, #8, #14).
10. §3 — rewritten around one namespace: §3.1 the chain of imports grounded in the kernel; §3.2 schema-value separation restated over !!import; §3.3 one namespace; §3.3.1 the constructor-role applicability rule and the desugar targets (meta.record, meta.array, meta.map, meta.tuple, meta.choice, meta.alias) resolved in that namespace, an alias of a constructor applied as its target in a held body as anywhere; §3.3.2 lookup order (parameters, locals, the closure); §3.3.3 an annotation resolves in the annotating document’s namespace; §3.3.4 a data document’s namespace is its imports’ closure; §3.3.5 retired (#7, #15).
11. §3.4 — the kernel, meta.tn, pre-loaded, header !!id alone, its one wait cycle the pre-loaded set; §3.4.1 Pass 2 in rule 1’s order, rule 5 replacing the forward-reference sentence, closure collection following !!import alone (#4, #8, #15).
12. §4.1 — rewritten: meta.top, meta.type, the three base kinds, meta.alias and meta.template under top, meta.namespace a refinement of meta.map; an entry a type exactly when its value is built by a constructor IS-A type, otherwise a value; a constructor an ordinary record type; “nothing in it lifting or minting” of every namespace type but schema; the kind derivation (#9, #10, #11, #14).
13. §4.2 — rewritten: meta.reference_type with of and allow_sibling, meta.ref, meta.field_type_ref, meta.type_ref, meta.identifier_ref; the atom with no vocabulary is meta.void_type alone; meta.identifier and its three aliases (#11, #12, #17, #21).
14. §4.3 — the operations table: refinement generalised to any value under its type’s rules; “alias chain” (#5, #10).
15. §5.2 — the dependent field: the sibling reference at a record field’s type, the position rule, the sibling’s rules, the declaration-order rule and the reading; the eager-resolution paragraph without the value-typed default; field_map keyed by text, two keys one value under the name type a resolver error; name_type a meta.identifier_ref; the default meta.identifier (#9, #17, #21).
16. §5.3 — a count facet admits any numeric.count, a bound past what a processor’s values reach met or never reached; set<T> the kernel’s root set; the desugar targets by path (#15, #16).
17. §5.4 — the emitter sentence for a disjoint choice; meta.declared classless; a reference string-class (#3, #6, #11).
18. §5.5 — !C { … } is an instance of C, a type where C IS-A meta.type; atom refinement one case of value refinement; construction creates peers; the family-by-family value-space clauses with the facets typed by their families (#5, #17, #22).
19. §5.6 — the end state over meta.record, meta.record_template, meta.template, meta.alias and a namespace value; the positional form’s bare-token rule restated over meta.ref<T>; an application sugar is data grammar (#9, #12, #13, #19).
20. §5.7 — ^ refines a value under its type’s rules, a type stating none refused; a restated field’s type IS-A the inherited one or void at a voidable position; “ordered” for “totally ordered”, a bound excluding NaN, infinities judged; the constructor-refinement exception goes; a restated dependent field only as itself; open modifiers over value_param (#5, #9, #18, #19, #21, #23).
21. §5.8 — a tightening entry under §5.7’s IS-A rule; a declared application of a template whose parent is an application IS-A that template too; <T> T & { … } left to the shadowing rule; a sibling as a discriminator (#18, #19, #20, #21).
22. §5.9 — rule 8 reads over one namespace (#7).
23. §5.10 — rewritten in its template-forms, held-bodies, parameter-type, form and family-base paragraphs: a record template is a meta.record_template, its fields labelled; the three places a parameter stands; a literal value needs a closed type; the absorbed-argument refusal; a value parameter’s type resolved in the schema’s one namespace, held to the uses it derives; a template whose body applies another takes that template’s form and an alias is never a form; an argument a reference or a token by the grammar; type_param/value_param closing to type/value (#2, #7, #12, #13, #19, #22).
24. §5.10.1 — the cycle sentence cites §3.4.1’s rule 4 (#4).
25. §5.11 — integer_type.multiple_of is integer; a member may be a sibling (#16, #21).
26. New §5.12 rewritten — Values by name — the first segment names an entry of the root namespace, a further segment a member of a !schema map, a key of a namespace value or a field of a record value; a dependent field’s type is the type its sibling names in the same value; the rule reaches a data document; a type entry admits no further segment (#11, #14, #21).
27. §6 — annotations resolve in the annotating document’s namespace; the kernel’s meta.annotation is void’s alias and annotates nothing, the “one exception is structural” sentence going; the author annotations are core’s, the classifying ones atom.*, meta.disjoint checked, meta.synthetic and meta.application derived; @meta.application’s value an application as written (#4, #7, #12, #15).
28. §7.1 — a data document’s !!imports bind it, several in one namespace, the root naming its type; the scoped-value paragraphs go; the schemaless case cites the libraries by name (#6, #8, #15).
29. §7.2 — “after alias flattening of both”; a tag is a qualified name; resolver output admitted at schema’s declared-typed values by every entry’s tag (#9, #10, #14).
30. §7.4 — enum the kernel’s root, meta.enum_type the constructor, name_type a meta.identifier_ref; “Constraint fields typed as value” and the eager-conversion paragraph go; unicode.identifier_type and the profile by path; a position typed by a reference over a constructor judged by membership in a data document (#9, #11, #15, #17).
31. §7.5 — scoped.scope leaves the list of set-typed positions (#6).
32. §7.7 — unchanged in substance; “alias chain” (#10).
33. §7.8 — reduces to declared: meta.declared_type, meta.declared, the LOCAL rule, a tag naming no type of the closure a resolver error; the table, the cell rule, the push, the typed-position restriction and the schemaless-document paragraph go (#6).
34. §8.1 — rewritten: an entry is its value, a type or a value by its tag; a type’s chain with parents, supertypes and subtypes typed meta.type_ref; open entries !meta.record_template and !meta.template; the kind derivation with ALIAS; the meta.alias, meta.record_field (type: meta.field_type_ref, value?: type!), meta.record_template_field and meta.field_map records; the derived indexes subtypes and disjoint, members gone; a resolved form’s header its source’s and nothing supplied at ingest; the ingest checks; the body-patterns table (#8, #9, #10, #11, #12, #14, #17, #19, #21).
35. §8.2 — a refinement source among the trigger positions; identity the parsed form of a reference, its arguments past alias chains; the bytes/structure sentence; @meta.application on every entry that closes an application, nested arguments unreduced (#1, #12, #24).
36. §8.3 — Aliases — !meta.alias { target: T }, an open target the application as written; “an alias is a hop, not a rewrite”; the instantiation and alias-template sentences (#10, #12).
37. §9 — rewritten: the six bundled documents, the placement table and its convention, the kernel’s root and six maps, the libraries’ roots and maps, core as the bundle, policy; the family pairs by path; the extension guidance over meta.ref<T>, meta.declared and nested maps (#7, #11, #14, #15, #17).
38. §10.1 — the library’s keys and sources over !!import; a resolved form read as the caller’s choice under its own header (#8).
39. §10.2 — a reference to §8.2’s identity sentence; the kernel’s self-reference goes, the kernel pinned by the libraries alone (#8, #24).
40. §11.3 — !!import the one sensitive directive (#8).
41. §11.4 — each schema map a scope; a value entry’s keys and a qualified name’s segments as before (#14).
42. §11.5 — the alias-chain and wait-depth rows; limits as positive int64 (#4, #10, #16).
43. §12.1 — schema-document = [id-directive ws] *(import-directive ws) *(annotation ws) "!schema" ws schema-map; schema-map-entry admitting "!schema" ws schema-map; type-ref renamed type-expr at every use and type-ref kept for qualified-name ["<" type-args ">"], with sibling-ref; qualified-name at every reference position; atom-refinement’s head generalised; the instance comment naming meta.alias; definition-mark before parameters unchanged (#5, #8, #10, #13, #14, #21, #22).
44. §12.2 — the dispatch summary follows: !schema at the root, a nested map’s tag, < and ! after a name (#8, #13, #14, #21).
45. §12.3 — the < and ! (suffix) rows (#13, #21).
46. §13.1 — unchanged but for meta.identifier’s UAX #31 citation; §13.2 carries the six normative artifacts with the pins as received and §13.3 the five fixtures (#15).

3.3 Companion artifacts

The revised artifacts shipped with this revision carry the baseline of §1 and every kernel-, library- and policy-level change in this log. Their entries are not edited by this adjudication; §6 lists the doc lines that disagree with the text and are left as received, with the pins they would move.

3.4 Part 3 — JSON Encoding

[TSON-JSON] is edited directly as findings arise, and arrived with the Part 3 halves of seven entries already in place: #6 (§1.6 item 14, §1.7, §5.7, §8.3, §8.3.1, §8.5, §9.4, §10.1), #8 (§1.3 principle 3, §1.6 item 20, §1.7, §2, §3.2–§3.5, §4.1, §6.4, §9.2, §9.4, §10.4), #11 and #12 (§1.6 item 16, §5’s table, §5.6), #13 (§5.6), #14 (§3.3’s $type as a qualified name) and #21 (§5.6’s sibling string, §6.1.6’s dependent-member order). The second pass completes it for the rest, and §7.1 lists the edits. Part 3 defines no type-system rule, so each is a spelling of a rule §3.1 or §3.2 owns.

4. Notable normative changes (reader’s digest)

Changes a Revision 38 implementer must act on:

1. One directive. A header is [!!id] *!!import. !!meta and !!schema are gone, parse errors naming !!import; a !!schema on a field, entry or element is a parse error.
2. A schema document’s root is tagged !schema. The tag classifies the document and names the pre-loaded kernel’s root schema, whatever the document imports; classification reads the header, the root’s leading annotations and its tag.
3. One namespace per schema. A schema’s namespace is its own entries and its import closure, and every name resolves there: constructor heads, refinement sources, type positions, a reference’s of, annotations. There is no meta-schema, no placement rule, no import level, no structure namespace. Any schema may declare a constructor.
4. The kernel is meta.tn, one pre-loaded document, header !!id alone, importing nothing. Its root holds void, boolean, integer, int64, text, bytes, iri, iri_reference, regex, doc, enum, set and schema; everything else is named by path under meta, atom, numeric, unicode, net and binary.
5. Four libraries, one bundle. numeric.tn, temporal.tn and net.tn each import the kernel alone; core.tn imports the three and declares @deprecated, @title, @comment, @examples, @read_only and @write_only. uuid, uri, uri_reference and email are net.tn’s. A schema importing a library reserves its roots and map names.
6. Nested schema maps. geo => !schema { … } declares; its members are entries named geo.address; a map of one path declared by several documents is the union of their members; every name resolves from the root, with no lexical scope.
7. Qualified names everywhere a type is named: !geo.address { … } in data, @atom.ordering:TOTAL, "$type": "geo.address", meta.ref<meta.record>.
8. An entry is a type exactly when its value is built by a constructor IS-A meta.type; otherwise it is a value — orders => !api { … }, create_order => !operation { … } — marked by nothing but its tag. schema’s values are declared.
9. namespace is a refinement of map, a namespace type an instance of it; field_map is a plain ordered map keyed by text, and no qualified name selects a field declaration.
10. One reference atom. meta.reference_type { of allow_sibling? }, spelled meta.ref<T>: over a constructor it holds a type’s name, over any other type a value’s qualified name; a constructor is an ordinary record type at a name slot; kind_type, ref_type, core’s kind and the derived members are gone; type_kind and identifier_kind are meta.type_ref and meta.identifier_ref.
11. An application is a reference value, written unquoted in data (t: set<text>, target: pair<uuid B>), identity its parsed form; the type_ref and type_argument records are gone. A tag carries no arguments.
12. A record template is meta.record_template, its fields record_template_fields labelling a parameter as type_param or value_param; meta.record is closed. A literal value needs a closed type.
13. Dependent fields. value?: type! types a field by its sibling type’s value; a sibling is required, defaulted, pinned or a group member, never voidable; a free sibling is written before the dependent field.
14. value and value_type are gone. Every facet is typed by its family’s instance (decimal_type.min: number, date_type.min: date, ipv4_type.within: [cidr4]); a field’s default or pin is read against the field’s own type.
15. A count is numeric.count, 0 to 2⁶³−1; int64 is the kernel’s; integer_type.multiple_of and integer_size.bits are integer; a limit is a positive int64.
16. The scope push is gone. The open sum is meta.declared, admitting every type of the governing closure by its tag; scoped, extern, dynamic, extern_of and extern_type are gone, and so is the foreign-schemas limit.
17. Resolution within a schema runs in wait order, source order never consulted; a wait cycle is a resolver error; max_wait_depth is a limit.
18. ! is an instance of the named type, and ^ refines any value under its type’s rules; a restated field’s type narrows by IS-A; a float’s bound excludes NaN and judges the infinities.
19. The alias body is !meta.alias { target: T }; “alias chain” replaces “reference chain”; max_alias_chain is the limit.
20. A refinement source is a trigger position, and a declared application of a template whose parent is an application IS-A that template too.
21. The emitter’s form at a disjoint choice is its tag: quote a text value whose content would resolve to another class.
22. Every bundled pin changes (§6), and the artifact set is six documents and five fixtures.

5. Open questions carried by this change log

Adjudicated 2026-11-08. The following remain deliberately open, or are the revision editor’s readings awaiting the spec author’s confirmation. They live in this change log only — the specification text carries no open questions.

Decisions taken 2026-11-08: #1 the register’s (a); #2 closed by #7; #3 the two sentences; #9 the exception gone; #20 the expansion rule; #22 the renames; #23 the proposal in full; #24 the sentence; every other entry as the register proposes and the artifacts build. Three more at the fourth pass (§9): #19’s closed-type literal is judged at the declaration; a sibling reference at a refinement source, a composition operand or a map key parses and the resolver refuses it, matching the code; a bounded float’s discrimination class is read off allow_nan and allow_infinity as written, whatever its bounds admit.

6. Artifact work

1. Received at Revision 39 — all eleven artifacts carry “2026 Revision 39 draft” and /2026/39/ identities, and each normative pin was checked against sha256 over the bytes past the !!id line of the copy received and matched: kernel (meta.tn) c9b069b6…, numeric 6e36be00…, temporal fb4ada8f…, net 371fc20c…, core 7cc227d2…, policy e9cb5b93… (§8). The chain is consistent — numeric, temporal, net and policy each pin the kernel; core pins the three libraries; the kernel pins nothing, importing nothing. Hash values remain non-normative; only the pin’s shape is. 1a. Re-stamped after the fourth pass (§9). numeric.tn’s float_type doc said its bounds “do not bound the special values”, against Part 2 §5.5 and §5.7 under #23; it now says they judge the infinities as ordered values and admit no NaN. Two pins move: numeric dfa66c5d…, core 4e8d9c43… (core’s import of numeric carrying the new digest); kernel, temporal, net and policy are unchanged, and Part 2 §13.2 carries the six rows. The three kernel doc lines in item 3 stand as received and would move every pin; they wait for the next kernel re-stamp.
2. The artifact set changes shape. meta-kernel.tn is gone, merged into meta.tn, the kernel; numeric.tn and temporal.tn are new; meta-kernel-resolved.tn is gone and numeric-resolved.tn and temporal-resolved.tn are new; policy.tn has no fixture.
3. Doc lines that disagree with the text, left as received (each would move the kernel’s pin and every pin above it, so they are recorded for the next re-stamp):
   • meta.tn’s unicode.identifier_type doc still says "." is reserved as a future identifier separator; Revision 38 made it the separator of a qualified name, and Revision 39 reads one at every reference position.
   • meta.tn’s meta.top doc says a constructor transitively IS-A a base kind “except alias and template, which compose with top directly”; meta.declared_type composes sum and is fine, but the doc does not say a namespace type is a map type under product, which §4.1 now does.
   • meta-resolved.tn’s conventions note says a slot that names a type “is typed meta.type_ref, the kind of the types” and calls the application production “data grammar ([TSON-DATA] §7.4)” — both right — but still describes supertypes as “every element a bare name” where type_chain types it meta.type_ref; a supertype is a name without arguments, which the doc of type_chain says and the note should.
   • numeric.tn’s header cites numeric.integer_type’s multiple_of among the steps under “one rule”; meta.tn types it integer, which is the rule (#16).
   • core-resolved.tn’s header says “Core’s entries are the author annotations, at its root” and nothing else — right, and the one fixture whose map count is zero.
4. Not verified, carried as notes: a resolved form is read under its source’s imports rather than over its own entries (#4, #15), so a library’s fixture holding instances of constructors its own source declares reads back only beside its source; #1’s order-independent closing, #20’s head edge and #23’s NaN and infinity rules are stated in the text and not running (§2); the annotation-in-an-imported-reader gap (#15) is this implementation’s.

7. Second pass: Part 3 and the Developer Guide

Both ship with Revision 39. Neither carries a decision that §2 does not record; where a sentence had to be written that no register entry dictates, it is marked [editorial] and is the spec author’s to confirm.

7.1 Part 3

tson-part3-json.md is the copy received, completed for what it had not yet consumed.

1. Header and status read Revision 39, “the fourth published revision of Part 3”, written against Revision 39 of [TSON-DATA] and [TSON-SCHEMA]; §11.2’s series references move to /2026/39/.
2. §1.6 — the opening sentence is rewritten (“items 15 to 19 are Revision 38’s, and items 20 to 22 Revision 39’s”); item 14 names meta.declared_type; item 16’s references and applications stand; item 20 stands; new item 21 — dependent fields (§5.6’s sibling string, §6.1.6’s member-order exception); new item 22 — qualified names (§3.3’s $type as a path, §5.6’s reference strings, $import as a list under #8). [editorial] — the numbering.
3. §2 — the example stands (!!import, !schema, $import as a one-element list); the walk-through’s “standing in for the header’s !!import and the root annotation” stands.
4. §3.5 — the example field stands as a one-element List, which RFC 9651 serialises as the single String; the sentence saying so was already in the received copy, and no edit was needed.
5. §5’s table — the two reference rows and the declared-position row stand; “kinds” stays the concept’s name (#22).
6. §6.1.6 — the dependent-member exception stands as received.
7. Cross-references. Every [TSON-SCHEMA] section Part 3 cites is checked against the renumbered Part 2 (§2.2.2 and §3.3.5 retired, numbers kept); §5.12, §7.8 and §8.1 keep their numbers and change their content, and the citing sentences are checked against the new content.

7.2 Developer Guide

tson-guide.md is realigned on the same two principles as before: it describes the design as it stands, and history lives in the change logs.

1. §1.1 — the chain, walked once: !!import on the data document, !schema on the schema, the kernel pre-loaded and importing nothing; “the kernel’s !!meta names itself” goes (#7, #8).
2. §1.3 — schemas as data under the new output shape: person => !meta.record { fields: { … } }, age => !numeric.integer_type { … }; “the meta layer is the sanctioned extension point” becomes “any schema declares constructors, under the names it reserves” (#7, #15).
3. §1.6 — three documents and eleven artifacts; the reading order (#15).
4. §2.3 — “! takes constructors only” becomes “! is an instance”: !C { … } is a value of C, and whether the line declares a type follows from C’s chain (#5).
5. §2.7 — a record template as meta.record_template with labelled fields; an application as a reference value; a refinement source as a trigger position; the head edge of an applied parent (#1, #12, #19, #20).
6. §2.8, §2.9, §2.10, §2.11 — !!import for !!schema; field_map keyed by text; name_type a meta.identifier_ref; the JSON-LD conversion by path (unicode. identifier_type) (#9, #11, #15).
7. §3.3, §3.4 — references are !!imports; the kernel pinned by the libraries, the self-reference gone; the publication discipline over the four-library chain (#8, #15).
8. §3.5 — the policy document is a policy.processor; “every naming position” by path (#15, #16).
9. §4 — “The Schema Ladder, Narratively” is rewritten as “One Namespace”: what schema-value separation still buys under !!import; why one namespace replaced one hop and import-what-you-expose; where annotations live (the annotating document’s namespace, so the asymmetry §4.4 explained is gone); why the kernel is one document and the roots hold the common vocabulary (#7, #15); the library principle restated over four libraries (#15).
10. §5 — the tour: construction as instantiation of a constructor; refinement of any value under its type’s rules; alias for reference; the three ways to name a type after another (#5, #10).
11. §6.1 — retitled “void, meta.identifier and the reference atom”; value gone (#11, #17, #21).
12. §6.2 — “Constraint fields typed as value” rewritten: a facet is typed by its family’s instance, the bootstrap ordering dissolved by one namespace and wait order (#4, #17).
13. §6.3 — a float’s bounds exclude NaN and judge the infinities (#23).
14. §6.4 — “Open sums” rewritten over meta.declared; the scope push’s history noted once; namespace as a refinement of map (#6, #9).
15. §6.7 — meta.tuple1 and meta.voidable_tuple1 the kernel’s (#15).
16. §6.8 — rewritten: one reference atom, applications as values, qualified names through nested maps, the meta-service example end to end under one namespace (#11, #12, #13, #14).
17. New §6.10 — “Dependent fields” — the sibling reference, the three ways a type is known, the ordering rule and its JSON cost, why reaching a type through a value is absent (#21).
18. §7’s worked example rewritten: !!import, !schema, flagged as a !meta.record_template with type_param and value_param, task’s fields by path, the synthetics under @meta.synthetic (#8, #12, #15, #19).
19. §8.1, §8.2 — the two identities with #24’s sentence; @meta.application as the application written; chain.supertypes typed meta.type_ref; the ALIAS kind (#10, #12, #24).
20. §8.3 — “alias chain” in diagnostics; a minted entry named by its application (#10, #12).
21. §9.2 — the library over !!import; a resolved form read as the caller’s choice; the policy document’s type (#8, #16).
22. New §9.5 — “Choosing libraries” — importing temporal.tn alone, numeric.tn and net.tn together, or core.tn; what each reserves (#15).

The Revision 33 guide candidates remain outstanding.

8. Third pass: verification

Run after the parts and the guide were revised, against the register and the eleven artifacts. The six normative pins were recomputed as sha256 over the bytes past each !!id line and match §13.2 (kernel c9b069b6…, numeric 6e36be00…, temporal fb4ada8f…, net 371fc20c…, core 7cc227d2…, policy e9cb5b93…), and the cross-pins agree: the four importers of the kernel carry c9b069b6…, and core carries the three library digests. The kernel’s root holds exactly the thirteen names Part 2 §9 lists and nests exactly the six maps (numeric, unicode, net, atom, meta, binary); the kernel fixture’s meta.top.subtypes holds meta.alias and meta.template and its meta.type.subtypes excludes them, with enum, binary.bytes_type, meta.namespace and meta.record_template in both, which is §4.1’s derivation; meta.namespace’s chain is [meta.map meta.product meta.top meta.type], meta.identifier_ref’s [meta.field_type_ref meta.type_ref], and numeric.count’s [int64 integer], each as §4.1, §4.2 and §9 state. Each of the 24 entries’ resolution items was found in the sections §3 names. No Revision 38 vocabulary remains in Parts 1 and 3; the eight lines in Part 2 and the thirteen in the guide that match the stale-vocabulary scan are each a sentence naming an earlier revision, or the ordinary map facet value_type. §2.2.2 and §3.3.5 are retired with their numbers kept, and §5.12, §7.8 and §8.1 keep their numbers. What the pass found, and what was done:

1. The received Part 3 already carried §3.5’s one-element-List sentence; §7.1 item 4’s [editorial] mark is withdrawn.
2. The guide’s §3.4 publication paragraph kept “core’s own !!meta carries meta’s digest” after the section splice; corrected to the four-library chain.
3. Part 1 §5.5’s library column names the kernel for !boolean, !text, !bytes, !regex, !iri, !iri_reference, !integer and !int64, net for !uuid, !uri, !uri_reference, !email and the network rows, matching the artifacts’ roots; the change log’s §1 housekeeping note on uuid, uri, uri_reference and email is confirmed against net.tn.
4. policy.tn’s policy.processor.token_policy is a policy.script_policy, as §1 and Part 1 §8.2 now say; the §5 naming row stands.
5. Part 2 §13.2’s two example pins (people.tn) are illustrative and unchanged.

9. Fourth pass: the implementation’s verification

Run by the implementer against the adjudicated text — six reviewers, each checking a group of entries against the revised text rather than this log, the main grammar errors and the §3.3.4 sentence re-checked by hand. All 24 entries were found delivered; what the pass raised was sixty defects in the revised text, folded into Parts 1, 2 and 3 in this pass. Three needed a decision, taken as follows: #19 — a literal under a closed field type in a record template is judged at the declaration, not when the template closes, the type being closed and the verdict unable to vary by application (Part 2 §5.10; a code change and a vector, and §5’s #21 remainder closes); #21/#22 — a sibling reference at a refinement source, a composition operand or a map key parses, as at every reference position, and the resolver refuses it naming the slot, which is what the code does and what §5.2 already said (§12.1’s refined-def, supertype-ref and map-key); #23 — a bounded float’s discrimination class is read off allow_nan and allow_infinity as written, whatever its bounds admit, a class being a fact of the declaration and the explicit narrowing the route Part 3 §5.4 already names (Part 2 §5.4, Part 3 §5.4). The errors fixed first: §12.1’s type-def and §12.2 still named type-ref after #22’s rename, so x => [int32], x => (a | b) and x => kind! did not parse; the document rule in Parts 1 and 2 had lost the leading whitespace Revision 38 allowed; Part 2 let !meta.schema classify a root where Part 1 and the code admit !schema alone; Part 1’s type-arg admitted a sibling reference against its own comment; §8.2’s identity paragraph reduced nested applications where §6, §8.1 and the kernel keep them as written; §3.3.1 called namespace types constructors and refused !integer 5 as a value entry, which §4.1 admits; four sentences let the kernel’s “map instances” be refined, against §5.7 (meta.namespace => meta.map ^ { … } is the record form over a constructor); and numeric.tn’s float_type doc contradicted #23, re-stamped in §6. The inconsistencies and wording items are applied as the review wrote them, among them: Part 1’s tag production renamed tag and its token production qualified-name-token, with an application production split out of reference; a resolved form called a schema document in canonical form rather than a data document; “governing” retired from Parts 1 and 3 outside §7.8’s own use; meta.record_template_field.type named beside meta.record_field.type as the two slots meta.field_type_ref types; the NAMESPACE kind dropped, a value entry taking no kind of its own; “kind” given both its senses in §1.4; chain.subtypes stated over the namespace of the schema being resolved; the collision rule’s exception for open maps stated in §2.2.3; and the Revision 38 “form” sentence in §5.10 replaced. One new code gap is recorded for the backlog beside the four §2 already lists: Part 2 §5.5 judges a float’s bounds against the value as written, before rounding, and the implementation compares the rounded double. The register opens against Revision 39 with that gap and with #1’s order-independent closing, #2’s alias refusal to go, #20’s head edge and #23’s NaN and infinity rules.