Phonetic, musical and specialist notation imports

Current execution results are recorded in the 2026-11-02 native validation report. That report supersedes earlier test-deferral notes below for its explicitly listed suites; untested variants and broader format conformance remain separate.

These native Rust readers belong to Standard (Lite) and are inherited by Pro. Core retains their syntax and catalog metadata; compiling a literal requires the Standard parser service. Each tag accepts ordinary quotes, raw triple quotes and angle blocks. Ordinary quotes process Grid escapes; use raw forms for X-SAMPA backslashes and fixed-column TLE records. Grid quotes support \n, \r and \t; they do not use JSON’s \f escape. Preserve a BRF form-feed byte literally in a raw payload when importing page boundaries.

Literal compilation produces native objects and arrays. Persisted constants do not need a parser; explicit PARSE_* function calls still do. The result is a structural import unless explicit transcription is described below, not a renderer, external tool invocation or promise of complete standards conformance. New profiles start at contract revision 1. The ipa, transliteration, abc, lilypond and tei contracts advance to revision 2 for the changes described below.

Explicit execution adapters connect LP/MPS to native solver reports, R formulas to MODEL.FIT, and annotation formats to Frame/Graph tables. Reading a literal alone remains descriptive.

Tag / function	Accepted input and native result	Boundary
ptb / PARSE_PTB	Penn Treebank bracketed trees, including a forest and unlabeled outer wrapper. Ordered roots, nodes, edges and tokens preserve labels, function tags, coindices, traces and UTF-8 spans. Bracket placeholders retain source spelling alongside decoded token text.	No tag-set ontology validation, grammatical analysis or probabilistic parsing. Preterminals contain exactly one token; constituents cannot mix children and bare tokens.
ipa / PARSE_IPA	A pinned IPA character inventory with segment/modifier/boundary tokens, optional /…/ or […], exact source and canonical X-SAMPA where representable.	Lexical inventory validation, not phonotactics, language identification or full IPA conformance. IPA uses Unicode NFD normalization (clusters capped at 1,024 UTF-8 bytes); decomposed or reordered tokens point to their complete authored cluster. Canonical inventory spellings such as ç retain their X-SAMPA encoding. Additional IPA-only symbols make xsampa null.
xsampa / PARSE_XSAMPA	Longest-token X-SAMPA decoding to IPA with original token spans.	Pinned mapping, not arbitrary phonetic escape conventions. Unknown tokens fail. Canonical output separates tokens with - where token concatenation could change meaning; authored spelling is retained separately.
roman / PARSE_ROMAN	Legacy chord lists retain their prior native shape. RomanText document profile v2 retains ordered metadata, measure/ending/variant identities, authored beat strings, key changes/ambiguity, copy ranges, pedals, bracket alterations and chained tonicizations. Source-only header, meter, minor-policy and chord completion/hover.	No pitches, durations, inherited harmony, copy expansion or reference resolution. This is descriptive import, not music21 score realization; native validation remains deferred.
nashville / PARSE_NASHVILLE	Degrees 1–7, accidentals, common major/minor/diminished/augmented/suspended symbols, extensions and slash-bass degrees.	A declared Grid textual profile of conventional symbols; no chart layout, rhythm diamonds, rehearsal marks or key inference.
figuredbass / PARSE_FIGUREDBASS	LilyPond-style figure payloads such as <6 4>2 <5 3>4 <_+>. Groups retain figures, duration denominators, dots and spans. Bare groups inherit the preceding duration and dots.	No executable LilyPond commands, continuo realization or engraving. Figures 1–99 or _, bounded modifiers, power-of-two durations 1–1024, at most three dots.
solfege / PARSE_SOLFEGE	Italian fixed-do note names (do re mi fa sol la si), LilyPond d/dd/b/bb accidentals, absolute octave marks, rests and inherited dotted durations.	Music-expression tokens only; no commands, movable-do inference or score renderer. Default octave is 3, default duration a quarter note.
jianpu / PARSE_JIANPU	Monophonic jianpu-ly tokens with explicit 1=tonic or 6=tonic, optional initial meter, numbered notes/rests, octave marks, duration letters, dots, extension dashes and initial KeepLength.	No chords, repeats, lyrics, layout commands or pitch realization. Default duration is a quarter note; KeepLength makes the duration denominator sticky. % starts a comment.
cif / PARSE_CIF	CIF 1.1 ASCII and header-selected CIF 2.0: ordered blocks, frames, scalar items and rectangular loops; original spellings and uncertainty lexemes; distinct unknown ? and inapplicable .. CIF 2 adds Unicode canonical caseless identities, nested lists/tables, triple quotes and text protocols.	DDL1/DDL2/DDLm declarations and authored imports are data. No implicit dictionary validation, import fetching, method execution, unit conversion or crystallographic calculations. See the CIF 2 contract below.
brf / PARSE_BRF	Six-dot Braille ASCII: uppercase ASCII space through underscore, LF/CRLF and form feed. Unicode braille cells retain dots, page/line/column and source spans.	Cell decoding only: no UEB/Nemeth translation or contraction expansion. Lowercase, tabs, Unicode braille input and lone CR fail. Positions are zero-based.
tle / PARSE_TLE	NORAD fixed-column two-line elements with optional name/0 name line. Validates 69-column ASCII lines, checksums, numeric satellite identity, fixed decimals and orbital ranges; preserves raw lines and decoded fields.	Numeric satellite IDs only; no Alpha-5, SGP4 propagation, SPICE or ephemeris retrieval. Epoch uses the NORAD 57-year pivot and preserves day zero (the preceding December 31). Blank exponent fields represent zero. Mean-motion derivative fields retain their published division factors in field names.
fsw / PARSE_FSW	Formal SignWriting in ASCII: optional sorting sequence, B/L/M/R sign boxes, coordinates, ordered spatial symbol keys and standalone punctuation.	Checks the 37,811 assigned ISWA 2010 fill/rotation combinations; does not infer sign meaning. SWU has a separate reader; no style/query extensions, fonts or rendering. Coordinates are 250–749.
dexpi / PARSE_DEXPI	Explicit DEXPI 1.3 / Proteus 4.1 PlantModel XML. Equipment, nozzles, piping systems/segments/components, instrumentation, attributes and drawings retain document order, containment and unique uppercase ID identities.	Also accepts the separate DEXPI 2.0.1 Model exchange profile described below; neither profile claims full metamodel validation. Required PlantInformation version/discipline/dimensionality metadata is checked. No inferred pipe connectivity, diagram geometry or symbol rendering.

syntax_tree = ptb"""(S (NP (NNP Zoë)) (VP (VBZ sings)))"""
pronunciation = ipa"[prʲɪvʲet]"
phonetic_ascii = xsampa"""pr_jIv_jet"""

harmonic_analysis = roman"I vi6 iiø65 V7/V | V7 I"
chord_chart = nashville"1 6m 4 5/7 | 1"
continuo_figures = figuredbass"<6 4>2 <5 3>4 <_+>"

See the complete example for the other readers, including a fixed-column orbital record. Source spelling and diagnostic spans are distinct from reconstructed or converted output. Formatting Grid source does not invoke these parsers or rewrite their payloads.

Existing readers extended

abc now reads all fifteen major and fifteen minor key signatures (minor tonic spelled with m). Explicit accidentals persist to the barline, following the pitch propagation default; a header %%propagate-accidentals not, octave or pitch selects the other supported rules. Mid-tune headers, other directives, modal/custom key signatures and ornament/repeat syntax fail explicitly. L: and K: remain required. The native score constructor derives measures from note durations; authored bar placement is not an engraving round-trip promise.

lilypond absolute monophonic blocks now inherit dotted durations correctly. Durations must be powers of two; empty blocks fail. Relative notation, Scheme, includes and general commands remain outside the profile. Neither music reader runs LilyPond or ABC software.

tei now exposes apparatus, readings, witnesses and apparatusReferences. References from wit, from, to and corresp retain their spelling. Local #id targets resolve within the document; wit targets must be witnesses. Dangling and external targets remain explicit unresolved records. No external resources are opened, and no editorial truth or complete TEI apparatus conformance is inferred.

Editor and resource behavior

The existing catalog supplies completion, hover, edition requirements and literal boundaries. Same-spelled functions and literal tags remain distinct completion choices, including ROMAN(...) and roman"...". PTB, IPA, X-SAMPA, harmonic symbols, figured bass, BRF, TLE FSW, CIF, solfège and jianpu have lexical grammars for raw triple/angle payloads; DEXPI uses XML. Ordinary quoted payloads keep Grid string highlighting. Semantic diagnostics require the host's injected Standard parser service. There is no new payload rename, graphical editing, phonetic keyboard, braille display or sign renderer.

Readers use the existing input, node, depth and result-size limits and cancellation checkpoints. Parsing and lexical allocation occur only on explicit parser calls or literal expansion. Registration is static; no discovery, I/O, worker or polling service is added. The common evaluator is unchanged. New catalog/table bytes and selected-parser allocation costs are not a claim of zero memory or latency cost. The local debug observer records 31 paired samples for thirteen fixtures, four scaling cases and ordinary compilation with/without the parser binding. It does not establish optimized production budgets or historical ordinary-path tax; the program ledger compares the retained ordinary-compilation anchor without replacing it.

Pinned data and external references

The phonetic conversion table is vendored from the MIT-licensed ipa-translate revision 9d845ae, with its license alongside it. Grid implements a longest-token scanner rather than that project's replacement algorithm. The mapping is a declared inventory, not certification against all revisions of the IPA chart.

Other source contracts are the Penn Treebank guidelines, LilyPond notation reference, CIF 1.1 syntax, jianpu-ly input convention, ABC standard, Braille ASCII assignments in liblouis 3.35.0, NORAD TLE format, TLE epoch and optional-field conventions, Formal SignWriting, TEI critical apparatus, and DEXPI 1.3 model metadata. These references explain the chosen subsets; none implies that the entire external standard is implemented.

Additional interchange profiles

Six more Standard (Lite) profiles use the same native literal, function, compiler and editor contracts. They perform no network reads or external execution.

Tag / function	Native interpretation	Explicit boundary
landxml / PARSE_LANDXML	LandXML 1.2 namespaced survey XML. Requires one Metric/Imperial unit declaration; checks finite North/East/[Elevation] coordinates, unique CgPoint and instrument IDs, numeric observations and local point/setup references. Raw records, CRS metadata and unresolved references survive.	Authored TIN and alignment projections are described below. No coordinate transformation, inferred CRS, curve realization or full XSD validation. Unresolved references produce no edges. Angles retain declared units; no DMS conversion.
omm / PARSE_OMM	CelesTrak GP JSON object or array with OMM keywords. Calendar epochs, elliptic element ranges and integer catalog identifiers are checked. raw, normalized fields and documented defaults remain separate.	GP JSON retains Earth/TEME/UTC/SGP4 defaults. Explicit CCSDS KVN/XML alternatives are described below; no defaults are invented for those messages. No propagation or leap seconds.
openpsa / PARSE_OPENPSA	Open-PSA MEF 2.0 fault/event trees with scoped components and retained instruction syntax. Typed events, ordered Boolean formulas, cardinality/arity validation, implicit basic events, top events and acyclic gate references. Constant house values, public parameters, stochastic expression trees, common-cause groups and substitutions remain native data.	Rejects duplicate declarations, missing/cyclic parameter references, ambiguous identities, external functions, consequence/reporting records and DTDs. No probability evaluation, sampling or expression type/domain certification. This strict profile rejects duplicate definitions rather than applying the broader MEF last-definition convention.
xmi / PARSE_XMI	UML structure, interaction and state-machine projection (contract revision 3). Resolves namespace-aware IDs and type QNames, selected concrete containment types, class/association and sequence-interaction tables, local links and explicit unresolved/external references.	Supports OMG UML 20131001/20161101 and Eclipse UML2 5.0 namespace spellings. Not complete UML/SysML metamodel validation, SACM support, diagram layout or behavior execution. External hrefs are never opened.
swu / PARSE_SWU	Sutton SignWriting Unicode structural encoding to native sign boxes, sequences and symbol keys, plus canonical FSW. Results and diagnostics refer to authored UTF-8 scalars.	Same structural and ISWA repertoire checks as FSW; no styles, query syntax, null symbols or rendering. SWU is its own encoding and is not a generic Unicode braille/sign-language decoder.
knitout / PARSE_KNITOUT	Knitout 2 headers, rail/carrier declarations, operation arity, finite rack/stitch values, needle beds and signed indices, carrier references, comments/source annotations and retained x-* extension instructions.	Strict version-2 profile with required carriers. Instruction import only: no machine execution, yarn/loop simulation, release-hook state validation or machine safety claim. Empty carrier sets are accepted for knitting operations.

XML profiles use existing DTD/entity protections and bounded document parsing. Raw angle blocks still end at their first matching closing tag. Use quotes or triple quotes for an unprefixed LandXML document: its </LandXML> would close the outer <landxml> literal. A namespace-prefixed XML root avoids that delimiter collision. No reader changes Grid delimiter semantics. The editor uses XML for LandXML/Open-PSA/XMI, encoding-aware lexical support for OMM, and dedicated lexical grammars for SWU and Knitout. Completion, hover, embedded boundaries and compiler errors use the shared catalog. Open-PSA public parameter navigation and unit completion are described below; LandXML local point editing is described in its profile. Neither capability implies unrestricted XML identity editing.

transliteration contract revision 3 adds russian-alalc-2012, identified by ala-lc:ru:2012. The native table follows the Library of Congress 2012 Russian letter table, including pre-1918 letters and combining ties. It normalizes NFC, preserves unlisted characters and does not infer language or apply another language's table. The fourteen existing ICU transforms retain their identities. Revision 4 adds Ukrainian 2011 (ukrainian-alalc-2011, ala-lc:uk:2011), bringing the selection to sixteen transforms. This does not certify other ALA-LC languages or contextual Pinyin/Hepburn conventions.

Source contracts: ALA-LC Russian 2012, LandXML ePlan mapping, CelesTrak GP guidance, Open-PSA fault-tree layer, OMG UML machine-readable model, Sutton SignWriting conversion contract, and Knitout format. Fixtures are newly authored minimal documents, except the SWU conversion example which is retained from the documented Sutton conversion example (MIT-licensed core project). Broader independently licensed conformance corpora remain work.

Open-PSA public parameters and expressions

Contract revision 2 adds the MEF 2.0 stochastic layer to the flat public fault-tree profile. parameters contains declaration IDs, units and expression roots; expressions contains ordered nodes with operators, argument IDs, attributes and payload-relative UTF-8 spans. parameterReferences resolves references to declarations. expressionEdges uses numeric XML node identities and remains separate from the event graph's string identities. Parameter and event names occupy separate namespaces, so both may be named pump.

Supported syntax includes Boolean, signed 64-bit integer and finite floating constants; parameter references; mission time; arithmetic, comparisons and Boolean operators; ite and switch; exponential, GLM, Weibull and periodic-test models; uniform, normal, lognormal, gamma and beta deviates; and histograms. case and bin are positional wrappers, not standalone expressions. Arity is checked, including periodic-test's 4/5/11 forms. Variadic arithmetic and Boolean operators require at least two operands. Each parameter requires one expression. Duplicate, missing and cyclic parameter references are errors. Forward references are supported. The unit vocabulary is bool, int, float, hours, hours-1, years, years-1, fit and demands.

Import preserves syntax without evaluating it. expressionSemanticsValidated is false: no inferred types, compatible-unit proof, derived probability-domain checks, histogram-bound ordering, random sampling or unit conversion is claimed. A basic event's probability is populated only for a direct numeric constant in 0..1; other expressions retain expressionRoot with null probability. External functions and consequence/reporting records remain unsupported. Revision 5 adds component/private identity resolution, and revision 6 adds event-tree syntax below. Revision 3 adds CCF group syntax below. Original XML records and attributes survive.

The editor retains XML highlighting and adds literal-local public parameter completion, definitions, references and hover, plus unit completion and operator arity help. Event names are never mistaken for parameter names. Duplicate, entity-spelled or DTD-bearing identities refuse navigation; component/private resolution is described under revision 5 below; parameter rename is unavailable. Help is source-only and never executes the expression. Compiler diagnostics use the shared literal source maps for ordinary quotes, triple quotes and angle blocks.

See the example and MEF stochastic-layer contract. The fixture is synthetic. Reader, native editor and compiler/runtime tests are authored but native validation is deferred; historical fault-tree results do not validate this increment. Source-only editor checks are recorded separately.

Open-PSA common-cause groups

Revision 3 imports root/fault-tree define-CCF-group declarations for beta-factor, MGL, alpha-factor and phi-factor. ccfGroups preserves model, member-node IDs, distribution root and factors; ccfMembers resolves event names and identifies implicit basic events. Shared expressions retain parameter links. Existing event formulas and probabilities remain unchanged; ccfExpanded is false.

Membership must be nonempty, unique within each group and basic-event compatible. For N members the factor counts are 1, N−1, N and N respectively. Explicit levels must be unique and within 1..N (2..N for MGL). Omitted levels remain null: no positional interpretation is invented. The profile accepts both a single factor and a factors container, but rejects empty factor sets. It preserves overlapping groups; it does not certify factor normalization, distribution domains, expansion or reliability results. Source records retain original spellings and order.

The editor supplies model choices and factor-level help. Parameter navigation also works inside group expressions; member-event navigation and rename remain unavailable. See the example and MEF CCF contract. Reader/editor/saved-LIR tests and the selected-cost observer are authored; native validation remains deferred.

Open-PSA substitutions

Revision 4 imports root/fault-tree define-substitution declarations into substitutions, substitutionFormulas and substitutionReferences. Numeric XML node IDs identify declarations; optional names remain null when absent. Type labels are open strings, including conventional delete-term, recovery-rule and exchange-event labels. They do not select executable behavior.

Each hypothesis is one Boolean formula over basic events. Arity/cardinality and declared event kinds are checked. Source omission represents an empty set; authored source sections must contain events. Targets are a nonempty event set or one Boolean constant. Duplicate named substitutions and duplicate source/target set members are rejected. Undeclared basic events remain explicit implicit events, shared with fault-tree and CCF references. Hypothesis operators and authored node order survive; no substitution is applied, cut set computed or graph rewritten. The result marks substitutionsApplied false. This profile does not prove logical consistency, substitution termination or applicability to a reliability analysis.

Editor type suggestions accept custom labels. Section help describes optional source and target forms. Boolean formula hover follows formula arities, distinct from stochastic expression arities. Event references remain separate from the parameter navigation index; event rename/navigation are not advertised.

See the example and MEF substitution grammar. Synthetic fixtures, native tests and a cost-observer case are authored. Native reader/editor/compiler/runtime validation remains deferred.

Open-PSA component and private identities

Revision 5 adds nested components and inherited public/private roles. Explicit roles override the enclosing component's role. Public event/parameter names stay global; private identities use full container paths. Event and parameter namespaces remain separate. References resolve public names, absolute paths such as FT.A.rate, and paths local to the current container such as A.rate inside FT. Bare private names resolve in their own container. The importer does not search arbitrary sibling/ancestor scopes. Competing interpretations are errors; it does not guess a shadowing priority. Unresolved qualified references are errors rather than new implicit events.

identityScopes records declaration names, canonical identities, paths, visibility, containers and authored/resolved references. Original records retain authored attribute values; working expression/event/CCF/substitution projections use resolved identities. Named containers and declaration paths must be unique; public names must be unique within their namespace. Inherited metadata attributes are retained through raw records and parent IDs, not flattened into effective attribute sets. The contract identity is now openpsa-mef-2.0-fault-tree-v1; the result profile is mef-2.0-fault-tree. Public-only data keeps its existing identity spellings.

The native importer and editor use one shared scope resolver. Parameter navigation supports private and qualified names; completion offers the shortest unambiguous public/local/full spelling. Ambiguous reference sites have no navigation target. DTD/entity-spelled identities and malformed scope declarations refuse indexing. Editor indexing remains bounded, including reference/candidate work; parameter rename and event navigation remain unavailable.

See the example and MEF name-resolution contract. Reader/editor/compiler/runtime cases and a scoped-cost case are authored but unrun; native validation remains deferred.

Open-PSA event-tree structure and instructions

Revision 6 imports event trees, local functional events, sequences, named branches, forks and custom path-state labels. eventTrees, eventTreeNodes and eventTreeEdges retain structure and reference links without enumerating paths. Each branch requires one terminal after its instructions. Duplicate states, missing targets, cross-tree local references, branch/rule/link/group cycles and conflicting initiating-event tree assignments are errors. Initiating groups may nest; declarations retain their resolved tree association and collected items. Consequence/reporting records remain outside this profile.

eventTreeInstructions preserves assignment directions, conditional/block order, collection, rule calls and tree links. Formula arguments use instructionFormulas and instructionReferences; stochastic arguments reuse expressions. Known assignment targets must have the correct kind. eventTreesExecuted is false: no traversal, probability collection, assignment, expansion or environment mutation runs. Functional tests outside a concrete tree (including model-wide rules) retain contextDependent references; caller-context validity, functional-event ordering along every path, terminal reachability and semantic state/type/domain checks are not certified.

Editor navigation/completion covers tree-local branches, sequences and functional events, plus model-wide tree/rule/initiating names. Assignment parameter targets share the parameter index. Direction/state suggestions and instruction help are source-only; custom states survive. Dynamic functional tests have no guessed target. Rename and fault-tree event navigation remain unavailable. The production adapter accepts openpsaEventTreeItem; its added transport test is synthetic.

The parser contract is now openpsa-mef-2.0-v1, with output profile mef-2.0-native-import. See the example and MEF event-tree grammar. Native reader/editor/compiler/runtime tests and the cost observer are authored, but their execution remains deferred. Source-only adapter/catalog checks are tracked separately.

Humdrum, citations, ephemerides and HNS-SiGML

Seven additional Standard (Lite)/Pro profiles share the native literal/function contract. These are external syntax readers with explicit bounds:

