The asset pipeline
Source models and textures live in a project's own assets_src/; a build hook converts them into flutter3d_generated/ on every flutter build/flutter run, and the engine loads the converted files by their source name. No step to remember, and no committed binary that drifts from the source it was built from.
flowchart LR
src["assets_src/models/chair.glb"] -->|"hook, every build"| gen["flutter3d_generated/models/chair.f3d"]
gen -->|"loadModelAsset('assets_src/models/chair.glb')"| doc["ModelDocument"]
Wiring a project #
dart run flutter3d_build:init
Writes four things, each idempotent:
hook/build.dart |
Calls buildAssets, the function the Flutter tool runs during a real build |
pubspec.yaml's dev_dependencies: |
flutter3d_build, pinned the way the rest of the project pins its dependencies |
pubspec.yaml's flutter: assets: |
flutter3d_generated/, and one line per subdirectory a source actually converts into; the warning below says why more than one line |
.gitignore |
/flutter3d_generated/: generated, never committed |
--check reports what a run would change without changing it; --force overwrites a hook/build.dart a person has edited, which is otherwise left alone and reported instead. A second run of init on an already-wired project is a no-op.
Flutter's own asset bundler does not read a declared directory recursively. flutter_tools lists it with a plain listSync(), without recursive: true. A source at assets_src/models/chair.glb converts to flutter3d_generated/models/chair.f3d, and a pubspec.yaml naming only flutter3d_generated/ bundles the hook's own bookkeeping file and drops every model in models/ without a warning. Two of this repository's own games shipped like that until their pubspecs gained the second line. init declares a line per subdirectory that actually holds a converted file, computed from the real sources on disk each time it runs, instead of one line assumed to cover everything under it.
A dependency added after the last build needs flutter clean before the hook runs. The build system's own incremental cache can remember "this project has no hooks" from before flutter3d_build was added, and neither a fresh pubspec.yaml nor a deleted flutter3d_generated/ on their own make it look again; only a full clean does. The same cause apps/flutter3d_demo_racing's own pubspec.yaml already names for SoLoud's "no available native assets".
What gets converted, and where #
Without a manifest, every recognised file under assets_src/ maps to flutter3d_generated/ with the same relative path, extension swapped to .f3d. An empty assets_src/, or none at all, plans nothing: that is a project that has not added a model yet, not an error.
With flutter3d_assets.yaml at the project root, a list of rules overrides the default per file:
rules:
- glob: "props/**.obj"
textures: etc2
- glob: "props/placeholder.obj"
exclude: true
| Key | Meaning |
|---|---|
glob |
Matched against the path relative to assets_src/. package:glob's own rule applies, and since glob 2.2.0 **/*.obj matches a root-level a.obj as well as props/a.obj |
textures |
auto | bc | etc2 | universal | none, overriding the build's own family for files this rule matches |
mips |
true/false: skip the mip chain for files this rule matches |
objNormals |
smooth | flat | none, for an OBJ with no normals of its own |
lods |
A list of triangle ratios, each strictly between 0 and 1: lods: [0.5, 0.25]. One simplified level per ratio, below |
impostor |
true ends each node's levels in a baked card |
chunks |
true, or a triangle count: split static meshes above it into clusters the renderer culls one by one |
exclude |
Leaves the file alone: no conversion, no entry in flutter3d_generated/ |
<pluginId>.<setting> |
A plugin's own setting for the files this rule matches (acme_boats.hullDetail: high), from format: 2. The build carries it and reads none of it; the plugin's importer gets it as ImportRequest.settings. An id that is no installed plugin package is a warning in the build's log |
A rule's textures, mips and objNormals do not reach the build hook yet. The manifest parses all eight keys and AssetLayout.plan carries the matching rule with every file it plans. buildAssets applies exclude, lods, impostor and chunks, and converts everything else with the converter's defaults and the build's own texture family: those three keys are read, checked, and ignored.
The last matching rule wins, not the first, so a broad rule and a narrower exception below it read the way a person writes them. A bad glob, an unknown key, or a plugin's setting in a manifest that does not say format: 2 names the line it is on, in flutter3d_assets.yaml:N: ... form, because the manifest's own author reads that error, not a player of the finished game.
What a .f3d holds #
A .f3d is a header, a directory of sections and the sections themselves,
little-endian throughout. A reader skips a section it does not know unless
the directory marks it must-understand, and from version 2 a table's record
size comes from its section, so records can grow at the end. Kinds from
0x80000000 up belong to tools, not to the engine.
| Sections | What they hold | Read back as |
|---|---|---|
| 1–18, 21–28 | Geometry, materials and their layers, images, nodes, clips, skins, morph targets, levels of detail, impostors, clusters, variants, extras |
ModelDocument |
| 29–31 | Lights (lux or candela), cameras, the nodes that carry them | lights, cameras, ModelNode.lightIndex/cameraIndex |
| 32 | Each material's lighting model, in the JSON .fmat uses |
SurfaceMaterial.lightingModel |
| 33 | Material language programs (.f3dmat source) by name |
F3dDocument.programs |
| 34 | Level and prefab documents ("format": "f3d.level") by name |
F3dDocument.prefabs |
| 35 | Files carried whole (models, .fmat, textures) by path |
F3dDocument.files |
| 36 | Physical materials the engine's catalog does not ship, by id ("format": "f3d.physicalMaterial") |
F3dDocument.physicalMaterials |
| 37 | What each material is made of and the program version it was written for, sparse | SurfaceMaterial.physicalMaterial, materialVersion |
| 38 | Who made the model and on what terms | DocumentAsset.copyright, author, license |
| 39 | Which light each material's occlusion map darkens, for a material that darkens only the direct or only the indirect light; a reader without it darkens both | SurfaceMaterial.occlusionAffects |
Sections 29–35 make a .f3d a whole asset, which is what flutter3d convert
writes by default (see Bringing assets in).
None of them is must-understand, and a model without them is the same bytes
it always was. F3dWriter takes programs, prefabs, files and
extraSections for a tool's own data.
Levels of detail, impostors and chunks #
Three things the converter can add to a model, each off until a rule or a flag asks for it. They are the same options on the command line and in the manifest:
dart run flutter3d_build:convert assets_src/tree.glb --lods=0.5,0.25,0.1 --impostor
dart run flutter3d_build:convert assets_src/scan.glb --chunks
rules:
- glob: "trees/**.glb"
lods: [0.5, 0.25, 0.1]
impostor: true
- glob: "scans/**.glb"
chunks: 200000
lods cuts one level per ratio from every node's full mesh, with flutter3d_mesh's attribute-aware simplifier, and measures how far each level is from the full mesh (surfaceDeviation). The file carries that distance, and the node switches to a level once it is less than a pixel wrong on screen. A viewer that cannot count pixels uses the older rule: the level takes over when the node covers less than half the square root of the ratio of the screen, so a quarter of the triangles takes over below a quarter of the screen. A surface with morph targets stays whole in every level, since a simplified mesh has no deltas to blend, and a node whose surfaces all morph gets no levels at all. Each level adds its triangles to the file. generateLods does the same from Dart and returns a LodLevelReport per ratio.
impostor ends the chain in a card that turns to face the eye. Every node that draws something is drawn by the software rasteriser from 8×8 directions laid out on an octahedral map, into an albedo atlas and a normal-depth atlas, and the bytes come out the same on every machine. At run time the node's LodGroup ends in an ImpostorNode: one draw, receiving shadows and casting none. At the default cell of 64 texels that is two 512×512 atlases per node. A texture the bake cannot decode is baked as its material's base colour, and the report names it. On five trees at the switch distance, 11% of the silhouette differs from the mesh and the mean colour error is under 13 steps a channel. bakeImpostors is the Dart entry.
chunks is for scans and CAD exports, one mesh of hundreds of thousands of triangles where most of it is off screen or behind the rest. Every static mesh above the threshold (65536 triangles for true and a bare --chunks, defaultChunkThreshold) is split into runs of up to 4096 triangles, each with a box and a cone of normals, and the scene pass tests each run against the view, its facing and the occlusion test. No vertex moves, and a skinned or morphing mesh stays whole. The table goes in a .f3d section of its own, written only when a mesh has one, so a reader from before 0.8.0 loads the same file and draws the whole mesh. splitLargeMeshes is the Dart entry.
One file per device class #
A phone and a desktop can load different cuts of the same source. classes: sits beside rules: and names the classes to build for:
classes: [phone, web, desktop]
rules:
- glob: "**/*.glb"
lods: [0.5, 0.25]
Each model is then written once per class, chair.phone.f3d, chair.web.f3d and chair.desktop.f3d, in place of chair.f3d, and each carries its own level-of-detail chain, impostor and largest texture side. The presets are DeviceClassBudget's:
| Class | Levels of detail | Impostor | Textures fit to | Light tolerance |
|---|---|---|---|---|
phone |
0.5, 0.25, 0.1 | yes, cell 32 | TextureBudget.mobile |
0.04 |
web |
0.5, 0.25 | yes, cell 64 | TextureBudget.web |
0.02 |
desktop |
the rule's own | the rule's own | TextureBudget.desktop |
0.01 |
A mapping in place of the list changes a preset's numbers, and a class left empty keeps its preset:
classes:
phone:
maxTextureSide: 512
impostorCell: 32
desktop:
The keys a class takes are lods, impostor, impostorCell, maxTextureSide and lightDifference, the last of which is for a level's lights and not for models. An image larger than maxTextureSide on either axis is box-filtered down before the texture encoder sees it. flutter3d convert has no class option: per-class files are the build's, read from this manifest. A build script that wants them by hand calls runConvert (package:flutter3d_build), the one-model converter, with --classes phone,desktop; it uses the presets, and applies --lods and --impostor where a class names no chain of its own.
Which files a build carries depends on its target. A native build writes the phone and desktop files, because a native application may be given either: a slow laptop reads the phone's, a tablet that samples BC reads the desktop's. A web build writes the web files alone, because a browser reads nothing else. The Flutter tool asks for a web build with no code configuration, and the hook takes that to mean the web. A project that builds some other way names its classes itself, in the same place as the texture family:
hooks:
user_defines:
my_game:
deviceClasses: [web]
The hook deletes class files an earlier build left behind, since the generated directory is bundled whole and a phone's models would otherwise ship in a web build. It still writes the single .f3d whenever a class it carries has no file of its own, so the loader always has something to fall back to. A manifest without classes: builds exactly what it built before, to the same cache entries.
How the running application picks a class #
The class is chosen once, on the loading screen, and remembered. flutter3d_core holds the choice:
final picker = DeviceClassPicker(
traits: DeviceTraits.of(device, web: kIsWeb),
memory: mySettingsBackedMemory, // a DeviceClassMemory
);
assetDeviceClass = await picker.pick(
measure: () => measureFrameMicros(drawProbeFrame),
);
DeviceClassSelector makes the decision. A browser is web. Otherwise a GPU that samples a BC format is a desktop and one that does not is a phone, because BC support comes with the silicon and a power saver cannot switch it off. The measurement can only demote: a desktop part whose probe frame takes longer than desktopLimit (8 ms, half a 60 Hz frame) is given the phone's files, and a phone that measures fast on a cool loading screen stays a phone. measureFrameMicros throws away two warm-up frames and takes the median of eight. What pick stores says whether it was measured or chosen, so picker.override(DeviceClass.phone) sticks and override(null) measures again on the next launch. An override the device cannot read, a phone class on the web, throws an ArgumentError.
assetDeviceClass is what every loader reads when its caller names no class. loadModelAsset('assets_src/chair.glb', deviceClass: ...) tries chair.phone.f3d first and falls back to chair.f3d, which costs one missed read, and LevelLoader.load reads crypt.phone.json before crypt.json in the same way. Null, the default, reads exactly what 0.7 read.
Upgrading from 0.7: one full conversion #
assetPipelineVersion is 2. A rule can now ask for levels of detail, an impostor or chunks, and an output cached by 0.7 may be missing them, so the first build after the upgrade converts every source once. After that a source is skipped when its bytes, the pipeline version, the texture family and what its rule asks for are all unchanged, as before.
Texture families #
The hook is told which platform it is building for, and takes the family that platform guarantees. That is a fact about the platform, not a guess about a device:
| Building for | Family | Why |
|---|---|---|
| macOS, Windows, Linux | BC | Every desktop GPU samples it |
| Android, iOS | ETC2 | Required by OpenGL ES 3.0, and by Metal on every iOS device the engine runs on |
| The web, or anything that names no target | none: textures ship as they arrived | A browser is whatever machine it runs on |
Every compressed texture carries a mip chain, down to the last level that is whole 4×4 blocks. A project overrides the family in its hook user defines, under its own package name, because hook/build.dart is the project's hook and a hook reads only its own package's defines:
hooks:
user_defines:
my_game: # this project's `name:`
textures: universal # or bc, etc2, none
A value that is not one of the choices fails the build, naming them, where it used to fall back to the platform's family; a key the hook does not read (textures, deviceClasses and fullShaders are the ones it does) is a warning in the build's log.
universal is the answer for a build that ships to more than one family, the web above all. It is not a GPU format but a 4×4 block intermediate, cooked once; the upload turns it into BC, ASTC, ETC2 or RGBA8 against what the device says it samples, so one file serves a laptop and a phone from the same build, at twenty bytes a block.
By hand, the converter takes the family by name, and --no-mips keeps the base level alone:
dart run flutter3d_build:convert assets_src/chair.glb --textures universal
--textures auto on the command line compresses nothing: the machine converting a texture is not the one that loads it, and only a build knows its target.
Loading by source path #
final document = await loadModelAsset('assets_src/models/chair.glb');
Reads the converted flutter3d_generated/models/chair.f3d. Missing it means two different things on purpose:
- In debug, decodes
assets_src/models/chair.glbdirectly instead, and prints one warning the first time, not one per frame. A project with no build yet still draws something. - Outside debug, throws an
AssetNotFoundExceptionwhosekeyis the generated path, namingflutter3d_build:init. A release build that shipped without its own hook ever running is a real problem, and paying the decode cost on every load without a word would hide it.
The debug fallback reads the source straight off disk, which only exists during flutter run/flutter test from a checkout: never in a shipped build, and never on the web, which has no dart:io. There, a missing generated file is the release error in every build mode.
A path somebody else wrote, such as a level document naming a coin's model, goes through loadModelByPath instead: assets_src/… is handed to loadModelAsset, anything else is read from the bundle exactly as it always was. FixtureVisuals and ActorVisuals in flutter3d_game, the level-driven loaders every game shares, both load through it, so a game that has not moved onto the pipeline keeps working unchanged. The strategy game is one: its models still live in assets/models/ and are bundled as they stand, while the dungeon, the platformer and the racer load theirs from assets_src/.
Gaussian splat captures #
convert also takes a splat capture, a .ply of fitted Gaussians or its compressed .spz form, and writes a .f3dsplat: an octree whose inner nodes are merged, coarser versions of their children, stored coarse levels first so a viewer reads only the pages its cut needs.
dart run flutter3d_build:convert captures/garden.spz -o web
That writes web/garden.f3dsplat. -o names a directory: dart run flutter3d_build:convert is an alias of flutter3d convert, and every output takes its name from its input. Before 1.0 the same name ran the one-model converter, whose -o named the file; that converter is runConvert in package:flutter3d_build, for a build script.
The converter reads the tree back and counts its leaves against the source before it reports success. Walking a directory, a .ply counts as a capture only when its header names f_dc_0, the fitted colour, so a folder that also holds a mesh saved as PLY still converts; a .ply named on its own is always tried, and refused with the reason. convertSplat is the Dart entry.
The build hook does not convert captures. AssetLayout.plan recognises model files only, so a capture is converted by hand and served however the application serves large files. The runtime side is on Assets & animation.
A level's lights #
dart run flutter3d_build:lights --optimize assets/levels/crypt.json --dry-run
Finds a smaller set of lights that lights the level the way it is lit now. Every light is drawn alone, in software, from a set of views; a light the others already cover is removed, a close pair is merged into one, and the rest are retuned, and a change is kept only while the picture stays within the optimizer's bounds. The plan that comes out is drawn again for real and held to the same bounds, and one that misses them is reported and not written.
| Option | |
|---|---|
--poses <file.json> |
Where players stood, as the list a game's GhostRecorder writes while it plays a run back. Repeatable. Without it, the views are four headings from every player spawn |
--state <file.json> |
A lighting state the level must still look right under, such as the noon sun, or a night with no lights at all. Repeatable; the level is judged under each, so a lamp the sun drowns out is kept for the night. Its lights are read as a level's are, at the version the file says: a state without "version": 5 is read in the pre-1.0 light unit and lifted to candela and lux, so write "version": 5 in a state whose numbers are already candela |
-o, --out <path> |
Where to write. By default the input is overwritten |
--preview <dir> |
before.png and after.png of the first view |
--dry-run |
Prints the moves and the numbers and writes nothing |
--classes phone,web,desktop |
One level per class beside the output (crypt.phone.json, ...), each held to its class's lightDifference from the nearest flutter3d_assets.yaml, or the preset's. The level itself is left alone |
It refuses to overwrite a level that says it was generated; --out writes a copy that takes ownership of itself. The command is flutter3d lights (dart run flutter3d_build:lights is its alias), in package:flutter3d_build/cli.dart, which the build hook's library does not import, so the hook never compiles the optimizer, and a level is optimised only when somebody runs it.
The engine's shaders #
The same hook compiles the engine's shader stages for the project, with the impellerc of the Flutter SDK that builds it, into flutter3d_generated/shaders/flutter3d.f3dshaders. It holds the stages the project needs and no others. One bundle for every application was 8.5 MB in every binary, and two thirds of it was lighting models most games never draw with.
A project needs:
| The base | Always: the mesh, skinned, batched and lightmapped vertex stages, Pbr and Unlit, the shadow, sky, probe and post passes, and the x-ray, normals and mirror stages the renderer draws by itself when a setting or a node asks |
| What its models light with | Read from the converted .f3d files: a glTF material with clear coat, sheen or anisotropy brings pbrLayered |
| Impostors | When a rule in flutter3d_assets.yaml says impostor: true |
| What its manifest lists | shaders: [toon, lambert] in flutter3d_assets.yaml, for lighting its code chooses (RenderMaterial(lighting: LightingModel.toon)), which a build cannot see |
| What its plugins declare | flutter3d_plugins: shaders: [toon] in a plugin package's pubspec, or a map from a library to its needs so a library the application leaves out brings nothing |
The engine's needs a project can name are pbrLayered, blinnPhong, lambert, toon and impostor (ShaderStageNeed.engine); a plugin names its own after its id, acme.glow, which is the plugin material compiled as the stage acme__glow (matched in any case), and a need no installed package compiles stops the build, naming the package or the manifest that declared it. shaders: full writes every stage, as does fullShaders: true under hooks: user_defines: and the project's own name in pubspec.yaml, or flutter3d shaders --full-shaders by hand. The editor and the modeller carry every stage: they draw whatever a user opens, and they load the bundle flutter3d_impeller ships, which has all of them.
A stage left out and asked for is a MissingShaderStageException when the renderer first draws with it. It names the stage and the need that brings it, which is the word to add under shaders::
the shader stage "Toon" is not in the bundle on Impeller: it comes with the
need "toon": list it under "shaders:" in flutter3d_assets.yaml, or build with
--full-shaders.
On flutter3d_app's example the native bundle is 3.7 MB with 95 of 105 stages, against 8.5 MB for all of them, measured on 2026-10-11 with Flutter 3.47.0. flutter3d shaders writes the bundle by hand and prints its size, and --json says which stages and needs it holds.
The bundle is compiled for the SDK it runs on. Its header carries the Dart that built it and its EngineBundleStamp section the engine revision. Impeller loads the project's bundle first and refuses one from another SDK with ShaderBundleException(stale: true), naming the file and saying to build again; it never loads one that parses and draws something else. The Dart is always checked; the engine revision is checked too when the application knows its own (FlutterVersion.engineRevision, which flutter run and flutter build set), so a Flutter hotfix on the same Dart is refused rather than loaded. A project without the hook gets the bundle flutter3d_impeller ships, held to the same check, and is told to run dart run flutter3d_build:init, which writes the hook: with it the project moves Flutter on its own, without waiting for a release of flutter3d_impeller. A project that builds its bundle with a script of its own writes it with stampedEngineBundle from flutter3d_impeller, to the same flutter3d_generated/shaders/flutter3d.f3dshaders. The bundle written before stays beside the new one as flutter3d.previous.f3dshaders, for an application that reloads across the rebuild; anything older is removed.
flutter3d_generated/shaders/ needs its own line under flutter: assets:, for the reason the warning above gives. init adds it to a project that draws.
The application's materials #
A .f3dmat anywhere under the project's assets_src/ but assets_src/shaders/ is compiled for every backend into a bundle beside it under flutter3d_generated/, which HotSwap.loadMaterial reads by the source's path. init writes the flutter: assets: line for each directory that holds one. Your own material is the whole path, from the source to a RenderMaterial drawn with it.
Plugins' materials #
A package that marks plugins and keeps .f3dmat sources under its own assets_src/ has every one compiled into the project, as flutter3d_generated/shaders/<material>.f3dshaders, for the SDK that builds the application. In the package's namespace: the source writes the bare name, material Hair, and a package acme_hair from outside the engine compiles it as acme_hair__Hair, the stage of its lighting model acme_hair.Hair; the source the bundle carries is renamed to match, and a name in another package's namespace is refused. On Impeller a data plugin's material, and a render step's fullscreen stage, is found there by its stage name (RuntimeShaders' prebuilt, which readPluginStage from flutter3d_app answers); one the build did not write is off, with a MissingShaderStageException in RuntimeShaders.refusals that names it and the plugin. Flutter3dView does not build the RuntimeShaders itself in 1.0.0-rc.1: the application puts one in PluginSettings.registries, as the flutter3d_plugin_runtime README shows for each backend.
Flutter3dView loads them itself. For every lighting model a plugin registers with the engine, the view reads flutter3d_generated/shaders/<stage>.f3dshaders (pluginMaterialAssetFor) and hands it to the renderer, so a lit-model plugin draws by being installed, with no loader of its own. PluginSettings.readBundle stands in for the asset bundle in a test.
A plugin may still ship a bundle it compiled itself, as flutter3d_effects does with its water. It is tied to the SDK its author built with: a device refuses it with ShaderBundleException(stale: true) on any other, by name. The view's copy, compiled for the application's SDK, is added in front of whatever the plugin loaded, so it wins wherever the hook ran.
A backend from outside #
A graphics backend that is not one of the engine's names its material compiler in its pubspec, and the hook compiles the engine's bundle and every plugin material for it too:
flutter3d_backend:
backend: acme_vk # the device's backendId
section: acme_vk # its compiler's bundleSection
compiler: bin/material_compiler.dart
The compiler file is one line, exit(runMaterialCompiler(const AcmeVkMaterialCompiler(), arguments)) (package:flutter3d_shaders/compile.dart). The build finds the package among the project's dependencies, runs the file against the project's package config with each request, and writes what it answers under the section. examples/flutter3d_backend_null is the reference, and flutter3d create plugin --kind backend writes both.
flutter3d doctor, run in a project that draws, says whether hook/build.dart runs buildAssets, whether pubspec.yaml ships flutter3d_generated/shaders/, whether the bundle there was compiled on the Dart and engine revision that build the project now, and which installed plugin materials are not compiled in yet.
When the hook fails #
| Symptom | Cause |
|---|---|
MissingShaderStageException names a stage and a need |
The project's bundle leaves that stage out. List the need under shaders: in flutter3d_assets.yaml, or build with every stage |
ShaderBundleException with stale set names flutter3d_generated/shaders/flutter3d.f3dshaders |
The bundle was compiled on another SDK, after flutter upgrade without a build since. Build again |
flutter analyze says an asset directory does not exist |
Expected on a fresh checkout: hooks run during a real build, never during analyze, and the declared directory has nothing in it yet. Build once |
flutter analyze says hook/build.dart's own imports are not a dependency |
hook/ sits outside test/, where the analyzer does not look for dev_dependencies:. Excluded from analysis in analysis_options.yaml, the way generated platform folders already are |
| A model that used to load throws in release | The generated .f3d is missing from the shipped bundle. Check that every subdirectory under flutter3d_generated/ has its own pubspec.yaml line, and that the build ran with flutter3d_build as a real dependency, not added after the last build with no flutter clean since |
A build with a brand-new flutter3d_build dependency still skips the hook |
flutter clean, then build again; the warning above says why |
What this does not cover #
Level geometry (BSP brushes) names its own surface textures directly in the level document, read by LevelLoader. That is a completely different path from a model's own materials, and one this pipeline has no way to convert a bare texture file for: AssetLayout.plan recognises model files, and an image is only ever converted as part of the model document that carries it, which a level material is not. Those textures stay hand-placed and hand-committed.
Next #
- Assets & animation: the runtime side (decoders,
.f3d, loading, skinning, morph targets) - Package index: where
flutter3d_buildsits among the rest - Testing: what
dart run tool/structure.dartholds every package to