flutter3d → 1.0

D13 (encoders) scratch buffers per uniform block in the four encoders, the skin block written in place, the Impeller readback staging pool bounded (moved here from wave 4 on decision 52, because it is the one change that moves the number on a phone); GPU timings on Impeller through the engine's own timeline where flutter_gpu gives none (decision 53); A6 one open: async, {required int width, required int height} on every backend, WebGlDevice.open async, GpuRenderBackend.open takes the size, openDevice the sugar; A4 Recorded → abstract base; readBufferSync to testing.dart; presenterFor/addPresenter typed; createStorageBuffer folded into createBuffer(usage:); EncodedImageUpload.decodeTexture throws; the stale supportsX comment; D11 the dispose contract in the HAL doc, debug checks on double dispose and use-after-dispose, the live-handle counter in FakeBackend (the rule itself is 2Z's); mixins-as-capabilities documented against DeviceFeature (no change, a doc); D25 default bodies on every feature-gated member of PassEncoder, ComputeEncoder and TransferEncoder, the backend.dart stability sentence in README and CHANGELOG, and every break of this wave labelled "for outside backends" in hardware's CHANGELOG (the readBufferSync move, the createStorageBuffer fold, non-null decodeTexture, typed presenters, DeviceLoss as an obligation).

D13 (core) RenderSettings.telemetry (off, counters, timings) with the per-node Stopwatch/Timeline behind it, the compiled frame graph cached until its inputs change, transmission without the three clones, decal and particle sorts on packed keys, toHeld() keeping pipelineStalls (moved here from wave 4 on decision 52); MemoryBudget with an event on crossing it and ResourceCache with a priority queue and cancel (decision 53); D39 MaterialParameters with ParameterKey<T>, set, setNamed and the schema from .f3dmat, defined on day one and its sketch written into the hand-back for 2E (the generator) and 2F (Material3D); A2 core's 18 record returns reviewed: maths pairs stay, the rest become classes (IrradianceField.toAtlas, PhysicalSky.look, …); A5 ModelLightType, ShadowCastingMode, MaterialAlphaMode, AnimationBlend, DiffuseModel, SortMode, TangentMethod → open final classes with wire names; A4 MaterialExpression → abstract base; A9 writeIrradiance(LinearColor), RenderView.clearColorSrgb: LinearColor; A10 DeviceClass.parse throws; A8 agxFull deleted; one vocabulary for an off step (stepsOff + only/without, the rest go); maxFramesInFlight, maxMorphTargets, maxJoints, maxResolution as getters; Photometric.legacyUnit/legacyNits private (found in wave 1: model_core's lighting_sync.dart converts ProjectLight.intensity, still in the pre-1.0 unit, through the public constant, so making it private bumps the project format to store lux, with its lift and fixture), LightNode.intensity default in candela and Atmosphere in lux with the same picture; ResourceId('hdr_color'), 'scene_color', RenderStep('color grade'); UnsupportedError → UnsupportedCapability in core; yfov kept as the glTF field, fovY everywhere else, documented.

D36 StepSystems/StepContext removed in favour of addSystem/LoopContext (2D moves the elements, 2F the genres, against the same signatures); D42 Level.world as WorldPropertiesPatch and Level.renderSettings as RenderSettingsPatch (the patch types come from 2B for render and from 3A for the world; 2C writes the level side against their sketches); A5 LevelLightType → open class; A9 Level.fogColor, LevelLight.color → LinearColor, level format version bump with a migrator and fixture; A2 sim's 6 record returns; A8 Level.gravity ×2 removed; maxGoals, Lightmap.maxSize as getters; JSON key 'behaviour' → 'behavior' through the level migrator; InputFrame.axes/tunes/values and Tunables documented as the data plugin's string map (kept) with a typed Tunable<T> beside; D2 TimeSource (realTime, scaled, log, manual) as the loop's clock with FrameCadence reading it (the view wiring is wave 3); RoomDoor named constructor.

A1 CharacterMoved, JetDrop → final classes; A4 CollisionShape → abstract base with ShapePhysics as the extension point; A3 DirectionalBackend, MixingBackend, PlacedEvent → abstract base with defaults; Collider.kind/shape/world/userData/material final, world set by CollisionWorld; A8 oil ×2 removed; foundation's 3 and net's 1 record returns; SilentVoice, Emission, Audible named constructors; BlackBody.color → LinearColor; SettingKey<int>.decode never throws (game, by agreement with 2F: 2F does it).

