The method’s central claim is evidentiary. Text is treated as a building medium only when operational relations remain replayable under revision. Replayability is an external system test rather than an internal declaration. Geometry-only outputs can describe one state of a building, yet the same system cannot show which relation changed, why the change occurred, or how far the change propagated. Replayability therefore separates descriptive records from constructive evidence. That distinction governs the entire evaluative framework: evidentiary status is determined by published inspectability rather than by the richness or historical authority of the source.

The practical risk for the system is evidentiary opacity under revision pressure. A team can redraw a plan many times without exposing the governing relation chain. Visually plausible geometry can also hide dependency shifts inside undocumented system adjustments. That failure blocks comparative review because reviewers cannot rerun the same derivation. Accordingly, authors are required to publish relations, not only dimensions, and reviewers are required to test revisions as named parameter, branch, override, and correction changes. This implies that the publication contract, not the internal drafting process, is the site where evidentiary quality is determined.

The method’s evaluative scaffold is a set of seven disclosure surfaces, each of which a replayable package must publish. These surfaces are not a private axiom set; they are the published correlates of the thesis’s own evaluative apparatus, and each surface maps directly onto one of the four critical properties of a constructive representation (interoperability, transportability, manipulability, and transformability) and onto the testable propositions P1 to P5 declared at §3.5. The seven surfaces are: representation (the identity and scope a package declares, bearing on semantic-interface persistence, P1); modularity (stable, reusable part identities, bearing on interface-bounded modularity, P2); commensurability (a declared base measure that lets ratio claims travel into a new context, bearing on transportability); procedural generation (a published generator that makes revision an executable, replayable operation, bearing on transformability and P3); translation (a contract under which meaning survives exchange across tools and notations, bearing on interoperability); correction (an explicit, auditable record of discretionary edits, bearing on manipulability); and integrity (a revision trace that keeps change local and reviewable, bearing on integrated utility under diachronic burden, P5). Alongside these surfaces, a three-rung ladder states what the source base can justify as instance description, canonical identification, or generative definition. The ladder prevents over-claiming because the method ties evidentiary status to published surfaces rather than rhetorical confidence.

Two governance devices operate as release controls in the method. The evidentiary sequencing procedure sets the minimum disclosure sequence before teams treat geometry_outputs as stable for reuse. The credibility test protocol applies pass or fail tests for replay under revision. Both devices function as release standards and not as claims about historical production order. Their role stays narrow: the devices specify what must be inspectable at release time regardless of internal work sequence.

The publication contract is direct inspectability of those seven surfaces with explicit fields. The representation surface requires publication of representation_level, scope_statement, and declared competence boundaries. The modularity surface requires stable role and module identities through roles_map and role definitions. The commensurability surface requires modulus or base measure, explicit units_policy, and bounded constraints. The procedural-generation surface requires publication of dependency_graph, declared branch_conditions, explicit branch_state, and override_policy. The translation surface requires a translation_contract that states term-element mapping, directionality, and round-trip limits. The correction surface requires correction_policy and applied correction_records, with those records held separate from derivational overrides. The integrity surface requires transform_log, persistent uncertainty_register, and release rules that keep revision effects local and reviewable.

The ladder is an explicit triage routine for mixed evidence packages. A package is instance description when artefact state is exposed but replayable generation rules are not. A package is canonical identification when reviewers can normalise variants for comparison yet revision logic still remains unpublished. A package is generative definition only when authors publish enough of the seven disclosure surfaces for independent replay. Operationally, this triage rule tells reviewers which claims a package may support and which claims the method must defer. Across cases, the routine protects synthesis quality by comparing like with like instead of promoting descriptive material to generative status.