Tag / function	Native result and checks	Deliberate boundary
humdrum / PARSE_HUMDRUM	Ordered records, stable spines, split/add/join edges, exchange and termination; **kern absolute pitches/rests/chords and exact rational reciprocal durations, **solfa movable-do degrees with explicit tonic, **recip durations and **text. Joins require compatible interpretations and tonic contexts.	Other exclusive representations fail. Tandem interpretations and articulation marks are retained rather than performed. No time alignment, tie realization, engraving or playback. Durations accept up to 15 augmentation dots. 0, 00 and 000 encode two, four and eight whole notes. The extended 3%2 encodes two thirds of a whole note, and 3%2. encodes one whole note. Ratio components must be positive 32-bit integers. Durationless q grace notes cannot also carry a numeric duration in this profile.
ecli / PARSE_ECLI	One identifier per nonblank line; canonical ASCII uppercase, jurisdiction, court, year, ordinal and authored UTF-8 span. Checks the five components, court length 1–7 and ordinal length 1–25.	No national court registry or decision lookup. Lexical validity does not establish an existing decision.
usc / PARSE_USC	Single citations such as 5 U.S.C. 552(a)(1) (2024), with numeric title, textual section, ordered subsections and optional year. § is optional.	U.S.C. or USC spelling; numeric ranges require explicit §§ and preserve endpoints without expansion; no section lists, annotated code editions, case reporters or legal interpretation.
cfr / PARSE_CFR	Single citations such as 40 C.F.R. § 60.1(a) (2025); the period separates part and section within the preserved section identifier.	C.F.R. or CFR spelling; no ranges, whole-part references, amendment tracking or regulation lookup.
oem / PARSE_OEM	CCSDS OEM 2.0/3.0 KVN and unqualified XML headers, segments, metadata, ordered position/velocity samples, optional accelerations and six-row lower-triangular covariance records. Validates civil dates, interval endpoints, strictly increasing samples, finite coordinates, row dimensions and nonnegative covariance diagonals.	Calendar or ordinal epochs; leap seconds rejected. Time-system/frame names are preserved, not converted. No interpolation or propagation. Positive-semidefiniteness is explicitly unchecked. Total segment intervals may overlap; usable intervals cannot. Time system and object stay fixed across segments; state and covariance epochs must be ordered.
spice / PARSE_SPICE	KPL/PCK, LSK, SCLK, IK, FK, MK text-kernel assignments. Ordered authored assignments plus final variables after = replacement and += append; scalar/vector numbers, doubled-quote strings and raw @date tokens. Numeric/string mixtures fail.	ASCII data lines, at most 132 columns; no tabs, multiline strings or strings over 80 characters. @date is a preserved lexical token, not a validated or converted epoch. No binary kernels, string-continuation joining, kernel loading, coordinate evaluation or filesystem access.
sigml / PARSE_SIGML	Unnamespaced sigml containing hns_sign with a required gloss and exactly one nonempty hamnosys_manual. Validates placement, attributes, 216 published manual token names and balanced nested group markers. Retains sign-language/gloss-language and positive speed metadata.	HNS manual-token subset of SiGML 1.2. Nonmanual, gestural, player, avatar and animation forms fail. Token membership and group nesting are checked; HamNoSys phonetic sequence validity is explicitly unchecked. No external references or animation.

Humdrum, ECLI, USC, CFR, OEM and SPICE have dedicated lexical grammars; SiGML uses XML highlighting. Completion and hover describe the exact profile. As with other imports, ordinary quoted payloads remain Grid strings; raw triple quotes and angle blocks embed the payload grammar. Compiler diagnostics use the normal native parser service. XML structural diagnostics retain the shared XML reader's locations; semantic XML errors may refer to the payload start.

These readers implement the published Humdrum spine model, kern and solfa representations and the extended rhythm convention; ECLI identifiers; US Code citation structure and CFR citation structure; CCSDS 502.0-B-3 orbital messages; NAIF text kernels; and the UEA HNS-SiGML token vocabulary. The SiGML implementation contains the factual token identifiers, not a bundled DTD, external entity loader or full schema validator.

LandXML contract revision 4 retains the revision-2 projection of authored TIN Pnts and Faces as surfaces[].vertices and surfaces[].faces. Point IDs are unique positive integers within each surface, coordinates require elevation, and each face refers to three distinct existing vertices. Optional neighbor indices and visibility markers are checked. One point/face collection per TIN definition is supported. Grid surfaces, alignment realization, triangulation of source points, orientation/manifold checks and topology certification remain outside this profile. Units retain their authored meaning. The structural reference is the buildingSMART LandXML surface convention.

LandXML revision 4 adds parcels with ordered boundary segments, optional centers, authored area/volume, parent parcel identities and raw attributes. Names must be unique within a collection. parcelReferences resolves pclRef only when one parcel has that name; missing or ambiguous names stay explicit and produce no reference edge. Point and parcel identity spaces remain separate. Nested membership becomes parcelContains edges; reference cycles are preserved as references, never expanded recursively. VolumeGeom is retained by record identity, without solid reconstruction. Declared quantities remain in authored units, without computing area, closing rings, choosing winding or establishing legal validity. Generic XML records retain addresses and other metadata.

XML highlighting, local CgPoint completion/navigation and checked point rename also apply inside the bounded parcel/geometry vocabulary. Point rename leaves same-spelled parcel names and pclRef unchanged. Parcel-name navigation/rename and unknown extension vocabularies remain outside checked edits. The parcel example is synthetic and deliberately has an open boundary. Native reader/editor/runtime validation is deferred. The structural source is the NSW LandXML recipe, Parcel section; this bounded projection does not claim NSW or other jurisdictional conformance.

Raw angle literals still end at the first matching closing tag. A full SiGML document contains </sigml>, so use sigml"""…""" or an ordinary escaped quoted literal for that document. The same collision rule applies to LandXML and other XML roots matching their Grid tag. Editor grammar state never changes these compiler delimiter rules.

Orbital encoding variants and alignment geometry

The existing tags select the encoding from the payload: omm accepts GP JSON, CCSDS KVN and unqualified XML; oem accepts KVN and unqualified XML. The parser runs once during literal expansion, producing native values. Calling PARSE_OMM or PARSE_OEM explicitly parses the supplied string at runtime. OMM and OEM contracts are revision 2; LandXML is revision 4.

OMM/OEM editor assistance shares fields, units and time scales with the Rust readers. KVN completion replaces field names or scalar values; OEM suggestions follow header, metadata, sample and covariance sections. OMM 2.0 omits 3.0-only BTERM/AGOM choices. Within explicit OMM unit brackets or XML units attributes, completion offers the admitted unit without converting the number. GP JSON choices are record-local and preserve the EARTH/TEME/UTC/SGP4 profile defaults; unknown metadata is not interpreted. XML assistance covers existing scalar, version and unit values in recognized unqualified structure; paired element names are not rewritten.

Assistance runs without importing data or opening resources, including in an edition without the reader. Quoted, triple-quoted and angle literals use the existing source map. Comments, ambiguous/foreign XML, DTDs, entity-spelled XML values, duplicate JSON keys and oversized payloads refuse assistance. This is not schema validation, reference navigation, rename or payload formatting. Existing lexical highlighting is unchanged. Native editor/compiler/runtime cases are authored and unrun; no rendered QA is claimed. See the orbital example.

CCSDS messages require an explicit version 2.0 or 3.0, header, object, reference frame and time system. OMM KVN uses ordinary KEY = value lines without OEM's META_START delimiters. The XML profile requires omm/oem, the matching CCSDS_OMM_VERS/CCSDS_OEM_VERS id, header, body and segment containers. OMM accepts exactly one segment; OEM accepts ordered segments. Qualified XML, combined ndm containers, duplicate fields, foreign elements and DTD declarations are rejected. Schema locations remain inert; no document is fetched.

OMM retains explicit mean elements, spacecraft/TLE parameters, user-defined fields and optional 6×6 Cartesian covariance. It accepts exactly one positive mean motion or semi-major axis, elliptic eccentricity, bounded angles, calendar or ordinal epochs and exact integer identifiers. Optional covariance requires all 21 lower-triangle fields; diagonals must be nonnegative. No positive- semidefinite test, element-theory execution or propagation is performed. Numeric units must match the declared CCSDS units (for example deg, km, rev/day, km**3/s**2); units are not converted. The JSON branch alone retains the CelesTrak GP defaults. Both CCSDS encodings return elements, header, comments, version and encoding; raw lexical fields remain separate from normalized fields and user-defined data.

A present TLE parameter block requires BSTAR, MEAN_MOTION_DOT and MEAN_MOTION_DDOT; version 3 permits BTERM instead of BSTAR and AGOM instead of MEAN_MOTION_DDOT. Alternative pairs are mutually exclusive, and ELEMENT_SET_NO is limited to 0–9999. Omitting the entire optional block is distinct from authoring an incomplete block. The positive XML fixtures were also checked independently against the published SANA NDM/XML 3.0.0 schema; this fixture check does not make the native reader a general XSD validator.

OEM XML feeds the same segment/state/covariance validator as KVN. Position, velocity and acceleration fields accept their standard km-based units; unknown units fail. All three acceleration components must be present together. XML diagnostics and sample spans point into the original XML, including when Grid quoted literals escape the XML attribute quotes. Comments retain Unicode. Use triple-quoted or ordinary quoted literals for complete omm/oem XML messages: their closing root tags collide with the corresponding outer angle literal delimiter.

LandXML alignments retains ordered Line, Curve, Spiral and IrregularLine segments as parameters and control points. North/east/[elevation] order and source units are unchanged. Point references resolve to existing CgPoints; dangling alignment control points fail. Curves require positive radii and cw/ccw rotation. Spirals retain positive or INF endpoint radii and the authored standard spiral type. Irregular lines retain explicit 3D point lists. Station equations retain internal, back and ahead stations. Vertical ProfAlign records contain ordered PVI, ParaCurve, CircCurve or UnsymParaCurve entries; ProfSurf retains ordered station/elevation pairs. Native fields are accompanied by original XML records. geometryRealized and continuityCertified remain false: no tessellation, continuity adjustment, vertical curve evaluation, station inversion or transformation is implied. Profile endpoints must be PVIs and station sequences must increase. Unknown geometry kinds fail explicitly.

The orbital lexical grammar recognizes KVN fields/comments, XML tags/attributes, comments and CDATA, and GP JSON strings/numbers. LandXML uses the XML grammar. Completion and hover identify the contract without running a parser; diagnostics use the existing injected native service. No format-specific rename or visual geometry editor is advertised. Namespace-qualified orbital XML and full NDM containers remain explicit follow-up profiles, not accepted aliases.

References: CCSDS ODM 502.0-B-3, CCSDS XML 505.0-B-2, and buildingSMART LandXML alignments.

Chinese and WXF xiangqi moves

xiangqi contract revision 2 retains existing UCCI/ICCS coordinate moves and adds whitespace-separated four-symbol Chinese/WXF descriptors: 炮二平五, C2=5, H8+7, 前車进一, +R+1, R++1 and the WXF multi-pawn form 36=5. Traditional/simplified characters and Chinese, ASCII or fullwidth digits are accepted. = and . mean traverse; + and - mean advance and retreat. Front/rear selection is retained explicitly; middle and numbered selectors apply to pawns. Files are numbered from the moving player's perspective.

Each descriptor records piece, selection or source file, action, and a target file or distance. Source bytes and UTF-8 spans survive. boardResolved: false and legalityChecked: false mean no square, side-to-move, capture, legality or board position is invented. Game headers, move numbers, annotations and engine commands remain outside this movetext profile. Coordinate records retain their existing shape. Highlighting covers all accepted token families.

References: WXF 2018 rules, section 7 and XQBase computer notation conventions.

Dictionary declarations, text runs, explicit connectivity and tuplets

cif contract 2 accepts non-nested, explicitly closed save_name … save_ frames alongside CIF 1.1 data blocks. Frame and data-name identity is case-insensitive; duplicate frame names, empty/nested/unclosed frames and incomplete loops fail. Frame-local data names have their own scope. dictionary.definitions projects DDL1/DDL2 declarations into names, types, categories, mandatory codes, enumerations, units and paired parent/child links. Original items, unknown categories, lexemes and uncertainty spellings remain available. This is a dictionary declaration reader. Explicit VALIDATE_CIF(data, dictionary) performs the bounded validation described below. Implicit imports and methods remain outside the parser; explicit supplied-resource validation is described below; CIF 2 syntax and explicit DDLm validation are described below. The projection preserves mandatory/type codes as stated rather than converting them into stronger validation guarantees.

dexpi contract 2 retains DEXPI 1.3/Proteus 4.1 and adds connections, nodes and edges. A segment's explicit Connection endpoints retain FromID/ToID and zero-based FromNode/ToNode. A declared index into an existing owner's ConnectionPoints/Node list must be in range. Missing and dangling owner references remain unresolved; they produce no graph edge. Nodes include isolated identified entities. Graph edges are undirected connectivity: endpoint order does not establish fluid flow. Missing endpoints are not inferred. Contract 3 additionally accepts the distinct DEXPI 2.0.1 exchange model, described below.

tei contract 3 adds textExport.runs: ordered text, line/page/column breaks and gaps from TEI text content. Each run identifies its owning XML node and nearest editorial alternative (lem, rdg, orig, reg, sic, corr, abbr or expan). Mixed text before/after child elements keeps document order. This export does not silently concatenate alternatives into a reading edition, normalize whitespace or reconstruct glyphs. Contract 4 also supplies a native DOM for explicit editing and XML export, described below. Local target, ref, sameAs, next and prev pointers join the existing apparatus references. Unresolved/external pointers remain explicit. Full P5 schema/ODD validation is not claimed.