A7 MissingToolException, ToolFailedException exported; ConvertCommandSettings.parse throws; usage renamed; bin/ reduced to flutter3d plus thin aliases documented as such; A8 legacyPluginMarkerKey, LoopPhase.elements removed; plugin_runtime reads sections only through DataSectionRegistry and drops core, sim, shaders, physics, hardware from its pubspec (§2.5.3); D40 ScriptRuntime removed and scripts → expressions with a migrator; D46 PluginGroup with set, with, without in plugin_api and the project document's plugin list in the same shape (2F writes StandardPlugins, GamePlugins, TwinPlugins, LabPlugins against it); SimulationProfile enum-free marker type in plugin_api for wave 3 (deterministic, accurate as a final class with wire names); outputSchema on every editor tool, annotations on every model tool.

D41 Flutter3dView(simulation: SimulationPlacement.isolate) over IsolateSimulation with the web placement documented (moved here from wave 3 on decision 52; 2C provides the loop side); D13 warmUpInSlices from the view after the device opens; EngineLog with levels and a crash-report hook in foundation and the view (decision 53); the first-hour fixes of decision 54: a DidNotStart-style banner when Impeller is off instead of a silent CPU fallback, Mesh3D.onTap/Model3D.onTap(part) over the raycaster, OrbitCamera3D for Scene3D, Light3D.sun()/Light3D.lamp() with sensible candela; D36 the genres on addSystem/LoopContext; D39 Material3D on MaterialParameters; A4 ActionBinding, TimelineCommand → abstract base; A2 game's 4 record returns; outlineColorOf → LinearColor; loadEnvironment/loadTexture throw; A8 ext.flutter3d.hotSwap alias removed; flutter3d_game.dart:49 gets a show list (reexportedWhole empties in 2Z); D9 Flutter3dView parameters grouped into DeviceOptions, ViewOptions, LoopOptions, PluginOptions; Scene3D documented as sugar on it, SceneSurface as the lower layer; Flutter3dView calls warmUpInSlices after the device opens (D13 part); the 19 widget classes final; SettingKey<int>.decode never throws; defaultSunIntensity in lux.

Snapshots, migration seed and fix_data for every rename (the Breaking labels in the CHANGELOGs); the rules: sealed/enum only on an allowlist with a reason (D8), a major release deprecates nothing (D12), live handles after each test (D11), reexportedWhole = {}; analyze, structure, all touched suites; commit by area, push.

D20 RenderStep.velocity on its own, FrameContext.previousViewProjection, viewIndex and views, per-view resources through keeps; D21 extra uniform blocks and textures for a plugin's lit model (the slot table in .f3dmat, the binding plan per backend, the CPU shaders, the bundle writer); D22 a light-loop hook (LightType with its own falloff and packing), a ShadowTechnique that produces shadow_map and the cube atlas, decals through LightingModel with the limits as settings; D22b the rest of the hooks, to the maximum: declared vertex attributes and layouts for a plugin's vertex stage (instanced and lightmapped variants included), plugin-declared resources and MRT outputs as a documented API, per-view resources and views, a RenderList hook for culling and sort keys, a TextureCodecRegistry beside the model decoders, a LOD policy hook, a skinning hook beside SkinBlend, a pacing hook on FramePacing/AdaptiveQuality, compute steps in the frame graph with a typed refusal where the device has no compute and .f3dmat compute on WebGPU, Wasm plugins on the data plugin's render surface; D23 <pluginId>. enforced on every registration, LightingModels per engine, case-sensitive names, conformance render checks (a plugin step and a plugin lit model on four backends); D24 the material AST and ResourceSize as abstract base with a visitor and visitUnknown, the three translators on it. D26 MaterialCompilerRegistry: a backend registers its .f3dmat compiler and bundle section, RuntimeShaders and material_compile.dart consult it, the four backends register themselves; D27 the shader contract for a backend author: compileStage({target}) returning SPIR-V and the target text, stageBindings/uniformBlocks in package:flutter3d_shaders/backend.dart, the entry-point list and the F3D_* defines in CONTRACTS. D29 the Wasm render ABI: f3d_render_node records encoder commands through Recorded against declared resources, versioned with the step ABI; .f3dplugin declarations for light types, vertex layouts and LOD tables; a conformance check runs a Wasm render node on four backends; D37 SceneBinding in core and plugin_api (component → node kind and material, interpolation, lifetime) and the .f3dplugin bindings: section (the Scene3D widgets are 3G's, actor_visuals.dart is 4D's); D38 RenderNode.setup(FrameGraphBuilder) with FrameGraph.compile from declarations, aliasing and lifetimes for plugin resources, declare in execute as the documented exception; D43 one entrance per thing: lighting models only through host.registry<LightingModels>(), stages only through addMaterials, extraBundles and stagesFor made internal; D44 the f3d.pipeline document (anchors, nodes with reads/writes/keeps, switched-off steps, settings slots) with codec, fixture and migrators, the standard pipeline written as one, RendererSteps.fromDocument, the .f3dplugin pipeline: section (the editor's panel is 4I's). A sample plugin under packages/flutter3d_plugin_runtime/example exercises every point and runs in conformance, once from Dart and once from data plus Wasm. Two agents if the files allow: 2X1 on core/shaders/plugin_api/conformance (hooks and names), 2X2 on the four backends and the bundle writer (bindings, compute, codecs, the compiler registry), with the shader ABI agreed in writing first.