The comparative design uses one question across most-different systems: does a published package remain revisable without collapsing its dependency chain in the reporting system. Greek proportion discourse enters the analysis because that literature frames symmetria as commensurability across related parts and therefore supports ratio-governed comparability rather than mirror-style resemblance.¹ Japanese kiwari evidence enters the analysis because manual cascades and case analysis document anchor-to-dependent proportional transmission, so the system must expose branch handling and authorised discretion for replay to remain credible.²³ Vietnamese bay modularity enters the analysis because instrument-mediated proportion control separates strict commitments from discretionary bands, and correction governance must preserve that separation.⁴ Taken together, the three cases stress-test commensurability pressure, cascade pressure, and modular-anchor pressure within one reporting system.

The method remains explicit about competence boundaries. Tacit craft competence can supply missing values in practice when teams declare that choice in the method record. When that occurs, each substitution must be carried as a named uncertainty class with scope and propagation notes. The requirement is enforced because silent completion can accelerate drafting while destroying replay accountability. Later reviewers otherwise cannot separate observed data from discretionary completion, and evidentiary force then collapses.

Overall, this framing makes three methodological commitments. The first commitment: each case section must report observable indicators, pass or fail conditions, and required evidence types for the seven disclosure surfaces. The second commitment: disagreement under revision must localise to named parameters, branch states, overrides, correction records, or uncertainty classes. The third commitment: missing required publication fields keep the package in draft status. In summary, the method is governance-oriented rather than uniformity-seeking. A package passes when independent reviewers can inspect it, replay it, revise it, and identify where and why outcomes diverge.

Text operates as a building medium when it preserves operational relations in a representation that remains replayable under revision. The claim concerns evidentiary capacity rather than stylistic form, so the governing requirement is disclosure: reviewers must be able to inspect the generator, the commensurability standard through modulus and units_policy, and the declared correction and revision-governance surfaces. The question of whether text operates as a building medium is therefore always an empirical question about what is published, not an aesthetic judgement about the prose style of the representation.

Geometry-only releases remain legitimate representations, but they typically function as instance descriptions because they preserve end-state geometry while hiding rule commitments and adjustment logic. Relation-first reporting instead treats revision as change to named parameters, branch_state, overrides, or correction events, which keeps downstream effects traceable. This implies that a practitioner team choosing between geometry-first and relation-first packaging is not making a technical choice but a governance choice: one that determines whether future reviewers can audit, extend, or challenge the reconstruction.

A three-rung representation ladder clarifies what sources justify. Instance description reports one artefact state without a published generator and therefore cannot support revisable rule chains. Canonical identification normalises variants for cross-case comparison but still does not justify revision as rule change. Generative definition publishes a rule family with explicit dependencies, branch conditions, and override priorities, and that publication is what localises disagreement. Overall, the ladder is thus a triage instrument that protects synthesis quality by preventing descriptive material from being promoted to generative status without sufficient evidentiary warrant.

To satisfy the seven disclosure surfaces, a replayable package must publish relations, generator surfaces, and decision records rather than dimensions alone. The representation surface requires representation_level and scope_statement; the modularity surface requires roles_map, role_definitions, and declared modules; the commensurability surface requires modulus or base measure, explicit units_policy, and a constraints_set with inference_notes for inferred constraints; the procedural-generation surface requires dependency_graph, branch_conditions, declared branch_state, and override_policy; the translation surface requires a translation_contract with directionality and round-trip limits; the correction surface requires correction_policy and correction_records; and the integrity surface requires transform_log, uncertainty_register, and a competence-bounding profile so tacit filling remains visible. Taken together, these seven fields constitute the minimum inspectable surface through which text earns its status as a building medium rather than a geometric description.

Borderline cases keep the ladder non-arbitrary. A manual may publish proportions but omit conditions for variant selection or authorised correction; that omission must be carried as an explicit uncertainty class across revisions rather than absorbed as implicit competence. A short cascade makes the point: if a base anchor yields derived members and span by ordered proportions, replay under alternative lineage conditions is possible only when branch conditions, selected branch_state, and authorised discretion bands are published, otherwise the logic remains implicit inside final geometry.⁵

The stop condition follows directly: if required fields remain unpublished, the package remains in draft status. In summary, text therefore operates as a building medium when and only when the seven disclosure surfaces are published in full, and thus the governing test is always disclosure completeness rather than formal or stylistic qualification.