abc contract 3 adds triplets (3CDE and explicit ratios such as (5:4:5CDEFG and (3:2:2CD. A group scales the next r notes/rests by q/p; r defaults to p. Only triplets have an implicit q (2). Other groups require it explicitly. Nested, incomplete and overflowing groups fail. Durations enter the existing native score constructor; no second score evaluator is introduced. The selected written-repeat, ornament and simultaneous-voice additions are specified in specialist enhancements; full ABC/LilyPond conformance remains outside the profiles.

The existing tags provide completion, generated hover/help, native diagnostics and embedded highlighting. CIF save frames and ABC tuplets have lexical tokens; TEI/DEXPI continue using XML highlighting. Dictionary reference navigation remains unimplemented. XML navigation is described below; XML rename is not supported.

Primary contracts: IUCr DDL2, DEXPI 1.3, TEI P5, and ABC 2.1.

Maritime visual-hoist transcription

maritime contract 3 accepts the existing Grid record v1 JSON and a second, explicitly bounded surface: whitespace-separated uppercase visual hoists (A–Q, S–Z, plus NC, CB and BR). For example, maritime"A G P Z" returns hoists with code, individual flags in order, authored UTF-8 span and codebook concept identifiers. The fixed codebook is NGA Publication 102 (2020), selected visual signals. NC retains distress/immediate-assistance concepts, CB immediate assistance, and BR an urgent helicopter request. They are complete hoists, not separate letter instructions. The reader does not act on these messages. Fishing-ground and harbor alternatives remain conditional; the reader does not select an operating context. These are textual transcriptions of visual symbols, not a standardized interchange file container or an operational signaling system.

R, other multi-letter codes, numerical complements, procedure/radio signals, icebreaker exchanges and landing signals are outside this profile and fail explicitly. JSON record-local navigation and checked rename continue to apply only to the existing JSON carrier; visual hoists have no identifier definitions to rename. Both surfaces have embedded lexical highlighting and native diagnostics. Visual tokens also have bounded code completion and concept/context hover. The new two-letter assignments are in Chapter 2. The primary codebook is NGA Pub. 102, Chapter 1, page 21.

XML identifier navigation

The editor offers definition, references and occurrence highlighting inside individual LandXML, TEI and DEXPI literals. LandXML links pntRef to CgPoint name; TEI links local fragment pointers to xml:id (with witness typing for wit); DEXPI links Proteus Connection endpoints to ID, and 2.x ObjectReference.object / References.objects local fragments to Object.id. Namespace aliases are resolved, foreign namespace lookalikes ignored, and references never cross literals. Grid escapes and UTF-8 payload offsets map back to LSP UTF-16 positions.

This syntax-only index does not invoke native parsers or fetch schemas. It bounds payloads to 256 KiB, depth to 128 and total XML nodes/attributes to 25,000 per document index. Duplicate identities, DTDs and entity-spelled identity or reference attributes refuse navigation for that literal. Unresolved/external references provide no target. Local reference completion offers up to 128 identities within the same literal, replaces only the reference token, and restricts wit candidates to witnesses. Checked identity rename is available under the closed reference-completeness rules below; imported/named DEXPI path completion and cross-dictionary completion remain unsupported. The index is lazy per document revision; it adds no runtime resolve work or background service.

For XML roots whose name matches the Grid tag, prefer triple quotes. Inside an angle block, use an XML namespace prefix to keep the inner closing tag distinct, for example <landxml><l:LandXML xmlns:l="http://www.landxml.org/schema/LandXML-1.2">…</l:LandXML></landxml>. The prefix does not change the XML namespace. Existing Grid delimiter semantics are preserved.

DEXPI 2.0.1 exchange model and TEI DOM interoperation

dexpi contract 3 dispatches an unqualified Model root to the native DEXPI 2.0.1 exchange reader. Static structural rules are generated from the published DEXPI XML schema 1.0.0; that schema version differs from the specification version. The input root has no version attribute: the output names the pinned reader contract, not a version discovered from the document. PlantModel continues to select the legacy 1.3 profile.

The exchange reader retains packages, type/property declarations, imported-model URIs, instances, ordered compositions, scalar values and references. It checks required/allowed attributes, child ordering/cardinality, lexical scalar values, unique IDs/named declarations and declared import prefixes. String, Boolean, Integer, Double and DateTime values retain their lexical spelling. Integers outside native 64-bit JSON integer ranges remain text with exactIntegerAsText; INF, -INF and NaN also remain explicit text. Dates remain authored text; the bounded lexical validator supports 4–9 digit nonzero years.

objects, scalarValues, compositions, references, nodes and edges are native data. Use graph plant = GRAPH(dexpi"""...""") for the compiled graph: the existing constructor admits inline closed data. A named parsed-data binding is not yet a supported live graph source; compiling it as an immutable snapshot would incorrectly discard later overrides. Graph nodes include anonymous and isolated objects. IDs based on zero-based document positions are deterministic for identical input, not durable identities across document restructuring. Directed edges describe composition or explicit object references, not process flow. Dangling and imported references remain unresolved and do not create graph edges. Imported models are never fetched; metamodelValidated, importsResolved and connectivityInferred are false. Structural exchange validation does not check all imported Plant/Core classes, physical units or property-type constraints.

tei contract 4 adds dom, using Grid's existing native DOM structure with qualified element names, namespace declarations, attributes and ordered text. Existing DOM operations accept the TEI object directly:

source = tei"""<TEI xmlns="http://www.tei-c.org/ns/1.0"><text><body><p>Hello <hi>world</hi>.</p></body></text></TEI>"""
updated = DOM_SET_TEXT(source, "hi", "Grid & friends")
xml_text = TO_XML(updated)

The result is an XML DOM; it does not update the original TEI projection in place. Reparse xml_text explicitly when fresh TEI entity tables are needed. Export preserves text, namespace prefixes and XML escaping; it does not promise original bytes, attribute order, CDATA/entity spellings, comments, processing instructions or a schema-valid edited document. No witness choice, ODD lookup or external schema validation is implicit.

Primary contract: DEXPI 2.0.1 metamodel and exchange format.

TEI temporal alignment

TEI contract 5 adds timelines, timepoints and temporalReferences alongside its existing DOM and text/apparatus projections. Points preserve document order, absolute-time lexemes, interval strings (including unknown/regular values), inherited units/intervals and the source node for each inherited value. An omitted since uses the enclosing origin only when no absolute value is given. No timestamp arithmetic, timezone inference or media retrieval is performed.

Timelines require one or more direct when children; each when requires an identity and empty content. Local since targets must be other points in the same timeline; origin targets its own points or another timeline. Explicit start/end on TEI timed elements target points; global synch also permits other TEI identities. Unresolved/external/wrong-kind targets remain explicit records with resolved: false. This resolves identities, not time equations; cycles, temporal datatypes and full TEI schema conformance are not validated.

Completion filters temporal targets by kind/scope. Definition/reference lookup and checked rename share those constraints, and rename refuses unresolved or wrong-scope references. Native diagnostics retain payload locations through all literal delimiters. See the working model and the TEI definitions of timeline, when and timed attributes.

Explicit CIF dictionary validation

VALIDATE_CIF(data, dictionary) takes two already parsed cif objects in Standard (Lite) or Pro. It returns grid.cif-validation.v1: valid, complete, conformsToSupportedRules, checkedValues, diagnostics and unsupportedRules. valid is null when any dictionary rule or required lookup is unsupported; conformsToSupportedRules then describes only the checks actually performed. Diagnostics retain block/frame, item name and original payload byte spans. Imports are never fetched, dictionary methods never run, and declared units are metadata rather than conversions or dimensional proofs.

The implemented DDL1/DDL2 rules cover primitive character/numeric types, enumerations, DDL1 inclusive numeric ranges, DDL2 open ranges and explicit singletons, permitted uncertainty, loop placement, category/item requirements, aliases, composite keys and same-block parent links. Supplied DDL2 type constructs use the supported Rust regular-expression subset, anchored to the complete value. Unsupported constructs make the result incomplete. Type declarations are limited to 128, each pattern to 16 KiB, aggregate patterns to 256 KiB, and each compiled expression to 1 MiB. Exact decimal comparisons preserve uncertainty lexemes and support exponents from -1,000,000 to 1,000,000; larger syntactically valid exponents produce an incomplete result. Validation uses existing input/output limits, cancellation checkpoints and at most 10,000 findings. Identifiers are bounded to 75 printable ASCII bytes, composite keys to 128 fields, and semantic work to the context node budget (one million by default). unsupportedRulesTruncated records the 10,000-rule reporting cap. Implicit mandatory codes, imported dictionaries, methods and DDL1/DDL2 save-frame data validation are explicitly unsupported. DDLm uses the separate profile below.

DDL1 null definitions describe the dictionary itself; they are accepted in a supplied dictionary and rejected as data items. Both su and esd permit standard uncertainty, and an explicit none condition is supported. Omitted _list means no, as specified by DDL1; _list both permits scalar or looped values. Only loop level 1 applies to CIF 1.1. Other levels and sequence (seq) conditions remain incomplete rather than silently accepted.

Parent relationships can be declared on either side with _list_link_parent or _list_link_child; child values require matching parents in the same data block, without imposing parent uniqueness. _list_reference requires its names in the referring item's loop. _list_uniqueness checks the declaring item combined with the named fields; reference checks respect that explicit composite instead of imposing a conflicting singleton key. The published PUBL_BODY shape therefore permits a section and a footnote with the same label, but rejects a repeated label/element pair. DDL1 alternatives and replacements are explicit, directed relationships. Required fields may be satisfied by a declared alternative in the same loop; references and scalar parent links can use a replacement when the canonical field is absent. Chains are followed with cycle detection. A present canonical field takes precedence. A replacement does not rewrite authored data: use of the replaced name returns CIF_DEPRECATED_ITEM with severity warning, and warnings alone do not make valid or conformsToSupportedRules false. convention and conversion describe relationships but do not perform value conversion or transfer required-field checks.

Trailing-underscore selectors expand to all matching non-dictionary-only fields. Every component of a compound alternative/key must be present, and key components must share the source loop. Group width is capped at 128 and relationship depth at 64; traversal consumes the semantic-work budget. Malformed relationship pairs fail explicitly. Unresolved names, over-depth chains, multiple applicable alternative key/parent selections and compound scalar-parent replacements make the result incomplete. No arbitrary field or conversion is selected. Direct related-item names retain literal-local editor navigation; compound selectors have no fabricated single definition target. Compound identifiers follow International Tables G, section 3.1.4.1. These rules also follow the DDL1 reference and its published validation examples.

DDL2 _item_range.minimum and _item_range.maximum are row-aligned pairs. Each pair denotes an open interval; equal endpoints admit that exact value, and multiple pairs form a union. An unquoted . is unbounded; quoted '.' remains a character value. ? makes the range incomplete. Character ranges use ASCII ordering, with case folding for uchar. Constraints over abstract types or another item's range remain unsupported. Reversed, unpaired or malformed bounds fail even if that item is absent from the data. Range bounds are compiled once per definition; range and enumeration comparisons consume the validation work budget. These semantics follow the DDL2 ITEM_RANGE contract.

The function borrows the native objects and validates their structure; it does not reparse source or trust the optional cached dictionary projection. It remains usable on saved LIR values after the literal parser binding is removed. Invalid native shapes and malformed supported dictionary declarations fail explicitly.

CIF editor assistance recognizes literal-local DDL1 _name and DDL2 _item.name definitions, both DDL1 parent/child declarations, _list_reference and _list_uniqueness, DDL2 category keys and _item_range.name associations. Definition, references, highlights, hover and up to 128 local name completions share the native CIF lexer. Duplicate identities, malformed loops and text-field identities refuse indexing. There is no dictionary execution, cross-literal lookup or checked rename.

Assigned SignWriting repertoire

FSW and SWU contract revision 2 validate every key in sorting sequences, spatial symbols and punctuation against the pinned ISWA 2010 repertoire: 652 bases and 37,811 assigned glyph combinations. Invalid combinations fail at the full FSW key or original SWU scalar span. Results include glyphsValidated: true and repertoire: "ISWA-2010"; those fields assert assignment, not rendering quality, linguistic validity or signing semantics. Existing compiled values retain their original metadata. New parser cache identities use revision 2.

FSW completion offers at most 96 assigned variants after a base such as S14d, replacing only that symbol key. FSW and SWU hover explain assignment, base, fill and rotation, including in escaped literals. Editor and parser use one immutable repertoire table; they load no fonts and access no network. Metadata provenance and the source font's SIL OFL notice are retained under rust/grid-format-core/data/iswa-2010.json and OFL-ISWA.txt.

SiGML manual-token authoring

Within an unnamespaced sigml/hns_sign/hamnosys_manual sequence, the editor completes partial ham... element names and explains known tokens on hover. Its 216-name vocabulary is shared with the native reader and comes from the published HNS SiGML DTD. Edits replace only the element name, preserving XML delimiters and authored Grid escapes across all three literal forms. A </sigml> XML root terminator also closes Grid's angle form: use quoted/triple literals, or legal XML closing-tag whitespace (</sigml >) inside the angle payload. Comments, CDATA, attributes, DTDs and foreign-namespace parent elements do not receive manual-token suggestions. Requests inspect at most 256 KiB of payload, 25,000 XML events/attributes and 128 parent levels. No parser execution, schema retrieval or animation occurs. The reader preserves group tables per sign: id, kind, zero-based inclusive startToken/endToken, and nullable parent. Sequence, parallel, fusion and alternative begin/end pairs must nest correctly, with at most 128 open groups. Unmatched, crossed and unclosed pairs report GRID_SIGML_GROUP at the authored token; a group cannot cross sign boundaries. groupingValidated is true, while phoneticSequenceValidated remains false. Empty balanced groups are retained; this structural check does not assert their phonetic validity. Token streams and existing attributes retain authored order. No motion is expanded or timed.

Completion offers a closing group marker only for the innermost open pair; hover explains the matching pair. Grouping context resets for each manual sign and malformed preceding group nesting suppresses suggestions. Ordinary tokens remain available; the editor does not guess handshape/orientation constraints. The UEA manual example provides an independent parallel-group fixture, with its nonmanual tier omitted explicitly. Hanke's description, section 2.5 explains movement grouping; this reader does not implement the complete phonetic grammar or avatar semantics. That work remains open. Navigation and rename are unsupported because these tokens are vocabulary symbols, not user-defined identities.

Checked XML identity edits

TEI xml:id, LandXML CgPoint.name, Proteus ID and DEXPI 2 Object.id can be renamed with their resolved local references in the same literal. TEI linking lists include copyOf, synch, exclude and select alongside the existing pointers; DEXPI 2 includes DataReference.data. DEXPI object names and named/imported paths are distinct from object IDs and are preserved when an ID changes.

Rename requires a recognized element/attribute vocabulary and complete local reference resolution. Unknown extensions, foreign elements, base-URI overrides, entity-spelled/encoded identities, extended pointers, duplicates, invalid witness targets or dangling references refuse the entire edit. TEI external pointers also refuse rename because the editor cannot establish whether they target this document. Navigation remains available where its narrower index is trustworthy. DEXPI 2's attribute and name/reference facts are shared with the native reader. TEI, LandXML and Proteus use the documented conservative vocabulary in the identity contract; this is reference-completeness checking, not full schema/metamodel validation.

New IDs are limited to 256 UTF-8 bytes. TEI uses XML NCNames; DEXPI 2 uses its ASCII exchange-name grammar. LandXML/Proteus accept the bounded unescaped name characters documented by the editor. Collisions in the same literal and edits that would exceed the 1 MiB source budget are rejected. Authored text, comments, other literals and named paths remain untouched. Ordinary, triple and angle literals use the compiler's existing Unicode/escape source mapping.

Monaco accepts the native-format symbol kinds returned by the Rust service, retains unavailable-rename reasons, and checks the exact occurrence set before applying one version-fenced workspace edit. Native identities do not use cached runtime-cell value hovers. This changes semantic editor behavior, without adding a visual layout, a parser in JavaScript or a second runtime evaluator.

CIF 2 and DDLm declaration reading

The exact initial #\#CIF_2.0 header (optionally preceded by a UTF-8 BOM) selects CIF 2 syntax. Other files retain the CIF 1.1 reader. Native parser contract revision 3 prevents reuse of earlier CIF expansion cache entries. Standard/Lite and Pro include this reader; Core edition allocation is unchanged.

CIF 2 permits Unicode names and applies canonical caseless matching to block, frame and data-name uniqueness. Authored spellings remain separate. Lists use kind: "list", items; tables use kind: "table", entries, retaining authored entry order, logical keys, raw keys, key spans and values. Compound values occupy one loop cell. Duplicate exact logical table keys are rejected; key case remains significant. No numeric precision or uncertainty is discarded.

Triple quotes do not process escapes. CR, LF and CRLF become logical LF inside values; rawText appears when text normalization changes the physical text. Semicolon fields implement prefixing and folding, including end-of-field fold separators, following CIF 2 sections 3 and 5. All spans remain byte offsets in the original payload. Lines are bounded to 2048 Unicode characters. Existing input, node, output and cancellation limits apply; compound nesting additionally has a hard maximum of 128 and respects the supplied depth budget. The final native-object depth budget can impose a lower practical nesting limit because objects and arrays each contribute a level.

DDLm definitions expose names, categories, types, containers, dimensions, aliases and import tables alongside all original fields. Imports are not resolved and methods are never executed. VALIDATE_CIF accepts supplied DDLm declarations over CIF 1.1 scalar or CIF 2 compound data. Parsing alone never validates data. The optional supplied-resource validation profile below composes Contents imports.

The source-only editor navigates Unicode DDLm item definitions and recognized scalar or flat-list references. Category definitions, method bodies and import tables cannot create item identities. Compound loop values preserve column alignment. Rename remains unsupported. Monaco recognizes CIF 2 triple strings, compound delimiters and table keys in raw embedded literals; ordinary quoted Grid literals retain Grid escape highlighting.

Five upstream COMCIFS CIF API fixtures are retained with exact Git blob identities and their LGPL notices. They exercise lists, tables, Unicode, triple quotes and text protocols. The 2015 upstream C expectation for a final folding backslash predates the normative 2016 rule; Grid's assertion follows the latter. These fixtures establish bounded interoperability, not complete CIF/DDLm conformance. No C parser or external executable is linked.

Explicit DDLm validation

VALIDATE_CIF(data, dictionary) now recognizes _definition.id declarations. It returns the same report with dictionaryLanguage: "DDLm". Each block and save frame is checked separately; links never borrow values from another scope. The input dictionary must contain the definitions needed for the data. This bounded declarative profile supports:

• Text, Word, Code, Name, Tag, Integer, Real, Dimension, Range, Symop, Date, DateTime, Uri and Version contents, using the declared defaults when attributes are absent.
• Single, List, Array, Matrix and Table containers; explicit list/array/matrix dimensions, including zero sizes. Nested lists without dimensions remain incomplete. Table keys support Text, Code, Date, Uri and Version syntax and retain case-sensitive identity.
• Whole-value enumeration states, optional enumeration enforcement, and exact inclusive numeric bounds. Table entry order does not affect enumeration comparison. Malformed enumeration states are rejected with the dictionary.
• Unicode canonical caseless item identities, aliases, Set/Loop placement, compound category keys, Key uniqueness and same-scope linked values.
• Exact Number-purpose values without uncertainty. Scalar and compound Real Measurand/SU definitions associate through the SU item's explicit _name.linked_item_id; no name suffix is inferred. Parenthesized and separately supplied uncertainty must agree exactly, including exponent and authored trailing-zero precision. SU values must be nonnegative and cannot themselves carry uncertainty. An integrated SU value is checked against its own definition's constraints. For aligned associations, columns share a loop and row alignment or are both scalar. Different explicitly declared Set categories may associate within the same scalar scope; no value is borrowed across blocks or save frames. Missing recommended uncertainty is a warning; a known SU without its measured value is an error. Matching List/Array/Matrix definitions pair elements by position; matching Table definitions pair case-sensitive keys independently of key order. Containers and declared dimensions must match. Effective integrated uncertainty trees inherit SU ranges and whole-container enumerations. Integrated leaves can fill unknown explicit SU positions before enumeration checks. Missing SU definitions, unresolved cross-category associations, uncertainty-aware measurand ranges and uncertain-value identity remain incomplete. See the working measurement example. Separate Loop categories can also associate through explicit _name.linked_item_id relationships covering a complete declared category key in either direction. Compound keys use their declared content types, including canonical caseless Code values and exact numeric identities. Both sides must match uniquely; row order is irrelevant. Missing counterparts retain missing/orphan diagnostics. Missing or ambiguous link plans, unresolved key values, and non-one-to-one correspondence remain incomplete. No multi-hop relation or positional join is inferred. Shared key correspondence is indexed once per scalar/frame scope and row layout; identity bytes and comparison work consume the operation limits. These distinctions follow the DDLm 4.1 purpose definitions.

Uri uses the existing pinned Rust fluent-uri parser for RFC 3986 reference syntax, including absolute, relative, fragment-only and empty references. Invalid escapes, authority syntax, raw Unicode IRIs and spaces fail. Validation neither fetches nor normalizes a resource. DateTime accepts RFC 3339 full dates and timestamps with T/t, seconds, optional fractional seconds and an explicit Z/z or numeric offset. Calendar dates, clock fields and offset ranges are checked. Reduced dates, offset-free times and hour 24 fail. A syntactically well-formed second 60 keeps the result incomplete because leap-second history has not been established; it is not certified as valid or rejected as an ordinary malformed timestamp. Offsets, precision and authored spelling are preserved, with lexical enumeration/key identity rather than instant or URI equivalence. Direct _type.indices choices follow DDLm's separate vocabulary: DateTime is not a direct index code. See the URI/date example, DDLm contents, RFC 3986 reference syntax and RFC 3339.

ByReference resolves _type.contents_referenced_id and Table _type.indices_referenced_id against supplied item definitions and aliases, including forward chains and explicitly composed imports. Resolution is memoized once per validation, with iterative traversal and the operation's work/cancellation limits. Missing targets, cycles or unsupported target types leave validation incomplete, even when no corresponding values occur. The referenced contents syntax applies to the receiving item's leaves; its own container, dimensions, purpose, range and enumeration still apply. These constraints are not copied from the target definition. Referenced Table keys can use a supported scalar syntax such as Integer or DateTime, but remain case-sensitive strings: '01', '1' and '+1' are distinct keys. Timestamp history and bounded-exponent limitations also apply to referenced keys. Inactive reference attributes do not change an explicitly declared direct type. See the referenced-type example and DDLm reference definition.

The DDLm 4.1 range definition permits reported values with associated SU to lie outside the declared inclusive range; that definition supplies no confidence threshold. Grid therefore reports these range checks as incomplete rather than inventing a Gaussian multiplier. Adding an explicit caller policy would be a separate validation contract, not an interpretation silently attached to imported dictionary declarations.

Implied contents/container declarations are supported for reference-dictionary attributes (_definition.class Attribute). For each supplied save-frame definition, contents come from that definition's _type.contents; container, shape and Table index rules come from its structure declarations. Omitted contents/container use DDLm defaults Text/Single; explicitly unknown declarations remain incomplete. Contents and container may independently be Implied. The receiving attribute keeps its own purpose, range and enumeration policy. Forward contents/index references and aliases resolve only inside the same supplied block, with memoized iterative traversal and existing work limits. Missing/cyclic references, recursive Implied contexts and conflicting identities are never inferred from the values. Attribute values in ordinary instance data remain invalid. The source-only editor offers Implied choices and context help. See the executable example and the DDLm container contract. This is selected attribute validation, not full reference-dictionary certification.

_dictionary_valid declarations now check attribute applicability in supplied Reference and Instance dictionaries. Dictionary addresses the data-block root; Category and Item address save frames using _definition.scope (Item when omitted). Template and Function dictionaries are excluded. Missing dictionary class uses the DDLm Instance default; explicit unknown classes/scopes remain incomplete. This does not fetch a dictionary or execute its methods.

Each _dictionary_valid.attributes list names attributes or categories. Attribute aliases resolve to the same identity; categories include attributes in descendant categories. Mandatory omissions are errors, Recommended omissions are warnings, and Prohibited occurrences are errors. Recommended is the default option. Presence is distinct from a known value: an authored ? satisfies a presence requirement, and still violates a prohibition. Ordinary type/value checks continue separately. The deprecated two-element _dictionary_valid.application declaration is accepted; conflicting current and legacy declarations fail. Columns must share rows, duplicate scope/option rows and Mandatory/Prohibited overlaps fail, and unknown selectors or scope codes remain incomplete. Category cycles fail within the existing work budget.

Reference Attribute purposes Audit and Identify are recognized. Source-only editor completion and hover cover applicability scope/option, dictionary class, definition scope and these purposes across the three literal delimiters. The applicability example uses a Grid-authored minimal schema, with provenance beside its fixtures; it is not the entire DDLm metamodel. Validation never inserts defaults into imported data or certifies unsupported methods, inherited rules or other unknown semantics.

Inherited types, IRI/complex contents, method execution, nested Loop-category semantics and unrecognized attributes remain explicitly unsupported. complete: false and valid: null prevent partial checks from claiming full conformance. This is instance validation, not certification of a dictionary against the complete DDLm reference dictionary. Dictionary authors can use local completion, navigation and Unicode reference highlighting without executing validation. Scalar _type.contents, _type.indices, _type.container, _type.purpose and _enumeration.mandatory values offer supported-profile choices and hover help when the literal contains a DDLm definition declaration. The editor replaces the authored value content, retaining its quotes. It tracks loop columns and excludes comments and method text; the missing default slot described below also accepts insertion. The Monaco adapter preserves these replacement ranges and enumeration kinds and discards obsolete responses.

CIF 2 identifiers allow up to 2,048 Unicode characters; compound validation uses the existing structural limits, at most 64 dimension axes, 128 key fields and the context's semantic-work budget. Comparison text also consumes one unit per 64 bytes, and canonical compound identities use a single size-bounded buffer. No ambient dictionary lookup occurs. The maintained tests include exact COMCIFS Core Dictionary save-frame excerpts under CC-BY-4.0, with provenance beside the fixture.

Static DDLm enumeration defaults

VALIDATE_CIF(data, dictionary) checks an item’s _enumeration.default against the same type, container, dimension, purpose, range and enumeration rules as an explicit value. This includes resolved ByReference types and whole compound enumeration members. An incompatible default makes the dictionary invalid even when the data supplies an acceptable value. DDLm 4.1 reference

For an omitted item, validation borrows the declared value when the authored data establishes its row count. A Set category supplies one scalar packet; a Loop category supplies one value per row of a single physical loop. Items without a category require an unambiguous scalar packet of known uncategorized items. An explicit item or alias takes precedence, including an authored ? or .. Defaults never create rows or alter the imported CIF value.

The report gives staticDefaults.declarations and staticDefaults.applied. When a value is inferred, staticDefaults.inferredValues counts the effective values used during validation. They participate in parent links, category keys and measurement checks. A diagnostic on a borrowed value identifies its span with spanSource: "defaultDeclaration". Absent or split packets, conflicting defaults, unresolved types and method-derived defaults leave inference incomplete. Working example

In a closed CIF 2 item save frame, the editor offers up to 128 short, single-line scalar states declared by _enumeration_set.state. At a scalar default, the edit replaces the entire token, preserving the selected state’s CIF quotes and Grid escapes. After _enumeration.default and horizontal whitespace at the end of a line, completion can insert a missing default. Compound states are checked by the validator but have no insertion suggestion.

Indexed DDLm enumeration defaults

VALIDATE_CIF can check omitted items using a dictionary lookup. For the single-selector form, _enumeration.def_index_id names an item and _enumeration_default.index and _enumeration_default.value supply paired code keys and defaults. In the ordered form, _enumeration.def_index_ids names the selectors in order. Each _enumeration_defaults.index list contains one value per selector, paired with _enumeration_defaults.value. The validator checks those key components against their selector definitions and checks the defaults against the receiving item. It rejects duplicate canonical keys, wrong tuple widths and unpaired table columns. DDLm 4.1 and IUCr dictionary handout

Explicit data columns, including explicit unknown values, take precedence. For an omitted column, Grid uses authored selectors in the same scalar packet or the same physical Loop category. Aliases resolve before lookup. Code matching uses the validator’s case-insensitive identity, while integer selectors use exact numeric identity. Grid treats inferred values as a temporary column for type, category-key, measurement and parent-link checks. Rules requiring an attribute to be explicitly present still inspect the authored data. The report counts them in indexedDefaults.inferredValues. A finding located in an inferred value carries spanSource: "defaultDeclaration". The source data remains available exactly as imported. Working example

A known selector outside a single-index code table produces CIF_DEFAULT_INDEX. Missing selectors, unmatched ordered tuples, split packets, cross-category selections, and competing static defaults leave the result incomplete. Defaults do not chain through other inferred selectors. Dictionary references in selector lists have literal-local completion and navigation. A scalar default-table value offers state choices from the same item save frame.

Supplied DDLm dictionary resources

VALIDATE_CIF(data, dictionary, resources) accepts an optional closed object mapping absolute resource URIs to already parsed native CIF dictionary values. The two-argument call preserves its existing behavior: import declarations remain unsupported unless resources are supplied explicitly. This optional argument is for DDLm dictionaries; it does not make DDL1/DDL2 import systems executable.

The complete example defines the data, dictionary, reusable type template and resource map in one model. After literal expansion, validation uses those native values from saved LIR. The compiler parser binding is needed to recompile the authored literals.

The supported Contents profile resolves nested save-frame imports, including same-dictionary references, and caches each selected frame only for the current validation call. Different resource values are separate inputs; there is no process-global dictionary cache. Relative URI references resolve against the importing dictionary's _dictionary.uri, or its explicitly supplied resource key when no URI is declared. URI syntax uses the pinned Rust fluent-uri parser; reference resolution follows RFC 3986 section 5.2. Resource keys use exact resolved strings, without filesystem, DNS, percent-decoding, host-case normalization or network discovery. Missing resources are errors even when miss: 'Ignore' is set, because that policy concerns a missing definition inside a supplied dictionary.

_import.get list-of-table declarations and ordered _import_details rows (scalar columns or explicit single tables) are accepted. If both are authored, their directives must agree. version requires a valid semantic version with the same major version as the supplied dictionary. dupl defaults to Exit; Ignore and Replace act on the entire affected Loop category when an attribute collides, including scalar one-row authoring. miss defaults to Exit; Ignore retains an explicit skipped-frame trace. Save-frame matching follows CIF's canonical caseless identity. Original source values remain unchanged. The report includes imports, dictionaryResources and importsResolved; those fields describe resolution, not complete dictionary conformance. Methods still make validation incomplete and never run.

Full imports bring in the selected definition and its descendants. The importer must be a Category; the selected root becomes its child. Head-to-Head imports omit the foreign Head and reparent only its immediate children. A Head cannot be imported into a non-Head category or through Contents. Category _definition.id and _name.object_id must agree canonically when both are given. Ignore skips an already-present selected root and its incoming subtree; otherwise duplicate policies apply to whole save frames, including descendants. Replace replaces each colliding definition rather than merging its attributes.

Source dictionaries containing Full declarations are assembled before a Contents lookup, so newly introduced or replaced definitions are visible. Same-dictionary lookups also resolve pending Full declarations. Plain Contents-only dictionaries retain lazy frame lookup. Full-source dictionary dependency cycles are rejected, including cycles whose individual frame selection might be acyclic; category and active-frame cycles also fail explicitly. This is bounded dictionary composition, not complete metamodel validation: methods and unsupported measurement rules still make complete false and valid null.

Importable dictionaries currently require one data block. Limits include 128 supplied resources, 4,096 bytes per resource URI, 64 active frames (also bounded by context depth), 10,000 trace/unresolved entries, and separate composition work and cumulative logical copy budgets derived from the context's node/output limits. Those are bounded logical operations, not measured peak RSS or hard real-time preemption.

Editor completion offers Contents, Exit, Ignore and Replace, plus Full when the same save frame has one explicit Category scope declaration. These choices appear both in import-detail scalar fields and direct mode, dupl and miss values inside _import.get and _import_details.single tables. It preserves quotes and authored source offsets, and does not resolve resources while providing suggestions. The Full-category example shows an imported category and its item definition using the same native API.

Explicit UEB plain-text transcription

Standard (Lite) and Pro add ueb1 / PARSE_UEB1 and ueb2 / PARSE_UEB2. The grade is explicit: ueb1"⠃" produces text b; ueb2"⠃" produces but. All three literal delimiters work. Results contain format, grade, the pinned profile, authored source, decoded text, transcribed and tableVersion. Compiled literal results are ordinary native constants; saved LIR needs no braille parser. Recompiling the literal requires the Standard assembly.

BRAILLE_TRANSLATE(text, "ueb2", "forward") encodes text to six-dot Unicode braille; "backward" decodes it. The returned object contains profile, grade, text, braille and tableVersion. Use "ueb1" for uncontracted English. These are the pinned liblouis 3.39.0 plain-text tables executed by the repaired native Rust louis-rs engine. No C executable, WASM, network, runtime table files, locale discovery or caller-selected table program is used.

Layout whitespace is normalized to spaces (CRLF becomes one space) during transcription; forward U+00A0 nonbreaking spaces retain the pinned table's numeric-grouping meaning. encoded braille uses the Unicode braille blank U+2800 for those spaces. the authored input stays in source for literal results, or the input-side field for explicit transcription. BRF still decodes ASCII cells only. It does not infer a grade. These profiles do not claim full UEB validation, arbitrary caller tables, page layout, regional rules, mathematical expression transcription or contextual Nemeth. Undefined-character fallback is an error; transliterating unsupported characters into plausible output is not a fallback.

Forward transcription also accepts an optional fourth typeforms argument:

styles = [{class: "italic", start: 0, end: 16}]
result = BRAILLE_TRANSLATE("ROMEO AND JULIET", "ueb2", "forward", styles)

Each record has exactly class, start and end. Offsets count Unicode scalar values in the authored print string, starting at zero, with an exclusive end; they are neither UTF-8 bytes nor editor UTF-16 columns. Ranges must be nonempty and within the string. Supported classes are italic, underline, bold, script, transnote, and trans1 through trans5. The pinned table defines their indicators; callers cannot install custom rules. At most 4,096 spans are accepted and overlaps are allowed. The result additionally retains authored typeforms and typeformOffsetUnit: "unicode-scalar".

Styles follow character origins through normalization and table corrections: copied text keeps its origin, inserted replacement text inherits the first replaced character, and deletions do not shift later authored styles. A style covering only a removed CR contributes no indicator. Generated style runs are also capped at 4,096. Supplying typeforms for backward transcription is an error, including an empty array. To recover annotations, explicitly select the three-argument backward-typeforms direction instead:

decoded = BRAILLE_TRANSLATE("⠨⠂⠃", "ueb2", "backward-typeforms")
/* text: "but"; typeforms: [{class:"italic", start:0, end:3}] */

Recovered ranges index Unicode scalars in the decoded text, including contraction expansion and correction-rule provenance. They are ordered by class then start, with adjacent same-class output merged. Overlapping classes remain separate. The output additionally contains typeforms (possibly empty) and typeformOffsetUnit: "unicode-scalar". Plain backward and literal parsing retain their plain-text result shape. The pinned reverse algorithm includes a terminating space in word emphasis before clearing that class; phrase emphasis survives spaces until its terminator. This is explicit indicator recovery, not font inference or a guarantee that translating back recreates identical cells. The reverse example includes overlapping bold/italic styles and a grade-2 contraction. Independent reference coverage includes nine grade-1 and eight grade-2 reverse style answers; broader translation options and full UEB conformance remain outside this claim.

The styled example includes a combining-accent correction. The public adapter matches 98 pinned forward grade-2 styled answers; this is a selected reference corpus, not full UEB or grade-1 styled conformance.

Function signature help exposes the optional argument, and hover documents classes, offset units and limits. Span records use ordinary Grid object/string highlighting. There is no inferred visual styling or record-field completion.

The authored input is capped at 65,536 UTF-8 bytes. Translation has a 524,288-byte per-stage output cap, 2,097,152 cumulative emitted bytes, 131,072 emitted events, and 64,000,000 logical work units. Host parser limits can lower applicable caps. Cancellation is checked in translation loops, the pattern VM and normalization. These are logical execution limits, not RSS quotas. Fixed tables initialize once per selected grade/direction on first use; table compilation is outside the per-translation budget. Partial output is discarded on failure.

The catalog supplies completion, hover and edition requirements. Raw angle/triple payloads highlight six-dot cells and flag eight-dot cells; ordinary quotes keep Grid string highlighting. Native validation maps errors through escaped and Unicode source spans. No payload formatting, identity navigation or tactile renderer is advertised. See the working model.

Mathematical braille from MathML

mathml / PARSE_MATHML contract revision 2 preserves the existing Content MathML subset and adds MathML 3 Presentation elements, ordered text, attributes, script pairs, table structure and opaque XML annotations. Fixed child counts, parent ownership and semantics ordering are checked. MathML's named character entities use the pinned WHATWG character-reference data, including multi-codepoint values, without loading a DTD; other XML readers keep their existing entity policy. This is structural import, not full schema validation, mathematical evaluation or rendering. Content dictionaries and arbitrary annotations are not executed. Namespace declarations remain required on imported MathML roots.

MATH_BRAILLE(mathml, profile) explicitly transcribes either MathML text or a native mathml object. Select "nemeth" or "ueb-technical" for a linear transcription, or "nemeth-spatial" for a standalone matrix. Standalone text also accepts an unqualified math root. Native object indices, parent ownership and ordered content are checked before serialization; corrupt or unreachable records fail. A linear result contains code, profile, Unicode braille, canonicalMathml, engineVersion and engineCommit. The working example uses both input forms. BRAILLE_TRANSLATE remains the separate plain-text UEB operation; braille and brf remain cell decoders.

The Standard/Pro native implementation pins MathCAT tag v0.7.7, commit 764d24d1241b20c0973e9dbcee62d022c1f99a4a; its upstream Cargo version is 0.7.6-rc.4. Fixed English/Nemeth/UEB Technical tables are embedded. There are no user rule paths, ambient preferences, network retrieval, external processes or WASM. Profile initialization is lazy on the invoking thread. Compilation of an ordinary model does not initialize the engine. Saved native MathML values need no compiler parser when loaded; executing MATH_BRAILLE still needs Standard's native transcription function.

The separate "nemeth-spatial" profile produces up to 25 lines of 40 six-dot cells each for one standalone rectangular matrix. Provide two or more rows and explicit square, round, or determinant fences, using mo tokens or mfenced. A cell can contain an unsigned integer, a unary minus followed by an integer (optionally inside one mrow), a single Latin letter, a horizontal ellipsis (… or ⋯), a vertical ellipsis (⋮), or a descending diagonal ellipsis (⋱). An empty cell becomes a short dash. Cells are left-aligned within each column with one blank cell between columns. Width includes the enlarged grouping signs. rows holds individual Unicode braille lines; braille joins them with newlines. widthCells and heightLines describe the result.

Styled, spanned, ragged or oversized matrices, complex cell expressions, runovers and surrounding equations are refused by this profile. The reference fixtures reproduce BANA examples 25-69 and 25-71, including their original column padding. One augmented separator is supported through mtable columnlines: supply exactly one none or solid value per column gap, with at most one solid. Working model and BANA Nemeth Code, rules 19.6 and 25.8.

The two linear six-dot profiles reject undefined-character fallback and eight-dot output. In particular, two upstream linearized-matrix examples emit an eight-dot row marker and are explicitly refused. This does not claim every MathML construct has a supported braille rendering, bidirectional mathematical-braille decoding, page layout, caller-defined typeform mappings/preferences or complete regional conformance. Budgets cap input at 64 KiB, input elements at 4,096, depth at 128, each engine-emitted string at 512 KiB, created nodes at 131,072, logical intermediate strings at 4 MiB and observed work at 2,000,000 units. Caller limits can reduce those bounds; cancellation and exhaustion return errors. The final native object additionally obeys the caller’s total output limit. Logical budgets are not RSS limits.

The language service offers namespace-aware element completion and hover, including parent-specific table children and matching closing names, across all three literal delimiters. Within a complete quoted mathvariant attribute on MathML tokens or mstyle, it offers the 18 MathML 3 symbol classes and explains their role. Completion replaces the whole attribute value while preserving quotes, namespace prefixes and Grid escapes. Unknown/foreign scopes, comments, CDATA, opaque annotations, duplicate attributes and unfinished quotes receive no typeform assistance. Other attribute values remain outside this completion profile. These syntax operations do not execute the parser or braille engine. Native validation supplies mapped payload diagnostics. Existing XML highlighting covers raw triple-quoted and angle payloads; ordinary escaped quotes retain literal-boundary highlighting. Payload formatting and semantic identity rename are not added for MathML.

Authored mathvariant values already survive native import and feed the fixed transcription profile. For example, MATH_BRAILLE("<math><mn mathvariant='bold'>0</mn></math>", "nemeth") returns braille ⠸⠼⠴. Editor-to-runtime checks cover bold, bold-fraktur, sans-serif and script under Nemeth, plus bold-italic and italic under UEB Technical, using unchanged pinned upstream answers. Offering a valid MathML class does not promise a distinct braille rendering for every character/class combination; arbitrary plain-text UEB typeform runs remain separate.

Direct HamNoSys characters

hamnosys / PARSE_HAMNOSYS imports the 200 distinct character spellings in the University of Hamburg's published input palette, pinned on 2026-10-31. This is a subset of Grid's existing 216-name SiGML vocabulary. It accepts Unicode/private-use characters, rather than XML elements or textual symbol names. The native object retains the original source, ordered tokens with character/name/codepoint/UTF-8 span fields, layout records and nested groups.

Sequence, parallel, fusion and alternative grouping use the same checked pairs as SiGML. Spaces remain hamspace symbols. Tabs, CR and LF are retained separately as layout; they do not invent sign boundaries or motion. Unknown characters, empty/space-only streams, crossed/unclosed groups and resource overruns fail explicitly. These records do not certify phonetic sequence validity, choose a sign-language interpretation or animate a sign. The Code editor loads an attributed Hamburg webfont only for raw published glyphs inside HamNoSys literals. It does not install a system font or apply a global private-use fallback. Other editor clients need a compatible font. The repertoire provenance and checksum-bound generated native table are retained in grid-format-core/data.

The unchanged webfont comes from Thomas Hanke, Universität Hamburg, HamNoSys 4.1.7, copyright 1989–2022 Universität Hamburg, under CC BY 4.0.

The editor offers published character-name completion (type a ham prefix), matching group closers and codepoint/name hover without invoking the reader. The working example uses actual Unicode characters and explanatory symbol-name comments. Quoted literals retain Grid’s existing escape rules; Rust-style \u{…} escapes are not supported.

Binary SPICE kernels

PARSE_DAF(kernel_bytes) accepts a supplied array of byte integers in Standard (Lite) and Pro. It reads NAIF DAF SPK, binary PCK and CK files with explicit LTL-IEEE or BIG-IEEE representation. It is a function-only reader; there is no daf literal. The ordinary function catalog supplies editor completion, hover and argument help. Existing spice literals continue to read text kernels.

The result has kernelType, binaryFormat, internalName, ftpMarkerPresent, firstFreeAddress, commentAreaHex and ordered segments. Each segment keeps its name, time bounds, time scale, integer descriptor, one-based inclusive word addresses and exact dataHex in the input byte order. SPK records expose target/center/frame IDs, PCK records expose frame-class and reference-frame IDs, and CK records expose instrument/frame IDs and the angular velocity flag. IDs remain integers; no implicit kernel or frame lookup occurs. Raw comment records are retained as hexadecimal, not interpreted as prose.

SPK types 2 and 3 and PCK type 2 additionally expose records with the initial epoch, interval length, record size, polynomial degree, component names and ordered midpoint/radius/coefficient arrays. Other types keep their payload, set decoded to false and records to null; the native parser also emits GRID_DAF_OPAQUE_SEGMENT. Thus preserved data never implies a decoded record layout. CK bounds are encoded spacecraft clock values; SPK/PCK bounds are TDB seconds past J2000. No conversion, interpolation or propagation is performed.

Structural validation rejects truncated records, unsupported representations, damaged FTP markers, bad summary dimensions/links, invalid address ranges, metadata/data overlap, duplicate array storage and malformed supported Chebyshev directories. Input, output, node, depth and cancellation limits apply. Other DAF architectures, legacy files without explicit IEEE representation, DAS/DSK kernels, record codecs beyond those named above and full numerical kernel validation remain outside this profile.

The maintained examples are the exact external de430sub.bsp and VEX_BOOM_V01.BC fixtures under rust/grid-format-standard/tests/fixtures/daf/. Their provenance records pin source URLs, hashes and independently decoded summaries. The compiler/runtime test imports each byte array through the normal function and queries the loaded LIR result. A runtime function call still needs the Standard parser assembly; a separately saved native value does not.

Sources: NAIF DAF, SPK, PCK, and CK.

Electrical SPICE netlists

spicenetlist and PARSE_SPICENETLIST(text) implement spice3-descriptive-netlist-v1 in Standard (Lite) and Pro. Core reports the parser as unavailable. All three Grid literal delimiters use the same native reader; the payload's first line is its title, including for angle blocks. This is an electrical format, separate from the orbital spice and daf profiles. See the voltage-divider example.

The native object preserves source, title, ordered components, models, subcircuits, inert directives, and resolved/unresolved references. nodes and edges form a bipartite component/net graph suitable for the literal constructor GRAPH(spicenetlist"""..."""). The one-argument constructor for a named cell currently expects a parse/tree value, so use the inline native literal shown in the example. Terminal edges carry zero-based positions and point from component to net to represent incidence, not current or signal flow. Unused declared subcircuit ports and global nets remain nodes. Local nets and names are ASCII case-insensitive within their declaration scope; ground 0 and declared .global nets share root scope. IDs are deterministic for identical source; they are not persistent identities across edits. Subcircuit declarations remain separate scopes; calls are references and are never flattened or expanded.

The profile reads fixed-terminal R/C/L/V/I/B, D, J/Z/U, M/S/O, T, linear E/G, F/H/W controlling-source references, two-inductor K coupling and X subcircuit calls. Q has three or four terminals only when exactly one locally declared NPN/PNP model identifies the model position. Ambiguous or external-only Q models fail instead of guessing a substrate terminal. Active-device model references, X calls and controlling elements resolve in their declared scopes; other missing targets remain explicit resolved: false references. X calls to local declarations must match the declared port count. Expressions, numeric suffixes, device options and parameter assignments retain raw spellings; this reader does not validate every simulator's device semantics.

A nonempty title and final .end are required. + continuation lines join logical cards; * comment lines and unquoted ;/$ comments are accepted. Quoted paths preserve comment characters. Diagnostics use original UTF-8 card spans, including continuations, then map through Grid literal escapes. Duplicate local names, unbalanced expressions, mismatched .ends, malformed terminal lists and content after .end fail. Input/output, node/depth budgets and cancellation apply.

.include/.inc paths and external .lib path section directives are retained without opening files. Local library blocks, simulator control blocks, conditional topology, polynomial controlled sources, multi-inductor coupling, unsupported device prefixes, unknown dot directives (including net-alias commands) and implicit macro expansion are excluded. Parameter/function, option, output, initial-condition and analysis directives are retained as raw inert cards. There is no simulation, numeric suffix conversion, equation generation, external resource retrieval or ngspice execution.

The editor provides the native parser's tag/function completion and hover, lexical highlighting for raw literal bodies, literal-boundary ownership and compilation diagnostics. Ordinary quoted payloads retain Grid string/escape coloring. It does not claim net/model reference navigation, rename, completion inside payloads or visual schematic editing. Parsing runs at literal compilation or an explicit function call, with no discovery work on ordinary cell resolution.

Profile references: ngspice input structure and subcircuit declarations.

R model-formula syntax

rformula / PARSE_RFORMULA(text) implement r-model-formula-ast-v1 in Standard (Lite), inherited by Pro. This reads authored formula syntax separately from Grid's modelformula JSON record contract. It accepts one one-sided or two-sided formula and returns a native syntax graph: root, optional response, predictor, scalar-property nodes, and ordered child edges. Each node has its authored label, kind, sourceStart/sourceEnd UTF-8 offsets and a context distinguishing model syntax from expressions inside calls or indices. Original source is preserved. Graph IDs identify syntax occurrences, not variable bindings. See the working syntax graph.

The reader preserves symbolic +, -, *, /, :, ^, %in%, parentheses, intercept literals and . without expanding model terms. Calls such as I, offset, log, cbind and package-specific transformations remain syntax. Named arguments, namespace/member/slot access, single/double indexing, logical and comparison operators, custom percent operators and |/|| expressions retain structure. The latter do not imply a mixed-effects fitting engine. Operator precedence, right-associated powers and complete-expression newline boundaries follow R. Names retain case and spelling; backticks support names containing spaces. Numeric tokens are decimal lexemes with optional exponent, L or i suffix, not converted floating-point estimates.

evaluated: false, termsExpanded: false and environment: null are explicit. There is no R process, environment lookup, column substitution, expression execution, dummy encoding, intercept inference, coefficient fitting or model validation. Assignments, control statements, function definitions, blocks, multiple formulas, hex/raw-string syntax and missing call arguments are outside this profile. Quoted tokens retain simple R escapes; numeric Unicode/octal/hex escapes are refused—literal Unicode is accepted. Locale-specific identifier acceptance is not certified. Input/output/node/depth limits and cancellation bound lexing and AST construction.

References: R model formulas, operator precedence, and R language syntax.

Brat standoff annotations

brat / PARSE_BRAT(text) implement brat-1.3-standoff-v1 in Standard (Lite), inherited by Pro. They read TAB-separated .ann records independently of the associated document. Native annotations retain source order, authored IDs, types, text and original UTF-8 card spans. references identify targets and resolution status; scalar nodes and reference edges support native graph construction, including isolated annotations. See the annotation graph example.

Supported records are text-bound T, event E, binary relation R, equivalence */R … Equiv, attribute A/legacy M, normalization N, and annotation note #. Discontinuous text spans retain ordered, nonoverlapping segments. Document offsets are zero-based Unicode character counts with exclusive ends; source spans remain UTF-8 byte offsets in the annotation input. Binary attributes retain true, explicit attribute values stay strings, and normalization resource/entry identifiers are never fetched. Equivalence groups retain member references rather than expanding transitive pairwise links.

Duplicate IDs, malformed offsets or records, and incompatible local reference kinds fail. Forward references resolve after all declarations. Missing targets remain native unresolved references and produce no graph edges. Native parser, literal-compilation and editor diagnostics expose warnings; ordinary function calls return the value with its explicit reference status/counts, without a separate runtime warning channel. At most 64 individual warnings are returned; unresolvedCount remains complete and diagnosticsTruncated reports truncation. Warning counts and all reference records remain bounded by the normal input/output/node budgets.

documentValidated: false states that document length, mention-text agreement, annotation configuration/ontology, event-type conventions and normalization resources were not validated. Document-wide freeform notes without an annotation ID are excluded. No text/media files, network resources or executables are opened. The authoritative record syntax is the brat standoff specification.

Both readers provide tag/function completion and hover, raw-body lexical grammars, literal boundaries and native diagnostics mapped through Grid escapes to editor UTF-16 ranges. Ordinary quotes retain Grid string/escape coloring. Payload reference completion, navigation, renaming, semantic R assistance and rendered editor QA are not claimed by these new profiles. Parser costs occur only for explicit imports; ordinary cell resolution performs no discovery.

FOLD frames

fold and PARSE_FOLD use fold-1x-frames-v2 (contract revision 2). Existing single-frame results retain document, nodes, edges, faces and dimension. When file_frames is present, the result also has frames in source order, including the key frame at index 0. Each entry has id, parent, inherit, its resolved document, and checked geometry tables. The top-level document retains the complete authored JSON, including child frames. The other top-level tables still describe frame 0.

file_frames[i] has ID i+1. A child with frame_inherit: true must name an explicit integer frame_parent. Forward references are accepted; missing, self and cyclic parents fail, including cycles among non-inheriting frames. Inheritance copies missing whole fields, including custom metadata. A locally present value replaces the parent's value completely; arrays and objects are not merged, and null does not mean delete. File metadata and relationship control fields do not propagate. A child without inheritance is independent of its parent's geometry. File-level properties are forbidden in children.

Every resolved frame uses the existing coordinate/topology profile: finite 2D/3D vertices, checked vertex indices, edge assignments, optional fold angles and simple face polygons. Coordinate-free abstract complexes, derived geometry, layer-order validation and folding simulation remain outside this profile. The reader accepts up to 4,096 frames and applies parent-depth, cumulative expanded-node/byte and cancellation limits before or during expansion. The profile's duplicate-key behavior remains JSON last-value semantics.

Within closed JSON literals, the editor completes parent IDs and inheritance booleans, navigates parent references and highlights their occurrences. Parent suggestions exclude the current frame and descendants. Frame definitions are anchored to their opening braces. Hover explains IDs and whole-field inheritance. Source indexing rejects duplicate JSON keys to avoid ambiguous edits; native validation remains authoritative. Frame IDs are positional, so rename and payload formatting are not offered. The example compiles into native values that run after saved-LIR reload without a parser.

The contract follows the FOLD multiple-frame specification. Pinned upstream box and diagonal geometry fixtures exercise unchanged external files; inheritance/cycle/limit cases are authored contract tests, not an upstream multi-frame conformance corpus.

PED/FAM pedigrees and separated genotype calls

pedigree, ped, fam and PARSE_PEDIGREE use the Standard/Pro plink-ped-separated-alleles-v2 profile (contract revision 2). The six-column FAM output is retained. PED additionally accepts a consistent number of whitespace-separated allele pairs after the pedigree columns. This follows the published PLINK PED field layout.

For genotype-bearing input, the object adds variantCount, genotypeEncoding and genotypes. Each call has person (zero-based people-table row), variantIndex (zero-based authored variant order), alleles (two original strings) and missing. 0 0 is a missing call; half-missing calls, incomplete pairs and inconsistent row widths fail. Multicharacter alleles stay strings. Allele order does not establish phase. Compound two-character genotype tokens are not auto-detected; every two tokens are one variant in this explicit profile. Marker names/coordinates require a separate map and are not invented here.

Existing family-local parent links, dangling-reference flags, isolated people and cycle rejection remain. Phenotypes and sex codes stay authored values; no clinical interpretation, Mendelian checking or genotype-derived parentage is performed. Six-column and genotype-bearing records cannot be mixed in one literal. Comments begin with # at the start of a line.

The editor provides parent completion, definitions, references, highlights and hover within each family and literal, including ped/fam aliases and all three delimiters. Duplicate identities suppress that literal's navigation. Suggestions exclude self/other-parent IDs and offer 0 for an absent parent; they do not certify ancestry validity, which the parser checks. Completion is limited to IDs containing letters, digits, _, -, ., or : so insertions remain valid across delimiters. Rename and payload formatting are unsupported. See the model and fixture provenance.

WFDB headers, signals and annotations

Standard (Lite) and Pro provide three native entry points:

Entry point	Input and result
wfdb / PARSE_WFDB(text)	WFDB header text to native record, channel, group, calibration and segment declarations. All three literal delimiters work.
READ_WFDB(header, resources[, frames])	Header text or native wfdb header plus an explicit object mapping exact file names to byte arrays. Returns raw digital, missing-aware digital and physical samples per channel.
PARSE_WFDBANN(bytes[, format])	MIT (default), aha-distribution or aha-wfdb annotation bytes to native events. Explicit variant controls timestamp units; function only.

The example supplies signal bytes without filesystem or network access. Headers retain authored source and byte spans. Resource names are exact object keys, including names that resemble paths; no environment search path, stdin, URL or external file is opened.

Single-record decoding supports null signals (0), first differences (8), and amplitude encodings 16, 24, 32, 61, 80, 160, 212, 310 and 311. FLAC storage formats 508, 516 and 524 decode exact signed 8-, 16- and 24-bit amplitudes. Channel groups must be consecutive and agree on storage layout. Mixed samples-per-frame remain separate channel arrays with their actual sample frequency. Skew remains an explicit negative first-sample offset; the reader does not resample or silently align channels. Packed final groups accept the exact bytes needed for the requested sample count. Preamble offsets are honored, and unused trailing bytes are reported for uncompressed storage.

FLAC resources must contain one complete stream after any declared preamble. The FLAC channel count must match the file group (at most eight channels), and all group channels must have equal samples per frame. Blocks may split WFDB frames; decoding restores the WFDB channel ordering. Timing and sample frequency come from the WFDB header, never from FLAC's conventional 96000-Hz placeholder. STREAMINFO bit depth and nonzero sample count must agree with the header. Unknown FLAC sample counts and absent MD5 are accepted; present MD5, frame CRC, contiguous frame bytes, sample sequence and exact decoded length are checked. Trailing bytes, concatenated streams and damaged/resynchronized frames fail. Optional tags/pictures are skipped without interpretation or external lookup. Cancellation is checked between library packet/decode calls and while copying samples; a library call itself is not preemptible. Input, output and decoded block scratch are bounded before allocation. Native execution of this new profile is deferred; fixtures and integration tests are authored, not passing validation claims. See the FLAC example and WFDB signal formats.

Stored digital values remain available as rawDigital; encoding-specific missing values become blanks in digital and physical. physical uses (digital - baseline) / gain only when a nonzero gain is declared. Missing or zero gain remains uncalibrated. A declared checksum is checked against the full stored channel before any missing-value conversion. A missing or zero header frame count requires an explicit count; in that case checksum verification stays unknown. Declared and supplied counts must agree. Input, sample allocation, aggregate output and cancellation checks apply before and during decoding.

MIT annotation decoding retains signed skip intervals, persistent number/channel state and event-local subtypes. Auxiliary bytes remain exact, with a text field only when they are valid UTF-8. Metadata notes and user-defined codes are data: no implicit time rescaling, label substitution or clinical interpretation occurs. Malformed modifiers, truncation and missing termination fail explicitly. This entry point does not auto-detect annotation formats.

For fixed-width AHA files, explicitly choose aha-distribution (milliseconds from the annotated segment) or aha-wfdb (sample intervals from the record). Each event retains absolute time, unsigned serial, ahaCode, its mapped numeric code, byte span, unused prefix and exact eight trailing bytes. The WFDB variant additionally exposes storedMitCode, signed subtype, six exact auxiliary bytes and ASCII text up to the first null. The distribution variant leaves those extension fields blank: its trailing bytes are uninterpreted. code follows the AHA symbol; the stored MIT code remains a separate field. No timestamp conversion, clinical interpretation or inferred provenance occurs. Whole-record physical EOF and uniform 0xff logical-EOF padding are accepted; partial records, unknown AHA symbols and contaminated padding are rejected. See the AHA example and the WFDB annotation format reference.

Multisegment READ_WFDB inputs supply {segments: {name: {header, resources}}}. Each named constituent has its own header text and byte-resource object, so two segments may use the same file spelling without sharing their bytes. Repeated constituents decode once; segmentSpans preserves every occurrence and master frame offset. segmentRecords retains original header, samples and checksums. Nested multisegment records and conflicting lengths/frequencies are rejected.

Fixed layouts retain channel order, calibration and signal metadata. Variable layouts begin with an explicit zero-frame layout header whose signal files are ~ with format 0. Unique nonempty channel descriptions define the mapping; missing channels and null segments become blanks. Matching samples-per-frame, units are required: this profile does not infer unit conversions or resample. Changing skew is aligned exactly in channel samples to the layout offset, not rounded to frames. For target sample i, source index is i + sourceSkew - layoutSkew. Positions outside the current segment become blanks in all three arrays. No neighboring segment supplies a replacement. The aggregate retains the layout firstSampleOffset; unchanged-skew outputs retain their previous values. Changed channels have an explicit segmentSpans.signalAlignment window: source/target starts, copied count and leading/trailing blank counts. Original stored samples, including those outside the aligned window, and their complete checksums stay in segmentRecords. This is Grid's segment-local sample projection, not a claim of reproducing the C library's frame-rounded deskew buffer behavior. See the changing-skew example. Calibration changes map digital samples into the layout's gain/baseline, rounding nearest with ties toward positive infinity. Conversion overflow is rejected rather than saturated. Unknown calibration may be retained unchanged but cannot be used for a calibration transformation. digital and physical use layout calibration; rawDigital retains the source segment's stored values and must be interpreted with segmentSpans and segmentRecords, since calibration can change. layoutHeader retains the selected layout. Annotations are not automatically concatenated.

The multisegment example uses only explicitly supplied data. Ten assembly/reference tests and the existing codec/annotation tests pass in a focused source snapshot (27 checks total); five linked editor/compiler/runtime checks and ten assembly/reference checks also pass. Shared-source changes during that run are recorded in the integration evidence; physical editions, CLI and live editor interactions are not inferred. The WFDB multisegment reference defines the channel/layout distinction. Three synthetic multisegment cases match independent digital and physical answers from checksum-pinned WFDB 10.7.0 rdsamp: repeated fixed layouts, variable channel order/calibration with missing channels and null segments, and negative halfway rounding. Inputs, answers and reference identity are retained in tests/fixtures/wfdb/segments-reference.json under grid-format-standard. Timestamp interpretation and waveform rendering remain outstanding. Changing-skew assembly, AHA runtime/editor and FLAC native validation are deferred; the earlier execution evidence does not cover these additions. The waveform Grid record carrier is a different format.

The editor highlights header syntax and offers uncompressed and FLAC storage-format numbers while preserving xN, :skew and +byte-offset modifiers. Field hover explains calibration and explicit resources. External-reference navigation, renaming and payload reformatting are unavailable. Native parser diagnostics retain the ordinary/triple/angle source mapping.

The pinned synthetic fixture covers 499 frames in ten encodings against independent WFDB rdsamp answers. An upstream synthetic wrann fixture also checks repeated SKIP intervals at a 10-billion-tick timestamp. Unchanged bytes, license and provenance live in rust/grid-format-standard/tests/fixtures/wfdb. This verifies that fixture scope; it is not unrestricted WFDB, medical-device or clinical conformance.

SACM assurance-case interchange

Standard/Pro PARSE_SACM(text), sacm"...", sacm"""...""" and <sacm>...</sacm> import assurance-case instances. This is distinct from the existing Grid gsn record carrier and from importing SACM's UML metamodel with PARSE_XMI. The bounded sacm-instance-v1 profile recognizes the 20220301 SACM namespace and EMF package namespaces for SACM 2.0–2.3. It does not certify the complete constraints of those metamodel versions.

records retains every XML element in source order, including foreign models, attributes, mixed content, authored XMI identity, expanded type, source span and EMF containment path. collections indexes packages, claims, reasoning, relationships, artifacts and terminology by record number. Explicit assertion status and boolean declaration flags are retained; omitted defaults are not silently inferred. XMI IDs are namespace-aware and must be unique. SACM gid values remain authored attributes rather than substitutes for XMI identity.

references retains each authored role and target in order, its owning record, resolved local node (when available), and whether it is external. Local XMI IDs, #id fragments and EMF positional containment paths resolve within the supplied document. Child reference features using href or xmi:idref are supported. Unresolved local targets produce diagnostics and no reference edge. External references are retained without opening any file or network resource.

nodes and edges can be passed directly to GRAPH(...). Nodes represent recognized SACM entities, including isolated claims and relationship entities; explicitly referenced foreign records are also included. Other foreign records remain available in records. Edges distinguish containment from named reference roles. An inference with several sources remains one relationship entity with ordered links: the importer does not turn it into proved pairwise entailments. See examples/native-formats/sacm.grid.

Triple-quoted and angle literals embed XML highlighting; ordinary quoted literals retain Grid string highlighting. Parser diagnostics map through all literal delimiters. Source-only completion and hover explain assertion-status and boolean declaration values. Reference navigation, rename, automatic payload formatting and visual assurance-case editing are not implemented. No assertion is proved and no cited evidence is evaluated by this reader.

QIF 3.0 semantic PMI and GD&T

qif (alias qif3) and PARSE_QIF(text) import Quality Information Framework 3.0 XML in Standard and Pro. This is semantic manufacturing/inspection interchange, not Quicken's financial QIF format.

The qif3-semantic-pmi-v1 profile retains ordered XML records, identified entities, typed collections, references, and scalar-property nodes and edges for GRAPH(...). Collections identify characteristic definitions, nominals, items and measurements; corresponding feature families; datums and datum frames; standards; and external document references. Raw attributes, unknown records, source spans and exact numeric spellings remain available.

Scalar dimensional quantities identify their record, owner, numeric value, exact lexical spelling, unit name, unit declaration and unit-selection source. units preserves conversion factors and offsets as authored decimal text. Values are not converted. Explicit unit attributes override primary units; primary PMI units override the corresponding ordinary units only within the sections specified by QIF PrimaryUnitsType. Otherwise the schema's SI defaults apply. A custom explicit unit without a matching declaration remains explicit with no invented conversion. Vector and other structured quantities remain in source records rather than receiving inferred scalar semantics.

Local IDs resolve to entities. External xId and Id/XIds pairs retain the external object identity and local external-document entity separately. Assembly path references remain explicit. Nothing retrieves a URI, opens media, executes an inspection plan or proves a tolerance is satisfied. Dangling references and selected wrong-type reference targets produce warnings and no misleading graph edge; the authored reference remains available.

Known enum, numeric, boolean, identifier, fixed-length-list and required-attribute constraints are checked from pinned QIF 3.0 schema facts. The reader rejects conflicting IDs, unit definitions and reference-list counts. This is not a full XSD/XSLT validator or GD&T conformance engine: schemaValidated and inspectionExecuted remain false. The independent NIST, widget and reference fixtures are pinned with their upstream license and hashes.

Editor wiring selects XML highlighting and bounded, source-only completion and hover for unambiguous schema enum elements, including material conditions and datum precedence. It does not perform reference navigation, rename, XML formatting or graphical tolerance-frame editing. Four native compiler/runtime/editor checks pass against the recorded 0.76.0 artifacts, including saved-LIR graph reload. Rendered syntax passes the four theme/width cases; live popups remain separate.

Knotty XML stitch-pattern interchange

knotty and PARSE_KNOTTY(text) import the knotty-xml-2025-v1 profile in Standard (Lite) and Pro. It retains a stitch pattern's authored structure: ordered XML records, rows, rowGroups, instructionDefinitions, yarns, options, dimensions, optional gauge, and nested operations. nodes and edges describe row-group/operation containment for GRAPH(...).

A run names a stitch and optional yarn identity; a seq contains ordered operations. Both retain authored repeat counts. Missing or zero counts mean a variable repeat, represented by variableRepeat: true; Grid does not choose its width or expand it. Large fixed repeats remain compact. Yarn colors are six-digit RGB strings; gauge retains authored counts, measurements and cm/inch units without conversion. Unknown stitch identifiers and metadata remain explicit. Graph edges describe instructions, not inferred fabric connectivity.

The reader checks scalar structure, row coverage, duplicate row/yarn identities, RGB values, option enums, nonnegative counts, gauge values and declared repeat bounds. Undeclared yarns produce diagnostics and remain references, with no external lookup. DTDs are rejected. Input, depth, record, output and cancellation budgets apply. This is a structural interchange profile, not full XSD validation, knittability checking, machine execution or a chart renderer.

The pinned upstream lattice export uses dimensions/rows; its pinned XSD expects row-count. The reader accepts that exact compatibility spelling with GRID_KNOTTY_LEGACY_ROWS and records rowCountSpelling. The original fixture is unchanged and fails the upstream schema at that mismatch; it is not described as schema-valid. See reference provenance.

All three literal forms use XML lexical support. Bounded source-only completion and hover offer option enums and common stitch identifiers. XML-sensitive stitch text is escaped when inserted (w&t becomes w&t). These suggestions are not an exhaustive stitch vocabulary. Automatic payload formatting, reference rename, chart editing and visual knitting simulation remain unsupported. Native compiler/runtime/editor contracts pass all four checks against the recorded 0.76.0 artifacts, including escaped insertion and saved-LIR graph reload.

Example: knotty.grid.

CrochetPARADE descriptive syntax

crochetparade / PARSE_CROCHETPARADE(text) is a Standard/Pro structural reader. It preserves exact source, UTF-8 syntax spans, ordered syntax records, compact repeat spellings, labels, attachment expressions and inert directives. Its nodes and edges describe syntax containment, not fabric connectivity. Counter expressions are retained without validation or evaluation. Aliases and repeats are not expanded; directives and external resources are not executed. This limited profile does not provide full upstream grammar conformance, attachment resolution, geometric simulation or rendering.

All three literal delimiters have lexical highlighting. Payload completion, hover, navigation, rename and formatting remain unsupported. Native integration contracts pass all four checks against the recorded 0.76.0 artifacts. Seven direct reader tests passed, including four pinned upstream showcase patterns. See the fixture provenance.

Knitspeak written instructions

knitspeak / PARSE_KNITSPEAK(text) imports written knitting instructions in Standard (Lite) and Pro. The native value contains exact source, source-spanned records, courses, verticalRepeats, and syntax-containment nodes/edges. Course ranges and fixed/adjustable repeats stay compact, even for billion-count inputs. Courses retain their authored row/round distinction and explicit RS/WS faces; absent faces remain absent. Stitch-count assertions are retained, not solved against the instructions. Graphs describe syntax, not fabric topology.

The written-instructions profile accepts row lists/ranges, bracketed repeats, star repeats with end/last-stitch boundaries, common stitch/cable/compound phrases, wrapped yarn, short-row turns, in-next-stitch groups and final vertical repeat ranges. Statements end with periods. It rejects overlapping course numbers, missing vertical-repeat targets, unknown phrases, malformed groups, zero operation counts and nested/multiple adjustable-width sections. A zero stitch-count assertion after binding off is valid. Input, construction, depth, output and cancellation limits apply; course coverage is indexed without expanding ranges. The reader does not execute patterns, infer default faces, solve stitch counts, render charts or certify every knitting convention.

All three literal delimiters have lexical highlighting, source tag help and native diagnostic integration. Payload completion/hover, navigation, rename and formatting are unsupported. Four native integration contracts pass against the recorded 0.76.0 artifacts, including source mapping and parser-free graph reload. Ten direct-reader tests pass, including 31 pinned upstream row-list inputs; some upstream cases test unsupported stitch execution or fabric constraints, so accepting their syntax does not establish semantic equivalence with Knotty. Reference provenance and working example.

Xigt interlinear annotation interchange

xigt / PARSE_XIGT provides an external XML interchange reader for interlinear annotations, alongside the simpler gloss text reader and Grid-defined glosstiers records. See the Xigt contract for tier scoping, Unicode span selection, native graph tables and editor reference assistance. Six direct reader checks pass against independently recorded upstream values; compiler/runtime and rendered checks remain separately tracked in the parser ledger.

Open-PSA consequences and inherited metadata (revision 7)

openpsa / PARSE_OPENPSA now imports define-consequence and define-consequence-group into consequences, consequenceGroups and consequenceReferences. A consequence retains its initiating event, assigned event tree and sequence node. The sequence may be bare or fully qualified but must belong to that initiating tree, including assignment through initiating groups. Nested and empty consequence groups remain explicit. Consequences and groups may supply an initiating event's collected item. Duplicate members, unresolved references, cross-tree sequences and dependency cycles are rejected. These are structural records; no consequence probability or sequence traversal is computed. See the authored example and MEF organization grammar.

metadata.labels and metadata.declaredAttributes retain source node IDs and owners. metadata.effectiveAttributes maps each declared owner/key to its source attribute and owner, with an inherited flag. Values and optional type annotations remain strings, including empty values and numeric-looking spellings. Local names override inherited attributes; the complete declaration is replaced, so a missing local type does not inherit an old type. Only fault trees, event trees and components contribute inherited attributes; model metadata and labels do not. Duplicate local keys, missing values, nested attribute content and misplaced/empty metadata sections are rejected. Labels precede attributes, which precede the body, as defined in MEF anatomy and inheritance. The output keeps one declaration per authored attribute and bounded effective references rather than duplicating values. Import uses a mutable inheritance map with undo records; it does not clone the full map for each XML node.

Editor support retains XML highlighting and adds consequence/group navigation, initiating-tree sequence completion and metadata help. The source-only index propagates static initiating-group assignments; it does not guess missing tree contexts or run the native parser. Rename remains unsupported. Reader, language service and saved-LIR/function/example tests are authored but unrun under the owner's native-validation deferral. Node adapter checks establish frontend wiring only. Revision 7 supersedes the earlier metadata/consequence limitations above. Missions/phases, report-fragment import, external functions and full dynamic/type/ domain certification remain open. The report chapter supplies standalone result shapes but no general model-level report wrapper; Grid does not invent one.

RELIABILITY_REPORT admission accepts the current import profile for its existing independent static fault subset, and continues to accept historical flat models. It rejects nonempty CCF, substitution, event-tree, consequence or parameter tables and non-scalar stochastic expressions rather than ignoring their semantics. This source repair has an authored regression case; execution remains deferred. It does not add probability analysis for the new descriptive constructs.

Open-PSA missions and report fragments (revision 8)

define-alignment imports an ordered mission containing one or more named define-phase records. Native alignments and phases retain parent IDs, order, authored fraction spellings and instruction roots. Phase names are local to each alignment; instruction references retain model scope. Fractions must be finite and in [0, 1]; a compensated sum must be within 1e-12 of one. This is an explicit import-profile tolerance. Values are never rescaled. Alignment/phase metadata is local, not a new inherited container. Instructions use the existing expression, formula and instruction tables; assignments are not run. Tree-link instructions remain restricted to sequence definitions. See the mission example and MEF organization.

The same tag/function also accepts each of the three standalone roots documented in the MEF report chapter:

Root	Native tables	Example
sum-of-products	Ordered products and signed event literals; raw extra attributes	Products
measure	Mean/deviation, confidence/error-factor values and quantile bins	Measure
curve	Ordered X/Y points, optional Z and axis annotations	Curve

These return profile mef-2.0-report-fragment; model documents retain mef-2.0-native-import. No aggregate report wrapper is invented. Report references remain external names, with no implicit event declarations or navigation targets. Declared counts/order annotations remain separate from observed counts: sparse quantiles, duplicate/contradictory literals and empty products remain authored data. No probability, minimality, interpolation, unit conversion or statistical certification is computed. Numeric values must be finite; count fields must fit signed 64-bit integers. Invalid shapes, duplicate/out-of-order measure sections, invalid percentages/error factors/deviations, reversed bounds and unsupported curve units fail. Curve names use the existing XML NCName validator.

Editor support preserves XML highlighting and adds phase symbols, fraction/help text, report help and curve-unit completion. RELIABILITY_REPORT explicitly refuses missions/phases and standalone reports. Reader, editor and compiler/LIR cases are authored, but native validation remains deferred. External includes/functions, full dynamic/type/domain certification and other reliability grammars remain outstanding. Revision 8 supersedes the mission/report import limitations recorded in earlier checkpoints.

UML XMI structure and interactions

xmi and PARSE_XMI use uml-structure-interactions-v2 in Standard and Pro. The tag accepts ordinary quotes, triple quotes and angle blocks through the existing native literal service. Contract revision 2 replaces prior cached expansions. See the class and interaction example.

The result retains source-ordered elements, references and edges, and adds umlTables. Present tables contain source-ordered rows; a table with no rows is absent. Each row has node, optional id and name, owner (the parent element index), kind, feature, typeInferred and the original attributes. Indices refer to the result's elements array, not persistent cross-file IDs.

Tables	Content
classifiers, associations, generalizations, dependencies	Selected UML class/data/interface types, association entities, inheritance and dependency records
properties, operations, parameters, enumerationLiterals	Explicitly typed records and selected concrete containment features
interactions, lifelines, messages, occurrences, fragments	Authored interaction structure, message endpoints, ordering references and combined-fragment/operand records
values	Explicit literal value specifications and opaque expressions; supplied values remain attributes

A record belongs to one primary table: for example, an Interaction appears in interactions, and an AssociationClass in associations. All records, including unprojected guards and vendor elements, remain in elements.

The reader recognizes concrete containment types such as a Class's ownedAttribute → Property and an Interaction's message → Message, using the selected UML 2.5.1 metamodel features. An explicit XMI type takes precedence. Abstract features such as fragment, ownedBehavior, lowerValue and upperValue require an explicit supported type to enter a typed table; Grid does not guess a concrete subtype. typeInferred distinguishes this projection from authored type information. Foreign namespace elements and their unknown children remain raw records.

References include association ends, classifiers, generalization, dependencies, lifeline representation and coverage, message send/receive events and signatures, execution endpoints, and stereotype base_* links. Local targets become edges; dangling targets remain reference records with resolvedNode: null. External hrefs and URI fragments remain unresolved with external: true; no resources are retrieved. Duplicate IDs and malformed/unbound type QNames produce errors. Multiplicity defaults, metaclass compatibility, association consistency, message ordering and OCL constraints are not validated. Nothing executes a behavior or renders a diagram: metamodelValidated, behaviorExecuted and externalResourcesLoaded remain false. SysML profile semantics are separate.

The editor retains XML highlighting for triple-quoted and angle-block literals. Namespace-aware local ID navigation, references, completion and identity hover operate on authored source in all three forms. Suggestions enumerate document IDs without metaclass filtering. Fragment-only href="#id" can navigate; external links cannot. Duplicate identities, DTDs, unbound prefixes and entity-spelled identities refuse indexing. Rename and payload formatting remain unavailable because vendor/custom references cannot safely be rewritten. Indexing is bounded by the existing 256 KiB literal and 25,000 shared work-unit limits, depth 128, at most 128 choices per reference slot and 2 MiB choice text. It never invokes the format reader or loads a schema.

This increment is source-implemented. Native reader, language-service and compiler/runtime acceptance cases are authored but remain unrun under the owner's native-validation deferral. Frontend transport-shape checks do not establish native or live-editor conformance.

Morse symbols and nominal timing

morse / PARSE_MORSE use itu-m1677-symbols-timing-v2 in Standard (Lite) and Pro. Whitespace separates dot/dash groups; / separates words. Authored whitespace width does not encode timing. The signal example includes accented E and procedure signs. Empty input is an empty sequence.

// E, T, then A in a new word: 19 nominal dot units.
message_signals = morse". - / .-"

The selected ITU-R M.1677-1 (2009) assignments add ..-.. (É), ...-. (understood), ........ (error), .-... (wait), ...-.- (end of work) and -.-.- (starting signal). The existing letter, digit and punctuation mapping remains. Four groups retain machine-readable alternativeInterpretations: K/invitation to transmit, X/multiplication, addition/end of telegram and double hyphen/section separator. No meaning is selected from context and no procedure is executed, including the error sign.

symbols retain code, character text when present, meaning, source byte spans and nominal start/end units. Word-boundary rows retain source spans. text remains the character projection for character-only input; it is null with textComplete: false when any procedure-only sign appears. This avoids silently dropping procedure signs or treating error as a deletion command. Ambiguous character codes retain their legacy character projection and explicit alternatives.

timeline contains ordered marks and gaps, with durationUnits, startUnit, endUnit, source start/end and the relevant symbol index. Internal gaps have zero-width source locations; inter-symbol gaps reference whitespace and word gaps reference the authored slash. A boundary is replaced by one gap, not added to another gap. totalUnits ends at the final mark; no leading or trailing silence is inferred. Timing uses nominal relative dot units, with no speed, milliseconds, audio, measured rhythm or Farnsworth-spacing inference.

The profile rejects leading, repeated or trailing word separators, unlisted joined prosigns, non-ITU exclamation spelling and other Morse alphabets. ... --- ... is three characters; the joined distress signal is not admitted by this profile. Payload diagnostics retain UTF-8 spans. Expansion obeys cancellation and bounded node/output budgets, including timeline records.

Source-only editor completion replaces an existing token or inserts into an empty literal; labels explain supported symbols. Hover explains meanings, ambiguity and nominal duration. All three literal delimiters retain source mapping through escapes and Unicode; triple-quoted/angle payloads keep the existing Morse highlighting. No identity navigation, rename, playback or transmission is added. Indexing is lazy and bounded to 256 KiB per literal, 25,000 shared literal/token work units, and copied tokens of at most 16 bytes. Longer invalid groups remain the native diagnostic service's responsibility.

Contract revision 2 invalidates earlier expansion caches. Reader, editor and compiler/runtime cases are authored but native validation remains deferred; frontend wiring checks do not establish native or live-editor conformance.

Ahnentafel ancestry slots

ahnentafel / PARSE_AHNENTAFEL use ahnentafel-tabbed-slot-graph-v2 in Standard (Lite)/Pro. This is Grid's tab-delimited representation of the Ahnentafel numbering convention, not a general genealogy interchange standard. Each nonblank line has a positive unsigned 64-bit slot number, one tab and a nonempty name. Subject slot 1 is required. Duplicate numeric slots fail, including lexical variants such as 1 and 01. Names are preserved; equal names do not identify the same person. See the example.

The existing ancestors and links remain. Ancestors gain original numberText, UTF-8 source start/end and zero-based generation (subject is generation 0). Links retain whether their descendant slot was supplied. Added nodes use canonical decimal string IDs, with names and generation; edges point from an ancestor slot to its supplied descendant slot, labeled paternalSlot or maternalSlot. Edges expose native graph endpoints from/to and retain the existing source/target fields. Missing descendants do not create edges or fabricated nodes. Every supplied slot appears, including isolated slots. These tables describe positions in an asserted ancestry, not distinct people or certified parentage.

GRAPH(ahnentafel"""…""") uses the existing native graph admission path. The fixture's four supplied slots produce four nodes and two edges: slot 8 has no supplied descendant 4 and remains isolated. The reader, editor and saved-LIR compiler/runtime cases passed on 2026-11-02. Pedigree-collapse mappings, qualified unions, identity matching and narrative genealogy parsing remain separate work.

Number hover explains the slot's generation, descendant presence and conventional parent numbers. Checked integer arithmetic refuses to wrap parent numbers beyond the profile's range. Malformed rows, duplicate slots and missing subject refuse whole-literal help. All three delimiters retain source mapping through escaped tabs/newlines and Unicode. Existing tabbed-record highlighting remains; no rename, inferred-reference navigation or new person identities are added. The source index reuses the existing pedigree authoring cache with 256 KiB per literal and 25,000 shared row-work units. No native parser or runtime model is consulted.

Contract revision 3 invalidates earlier expansion caches for the corrected native graph endpoints. Live editor coverage is limited to the separately recorded QA observations; passing native service tests does not establish every rendered interaction.

Specialist profiles: signals, feature matrices, risk and geology

These additions use the existing signals, phonology, risk and geology tags/functions in Standard (Lite), inherited by Pro. Their contract revision is 2 for signals and risk; phonology uses revision 4; geology and maritime use revision 3. All retain the existing closed Grid JSON record v1 surface. No new tag, parser discovery, WASM guest or execution path is added. The revision changes invalidate earlier literal-expansion cache entries.

Tag / function	Additional selected input	Native result and limits
signals / PARSE_SIGNALS	SEMAPHORE followed by LH/RH position pairs, e.g. down/low high/up down/low	Ordered symbols with signaller-hand positions, letter/control, numeric alternative and UTF-8 spans. A-I/K retain 1-9/0 alternatives; J also indicates alphabetic mode. modeSelected and proceduresExecuted are false; text is null.
phonology / PARSE_PHONOLOGY	TEI P5 XML in http://www.tei-c.org/ns/1.0, rooted at fs, fLib, fvLib, fsdDecl or TEI	Ordered records, structures, features, values and links. Binary, symbol, finite numeric, string, nested fs, vAlt/vNot/vColl and default nodes are retained. Local feats/fVal targets must exist and have the correct kind. External references remain unexpanded.
risk / PARSE_RISK	CSV with the exact NASA SFMEA worksheet headings below	Ordered failure rows and original field text. Repeated item IDs represent separate failure modes; quoted commas/newlines remain CSV content. Detectability and criticality are not numeric scores by default.
risk / PARSE_RISK	bowtie-diagram export with $schema: "https://todus-advisors.github/bowtie/v1", integer version 1	Original document plus graph tables, including isolated nodes. Requires unique node/edge IDs, resolved endpoints, known node kinds, positions and base labels. Retains barrier metadata; no breach propagation or risk calculation.
geology / PARSE_GEOLOGY	CSV header id,convention,azimuth,dip	Unique orientation IDs; explicitly stated right-hand-rule or dip-direction. Finite decimal degrees with azimuth [0,360), dip [0,90]. Returns both right-hand strike and dip direction, retaining authored numeric spellings. No north datum or magnetic correction is inferred.
geology / PARSE_GEOLOGY	GeoSciML Lite 4.1 GeologicUnitView, directly or in GML/WFS 2.0 FeatureCollection	Unit identifiers, names, lithology/rank/history, vocabulary URIs, raw flat fields, finite numeric ages in Ma, shape-node links and ordered XML records. Both age bounds must be ordered when present. Shape may be nil; geometry and unknown extension subtrees remain records.

The semaphore position names are down, low, out, high, up, across-low and across-high; only pairs in the ANBG LH/RH table are admitted. The left/right viewpoint is the signaller's. Grid's whitespace carrier is a transcription convention, not an external file standard. Moving error signals, word timing and control execution are outside this profile.

TEI's feature-structure encoding is an external format. The included English [s] example is transcribed from its published feature matrix. Feature names remain theory-specific. Local fsDecl/fDecl declarations add type and feature-name vocabularies. Explicit authored features are checked against supported binary, symbol, string, numeric interval, alternative and empty typed-fs ranges. Unknown feature names, duplicate declarations and explicit out-of-range values are errors. Missing features are not filled or rejected merely for being absent: TEI partial structures may admit extensions. declarations and validation.checks explain the checks; local inheritance combines all applicable ranges. validation.unvalidated identifies missing base types, cross-feature constraints, defaults, collection comparisons, truncated numerics and general subsumption. Base-URI overrides are rejected in this local feature-reference profile. This is not a whole-document validity result. External declarations are not fetched; vocabularyValidated and completeSubsumption remain false.

The FMEA carrier uses these eight headers, in order:

ITEM DESCRIPTION,ITEM ID,FUNCTION,FAILURE MODE,LOCAL EFFECT,SYSTEM EFFECT,DETECTABILITY,CRIT

These are the NASA SFMEA worksheet columns; the CSV carrier is Grid-defined. The separate bow-tie import follows this pinned exporter. It is not a generic BowTieXP importer or an assurance assessment. center denotes the top event; other kinds are hazard, threat, consequence, and barrier, with preventive/mitigative barrier type. Labels, positions and metadata are retained without executing their behavior.

Orientation conversion uses dip direction = right-hand strike + 90° modulo 360, as documented by USGS. The CSV carrier is Grid-defined. GeoSciML Lite uses the exact namespace http://www.opengis.net/gsml/4.1/geosciml-lite and the fields of the 4.1 schema, revision 4.1.1. Basic and GeologicTime 4.1 use the exact GeoSciML-Basic and GeologicTime namespace suffixes. Selected entities project to units, events, materials, compositions, hierarchies, eras, boundaries, stratotypes, contacts and timeObjects when present. Ordered XML records preserve unprojected metadata, quantities and positional uncertainty. timePositions retains authored text, frame and indeterminate-position attributes; no conversion to years or dates is inferred. Prefix aliases resolve through actual XML namespace bindings. Duplicate/invalid GML IDs are errors.

relationships retains explicit property roles such as hierarchyLink, targetUnit, start, end, nextEra and previousEra. These meanings are not interchangeable. Native nodes/edges use stable document ordinal keys and from/to; inline and resolved local entity references yield edges, including self-links. External and dangling references are retained in references with a status and yield no unresolved graph edge. An inherited xml:base override marks references base-uri-unresolved; they are not rebound to local IDs. No URI retrieval, XSD/CRS validation, stratigraphic rendering, age correlation or inferred layer order is performed. The two OGC publisher instances are preserved byte-for-byte in the fixture corpus; they have not been run through the native reader yet.

Examples: semaphore, maritime hoists, feature matrix, FMEA, bow-tie, orientations, GeoSciML units.

Editor support uses hybrid payload grammars, shared semaphore/ICS choices, namespace-aware XML element/value choices and hover, bow-tie metadata enums, and orientation-convention completion. CSV fields retain source ranges through quoted commas, doubled quotes, CRLF and embedded line breaks. Separate lexical states keep CSV quotation distinct from JSON escapes and XML attributes; source formatting preserves all payloads. Ordinary quoted Grid literals retain flat lexical highlighting; completion/hover source mapping covers all delimiters. Existing Grid-record ID navigation/rename applies only to that JSON-v1 contract; TEI feature XML adds local feats/fVal navigation with target-kind checks, references/highlights and compatible-target completion. Bow-tie exports add node/endpoint navigation, references/highlights and endpoint completion. Duplicate identities refuse indexing; unresolved references do not invent a definition. External-format rename is unavailable because these indexes do not establish complete reference ownership. TEI declarations add local/inherited field choices and type/baseTypes navigation; GeoSciML has element help without identity navigation. Native diagnostics still require an injected parser binding. No parser runs for source-only help.

Native reader, compiler/runtime and language-service checks for these additions are authored and unrun, under the owner's validation deferral. Frontend/source checks are reported separately; no live-editor or complete-standard conformance claim follows from metadata or highlighting.

Remaining specialist encodings: selected implementation targets

These selections distinguish actual interchange from Grid's existing JSON record carriers. Selection alone is not an implementation or conformance claim. External executables, rendering and operational calculations remain separate.

Family	Concrete encoding and next implementation boundary
Category diagrams	Source-implemented, native validation deferred: quiver version-0 export: decoded JSON begins with version and vertex count, followed by positional vertex/edge arrays. Endpoint indices may target earlier edges as well as vertices, so preserve higher cells. Bounded JSON/base64/share-link import and decoded index navigation now preserve higher cells; malformed/forward endpoints are rejected. Labels remain inert; no TeX/macros or commutativity proof. See the quiver contract below.
Reaction records	Source-implemented, native validation deferred: selected CML Schema 3 vocabulary and pinned CMLXOM reaction/scheme examples. Participants, raw counts, hierarchy, typed references and native containment graphs have bounded editor assistance. No dedicated reaction convention was established from the published convention list; full convention/schema certification, chemical balance, formula grammar and kinetics remain separate.
Mechanism steps	Source-implemented, native validation deferred: CML schemes/steps, mechanism/component annotations and explicit electron atom/bond references, with same-kind/molecule-local editor navigation. The pinned vocabulary describes detailed mechanisms as experimental. Explicit map contexts and partial-set incidence are implemented with source-only endpoint assistance. Selected MRV now retains curved-flow geometry, weights and atom endpoints with native incidence and scoped source assistance. Rendering, electron-count inference and chemical execution remain separate; see the MRV contract below. Existing Grid mechanism records remain available.
Feynman diagrams	Source-implemented, native validation deferred: FeynML 0.2.0.1 wrappers and standalone diagrams from the pinned producer. Child-element and legacy attribute endpoint forms are distinct; mixed forms fail. Ordered vertices, propagators and external legs produce entity-incidence graph tables with diagram-local vertex navigation. Broader versions, XML identity rename, particle inference, rendering and amplitudes remain. See the FeynML contract below.
Laban movement	Source-implemented, native validation deferred: gestureBot timed-pose JSON. Pinned consumer establishes seconds, five joints, head/arm vocabulary and time/duration ordering. Native poses/tracks/cues and conditional editor choices preserve source data without interpolation or playback. Legacy LabanotationSuite/Kinect-export objects now retain named keyframes and milliseconds with array vocabulary assistance. Full Labanotation, sensor capture and Benesh remain separate.
Causal DAG interchange	Source implemented: explicit DAGitty graph documents, all graph/edge kinds, bounded grouped expansion and structural cycle checks; local variable editor assistance. Exact contract. Native validation deferred; no full MAG/PAG proof, causal inference, legacy adjacency import or rendering.
Choreographic formations	Source implemented: selected CalChart formatVersion-1 JSON shows, with performer/formation identities, explicit curves, holds, inert continuity ASTs and source-only positional reference support. Contract. Native validation deferred; no binary SHW/viewer import, inferred motion, execution or rendering.
Benesh	Benesh Notation Editor is an identified producer. A usable machine-readable exchange schema and independent file were not established by this inspection. Keep the Grid record carrier; obtain an available encoding before promising external-score import. PDF staff images are not an interchangeable structured score.
Welding	Reuse QIF 3.0's pinned schema, already represented by the native qif reader: FrameWeldSymbolType, weld characteristic types and side/contour enums. A new focused typed-fragment fixture and native/editor/runtime cases exercise this existing implementation; they are authored and unrun. Explicit xsi:type enables enum assistance. Complete AWS/ISO convention checks and symbol rendering remain separate.

New examples: declared features, GeoSciML Basic, geological time, QIF weld fragment. The QIF example is a synthetic typed fragment, not a full schema-valid drawing.

Quiver category-diagram exchange

categorydiagram / PARSE_CATEGORYDIAGRAM now accepts the pinned quiver v0 export in addition to the existing closed Grid record-v1 JSON carrier. Parser contract revision 2 invalidates earlier expansion caches. Allocation stays Standard (Lite), inherited by Pro; Core has no new physical dependency.

Inputs are decoded JSON arrays, standard-base64 UTF-8 JSON, or https://q.uiver.app/#q=... links. Legacy ?q=... links are also accepted. The bare canonical URL denotes the empty diagram. Additional share parameters (including macros, macro URLs and renderer options) retain their raw encoded text in shareParameters; no network request or label/stylesheet execution occurs. Base64 accepts omitted final padding, rejects noncanonical unused bits, and does not accept MIME line wrapping. Quiver contract errors select the whole authored payload, never a decoded offset inside encoded data. JSON integers are limited to the exact safe-integer range of the exporting JavaScript representation.

The array is [0, vertexCount, ...vertices, ...edges]. Vertices carry nonnegative grid positions and optional labels/colours. Edges carry source and target cell indices, optional labels, alignment, option deltas and colours. Endpoints must precede the referencing cell; this permits higher cells while excluding forward/self-reference cycles in the dependency structure. Ordinary loop arrows between the same vertex are valid. Duplicate vertex positions, invalid colours, arities, option types/ranges and duplicate JSON object keys are errors. Unknown option data is retained without interpretation. Legacy length/body-level options remain authored data; dependencyLevel describes reference nesting, not a renderer's overridden line multiplicity.

cells preserves every vertex and arrow in order, including higher cells; document retains the decoded export. nodes contains all cells and edges contains two labelled incidence links from each arrow to its source and target. This distinction keeps arrows-to-arrows representable. An isolated vertex remains a node. Edge IDs and endpoints satisfy the existing native GRAPH(...) table contract; the graph is not a commutativity proof.

graph cell_relations = GRAPH(categorydiagram"""[0,2,[0,0,"A"],[1,0,"B"],[0,1,"f"],[0,1,"g"],[2,3,"α"]]""")
cell_count = cell_relations.NODE_COUNT()
reference_count = cell_relations.EDGE_COUNT()

The expected counts are five cells and six incidence links. The saved-LIR case is authored but unrun under the current native-validation deferral. Standalone import example.

Decoded JSON has source-only indexed definition/reference/highlight support and endpoint completion limited to earlier cells. A definition selects that cell's opening bracket. Numeric index rename/reordering is unavailable; the existing Grid JSON record carrier retains its own checked ID rename. Base64 and share links have lexical and format help without fabricated JSON ranges. All Grid literal delimiters retain their source mapping; raw triple/angle payloads have embedded highlighting and ordinary escaped quotes remain flat.

The pinned upstream test corpus provides a retained legacy URL with 16 vertices and 57 total cells, including higher-cell references. Its decoded JSON is retained separately; Python's standard base64/JSON decoding establishes fixture structure only. The native reader, compiler/runtime and language-service cases are authored and unrun. The adjacent QUIVER-LICENSE retains the upstream MIT notice. No renderer or external executable is required by this reader.

FeynML diagram exchange

feynman / PARSE_FEYNMAN, contract revision 2, accepts the existing Grid record-v1 JSON and the selected unnamespaced XML serialization from FeynML revision 4f2ede5. A <feynml version="0.2.0.1"> wrapper uses child-element endpoints. A standalone <diagram> may use those children or the older attribute endpoints/sense. A diagram cannot mix the two forms; other wrapper versions fail explicitly. This is a bounded import profile, not universal FeynML version compatibility.

• diagrams retain source order, optional authored IDs and the selected endpoint encoding. entities retain ordered vertices, propagators and external legs, their authored attributes and scalar source/target/sense/name/texname fields.
• documentElements retains the ordered XML element/content tree, including symbolic momentum, labels, coordinates, styles, resource links and extensions. Particle IDs and coordinates remain authored strings; no PDG lookup or unit, momentum-conservation, particle-type or numeric-coordinate validation occurs.
• Entity IDs must be nonempty, whitespace-free and unique within a diagram. Diagram IDs, when supplied, must be distinct. Reusing an entity ID in another diagram is permitted. Endpoints resolve only to vertices in their own diagram.
• references classifies each required endpoint as resolved, missing, unresolved or wrong-kind. The latter three remain structured issues in the result and do not create graph edges. They do not silently become vertices. Duplicate IDs, duplicate scalar fields, mixed endpoint forms, misplaced structural elements, DTDs, malformed XML and xml:base fail compilation/import.

nodes and edges form an entity-incidence graph: every vertex, propagator and leg is a node, including isolated vertices. A propagator has a source and target incidence edge; a leg has a target incidence edge. All edges point from the connector entity to its referenced vertex. This direction describes incidence, not charge, momentum or time flow. Authored leg sense remains separate. Graph IDs are stable xml:<document-element-index> values within an unchanged input; reordering the XML can change them. Structured raw properties stay in entities/documentElements rather than nested graph properties.

Standalone example:

imported = feynman"""<diagram>
  <vertex id="v"/>
  <leg id="e" pdgid="11"><target>v</target><sense>incoming</sense></leg>
</diagram>"""
graph diagram = GRAPH(imported)

Raw triple/angle literals receive XML lexical highlighting. The existing bounded, lazy source index supplies local endpoint definition/references/highlights, vertex-only completion and incoming/outgoing sense choices. Duplicate identities, entity-spelled identities, ambiguous/mixed endpoint fields and xml:base refuse identity assistance. Unknown endpoint names have completion but no invented definition. XML identity rename and payload rewriting remain unavailable; existing Grid-record-v1 JSON rename retains its earlier contract. Ordinary quoted literals retain flat Grid escaping and mapped editor/diagnostic offsets.

The independent fixture extracts the complete XML stream output from the pinned producer's debug/css.ipynb: four vertices, four propagators and four legs imply 12 incidence nodes and 12 links. Its stylesheet URL is retained, never fetched. Fixture-only GPL-3.0 attribution/license is retained beside the data; no producer implementation or Python runtime is incorporated. A synthetic fixture exercises isolated vertices, non-ASCII IDs and symbolic momentum. Provenance records hashes and separates these origins; this task did not run the producer.

Reader, source-editor and compiler/saved-LIR/GRAPH/diagnostic cases are authored. Native execution, live-editor QA and Performance remain owner-deferred. No stylesheet/TeX execution, rendering, amplitudes, exporter, new evaluator or new runtime dependency is introduced. Standard (Lite)/Pro allocation is unchanged.

CML reactions, schemes and mechanism annotations

reactions / PARSE_REACTIONS and mechanism / PARSE_MECHANISM, contract revision 4, retain Grid record-v1 JSON and accept selected XML in http://www.xml-cml.org/schema. Roots are cml, reaction, reactionList, reactionScheme, mechanism or map. The old cml2/react namespace is not silently aliased. Namespace prefixes may vary without changing meaning.

The import is grounded in the pinned Schema 3 vocabulary and CMLXOM publisher examples. The published conventions list does not supply a dedicated reaction convention. This delivery therefore names a bounded structural import, not a newly invented CML convention or complete XSD validator. Schema 3's extensible content model and experimental mechanism details do not justify inferring chemical behavior.

The native object contains:

• records: ordered reaction/list/scheme/step entities; reactants, products, spectators and substances; molecules, atoms, bonds and formulas; mechanisms, components and electrons; condition lists, properties, amounts and scalars; maps and links. Other named CML elements become identity anchors, permitting contexts such as a named reactantList without inventing chemical semantics. Each record retains its XML element index, raw attributes/content, nearest selected entity parent, sibling ordinal and eldest-molecule scope.
• groups: element-kind to document-element-index arrays. These index documentElements, not positions in the smaller records array.
• documentElements: the full ordered element/content tree, including unknown extensions, names, units, quantity text, classifications and map annotations.
• references and issues: authored typed identity links and explicit unresolved, wrong-kind, ambiguous or external/unsupported targets.
• nodes and edges: every selected entity is a node, even if anonymous or isolated. contains edges preserve hierarchy and order; reference edges preserve resolved explicit links. map-context edges identify explicitly named contexts; map-endpoint edges run from a link entity to a resolved endpoint. Stable xml:<element-index> identities apply within unchanged input; reordering input can change them.

Participant count is retained as the authored stoichiometricCount string and checked as positive and at most 1e99. Missing counts stay absent; they are not silently defaulted to one. amount is measured quantity, not a stoichiometric multiplier. Quantity units, step yield/ratio and written ordering remain raw metadata without conversions, kinetic meaning or inferred sequential execution.

A supported ref points to the same element kind. Atom/bond IDs are scoped to the eldest containing molecule; other selected IDs use document scope. Duplicate IDs in one scope fail. Explicit bond/electron atomRef, atomRefs, atomRefs2, bondRef and bondRefs fields are checked for their supported arity and target kind. Outside a molecule, an atom/bond name resolves only when globally unique; ambiguity is retained instead of choosing a molecule. Compound identity spellings are matched literally, without URI dereferencing. Link locator ref is not interpreted as a same-kind entity reference. References are not recursively expanded or used to merge property values.

Unknown/unresolved targets create no reference edges, but their authored records and containment remain. DTDs, malformed XML, duplicate identities, invalid participant counts/reference arities and xml:base fail. Full formula/atom-array expansion, schema/convention constraints, reference inheritance and molecular validation remain outside this profile.

Map/link fromContext and toContext select descendants of explicit named CML containers. A unique context ID resolves directly; an otherwise ambiguous ID must name the nearest matching ancestor. Link declarations override their containing map's context and fromType/toType. Types are literal local element names per Schema 3; prefixed type strings such as the publisher's cml:atom remain authored values without guessed namespace stripping. Missing contexts produce issues and no endpoint edges; they never fall back to global resolution. With no context, targets must be unique for the selected type throughout the literal. fromRef/toRef are not aliases for the schema's context attributes.

mappings retains each endpoint's side, single/set attribute, expected type, authored context, resolved context/target element indexes and status. from and to each contain one ID; reserved null means unmapped, with no endpoint edge. fromSet and toSet contain distinct same-type identities. Partial sets have no inferred pairings or order semantics: four endpoint incidences for two sets of two members do not become four atom-to-atom mappings. Source order is retained as data only. mapSetsPaired remains false. Locator/extended links and links outside a map retain their records with an unsupported-form issue.

Map example exercises duplicate atom IDs in separate molecules, set incidence, a link-level bond type override, an unmapped endpoint and a missing context. Its graph has 14 nodes and 23 edges; the missing context and endpoint remain two explicit issues. The editor uses the same indexed identity/context lookup for definitions and bounded completion, with distinct token spans even inside escaped quoted payloads. XML rename is unavailable.

Working example imports a synthetic scheme with fractional participant count, a scoped bond and explicit electron association. GRAPH(imported) produces 15 entity nodes and 18 containment/reference edges. This is a structure graph, not a claim that the illustrated reaction is chemically balanced or that the electron moves along a specified path. Both tags use the same native XML projection.

Raw triple/angle payloads have XML highlighting. The bounded lazy source index provides definition/references/highlights and same-kind reference completion, including molecule-scoped atom/bond names and explicit map-context/endpoint slots. Duplicate or entity-spelled identities, ambiguous global names and xml:base do not produce guessed navigation. XML rename remains unavailable; existing Grid-record-v1 JSON rename stays intact. Ordinary quoted literals keep Grid escaping and mapped source positions.

Three independent CMLXOM examples retain attribution and their Apache-2.0 license. Only line endings/trailing whitespace were normalized and a modification comment added. Two fixtures are explicitly synthetic. A fourth publisher specimen is transcribed from pinned CMLMapTest.java with attribution, expanded namespace constant and whitespace. It intentionally lacks endpoint definitions; no prefixed type normalization is inferred. These files exercise real publisher vocabulary, including intentionally unresolved molecule refs and nested schemes; no producer, schema validator or chemical oracle was executed. Reader/editor and compiler/saved-LIR/GRAPH/diagnostic cases are authored. Native execution, live-editor QA and Performance remain deferred by owner. Standard (Lite)/Pro allocation is unchanged. No network loading, new evaluator, chemistry execution or runtime dependency was added.

gestureBot timed-pose JSON

laban / PARSE_LABAN, contract revision 3, retains the Grid record-v1 object carrier and accepts the timed-pose JSON array used by Microsoft's gestureBot Design Kit. This is a named five-joint upper-body robotics format, not complete Labanotation, or Benesh. The older Kinect/LabanotationSuite object format is described below. Standard (Lite)/Pro allocation is unchanged.

Each array item requires numeric time in seconds. Present joints use the case-sensitive keys head, relbow, rwrist, lelbow and lwrist, each with dur (seconds), dir and lvl. Times/durations must be finite and nonnegative; zero-duration placements and repeated timestamps are preserved. An empty array and a time-only pose are allowed. No missing joint pose is synthesized.

Directions and levels accept ASCII case variants while retaining original text. Arms admit forward, right forward, right, right backward, backward, left backward, left, left forward and place. The head omits the three backward directions. Levels are high, normal and low; place with normal is ambiguous and rejected. These rules are pinned to the joint consumer. The upstream controller logs some invalid values and proceeds with fallback angles; Grid rejects them instead of silently importing those fallback poses.

The native object provides:

• document: complete decoded JSON, including cues and extension fields.
• poses: source-order pose indexes and start times.
• movements: one row per authored joint occurrence, ordered by pose and the fixed joint list above, with original joint object, normalized direction/level, start, duration and computed end in seconds.
• tracks: movement indexes sorted by time, then duration, then source order. This reflects the consumer's ordering without creating or interpolating playback keyframes. Signed zero sorts as zero; original JSON remains retained.
• cues: text/MIDI/audio objects with source pose/time, optional duration/end and all original fields. Text, MIDI notes, encoded audio and file URLs are opaque; there is no speech, MIDI parsing, audio decoding or resource loading.
• issues: overlapping positive-duration intervals and unknown pose fields. Neither is discarded or silently resolved. Unknown fields stay in document.
• latestPoseSeconds and motionEndSeconds: separate maxima for authored pose starts and known movement ends. A time-only pose does not extend motion. Missing maxima are blank; unknown media duration is never fabricated.

nodes and edges form a pose-membership and track-order graph. Each pose, movement and cue is a node; pose-to-item edges describe membership and next-in-track edges link sorted occurrences of the same joint. Array indexes form identities, so inserting/reordering poses can change graph IDs. Track edges do not imply interpolation, physical feasibility or actuator commands. The example preserves out-of-order sparse poses, an overlap, Unicode text and an inert media URL; GRAPH(imported) has nine nodes and seven edges.

JSON highlighting applies to raw triple/angle payloads; ordinary quoted Grid literals retain host escaping. Bounded source-only completion offers pose/joint keys, head-versus-arm directions, compatible levels and seconds help. Enum insertions replace string contents only; invalid unquoted scalar fields receive help without corrupting JSON. Timed poses have no named references or identity rename. Existing Grid-record-v1 navigation and checked rename remain available for the older object carrier.

Duplicate JSON keys, missing required fields, invalid direction/level pairs, negative/non-finite timings and end overflow fail. Parser diagnostics select the whole authored payload and map through Grid escapes/Unicode. The import does not apply the controller's millisecond rounding, synthesize start keyframes, calculate joint angles, solve kinematics or run any controller.

Two independent publisher files are retained with MIT attribution: hello.json (ten poses, fifty movements, a 4.05-second motion end) and GestureFormat.json (which includes cues and a time-only pose at 232 seconds). A third fixture is synthetic. The producer/controller was inspected, not executed. Reader/editor and compiler/saved-LIR/GRAPH/diagnostic cases are authored; native execution, live-editor QA and Performance remain deferred by owner. No new runtime, media dependency, worker or network operation was introduced.

LabanotationSuite named gestures

laban / PARSE_LABAN, contract revision 3, also accepts the older JSON written by Microsoft's LabanotationSuite authoring tool. Standard (Lite)/Pro allocation, Grid record-v1 input and gestureBot arrays remain. This imports already-authored Kinect-derived notation, not raw Kinect sensor frames or a movement-recognition algorithm.

The root is an object mapping gesture names to objects of named poses. Each pose requires "start time": [value], a finite nonnegative number or numeric string in milliseconds. Joint fields head, right elbow, right wrist, left elbow and left wrist contain [direction, level]. They use the same pinned head/arm vocabulary as gestureBot. Missing joints remain absent, and time-only poses and empty named gestures remain represented. Gesture/pose names are nonempty; duplicate JSON keys fail, including escaped equivalents.

The upstream converter changes some initial timestamps and derives durations from adjacent poses. Grid retains the authored timestamp, including an initial 1 millisecond; it does not apply those playback transformations. An optional duration is checked as a one-item finite nonnegative numeric array and retained as authoredDuration. It is not used as a movement interval. rotation remains uninterpreted data.

The native result contains:

• document: complete decoded data, including unknown pose fields.
• gestures: every named gesture, its source-order pose indexes, a separate chronologicalPoses index and optional latestTimeMilliseconds.
• poses: gesture/name, authored-order index, timeMilliseconds, derived timeSeconds, authoredDuration and raw rotation.
• joints: individual authored joint arrays with pose/gesture membership, canonical joint key and normalized direction/level beside original values.
• tracks: joint indexes ordered by millisecond timestamp, then original member order for ties, independently for each gesture and joint.
• issues: unknown pose fields retained without interpretation.

Source member order is recorded independently of the JSON map implementation. A Position10 member before Position2 stays first in poses; names are not lexically or numerically sorted. Numeric object keys also retain textual order. No gesture is discarded because a downstream player handles only one at a time.

Graph nodes represent gestures, poses and joint occurrences, including empty or isolated entities. contains edges preserve membership; next-in-track edges describe chronological joint order, without interpolating movement. Positional graph IDs are stable for unchanged input and may change after member insertion/reordering. The example has three gestures, five poses, five joint occurrences, 13 nodes and 12 edges.

Raw payloads retain JSON highlighting. Bounded source assistance provides spaced field-name completion, conditional joint-array direction/level choices and millisecond help through all Grid literal delimiters. Non-string direction/level values receive no string-content replacement. Pose names are declarations, not cross-reference slots; this profile introduces no identity navigation or rename. Grid-record-v1 checked rename remains separate and unchanged.

Publisher hello.json and generated_motion_sample.json retain MIT attribution; only line endings/trailing spaces and terminal newlines are normalized. They contain 10/17 poses and 50/85 joint occurrences respectively. The sparse, multi-gesture fixture is synthetic. Source inspection confirms milliseconds and the retained initial times; neither the upstream producer/converter nor Grid's native importer was executed for this increment. Native reader/compiler/runtime validation, live-editor QA and Performance remain owner-deferred.

Benesh exchange-format research, 2026-11-01

The official editor introduction describes font-based, vector, freehand and text signs. The editor FAQ describes the product and access. Neither inspected document provides a machine-readable serialization contract or redistributable exchange fixture. This is a specific evidence gap, not proof that no format exists. A pinned file specification and representative permitted samples remain necessary for a real Benesh importer. Grid's existing Benesh record carrier is not renamed or counted as native BNE-file support; no software purchase, external contact or invented file encoding was used to fill that gap.

MRV molecules and curved electron-flow arrows

mechanism / PARSE_MECHANISM and reactions / PARSE_REACTIONS, contract revision 4, accept selected Marvin XML (MRV) through their existing Standard (Lite)/Pro parsers. No additional tag, package, ChemAxon dependency or runtime engine is required. Grid record-v1 and the CML profiles remain supported. The changed contract invalidates earlier expansions.

The reader accepts cml, MDocument, molecule or reaction roots, either in http://www.chemaxon.com or the older empty namespace. Elements in other namespaces remain raw data. It supports explicit <atom id="a1" .../> and compact <atomArray atomID="a1 a2" elementType="C O" .../> forms. Selected parallel columns are elementType, formalCharge, hydrogenCount, isotope, lonePair, radical, mrvMap, x2, y2, x3, y3 and z3. Column lengths must match atomID. Unknown compact attributes remain on documentElements with an issue; they are not guessed into per-atom columns. Mixing explicit and compact atoms in one array fails. Coordinates become finite numbers alongside original string properties. Charges, isotopes and bond order remain authored values, without valence or chemical validation.

Each MEFlow has exactly two direct children: a source MEFlowBasePoint or MAtomSetPoint, then a target MAtomSetPoint. A base point has one atomRef; an atom-set point has one or two distinct atomRefs. These use explicit molID.atomID references, such as m1.a2. Optional weights contains exactly two finite numbers, retained without normalization. An atom pair may describe an incipient bond: Grid does not require or invent a molecular bond between it. The pinned schema's numeric identity spellings are not a claimed XSD constraint; the selected reader permits local nonempty identity names without dots.

Flow arcAngle, head/tail lengths, widths and skips are finite numeric geometry. Head/tail flags and electron-container/index attributes are retained as integers. These flags do not infer electron count, electron occupancy or a chemical transformation. Missing geometry is absent rather than filled with viewer defaults. Other attributes and ordered XML content remain in documentElements. No arrow is rendered, animated or executed.

Identity scopes are explicit: molID is unique within its MDocument; atom IDs and bond IDs are local to their nearest molecule. Separate documents may reuse names. Forward references resolve after collecting atoms. Unresolved references produce issues and null atom indexes, with no invented graph edge. Duplicate identities, malformed endpoint cardinalities, nonfinite geometry and xml:base fail. Nested-molecule ancestor fallback, SGroup expansion, full XSD validation, non-flow graphical object references and external resources are outside this selected profile; their uninterpreted XML is retained.

The native object contains records, atoms, bonds, flows, endpoints, references, issues, nodes, edges and documentElements. Atom rows retain XML element and compact-row indexes. Endpoint rows retain their source/target role, raw references, resolved atom indexes and weights. Graph nodes represent selected XML entities and every atom, including isolated atoms; containment and reference edges describe incidence, not electron transfer. IDs are stable for unchanged input and may change with source insertion or reordering. The example contains two documents, four atoms and three flows; its expected graph has 19 nodes and 25 edges, with one unresolved endpoint deliberately omitted from graph links.

The editor retains XML highlighting and adds bounded, source-only definition, reference and completion support for compact atom tokens, explicit atom IDs, local bond endpoints and document-scoped flow endpoints through all three Grid literal delimiters. Entity-spelled or duplicate identities and xml:base refuse navigation. XML identity rename remains unavailable. Source navigation does not execute the parser and does not substitute for native semantic diagnostics.

The source contract was checked against the pinned 5.10 schema mirror and current publisher documentation. An independent ACE Organic mechanism test provides a 19-atom, 15-bond, three-flow fixture; Java string escapes were decoded and the upstream AGPL license is retained beside this test-only data. No producer, chemistry engine or XSD validator was run. Synthetic modern-namespace tests cover multiple scopes and unresolved endpoints. Native reader/compiler/runtime tests, live-editor QA and Performance remain owner-deferred.

TEI feature-type inheritance

phonology / PARSE_PHONOLOGY, contract revision 4, follows local fsDecl baseTypes declarations when checking authored feature values. The TEI P5 4.12 inheritance contract combines inherited and local specifications monotonically. A same-named local feature cannot widen an inherited range. The feature-system chapter separates that relationship from conditional defaults and full subsumption.

Grid now resolves forward-declared bases, traverses multiple inheritance and checks each supplied atomic value against every applicable supported range. Diamond paths contribute a shared declaration once. The existing binary, symbolic, string, numeric-range and alternation checks remain bounded. Empty typed-structure ranges accept a locally established subtype; the nested structure's authored fields are checked separately. Unknown type relationships remain unvalidated. This is explicit-value checking, not a general unification engine or a proof that an entire declared type has a valid instance.

Declarations retain their direct features and add baseTypes, ancestorDeclarations, effectiveFeatures with every contributing constraint, missingBaseTypes and inheritanceResolved. Successful checks identify all contributing declaration nodes. Local cycles and malformed base names fail. Missing bases and inherited fsConstraints disable complete explicit-value checks for the affected type and remain visible in validation.unvalidated. Nothing is fetched. Missing features and defaults are not materialized; conditional defaults, complex collection ranges, truncated numerics and full subsumption remain outside the selected checks.

The diamond-inheritance example combines numeric ranges 0..10, 2..8 and 4..6: its authored value 5 passes all three, while 7 fails despite passing the first two. The local label constraint narrows two inherited choices to one. Its nested Leaf structure satisfies an empty Base type range. Four explicit field checks are expected. The fixture is synthetic and specification-derived, not output from an independent TEI validator.

Source-only editor assistance combines inherited feature choices and navigates fs/@type and individual fsDecl/@baseTypes tokens to local declarations. Token edits retain their authored ranges through quoted, triple and angle-block Grid literals. Incomplete inheritance suppresses the affected feature choices; cycles or entity-spelled names refuse the index. Identity rename remains unavailable. No parser execution or external schema loading occurs for this help.

A shared iterative traversal charges reachable ancestry and edges against the existing ingress/editor budget; independent types do not allocate a whole-document state array per type. Effective constraint tables can still grow with inheritance depth and are bounded by that budget. Default-path and selected costs are unmeasured. Native validation, live-editor QA and Performance remain owner-deferred; source/frontend checks are recorded separately.

DAGitty causal graph interchange

causaldag / PARSE_CAUSALDAG contract revision 3 keeps the Grid-record-v1 branch and adds explicit braced DAGitty documents. The native implementation is based on the pinned publisher grammar, consumer, and structural checks. No upstream code or fixture is copied; the regression fixture is synthetic and has not been run through an upstream oracle. No JS runtime or dependency is added.

Use the causal-graph example. All three Grid delimiters and the native function share this profile. Standard (Lite)/Pro allocation stays unchanged.

For a native graph region, pass the literal directly:

graph causal = GRAPH(causaldag"""dag { X [exposure]; Y [outcome]; X -> Y; isolated }""")
nodeCount = causal.NODE_COUNT()

Named-data graph admission remains a separate recorded integration obligation.

• Headers: dag, digraph, graph, pdag, mag, pag, optional graph name and strict marker. The marker is retained, as in the upstream grammar; it does not introduce a separate evaluator.
• Bare or double-quoted identifiers, quoted concatenation, escaped quotes and backslash-newline continuation preserve decoded identity and authored text. Semicolons separate statements. Bare-body/legacy adjacency input and DOT comments/HTML labels are not admitted by this profile.
• Chained edges, anonymous/named groups and nested groups expand their actual member sets. Named groups are containers, not vertices. All nine operators retain tail/arrow/circle endpoint marks. Reversed operators normalize their source/target orientation. Repeated identical edge kinds merge attributes; parallel different kinds remain distinct. Self edges are rejected.
• Variables retain first-encounter order, including isolated vertices. Node declarations accumulate exposure/outcome/latent/adjusted/selected roles and their documented aliases; flags are presence-based even with an explicit value. Unknown attributes remain inert. pos requires two finite numbers, bb four. Latest repeated attribute values win, while document retains original spelling, group names, duplicates and statement order.
• variables and relations preserve rich role arrays, attribute objects, layout coordinates and normalized authored endpoints. nodes and edges are separate graph-ready projections with scalar properties. Edges use the native id/from/to contract and retain kind, endpoint marks and a relation index; nodes retain role flags and a variable index. The graph kind supplies directed:false; other kinds supply directed generic graph projections. A bidirected/partial relation stays one canonical marked relation, not an inferred set of causal reachability arcs. Generic traversal is not causal analysis. Empty variable names are rejected by the selected graph profile. Edge-chain/group attributes apply to every expanded relation; this deliberately avoids the upstream consumer's last-edge-only assignment for group products.
• DAG admits directed/bidirected edges and rejects directed cycles. Graph admits undirected edges. PDAG/MAG admit directed/bidirected/undirected edges; PAG preserves every mark. PDAG/MAG/PAG reject directed cycles after contracting undirected components. Digraph retains directed cycles. These structural checks do not prove full MAG/PAG validity, maximality or causal claims.
• Source-only editor indexing offers literal-local variable definitions, references and completion, graph-kind and node-attribute choices, and hover. Quoted completion copies the original mapped token so ordinary Grid quotes retain escapes. First explicit declaration is the definition, otherwise the first endpoint occurrence. Malformed syntax yields no identity index. The lexical grammar uses existing theme tokens; identity rename is unavailable.

Syntax work, nesting, group products, owned string expansion and cancellation are bounded before/following construction as appropriate. Union-by-size and Kahn traversal avoid per-variable cycle searches. Parsing runs only at explicit parser ingress/compilation, with no new per-cell or per-resolve work. Native correctness and Performance remain unrun, including ordinary-path tax and selected-path cost. Regression sources cover graph kinds, marks, group products, duplicates, Unicode spans, limits, cancellation, all delimiters, function/literal equivalence, documented examples and saved-LIR graphs without the parser. Causal estimation, adjustment sets, interventions, layout, rendering, external resources and broader legacy input remain outside the descriptive profile.

CalChart choreography show JSON

choreography / PARSE_CHOREOGRAPHY contract revision 3 retains Grid-record-v1 and adds CalChart formatVersion: 1 JSON shows, pinned to fb8e4bde3db9dabd52d1c27db5c064fd05dd36e9. The producer's show schema, show reader, sheet reader/writer and point reader define this selected contract. The source calls this a new JSON show format; this is not older binary .shw or the separate viewer export format.

Use the formation example. Quoted, triple-quoted and angle-block literals and the native function share the Standard (Lite)/Pro reader. formatVersion / labels_and_instruments selects the external branch; Grid's version/nodes/edges carrier remains unchanged.

• performers retain label/instrument data and zero-based array identities. Duplicate labels do not merge performers. formations retain sheet order, names, integer counts and tempo, plus cumulative authored beat bounds. Zero counts and tempos remain explicit; no elapsed-seconds timeline is inferred.
• positions retain authored coordinates, optional reference positions, symbols and display flags. Units are CalChart Coord::units (1/16 step). Fractions are not rounded; omitted references/flags remain null instead of receiving playback defaults. At most three reference positions are accepted, following the point reader rather than the looser published schema.
• curves retain authored control points and performer assignments. The pinned schema says point_indices; the actual reader/writer says marchers. Either is admitted with its original spelling recorded. If both occur, differing arrays fail; equal arrays are admitted without duplicate memberships.
• continuities retain symbol-scoped ordered procedure/value/point ASTs and legacy text. Shared native/editor vocabulary covers 22 procedure, 18 value and five point kinds. Known kinds require their declared fields, typed child kinds and enum values. Unknown future kinds are preserved in unvalidatedAst. This intentionally checks known nodes more strictly than the schema's broad fallback alternative, which could otherwise mask malformed known kinds.
• fermatas retain every authored hold in source order, including repeated beats. They do not silently collapse to the producer's last-value map or modify formation durations. Print continuity, media, images, mode and unknown fields remain in document; media/base64 strings are not decoded, validated as image/audio bytes, fetched or executed.
• Stable nodes/edges describe shows, performers, formations, positions, curves, continuity selection and next-formation order. No interpolated path, speed, collision, movement interval or choreography execution is invented. Point/performer count mismatches and out-of-range selection/curve/current-sheet references remain issues. Missing memberships are omitted, with isolated performers retained. Duplicate JSON keys and conflicting assignments fail.
• JSON highlighting stays active. Source-only assistance navigates numeric selection/curve indices to performer labels and current-sheet indices to formation names, with literal-local numeric completion. Point-object starts also navigate their positional performer when present. Fields, symbols and AST kinds offer vocabulary completion and hover. Dual assignment fields suppress source indexing conservatively. Positional identities cannot be renamed through this profile; existing Grid-record rename remains unchanged.

The publisher fixture is transcribed from its validator test and carries GPL-2.0 attribution. It contains two labels but one point: the importer exposes that mismatch. A synthetic fixture adds duplicate labels, two formations, assigned curves, unknown AST data, inert media and dangling references. Neither fixture has been executed here by upstream CalChart. Seven focused native reader/editor/runtime cases and combined delimiter/function/cancellation/example/cost cases are authored, unrun under the owner's native-validation deferral.

Work and output measurements are bounded at parser ingress and projections; all execution remains on Grid's existing LIR path. No native conformance, physical-edition availability, rendered editor QA or measured performance claim follows from these source changes. Broader choreography and Benesh remain separate families/contracts.

Additional Benesh investigation

The MacBenesh manual describes score frames, signs, saving and print/paint output, but the inspected manual does not establish a machine-readable exchange schema or permitted sample bytes. This adds another inspected source; it does not prove that a serialization is unavailable elsewhere. An actual encoding contract and representative permitted files remain the concrete prerequisites for a Benesh reader. No software was purchased or run, and nobody was contacted.

Native graph projection correction, 2026-11-01

Source review against grid-gir-passes/src/lowering/graph/native_data.rs found that the initial, unexecuted DAGitty and CalChart implementations emitted source/target graph endpoints, but native graph admission requires from/to. DAGitty also included non-scalar attributes/roles/positions in graph rows. Revision 3 corrects both contracts; rich DAGitty data remains in separate variables/relations tables. CalChart's existing rich tables remain unchanged. The earlier implementation evidence is retained as historical source evidence, not promoted to executed graph acceptance.

A new reader contract case checks eight specialist projections for scalar properties, unique identities and resolved from/to endpoints. A new compiler/runtime case compares DAGitty and CalChart projections with handwritten native graph constants through saved LIR. Both are authored and unrun. Named live-data GRAPH(binding) remains separate work: its current tree-source binding must not be replaced by a frozen compile-time copy.

The handwritten closed-object form also preserves directed: FALSE instead of forcing directed edges. Omission defaults to TRUE; nonboolean and live direction expressions refuse at compilation. Two lowering cases check the portable payload/handle flags and invalid inputs; all native cases remain unrun. The saved-LIR comparison now checks out-degrees and every ordered reachability pair, including reversed edges, undirected graphs and isolated vertices.

Shared graph data admission, 2026-11-01

The compiler's native graph constants now use the shared grid-value::native_graph_data admission owner. It borrows decoded JSON or resident closed records and ordered row sequences, checks the same portable GraphSpec, and rejects duplicate IDs, dangling endpoints, structured properties, nonfinite numbers and invalid direction. Node/edge counts, cumulative work and logical allocation bytes are bounded; the selected caller's cancellation and deadline control also reaches final GraphSpec validation. These counters are not measured RSS or latency. Preceding text decoders retain their own input, depth and duplicate-key obligations.

The resident adapter preserves native record identity rather than interpreting arbitrary key/value arrays as objects. Explicit legacy object carriers are accepted with duplicate-field checks; flat or one-row arrays and native vectors/tuples/deques may carry records. Encoded handles and unsupported scalar carriers refuse. Signed 64-bit exact integers remain exact; integral native numbers are checked before conversion, without saturation. Rich root metadata is not copied or traversed.

Five focused cases and the existing compiler/saved-LIR controls are authored, not executed. This is a shared admission implementation, not completion of live GRAPH(named_value). The next runtime change must version the source contract, carry changing direction through primary and derived graph handles, reuse exact source-revision caching, and preserve failure/recovery and saved-LIR behavior. Existing tree and certificate-bound symbolic result semantics remain intact.

Live native graph data, 2026-11-01

The shared admission stage above is now connected to GRAPH(named_value). For example, import a literal into data, then declare graph links = GRAPH(data). The binding tracks the current value; it does not freeze the initial literal. The same form accepts a computed native object with nodes, edges and boolean directed. See the reactive example.

Graph ABI 11/source schema 2 carries revision-dependent direction through primary and derived graph handles. Old schema-1 tree bindings remain readable. Changed sources are bounded before revision hashing, including metadata omitted from graph projections. Existing typed-object carriers decode with depth, duplicate-field and cumulative allocation checks. No original format parser is needed to hydrate compiled values. Invalid replacements fail; a later valid replacement can rebuild the graph through the existing resident store.

The editor uses the existing Grid reference and graph-method support; no tag or embedded grammar is added. Source-only payload navigation remains local to its literal. This does not add runtime-derived node completion or payload formatting. No rendered editor QA was performed for this increment.

Ten native cases cover bounded wire decoding, metadata extent, dialect/flag compatibility, old tree metadata, changed direction and derived graphs, query-only edits, columnar layout identity, malformed-value recovery, example reload and eight named specialist projections compared with inline graphs after saved-LIR loading. All are authored and unrun under the native-validation deferral. Source checks cannot establish these runtime guarantees; see the evidence record.

RomanText analysis documents

roman accepts the descriptive grammar in the RomanText specification, alongside existing chord lists. See the analysis example. A document returns format: "romantext" with ordered entries. Measure entries have a measure range/ending/variant and events; each event retains its source, payload-relative UTF-8 span and authored beat text (default "1" before an explicit beat). Key, meter and minor-mode changes remain ordered records, without inferred inheritance. A movement scopes measure identities. Duplicate/overlapping identities reject; variant readings and alternative endings remain distinct.

Copy entries retain equal-length earlier source ranges without materializing measures. This supports compact and overlapping copies without unbounded expansion. Gaps in numbering may imply held harmony in RomanText; Grid neither fills those gaps nor claims reference resolution. Pedal endpoints are retained with the standard exclusive end convention. Unknown metadata has known: false. pitchesRealized, copiesExpanded, timingRealized and referencesResolved are all false. Numeric subdivision strings such as 1.66.5 are never rounded into exact timestamps. Supported meter syntax is simple/additive integer numerators over power-of-two denominators, C, Cut, and Slow/Fast prefixes. Other music21 meter dialects, contextual musical validity, score rendering and playback remain outside this profile.

The implementation reuses native parser limits, cancellation and cache identity; no Python or external executable runs. Four BSD-licensed music21 source fixtures are pinned with provenance. Parser, editor and saved-LIR acceptance are authored but unrun while native validation is deferred. Monaco lexical support and shared LSP completion/hover are implemented; live rendered QA is outstanding.

Highlighting native payloads in VS Code

The editor recognizes all 204 literal spellings from the native parser catalog, including aliases. Angle blocks close on their own spelling with case-insensitive ASCII matching. An ordinary quoted string uses Grid escapes. Raw angle and triple-quoted payloads have more detailed highlighting, including GEDCOM records, Newick branch lengths, FASTQ read structure, KiCad schematics and RomanText analyses. Domain-specific assistance such as navigation and completion is listed for each parser in the editor catalog.

Delegated host grammars carry multiline state on interior lines. Grid bounds the host grammar's input on the line containing the closing delimiter. Format-specific states carry across lines for selected formats including CIF text fields, SGF values, FASTQ and SPICE. Host grammar availability depends on the editor installation. A quoted payload containing escaped foreign syntax can have fewer lexical colors than its raw equivalent.

KiCad electrical schematics

Use circuit or PARSE_CIRCUIT(text) in Standard (Lite) or Pro to read a KiCad 7 schematic with revision 20230121. Read elements for placed symbols, pins, sheets, junctions, buses, wires and labels. A wire's points hold the authored pair of XY coordinates in millimetres. Sheet properties retain the referenced filename. sections records every form in source order with its parent, attributes and UTF-8 byte spans into source. This keeps extensions and instance paths inspectable. Example · KiCad schematic specification

GRAPH(schematic) describes object containment, pin ownership, and local library use. A placed symbol resolves against the embedded library using its lib_name override when present, or its lib_id otherwise. Missing definitions produce unresolved reference rows. Duplicate library names, duplicate placed UUIDs, malformed coordinates, ambiguous scalar fields and unsupported revisions produce diagnostics. The structural reader retains unprojected forms as data. Electrical net inference, external sheet traversal, complete KiCad validation and rendering remain open.

The editor highlights schematic keywords, quoted strings and comments. Within a supported schematic, go to definition follows an embedded symbol reference. Completion offers local library definitions, label shapes and symbol flags. Library completion copies the authored spelling from the same Grid literal, including escapes. Grid JSON records continue to support their existing checked identity edits.

Benesh VBD key poses

In Standard/Lite and Pro, benesh and PARSE_BENESH accept the Virtual Ballet Dancer ASCII pose notation illustrated in Royce Neagle’s thesis. The reader retains the numbered frames in source order. Head, body and pelvis may have successive bend, tilt and turn instructions. Each hand or foot position carries its written width, stave height and qualifier. The supported position qualifiers are front, level and contact. A hash starts a line comment. Neagle, Emotion by Motion, chapter 4, figures 4.3, 4.4 and 4.6

Read frames for pose labels and marks for the ordered orientations and positions. The nodes and edges tables connect each frame to its marks. Omitted body parts stay absent. Grid does not derive Cartesian joint positions, timing or interpolation. The existing Grid record-v1 JSON remains available. BNE and MacBenesh score files require separate readers. Two-pose Grid example

Specialist enhancements in 0.76.0

These bounded Standard/Pro additions retain the single Rust LIR path. The delivery ledger records specifications, validation and the explicit Benesh deferral. The working example uses ordinary literals and explicit operations; no external program is executed.

• RESOLVE_ROMANTEXT(text) expands earlier same-movement measure copies and missing measures with held harmony, up to 4096 output measures. Keys follow the destination context unless copied events explicitly change key. It preserves source spans and ordered positive decimal beat labels (up to six fractional digits); each key change needs a following harmony. Alternate endings/readings, pivot chords, optional keys, missing copy sources and an initial chord without a key are refused. It does not realize pitches or calculate timestamps. roman stays descriptive.
• LANDXML_POINTS(data, unit) converts native LandXML 1.2 point coordinates with a declared linear unit. Supported targets are millimeter, centimeter, meter, kilometer, inch, foot, USSurveyFoot and mile. The exact rational scale is reported; arithmetic is binary64. Missing elevation stays null. Overflow and underflow-to-zero are errors. No CRS or uncertainty transformation occurs.
• RESOLVE_XIANGQI(board, move) interprets a Chinese/WXF descriptor using {side, pieces}; each piece supplies piece, side and square. Squares run from a0 to i9, with Red advancing toward rank 9. It checks ordinary piece movement, blockers, cannon screens, palace and river restrictions. Source-file selection must identify one piece; front/rear requires exactly two pieces on one file, middle exactly three pawns, and numbered pawn selection a unique file. Check, flying-general captures, repetition and game legality are not evaluated. The board remains unchanged; the result supplies UCCI coordinates.
• VALIDATE_DEXPI(text, resources) validates target-model objects against up to 16 supplied DEXPI XML 2.0.1 model texts, matching import URIs exactly. It checks inherited data properties, multiplicity, primitive kinds, nested aggregates (depth 32), and enumeration literals, including declared unit membership. Inheritance is bounded to 64 active definitions. Missing definitions, cycles, class extensions, relationship properties, bound/union types, primitive/enum inheritance and multi-valued uniqueness are refused. Unused definitions are not validated; no resources are fetched and no units are converted.
• abc revision 5 accepts explicitly paired, unnested |: / :| at complete measure boundaries. Written repeat marks remain in the native score. Selected preceding decorations are trill, lower mordent, turn, fermata, staccato and accent, including their supported standard short forms. Unknown decorations, alternate endings, partial-measure repeats and unattached marks are refused. Decorations attach to the first event of a split/tied note. No ornament notes are synthesized. lilypond revision 4 accepts two to four non-nested absolute voices in << { ... } \\ { ... } >>; each voice has independent duration inheritance and must span the same number of measures. Existing final-measure rest padding applies independently. Scheme, includes and relative pitch remain refused.
• xmi revision 3 adds regions, concrete vertices, transitions and triggers, including protocol state machines. Local event/submachine references resolve through the shared ID index. Abstract containment does not invent a type; external links remain data. There is no state-machine execution.
• maritime revision 4 adds NGA Pub. 102 (2020) AC, AN/AN1–2, BR1–4 and CB1–8. A selected numeric complement can be compact or separated by whitespace. The import preserves the original source span and canonical compact code.
• usc revision 2 adds positive ascending integer section ranges after §§, using a hyphen or en dash and an optional nonzero four-digit edition year. Endpoints retain their spelling and are not expanded. A single-section identifier such as 2000e-2 retains its existing meaning.
• transliteration revision 4 adds the ALA-LC Ukrainian 2011 letter table as ukrainian-alalc-2011 / ala-lc:uk:2011. The input is NFC-normalized; unmapped characters remain. Output is not declared reversible or word-contextual.
• phonology revision 5 checks local TEI symbol-only vColl ranges: lists preserve order, bags preserve multiplicity, and sets compare membership. Omitted org means list; empty collections are valid. Other collection expressions remain explicitly unvalidated. Defaults are not materialized and cross-feature constraints are not newly evaluated.
• VALIDATE_CIF can apply a supplied static default to a wholly absent root Set-category packet. Missing values explicitly authored as ? or . are not overwritten. Loop packets, save-frame packets, split packets and method-derived values are not inferred by this addition. Imported data is never mutated.
• sacm revision 2 reports expected types and local endpoint-type checks for selected asserted relationships. Wrong known endpoint types produce warnings while retaining links. Unresolved/external/foreign targets remain unchecked; the result still does not claim complete metamodel validation or proof.
• knitout revision 2 types four CMU settings only for the declared Machine SWG091N2: x-stitch-number (u32), x-speed-number (0–15), x-sub-roller-number (0–31), and x-presser-mode (off/auto/on). Each requires one argument. Other machine extensions retain uninterpreted arguments. These are imported commands, with no machine execution or fabric simulation.

Authoring uses existing embedded grammars, native diagnostics and catalog help. UML state references participate in local navigation, and the new maritime codes use the shared completion vocabulary. The new callable operations have function help and argument signatures; they do not add a second parser or board/model editor.