Snapshots (hardware's own line is touched: additive only), migrations, the namespace rule, analyze, structure, suites, goldens unchanged (the engine's own materials keep their picture); commit, push.

D33 the expression language in foundation: parser, typed AST with units, a deterministic evaluator on Portable maths, a codec; .f3dmat rebased on it with v1 and v2 files reading as before (the material fixtures prove it); the visitor of D24 is this AST's visitor; D45 version and updates in material {}, material instances carrying the version in levels and .f3d, the lift chain, the fixture rule over materials (the rule itself is 3Z's).

D4 PropertyLaw (constant, table, Andrade/Arrhenius, polynomial, with at(MaterialState): T, p, phase and an open set of quantities), every property of every group a law, the 20 °C value as the law at the reference state; D5 externalIds (CAS, IFC, MaterialX, …) and MaterialCatalog.byExternal(space, id); the verified data from 0.4 into the catalog (~100 fluids, ~100 solids, sources, estimates marked), .verified.json as the check; the inelastic group (hyperelastic, viscoelastic, plastic, damping) with its codec; friction for every solid, pairs through contact (found in 0.4:* the research has a static self-pair for 41 solids and a kinetic one for 9, and no restitution; the rest come from a second research pass or are marked estimate); a thermal group for basaltMelt; dielectricF0 in the optical group; the surface-tension floor 1e-5; defaultFriction and the NativeMaterial preset defaults as header constants; the generator writes thermal and fluid tables for the core and scalars for the rest; the conformance check for the catalog shape. Decision 61 of the product review: a confidence field in the type (measured, handbook, estimate) instead of a word in a comment; a generated coverage table on the matter README saying which properties of which materials carry a real temperature or pressure dependence and which are constants at the reference state; and the sentence, in the README and in CONTRACTS, "reference values for simulation, not for design or safety calculations".

D6 the core interpolates the thermal and fluid laws from the header tables per body state; a parity test holds the C and Dart interpolators bit for bit; P1/P2 the Dart NativeMaterial defaults and friction read from the generated header; NativeDynamics pushes the Dart-evaluated groups as scalars when state changes beyond a threshold; D3 the accurate profile's double path in the native wrapper (the core stays float; accurate means the Dart engine, documented).

D3 SimulationProfile.accurate in the Dart engine: double maths, adaptive integrators behind the fixed step, analytic tests (pendulum, projectile, orbit) in test/, the pendulum one named pendulum_period_test.dart with its number (the period at θ₀ = 0.1 rad over 100 periods within 1e-4 of the series, an energy-drift bound), and the documentation saying what accurate covers (point masses, liquids, cloth: the Dart engine has no rigid-body rotation and the C core stays float); ClothSettings.inWorld called by every cloth owner, wind drag scaled by ρ, cloth reading the mechanical group (P7); buoyancy and drag reading laws at the body's temperature; Vector3.toWorldPosition call sites audited.