Greek proportion narratives treat symmetria as commensurability under a declared standard and not as mirror resemblance. They also require iterative adjustment when Doric constraints conflict.⁶⁷ A replayable package therefore has to publish representation scope, stable Doric roles, declared modulus and units_policy, dependency and override surfaces, translation mappings, correction governance, and revision traces. Only then does reuse remain inference under revision. Building on this requirement, the Greek case is most instructive precisely where the evidence is under-determined, because those gaps force explicit uncertainty classification rather than silent gap-filling.

Packaging is decisive. Geometry-first releases expose final drawings and hide adjustment logic. Relation-first releases publish units, constraints, dependencies, branch_state, and override_policy. That choice localises disagreement to named parameters, branches, overrides, or correction events. Locality is what makes revision auditable. Overall, the packaging decision, geometry-first versus relation-first, is therefore the single most consequential governance choice in Greek proportion reconstruction, and this implies that publication format rather than source richness determines whether independent replay remains possible.

Evaluated against the seven disclosure surfaces defined in the framing section, and tested clause by clause through the credibility test protocol, the Greek case stresses two surfaces above the others. Commensurability (the transportability surface) is where Greek reconstruction most often fails, because metrology is typically reported while the generator logic that would let ratio checks be rerun is absorbed into final drawings; a release passes only when modulus, conversion rules, and units_policy make ratio checks rerunnable, not when a single best-fit modulus is asserted. Correction (the manipulability surface) is the second decisive gate: the Doric adjustment tradition, which involves known categories of perceptual refinement, must be carried as a governed correction layer (correction triggers and deltas recorded in correction_records, kept distinct from generator overrides) rather than left as unexplained geometric variation. The representation, modularity, procedural-generation, translation, and integrity surfaces apply in the standard form, with under-determined Greek evidence remaining manageable only when uncertainty classes stay explicit in the uncertainty_register. In summary, the Greek case demonstrates that commensurability pressure, the need to reconcile competing metrological standards and adjustment traditions, is precisely the condition under which the transportability and manipulability surfaces are most consequential, and consequently any contemporary reconstruction of Greek proportion systems must treat both as non-negotiable release conditions.

Kiwari manuals encode recursive proportional cascades that generate many member dimensions from a small anchor set.⁸ The cascade is replayable only when the seven disclosure surfaces are published. Those surfaces include representation scope, anchor and role structure, base measure with units_policy, dependency and branch declarations, translation mapping, correction governance, and revision traces. Kiwari evidence is most valuable as a stress test of cascade pressure: the condition in which a small change to one anchor propagates through the full derivation tree and must be traceable at each step.

Replayability depends on external inspectability of derivation. A credible release publishes the cascade as dependency_graph. It declares the active branch_state. It records authorised discretion in correction_policy and correction_records. Without those surfaces, tacit competence supplies missing parameters and executability loses bounds. If final dimensions are published without derivational propagation, anchor changes produce only drawing deltas and not auditable replay. This implies that the recursive structure of kiwari, its defining characteristic, is precisely what requires the most rigorous procedural-generation governance, since any gap in the dependency_graph breaks the traceable cascade.

Evaluated against the seven disclosure surfaces defined in the framing section, and tested clause by clause through the credibility test protocol, the kiwari case stresses the commensurability and procedural-generation surfaces jointly. The commensurability surface (the transportability surface) passes only when base measure, conversion rules, and units_policy make the proportional ratios testable rather than asserted without measurable standards. The procedural-generation surface (the transformability surface, P3) is the decisive one for a cascade: it passes only when dependency_graph, branch_conditions, declared branch_state, and conflict policies allow deterministic replay under a revised anchor, and it fails when revisions appear as manual patches, because any gap in the dependency graph breaks the traceable cascade. The representation and modularity surfaces require that representation_level, scope, competence assumptions, reusable anchors, and role vocabulary be made explicit, since making the anchor vocabulary explicit is the minimum modularity commitment for a release claiming generative capacity. The translation surface (interoperability) and the correction surface (manipulability) govern the interface between the manual tradition and contemporary analytical practice (their omission is the most common source of systematic bias in kiwari scholarship reconstructing proportions from translated sources) and the integrity surface requires that transform_log, persistent uncertainty_register, and release stop conditions preserve coherence across versions. In summary, the kiwari case establishes that recursive cascade structures are not inherently harder to govern than simpler proportion systems (they require the same disclosure) and consequently any release that cannot trace its cascade through a complete dependency_graph must be labelled draft regardless of how well its output matches measured remains.