P3 dielectricF0 from matter's optical group in the CPU shaders and the MaterialX exporter, and generated into the GLSL as one constant; P4 sunAngularRadius = 0.004653; P11 the four exposure copies and 683 lm/W read the canonical; the .f3d physicalMaterials section 36 (optional, skipped by 0.8 readers, v2 fixture), render materials referring by id (D5 consumer).

P5 AudioScene/Speakers take WorldProperties.speedOfSound, EqualPowerPanner.inWorld the default path; P6 occlusion reads the acoustic group per obstacle material; Speakers.pause documented.

D6 (review) Probe component (point, section, body; quantity with unit; derived: an expression) with codec, read in publish, ProbeReading in PublishedState and on the tape; D7 ExternalStateInput kind of InputFrame with a timestamp, an Assimilation system hook, a tape fixture with external frames; D3 SimulationProfile on EngineLoop and WorldProperties, SimulationVersion carrying the profile, the determinism check applying to deterministic only; D34 the relay's observer path serving an authoritative simulation's tape with telemetry frames, poses for the accurate profile; plugin_api names WorldProperties in the host; levels and prefabs refer to materials by id and refuse an unknown one naming the plugin; the .f3d section's level side; GeoOrigin (latitude, longitude, altitude, ENU frame) as a record on Level and WorldProperties with its codec and fixture (decision 62).