Vietnamese bay composition and instrument-mediated proportion marking treat modular units and inscribed constraints as reusable anchors.⁹¹⁰ Revision is auditable only when the full set of seven disclosure surfaces is published. That set includes representation level and scope, stable bay roles, commensurability through modulus and units_policy, replayable dependencies, declared translation mappings, correction governance, and revision traces. The Vietnamese case is most instructive as a study in modular-anchor pressure: the condition in which bay units must remain stable compositional identities across aggregation from frame to plan to dwelling, and where that stability must be explicitly declared rather than assumed.

The evidentiary payoff is separability. Bay modules bind repeated units to aggregation rules for frames and plans. Instrument marks then function as a rule store when each mark maps to role, ratio, and bounded range. A strict or discretionary split permits change to be traced as strict parameter updates, branch selections, overrides, or discretionary choices. Without that split, revision drift toward untraceable geometry deltas remains the typical outcome. The instrument, as a physical artefact, therefore carries governance information that must be re-encoded explicitly in the correction surface’s correction_records when the instrument itself is unavailable for inspection.

Evaluated against the seven disclosure surfaces defined in the framing section, and tested clause by clause through the credibility test protocol, the Vietnamese case stresses the modularity, commensurability, and correction surfaces. The modularity surface (P2) passes only when declared bay modules and roles_map compose larger plans without renaming parts: the bay-module taxonomy must be stable enough to survive aggregation across all three nesting levels (frame, plan, and dwelling) without re-defining part identities at each level. The commensurability surface (the transportability surface) together with the procedural-generation surface (transformability) governs the distinction between instrument-encoded constraint and post-hoc geometric approximation; a release that cannot tell these two sources of dimensional value apart fails both. The correction surface (the manipulability surface) is where instrument-mediated proportion control is most distinctive: it passes only when strict and discretionary bands are explicit and applied choices are recorded apart from generator derivations, making the instrument’s dual function, as both a rule carrier and a correction tool, auditable. The translation surface (interoperability) and the integrity surface apply in the standard form, with missing required fields keeping the package in draft status. In summary, the Vietnamese case demonstrates that instrumental modularity is not a simpler governance problem than text-mediated proportion systems (it is equally dependent on the same disclosure conditions) and consequently any reconstruction that treats instrument marks as self-evident evidence without an explicit translation_contract must be classified as instance description rather than generative definition.

Cross-case invariants define the minimum publication conditions that keep relation-first packages inspectable under revision. The invariants function as reporting requirements for contemporary reconstruction releases, not as claims about what every historical tradition documented. A package is reusable only when the seven disclosure surfaces are explicit: representation level and scope, stable roles and modules, commensurability standards, generator dependencies and choice logic, translation contracts, correction governance, and revision traces. The invariants that remain constant across Greek, Japanese, and Vietnamese evidence establish that governance completeness is a cross-traditional requirement rather than a culturally specific expectation.

On the representation surface, scope_statement, representation_level, and competence_profile make claimed operations visible, permitting description, comparison, and replay to be distinguished. On the modularity surface, roles_map, role definitions, and declared modules stabilise compositional identities so local edits do not force global reinterpretation. On the commensurability surface (transportability), modulus or base measures with units_policy and explicit constraints_set keep ratio-consistency and bounds testable rather than implied by end-state geometry. Overall, these three foundational invariants address the representational and commensurability preconditions that determine whether comparison across cases is meaningful rather than merely superficial. The three are jointly necessary: no amount of generator or correction governance can compensate for a missing representation declaration or an absent modulus.

On the procedural-generation surface (transformability), dependency_graph, branch_conditions, branch_state, and override_policy make revisions replayable as parameter or branch updates, with conflict localised to named overrides. On the translation surface (interoperability), translation_contract publishes term-to-element mapping, unit reconciliation, and directionality or round-trip limits so translation becomes a checkable contract instead of private interpretation. On the correction surface (manipulability), correction_policy and correction_records keep discretion bands and correction triggers explicit and separate from derivational overrides, which makes situated judgement auditable. Taken together, these three invariants address the generative and interoperability conditions that determine whether a package remains disciplined across revision cycles and across tool boundaries. Therefore, a package that satisfies the three foundational surfaces but fails the generative and interoperability surfaces demonstrates representational honesty without generative accountability: it can describe what was built but cannot support disciplined revision of how it was generated.

On the integrity surface, transform_log, persistent uncertainty_register, and release labels with stop conditions preserve coherence under pressure by forcing new inputs through declared surfaces. These invariants separate text-as-implementation from text as building medium as an evidentiary condition: a pipeline that publishes only an end-state plan remains an instance description even when a generator exists internally. The same checks govern the bridge to contemporary floor plan representations, while empirical coverage remains in the appendix-data evidence profile on text-based floor plan representations. In summary, the cross-case invariants thus demonstrate that the seven disclosure surfaces are not a post-hoc taxonomy imposed on disparate traditions but a set of disclosure conditions that each tradition confirms through its own characteristic failure modes when those conditions are unmet.

Contemporary text-based floor plan representations matter here as an evidentiary reporting problem and not as a natural-language problem. The first question concerns what artefacts are published for inspection. The second question concerns whether those artefacts support replay and revision rather than end-state comparison alone. Across the seven disclosure surfaces, relation visibility remains checkable only when representation level and scope, stable roles and modules, commensurability through modulus and units_policy, dependency and override surfaces, a declared translation_contract, correction governance, and revision traces are all published. The disclosure framework makes the reporting gap precisely locatable rather than impressionistic.

The reporting gap becomes concrete when any of those surfaces are missing. A package is externally reusable under revision only when it publishes the representation surface (scope and rung), the modularity surface (role stability), and the commensurability surface (constraints). It must also publish the procedural-generation surface (generator dependencies with branch and override declarations), the translation surface (directionality and round-trip limits with term mapping), the correction surface (correction bands and triggers), and the integrity surface (transform traces with persistent uncertainty classes and stop conditions). Without that disclosure, reuse depends on private interpretation. This implies that reporting gaps are always diagnosable by checking which disclosure surfaces are absent from the published artefact rather than by assessing the quality of the output geometry.

Two properties are decisive in current pipelines: directionality and completeness. Directionality states whether the method runs text-to-geometry, geometry-to-text, or round-trip. It also states which failure modes constrain each path. Without the translation surface (interoperability), translation claims cannot be tested. Completeness states which surfaces are actually published. Without the integrity surface, a changed output is indistinguishable from a parameter update, branch shift, override activation, or correction event. Revision then collapses to geometry-only comparison. Overall, the combination of missing directionality and missing transform traces is the most common failure mode in contemporary pipelines, and thus disclosure of the translation and integrity surfaces is the most practically consequential obligation for current practitioners.

The empirical coverage and quantitative readout remain in the appendix-data evidence profile on text-based floor plan representations, while the present argument remains conceptual. In summary, contemporary text-based floor plan representations fail the building-medium test not because of linguistic inadequacy but because of systematic omission of relation publication, and therefore the remedy is governance discipline rather than representational innovation.

The evidentiary sequencing procedure defines a minimal reporting sequence for a replayable reconstruction package. The sequence operates as a release standard aligned to the seven disclosure surfaces, not as a claim about historical work order. The sequence requires disclosure of representation choice, commensurability standards, generator structure, translation contract, correction governance, and revision governance before geometry_outputs are treated as stable. The step sequence operationalises those abstract disclosure requirements as an ordered checklist that any release team can follow without disciplinary specialist knowledge.