D2 the view wired to TimeSource (Flutter3dView.time:), FrameCadence driven by it; Scene3D.time:; the probe readings exposed to widgets through published state; D37 Binding3D widgets over SceneBinding in Scene3D; the probe readings behind SimulationPlacement.isolate (the placement itself is 2F's); level_scene reads materials by id.

The rule every world property and material group has a reader (D18), the lux rule covering LevelLight, the rule for a particle system without a world in an app that sets WorldProperties; physicalMaterials fixture counted by the format rule; snapshots, migrations, analyze, structure, suites; commit by area, push.

What of D13 wave 2 did not reach: ECS query.entities without the per-query Set<Type>; the shadow pass hash per cascade cached; the allocation benchmark's baseline.

releasePipeline implemented where the backend can; what of the scratch-buffer work wave 2 left with a note.

D56 vertex stages without gl_VertexID on the GLES path (an index attribute instead of the built-in) so Impeller draws on Linux, and Linux with Impeller in tool/ci.sh; D15 ShaderStageNeed declared by materials, settings and plugins; the project hook writes a bundle and web maps from the set; --full-shaders; MissingShaderStage under the root; the editor keeps the full set; the size written into the quickstart. D19 the same hook compiles every installed plugin's .f3dmat into the project bundle for the running SDK; Impeller's typed refusal for a missing plugin stage; doctor checks; the prebuilt-bundle option documented with its SDK check.

D37 actor_visuals.dart rewritten on SceneBinding; what 0.9-no-crutches.md needs from the core so the demos can drop their numbers (D14 package side): a channel carved into the ground, brands as bodies with heat, a hit test by contact, bombs on the native ballistics, heat on an actor from the field, crash and douse from the elements' state, find masses from the catalog; ElementSounds of racing folded into game_physics; BurningWrecks on published state.

§2.5.2 what the lesson viewers need from editor_core moves to level_scene or education; LessonPlayer one home in stereo; UniformMemberLayout one home; LightmapBaker → build (by agreement with 4C: 4E moves it, 4C does not touch it), SequencePlayer → camera; the unused dependencies of §2.5.8; D31 the experiment document f3d.experiment (a level, substances by id, probes, a scenario with steps and expected readings) read by education, edited in editor_core and the editor MCP, with the pendulum and the chemistry bench as the first two, and a pendulum.f3d.experiment fixture read by a test before any editor edits it; the check → AgsClient/XapiClient wire in education (moved here from 5F by decision 62: the clients and the LTI service exist, the wire is the cheapest item with the largest effect for an LMS buyer).

D35 for the laboratory audience in rc.1 (decision 62): Semantics on every control, textScaler honoured, keyboard focus order, the reduced-motion flag read; the accessibility test of 4K' run over both apps.

D30 USD import for twins: primitives, UsdPreviewSurface and MaterialX materials, the hierarchy and custom attributes into prefabs and levels, a report of what was not carried, a twin fixture; the "Bringing assets in" page gains the USD section.

D32 the editor plugin contract: inspectors from hints for plugin components, materials and entity kinds; plugin-registered commands shared with MCP, gizmos, importers, panels, docks and asset-browser entries; the editor installs the project's plugins; the experiment document's editing side of D31; a sample editor plugin in the runtime example. 4E keeps editor_core's moves (level_scene, LightmapBaker) and does them first.

D35 WCAG AA in game_ui: textScaler, reduced motion, Semantics on every control, contrast tokens, the flash limit; the structure rule and the CI accessibility test; the lesson viewers follow in 4J.

§2.7.4 web decoders in a Web Worker where the browser allows and documented where not; HDR panoramas decoded off the UI isolate on native; WebGPU createRenderPipelineAsync on the draw path with a one-frame fallback; KHR_parallel_shader_compile on WebGL.

D28 renderFrame(device:), testReplay(device:) and drawOnce exported from testing; conformance on one decline() for every refusal; the reference outside backend examples/flutter3d_backend_null (headless, published libraries only, passes conformance in CI); flutter3d create plugin --kind backend generated from it; the backend author's guide and the hardware SKILL rewritten for 1.0 (one open, base encoders with defaults, backend.dart, the compiler registry, the shader contract). The implements→extends detector and the "no internal/src from examples/" rule are 4Z's.

A draw-count and allocation benchmark on the CPU backend in CI (tool/ci.sh), asserted against a baseline; rules: apps covered by the layer, re-export and runtime rules, hook/ read by declare what you name, a demo declares no class a package exports, the GraphicsDevice detector reads extends, examples/ reaches no internal or src; examples/flutter3d_backend_null in the workspace and in check; analyze, structure, suites; commit by area, push.

D9 on Flutter3dView; D14 hazard tables by level name gone, River's bed and 60 m reaches gone, Arcade's meteor temperature from the catalog; P8 particle systems with the game's world; D6 probes instead of run.world; DemoRecording in arcade and river; the demo hooks on flutter3d_build_hooks with hooks declared (§2.5.1).

D9; D14 Strategy's channel, brands, hit test and caps; Hollow's bombs and roof; Dungeon's CryptHarm.flux and _splits; probes; the hooks.

D9; D14 Racing's _wrecking, _burnsFor and ElementSounds copy; Reef's find masses from the catalog and pressureAt through a probe; Water's densities; probes; the hooks.

D9 on Flutter3dView; the viewers off editor_core and their OpenKind/LessonPlayer copies gone; the labs on SimulationProfile.accurate with a TimeSource.manual slider and the f3d.experiment document (D31); the viewers on the relay's observer path (D34); WCAG AA in the viewers (D35); the showcase's intensity: 6.0/5.0 in lux, its ClothSettings in the world, its densities; textScaler honoured in the showcase's text.

The quickstart, the scaffold and the examples start from Flutter3dView; a twin-shaped example and a laboratory-shaped one (accurate profile, manual time) beside the game one. The twin-shaped example reads one real source, not a sampler (decision 62): a MqttExternalStateInput on mqtt_client or a REST poller in the example's own code, the history on a tape, a scrub through RunTimeline, a probe, a scaled time source; the five references to the non-existent flutter3d_lab_twin in apps/flutter3d_lab_incident removed or pointed at it.

The demo allowlist of the run.world rule emptied; the apps' rules on; 0.9-no-crutches.md closed with a line per item; analyze, structure, every app suite; commit by area, push.

D47 ModelViewer3D: a model from the network, a file or an asset through ModelDecoders.addSource; orbit by gestures with limits and auto-rotate that yields to a scrolling parent; poster and progress; hotspots from a surface point; variants; environment presets; screenshot; Quick Look (USDZ) and Scene Viewer (GLB) launch, from a web page too (rel="ar" and the Scene Viewer intent); VideoTexture fed by video_player or a camera through overwriteTexture; spec-gloss converted to metal-rough on read. The widget is built from the modeller's own viewport pieces (OrbitController, Flutter3dView, RenderView), and the modeller's preview panel, its share page on models.pleion.dev, the tutorial gallery and the MCP render answer show models through it, so the editor and the viewer draw the same picture and the widget is proven on the web first. The edit viewport stays the editor's.

D48 TextNode on an SDF atlas from Flutter fonts, BillboardNode, SpriteNode; PointCloudNode from PLY and LAS with an octree, a point budget and eye-dome lighting; clip planes as a renderer setting with the material-level discard and the gizmo hook.

D49 subsurface, hair and cloth lighting models in GLSL and CPU, each declared through the plugin slot table of D21; D50 the terrain layers material (height, slope, mask) and the grass stage with wind and LOD.

D50 GrassField over the terrain layers with the chunk streaming interface generalised from the Flame bridge; D51 RibbonTrail; reverb on the SoLoud filters behind ReverbEffect.

D52 measurements (distance, angle, area, snapping), exploded view, an element tree with show, hide and isolate, camera bookmarks carrying visibility and sections, over 5B's clip planes (coded against its sketch); the showcase pages.

D53 the viewer asks check questions on the f3d.experiment document (the LTI and xAPI wire itself is 4E's, rc.1); the Rule document over probes and expressions with SceneBinding colouring and acknowledge; the twin example uses it.

D54 XrSession base, WebXrSession (reference spaces, hit test, anchors, hand input) on both web backends, Flutter3dView(xr:); a showcase page.

D57 a Rapier backend on PhysicsBackend with prebuilt binaries per target and wasm, the physics-backend conformance checks, the racing demo switchable to it in a test.

D59 post parity: DoF bokeh shape (blade count, rotation, curvature) and quality tiers; AO bent normals, multi-bounce, specular AO, depth-mip chain; SSR glossy blur, resolution scale, distance fade, debug views; linear fog with sky blend and sun in-scatter; SMAA tuned at run time with diagonal search; shockwave screen distortion; animated grain as an option; bloom firefly suppression; per-node debug views; the shadow map and a node mask as custom-pass inputs; goldens for each on four backends; the comparison page's post rows corrected and the missing rows added.

Snapshots, migrations, the showcase pages for every new node and widget, goldens for the new stages on four backends, the structure counts; analyze, structure, suites; commit by area, push.

The proof on hardware (the five items above): pacing on the A55 and an iPhone, the soak, the C-core parity table, rollback between eight phones, the build sizes; plus one session played on Windows with its report in SUPPORT (D56). The pacing and parity tools exist (tool/pacing.sh, the parity tests); the reports are committed under doc/pacing/ and doc/parity/.

Every suite: the fast ones, the Flutter ones, the apps, the browser runs (tool/ci.sh in full), the Windows job. What is red is fixed by the owning agent of its last wave.

Re-record the four golden sets after the last shader change, ascent.f3drun, the site's platformer and racing tapes, the sim and strategy fixtures; the modeller screenshots through publish_modeler_screenshots.dart.

CI: nightly.yml on schedule: for the impeller runner with goldens, conformance and pacing, the artefact and the badge (D16); the Galaxy A55 attached to the same runner runs three demos nightly with a p99 threshold that turns the job red (decision 53); the tool suites and the root structure_test in check; a build step for every app; web builds for every demo.

Documents: the quickstart rewritten from the pub user's side first (flutter create, two dependencies, the two platform keys, Scene3D with Model3D) and the checkout last; core/tutorial.md on the 1.0 API; one material type in the quickstart and the READMEs (RenderMaterial in code, Material3D in widgets) with the other three named in the glossary as not for applications; the glossary linked from the quickstart; a cookbook of twenty task-shaped recipes of forty lines or fewer ("a GLB with a buy button", "a runner at 60 fps on a phone", "a pendulum with a length slider"); doctor checks the platform keys, hook/build.dart and the assets: lines (decision 54); the hand-written counts replaced by rule-held ones (README, SUPPORT, site index, packages.md, AGENTS); README's table and packages.md complete; SECURITY, AGENTS and ROADMAP rewritten for this tree; comparison.md, quickstart's stale lines, the root LICENSES.md sentence, /showcase/learn/; CONTRACTS' .name sentence true (the rule widened to .name in the format paths, the six sites fixed) and its precision paragraph (D1); SUPPORT's Impeller-memory and nightly sentences (D11, D16); the plans' status notes (1.0-boundaries.md, 1.0-publish.md tiers and versions, 1.0-scope-additions.md item 9); ARCHITECTURE's duplicate §3.3, the new types (TimeSource, SimulationProfile, Probe, PropertyLaw).

Publishing: flame_multiplayer and flame_multiplayer_dashwire to 1.0.0-rc.1 with a CHANGELOG note on the jump (D10); descriptions under 180 characters; tool/api_against_pub.sh run and clean; tool/publish_check.sh run and clean; the upstream issue to flutter_gpu for a native dispose filed and linked from SUPPORT.

flutter3d create project --kind viewer and --kind arcade (the Flame bridge) beside the four genre templates; a playground page on the site that renders a level or prefab document through the web backend as the user edits it (decision 54).

D55 the editor distributed: editor_release.yml building a notarised macOS dmg, a Windows zip and a Linux tar.gz with SHA256SUMS on a tag; the web editor deployed on the site beside the modeller; a download page. D58 comparison.md reread against flutter_scene 0.24.3 with the stale lines fixed, and the four items still to verify on this side (an ETC1S encoder, a shadow-catcher material, a point light radius, tvOS and visionOS variants) answered one way or the other.

Commit by area, push, tag v1.0.0-rc.1, publish by the L0–L9 order, mark the five absorbed names discontinued, deploy the site, then the videos and the posts through the humanizer. For rc.2 the same sheet with v1.0.0-rc.2.

Answer issue #81 (the pointer_lock name: an apology, a cross-link, and a decision on a rename) and #80 (declare the plugin's platforms), before any post.

Discussions on with categories; one chat channel named in README and SUPPORT; a paragraph in SUPPORT "where to write and when to expect an answer"; a Code of Conduct contact that is not a security advisory.

1.0-publish.md regenerated from the order rule (today it omits flutter3d_foundation and flutter3d_matter); D10 applied in the pubspecs of flame_multiplayer and flame_multiplayer_dashwire; a script that publishes one layer and waits on /api/packages/<p> before the next; plan B written (+1 build metadata on a broken package); the five discontinues on the sheet; every description under 180 characters; dart-apitool confirmed installed.

The site deployed from CI on the tag (today a manual rsync, two versions behind); a curl of five URLs in the release checklist; migrating-to-1.0 live.

README and index.md: one sentence on the three audiences and their hierarchy ("a game engine; the same fixed step, probes and time source carry a laboratory or a device twin, and flutter3d_education carries LTI"); a link to /education/ from the index; an "an agent in two minutes" section with the mcpServers snippet; the package count held by a rule. In 5.4.

Quickstart: flutter pub add with the explicit ^1.0.0-rc.1 constraint (plain pub add brings 0.8.5); flutter clean after adding the build dependency; what happens after flutter upgrade and what to do; "the viewer widget arrives in rc.2". In 5.4.

The cookbook as its own item, out of 5.4: twenty files in examples/cookbook/, each under forty lines, built in tool/ci.sh; recipes that need rc.2 API are marked and land with rc.2.

A download page: the web editor by URL first, "build from source" second, the native builds of D55 when they exist, each platform with its SUPPORT status, the unsigned fallback described (xattr), gallery.md:54 corrected (the editor has a web build).

A GitHub Release for every tag with notes; a "what 1.0 is and why migrate" page (strict semver, four backends, determinism, the agent, migrate in one command); the changelog page keeps its list; the migration guide says "1 538 entries, 721 by hand", not "about two hundred places", and drops the GameLoop deprecation sentence.

A launch checklist: channels (r/FlutterDev, Show HN, Mastodon, X, the Flutter and Flame Discords), dates, the URL each post leads to, the first comment, who answers in the first 72 hours; one two-minute video (a bug arrives as a tape, a test reproduces it, rollback on phones) shot before the post, not last. The posts through the humanizer.

D58 comparison.md reread against 0.24.3 with "as of" dates on every "no", a community row (stars, downloads, contributors, dated), rows for external textures and billboards marked "flutter3d: rc.2", one MCP package name on the page, the four items still to verify answered.

SECURITY rewritten to point at SUPPORT's windows and to name the relay, LTI, MCP and Wasm plugins in its scope; ROADMAP rewritten with a revision date; both under a rule; the root LICENSES.md README links to; the LTC licence at the path ltc.dart names; the SMAA notice in the shader headers; one line that the project is not affiliated with Google or Flutter.

"One number for the shelf" against "a patch of flutter3d_impeller only" decided and written in SUPPORT; LTS removed from the 1.0.0 texts until a release is named; the Impeller-memory sentence of D11 in the quickstart as well as SUPPORT.