At step one, on the representation surface, the reconstruction scope and representation rung are set from the source set and research question. Publication then follows for scope_statement, representation_level, and competence_profile so claimed operations are bounded. At step two, on the modularity surface, source terms and observed elements are converted into stable part identities and reusable modules through roles_map and role_definitions. Each later step then operates on named parts and not ad hoc geometry. The role and module vocabulary fixed at these two surfaces is what all subsequent steps depend on; no downstream disclosure is auditable without first completing the representation and modularity surfaces.

At step three, on the commensurability surface (transportability), modulus or base measures, unit conversions, and constraint forms are declared as units_policy and constraints_set. Inferred constraints are marked in inference_notes so commensurability remains testable. At step four, on the procedural-generation surface (transformability), the generator is published as dependency_graph with named branch_conditions, declared branch_state, and explicit override_policy. Replay then produces derived_parameters and geometry_outputs with conflicts resolved through declared priorities. Overall, these two surfaces together determine whether a package supports genuinely deterministic replay or only approximate reproduction, and thus they are the most technically demanding gates in the sequence.

At step five, on the translation surface (interoperability), translation_contract is published so term mapping, unit reconciliation, directionality, and round-trip limits are explicit before interoperability claims. At step six, on the correction surface (manipulability), the correction layer is published through correction_policy and correction_records. Discretion bands and triggers are defined. Correction events are held distinct from generator overrides. Taken together, these two surfaces govern the interfaces between the reconstruction package and external parties (translators, tool integrators, and practitioners applying situated corrections) and therefore their omission is the most common source of silent incompatibility in collaborative release environments.

At step seven, on the integrity surface, revision governance is published by recording parameter, branch, override, and correction changes in transform_log. Unresolved issues are carried in uncertainty_register. A release_label is assigned with explicit stop conditions. In compact form, field responsibility maps as: representation: scope_statement and representation_level; modularity: roles_map; commensurability: units_policy and constraints_set; procedural generation: dependency_graph, branch_state, and override_policy; translation: translation_contract; correction: correction_policy plus correction_records; and integrity: transform_log plus uncertainty_register. In summary, the step sequence is thus a disclosure protocol rather than a workflow prescription, and this implies that teams may complete the steps in any internal order so long as all required fields are published before the package is released as replayable.

Release discipline is strict. If any required field is missing, the package is labelled draft rather than replayable. The required minimum is scope_statement, representation_level, roles_map, units_policy, constraints_set, dependency_graph, branch_state, override_policy, translation_contract, correction_policy, transform_log, and uncertainty_register.

The credibility test protocol defines a minimal credibility test for reuse under revision. Reuse means an external reviewer can replay a package, revise it, and report where disagreement appears. The checkpoint keeps disagreement local. It should resolve to branch_state, override, or correction event. It should not diffuse into competing end-state drawings. Building on the seven disclosure surfaces, the checkpoint translates those abstract requirements into a structured pass-or-fail evaluation applicable to any reconstruction release.

On the representation surface (semantic-interface persistence, P1), a package passes when scope_statement, representation_level, and competence_profile are explicit. It also passes when claimed operations match published artefacts. It fails when generativity is implied but only detached dimensions or end-state geometry are published. This implies that the first credibility gate is always representational honesty: a package may not claim replay capacity it cannot demonstrate through published surfaces.

On the modularity surface (interface-bounded modularity, P2), a package passes when stable anchors, role vocabulary, and compositional units can be reused without redefining terms. It fails when the release is only a geometry dump with no persistent part identities. Thus, a package that omits role structure fails the modularity gate regardless of how detailed its geometric output may be.

On the commensurability surface (transportability), a package passes when modulus or base measure, units_policy, and constraints_set support ratio checks. It fails when unit assumptions stay implicit. It also fails when commensurability is reduced to one best-fit output. Therefore, multiple reviewers must be able to independently reproduce ratio checks from published standards without recourse to private metrology assumptions.

On the procedural-generation surface (executable transformation, transformability, P3), a package passes when dependency_graph, branch_state, and override_policy are sufficient for independent replay. It fails when replay depends on hidden scripts, private rules, or tacit steps outside the declared competence profile. The test criterion here is therefore procedural completeness, not output quality.

On the translation surface (interoperability), a package passes when translation_contract publishes term-to-element mapping, unit reconciliation, directionality, and round-trip limits. Residual mismatch must remain in uncertainty classes. It fails when mapping is implicit or translation depends on private interpretation. The correction surface then closes the remaining accountability gap.

On the correction surface (manipulability), a package passes when correction_policy defines legitimate discretion and correction_records keep applied corrections distinct from generator overrides. It fails when correction is hidden in geometry or absorbed into derivations without disclosure. Overall, the translation and correction surfaces together ensure that both meaning exchange and discretionary editing remain publicly auditable rather than private adjustments.

On the integrity surface (integrated utility under diachronic burden, P5), a package passes when each revision records what changed, why it changed, and what propagated in transform_log. It also passes when uncertainty classes persist in uncertainty_register. It fails when revision appears only as new geometry. It also fails when uncertainty is flattened into one authoritative output. Taken together, the seven surfaces constitute a mutually reinforcing disclosure sequence in which each gate conditions the credibility of subsequent claims.

A schematic replay package shows the minimum publication shape and does not make a historical claim. The schematic begins with a proportional rule fragment, a partial survey measurement, and one repeated frame unit across bays. Publication then follows for representation_level as generative, scope_statement, roles_map, units_policy, constraints_set, dependency_graph, named branch_conditions, declared branch_state, explicit override_policy, translation_contract, correction_policy, and uncertainty_register. On revision, a new anchor measurement inside its uncertainty band triggers replay of derived members. The package then records the change in transform_log. If one reviewer selects R1 and another selects R2, disagreement is reported as branch-state divergence. In summary, the schematic package demonstrates that disciplined disclosure is achievable even with partial evidence, and thus completeness of the published record matters more than richness of the underlying source base.

The checkpoint rejects geometry-first releases even when the output looks plausible. If only end-state geometry is published, no audit can determine whether change came from parameter updates, branch shifts, override activation, or correction events. Relation publication is therefore a release condition for disciplined revision. Missing required fields keep the package in draft status.

A replayable reconstruction package remains conditional. Text can operate as a building medium only when representation_level and scope are declared, roles and competence_profile are published, and tacit completion is held bounded and reported rather than assumed. A declared modulus with units_policy, an explicit dependency_graph, and an override_policy are also required, because commensurability failures and conflict resolution must remain visible when sources preserve only detached dimensions.

The same condition applies to interoperation and revision governance. A translation_contract that states directionality and round-trip limits for text, drawing, and survey exchange is required, and a correction_policy with correction_records is required so correction events remain distinct from derivational overrides. A transform_log and uncertainty_register are then required so unresolved disagreements stay labelled as draft inference under revision rather than being released as settled output. These disclosure requirements make the practical boundary between text-mediated reconstruction and mere geometric description testable.

This boundary is practical. Text-mediated reconstruction is a conditional substitute for drawings, not a universal replacement. It is strongest when sources preserve operational relations such as roles, constraints, dependencies, and declared choice points; it weakens when sources preserve only appearance or detached dimensions, because the generator, correction layer, and revision governance remain unavailable for inspection. The applicability criterion follows: the evidentiary value of a textual source scales directly with the completeness of its published operational surfaces.

Replayability is fragile when copying or translation drift alters constants or scope without trace. A procedure may look explicit and still depend on private craft competence, so competence must be declared as a bounded condition. In parallel, measured drawings remain primary constraint carriers in some contexts because they preserve geometric interactions and clash conditions never codified in words. In those contexts relation-first reporting remains useful, but the drawing is treated as the primary representation and the source of textual rules must be stated as inferred. Overall, the distinction between text as description and text as a building medium rests entirely on whether the publication record is sufficient for independent replay.

Two failure packages make the boundary testable. In a geometry-only package, a cleaned plan and ratio table are published while declared rung and scope, role mapping, units_policy, dependency surfaces, branch or override disclosure, correction layer, uncertainty classes, and transform trace are omitted; revisions then require manual redraws and disagreements cannot be localised for review. In a procedure-only package, a recipe is published while scope, term mapping, commensurability standard, and tolerance or discretion policy are omitted; identical wording then yields different outputs across reviewers, and replay depends on private competence rather than published evidence. Taken together, these two failure modes confirm that applicability boundaries are determined by published surface coverage rather than by source type or stylistic form.

The same boundary remains visible in contemporary pipelines. When authors do not publish directionality, completeness, and the replay fields of the seven disclosure surfaces, including translation_contract, correction governance, and integrity-governed traces, interoperability and round-trip claims remain uncheckable; concrete cases remain in the appendix-data evidence profile on text-based floor plan representations. A disciplined release rule follows therefore directly: publish the seven disclosure surfaces or label the package as draft. In summary, failure conditions are always disclosure failures rather than content failures, and thus the same governance framework governs both historical reconstruction and contemporary pipeline evaluation.

Text can be defended as a building medium only when the full set of seven disclosure surfaces is published under revision: declared representation level and scope, stable roles and modules, explicit commensurability through modulus and units_policy, inspectable generator dependencies with override rules, a declared translation_contract, explicit correction governance, and revision traces through transform_log and uncertainty_register. Under that condition reuse remains inference under revision rather than a static geometry release. That condition is the foundational release standard against which every package in this study is evaluated.

The comparative argument across Greece, Japan, and Vietnam is coherent because each case is evaluated as a carrier of operational relations rather than as a drawing tradition alone. The comparison therefore concerns how each lineage publishes relations, constraints, dependencies, and correction boundaries, not whether each lineage uses the same surface representation. The three cases collectively stress-test the seven disclosure surfaces under commensurability pressure, cascade pressure, and modular-anchor pressure, and thus confirm the framework’s cross-tradition applicability.

The substantive contribution is a repeatable reporting and evaluation method built on the seven disclosure surfaces, each tied to one of the four critical properties of a constructive representation (interoperability, transportability, manipulability, and transformability) and to the testable propositions P1 to P5. A representation ladder states what a source can justify as instance, canonical, or generative evidence, and the disclosure readout states what must be published for external replay: representation choice, modular role structure, commensurability standard, generator structure, translation contract, correction layer, and integrity-governed revision traces. Overall, the ladder and the readout together constitute a governance-oriented evaluation instrument that operates independently of tradition, medium, or historical period.

The evidentiary sequencing procedure and the credibility test protocol operationalise that governance as a minimal disclosure sequence and a credibility test. Their joint purpose is to keep disagreement local and testable as parameter updates, branch states, overrides, correction events, or uncertainty classes, rather than letting disagreement collapse into competing end-state drawings. Taken together, these two devices translate the abstract disclosure requirements into auditable release conditions applicable to both historical reconstruction and contemporary generative pipelines.

The same governance requirement applies to contemporary text-based floor plan representations. When relation structures and revision surfaces are omitted, verification and reuse collapse to output comparison; when generators, translation contracts, correction layers, and integrity-governed traces are published, external review becomes possible. In summary, the closing position of this supplement is that governance completeness, not stylistic or representational form, determines whether a package qualifies as a building medium rather than merely a geometric description, and thus the seven disclosure surfaces provide the decisive test.

The full citation map for the claims advanced across the TMHR supplement set (Framing, Greek, Japanese, Vietnamese, Invariants, Contemporary bridge, Evidentiary Sequencing, Credibility Tests, and Boundaries sections) is recorded in the supplementary citation ledger appendix-c–tmhr–citation-ledger.