plan.md

CNA Samples Master Port and Re-audit Plan

Authority and scope

This is the only authoritative plan for the sample collection. It merges the former cna-samples/PLAN.md migration list and cnanext/plans/plan_samples.md CNA-gap list. Sample implementation, framework/runtime gaps, original-reference evidence and web delivery are tracked in one place so that a sample cannot be called complete while a workaround or a hidden CNA bug remains elsewhere.

The local upstream snapshot is /rv/tmp/XNAGameStudio/Samples. A direct inventory on 2026-08-22 found 153 directories after excluding .idea. All 153 have an individual row below. Historical labels such as Done, Placeholder, Ignored, permanently out of scope and earlier owner declines are evidence to re-check, not current conclusions. Every directory, including all 67 previously ignored entries, receives a fresh source audit.

The large Racing Game remains governed exclusively by plan_racing.md. Its source directory is present in the inventory as SAMPLE-152, but this plan must not duplicate, renumber or modify Racing tasks, plan_racing.md, racing_api_matrix.md or racing_feasibility.md. Racing is deliberately scheduled as the final port, after every other sample row and shared sample infrastructure task has either passed or received an explicit owner decision.

Goal

Port the maximum possible number of original XNA samples to C++ with behavior and structure as close as practical to the original source, using CNA and sharp-runtime rather than sample-local substitutes. Every port must work natively and must also produce a tested browser build suitable for later publication.

The active development dependency chain is temporarily:

Repository	Required checkout	Current branch at plan creation
cna-samples	this repository	develop
CNA	../cnanext	next
sharp-runtime	../sharp-runtimenext	next

cna-samples must set CNA_SHARP_RUNTIME_ROOT to ../sharp-runtimenext before adding ../cnanext as a subdirectory. It must no longer build against ../cna or indirectly select ../sharp-runtime during this development campaign.

Renderer boundary for the sample campaign

EasyGL is the only reference renderer for this campaign:

• Native sample builds use CNA_GRAPHICS_RENDERER=OPENGLES3.
• Emscripten sample builds use CNA_GRAPHICS_RENDERER=WEBGL2, the browser/WebGL 2 spelling of the same EasyGL OpenGL ES 3 implementation. OPENGLES3 itself is intentionally rejected under Emscripten, so WEBGL2 is not a second renderer scope.
• Do not build, debug, compare or add sample-specific handling for Vulkan, SDL_Renderer, Bgfx, WebGPU, desktop OpenGL or any other renderer during this campaign. A CNA/sharp-runtime fix found by a sample is implemented cleanly in its owning layer, but sample acceptance and regression verification are performed only on OPENGLES3 plus its WEBGL2 browser target.

Sources of truth

Use these in descending order for each audit:

1. The exact original sample under /rv/tmp/XNAGameStudio/Samples for source structure, control flow, content declarations, assets, controls and visible behavior.
2. A running original XNA build for observable behavior. First rediscover and document the previously used direct Linux-side route. If that is unavailable or unreliable, use the local Windows 7 VirtualBox VM with Visual Studio 2010 and XNA Game Studio 4.0.
3. /rv/data/library/github.com/FNA-XNA/FNA for XNA API and behavioral details not established by the sample itself.
4. Local XNA documentation/specification mirrors where runtime observation is impractical.
5. MonoGame ports only as supplemental evidence, never as authority over the original sample or FNA.

The machine currently has 268 .sln and 359 .csproj files under the source snapshot. The VM definition exists at /home/robertvokac/VirtualBox VMs/win7/win7.vbox, but on 2026-08-22 VBoxManage reported that /dev/vboxdrv was unavailable. This is an environment prerequisite to resolve, not permission to skip original-reference validation.

No-workaround and fidelity policy

The following rules apply to existing ports as strongly as to new ports:

• Compare every original C# source file and relevant content declaration line by line with the C++ port. Preserve class/file decomposition, names, lifecycle, algorithms, constants, default values, input mapping and draw/update order wherever C++ permits.
• Use the public XNA-shaped CNA API. Do not call backend helpers, construct replacement runtime objects to bypass Content.Load<T>(), use raw-mesh loaders because Model is broken, add sidecar data because buffer readback is missing, or replace a missing property/event/network behavior in sample code.
• Do not omit or simplify scenes, screens, gameplay, effects, audio, networking, content processing or controls. Do not invent keyboard controls, substitute bodies/services, fake data or a reduced demonstration and then call the sample ported.
• Remove legacy sample-side workarounds as their rows are audited. A workaround previously approved for expediency is not grandfathered into the new completion definition.
• The existing mandatory F1 help overlay is not part of the original XNA samples. Remove its code and porting requirement from every audited sample. Preserve only the historical help.png by moving it out of Content into the sample root beside CMakeLists.txt; it must not be loaded, copied or preloaded by the sample. Apply the same asset-preservation rule to future audits.
• Prefer System::* types and primitive aliases from sharp-runtimenext when the C# source uses a .NET concept. Do not replace missing runtime functionality with an unrelated STL implementation merely to make a sample compile.
• Unavoidable C#-to-C++ mechanics such as ownership/RAII and a lossless offline asset-container conversion are allowed. Asset conversion is not a license to change behavior: the port must keep the same content identifiers and use the corresponding public CNA load call. Converted output must be reproducible from the original source asset.
• missing.md is an audit record, not a waiver. A sample with an active behavior difference, missing feature or workaround cannot be ✅.

When the faithful C++ translation exposes a missing or incorrect API, fix the owning repository in the same sample session:

Gap belongs to	Required action
XNA/FNA behavior or API	Implement/fix it in ../cnanext, add the required CNA tests and follow ../cnanext/AGENTS.md plus CHECKLIST.md.
.NET System.* behavior or primitive/runtime type	Implement/fix it in ../sharp-runtimenext, add its required tests and follow that repository's AGENTS.md.
Sample translation/content	Fix it in cna-samples; do not hide a framework/runtime gap here.

One session may therefore change all three repositories. Use the same sample task ID in their commit messages and record the resulting commit hashes in the sample row or its audit report.

Definition of done for one sample

A row may become ✅ only after all applicable gates pass:

1. Classification: inspect the physical upstream directory and record whether it is a runnable XNA game, tool, library, training sequence, platform variant, asset pack or documentation. Never accept the old classification without reopening the files.
2. Original evidence: select the correct original project/configuration, build and run it when runnable, record exact commands/environment, controls, screenshots or frame captures, audio and important state transitions. If it truly cannot execute, record file-level evidence and the exact external dependency.
3. Complete translation: audit every C# source file and relevant content item. Port the complete selected original, including all overload use, screens and optional branches exercised by that project.
4. Zero workarounds: run a targeted review for bypasses, substitutions, invented behavior and stale missing.md deviations. Fix CNA or sharp-runtime gaps in their own repositories.
5. Native verification: configure/build the sample against ../cnanext + ../sharp-runtimenext with CNA_GRAPHICS_RENDERER=OPENGLES3, run it, and compare it with the original reference. Build and run relevant CNA/sharp-runtime tests for every dependency change on that renderer only.
6. Web verification: produce .html, .js, .wasm and any .data/content artifacts with Emscripten; serve them over HTTP; run in a real browser; verify rendering, input, audio/content loading and a representative interaction path. A successful link or Node-only run is not enough.
7. Documentation and status: update the sample's missing.md with either No known differences plus evidence or the still-open differences; update this row and any historical gap documents; commit all touched repositories by explicit file list.

Every ported sample must keep its web bundle reproducible. The eventual publication location is not part of this task, but the generated bundle and instructions must be suitable for copying to the owner's website without source edits.

All original-reference, native, web and comparison artifacts produced by this campaign are retained under /rv/tmp/samples/SAMPLE-nnn-UpstreamDirectory/, never in an ad-hoc /tmp directory. Use the following stable layout so every completed audit can be reopened and rebuilt:

Directory	Contents
xna4-original/	The exact original source/configuration used for comparison and its compiled executable.
cna-native-opengles3/	Reusable CMake build tree and resulting native EasyGL/OPENGLES3 executable.
cna-web-webgl2/	Reusable Emscripten CMake build tree and complete .html/.js/.wasm/.data bundle.
evidence/	Original/native/web screenshots, captures and relevant run logs, including failed-before-fix evidence when useful.

Per-sample missing.md files must record their exact artifact root and build/output paths. Browser profiles and shared CNA regression build trees are temporary infrastructure rather than sample artifacts and are not copied into each sample directory.

Build with the whole machine: -j$(nproc) or a plain --parallel. There is no CPU-core limit. This paragraph used to impose -j6; that ceiling existed for a cooling fault repaired on 2026-08-22 and the owner removed it here on 2026-08-25. Memory is the remaining constraint, not core count — if one target starts swapping, lower the job count for that target alone. Use CCACHE_DIR=/rv/cnaccache for every build in this campaign.

Status legend

Symbol	Meaning
⬜	Fresh audit not started; historical status is untrusted.
🔎	Source/reference audit in progress.
🛠	Port or cross-repository fix in progress.
🛑	Audited far enough to require an owner decision before a large new subsystem or scope expansion.
✅	All native, fidelity, no-workaround and real-browser gates passed.
↗	Managed by a separate owner-approved plan; do not modify it here.

Progress at a glance

Recount this from the table itself rather than trusting the numbers; they are a convenience, not a source of truth (grep -c '| ✅ |$' plan.md and so on).

Status	Rows	Notes
✅ complete	57	SAMPLE-001–SAMPLE-058 except SAMPLE-014
🛑 owner decision pending	1	SAMPLE-014 Spacewar — needs a ruling on an XML serializer in sharp-runtime
⬜ not started	94	the queue continues at SAMPLE-059
↗ separate plan	1	SAMPLE-152 Racing remains last and is governed only by plan_racing.md
total rows	153	one per physical upstream directory

Two of the ✅ rows are evidence-backed non-port boundaries the owner accepted rather than ports: SAMPLE-004 StockEffects and SAMPLE-015 TicTacToe. Racing (SAMPLE-152) is deliberately last and governed by plan_racing.md.

Baseline artifact inventory

This describes only what exists before the fresh audit; it is not a completion count.

Existing artifact state	Count
Has sample source and CMakeLists.txt	63
Placeholder directory without source/build target	23
No samples/ directory	67
Total upstream directories	153

Foundation tasks

Task	Status	Work
SAMPLES-INFRA-001	✅	Merge the two former plans into this lowercase plan.md, move all 153 upstream directories into individual rows and remove the duplicate plan from cnanext.
SAMPLES-INFRA-002	✅	Changed the development build to add_subdirectory(../cnanext CNA_BUILD) with CNA_SHARP_RUNTIME_ROOT=../sharp-runtimenext, removed the monolithic-target and obsolete-renderer assumptions, restricted native presets to OPENGLES3, and proved the configuration with SAMPLE-001.
SAMPLES-INFRA-003	⬜	Reconcile README.md, CLAUDE.md, NEXT.md, DEFERRED.md, ignored.md, root missing.md and per-sample guidance with this plan: new dependency paths, no permanent-ignore authority, no F1 requirement, no workaround acceptance and lowercase plan links. Preserve useful historical evidence.
SAMPLES-INFRA-004	⬜	Add an inventory validator that compares the 153 physical upstream directories with exactly 153 unique SAMPLE-nnn rows and reports added, removed, renamed or duplicate sources.
SAMPLES-INFRA-005	🛠	Proved the direct Linux-side XNA 4.0 compiler route and the official BuildContent task under an isolated Wine prefix. SAMPLE-003 covers the stock FBX, texture, font and effect pipeline; SAMPLE-007 additionally covers a sample-owned processor assembly, reflective custom runtime type and live original-window capture; SAMPLE-010 and SAMPLE-011 prove that the Miramonte and Segoe UI Mono faces distributed inside XNA Game Studio can be installed into the isolated prefix for exact original font builds. Still extract the reusable workflow, Win7/VS2010 VM fallback and shared capture checklist from the per-sample evidence.
SAMPLES-INFRA-006	🛠	Qualified CNA_GRAPHICS_RENDERER=WEBGL2 with SAMPLE-001, SAMPLE-003, all seven SAMPLE-005 screens, all five original SAMPLE-006 sprite-effect modes, SAMPLE-007's official custom-processor atlas, SAMPLE-008's BasicEffect line primitives, SAMPLE-009's complete standard-gamepad report, all nine SAMPLE-010 buffered moves and SAMPLE-011's 1280x720 title-safe/camera behavior in real Chrome. These gates cover compiled effects, models, fonts, cubemaps, skinning, signed textures, secondary samplers, custom XNB object graphs, line primitives, input and a large browser canvas. Still add reusable local-HTTP/browser smoke automation before making this the shared per-sample web gate. Do not test or claim another renderer.
SAMPLES-INFRA-007	⬜	Add a per-sample audit template and mechanical scans for known bypass patterns (RawMesh/RawModel, direct SetData content substitutes, NOXNA graphics helpers, sidecars, invented input, omitted/simplified branches). Scans support, but do not replace, line-by-line review.

Owner decision queue — ask when the owner is at the computer

Auditing and small fixes continue without asking. When one of these is confirmed by a concrete sample, stop before implementing the large subsystem, mark the affected row 🛑, present measured scope/options and ask the owner. Do not silently reintroduce a sample workaround.

Decision	Current evidence to verify	Owner choice needed
SAMPLES-DEC-001 — Native/custom .fx path	SAMPLE-003 proves that an official XNA 4.0 Effect XNB with 13 techniques loads and renders through the compiled-effect path on OPENGLES3 and WEBGL2. SAMPLE-006 adds four original pixel-only effects, parameter updates, secondary sampler slots and a signed normal map. Neither audit required hand translation. Audit later shader samples for constructs outside this proven subset before escalating a large missing subsystem.	If a concrete later effect remains unsupported after retest, choose a reusable faithful ingestion/translation strategy versus the exact bounded alternative supported by evidence. Do not hand-wire effect behavior inside each sample.
SAMPLES-DEC-002 — XNA content-pipeline extensibility	SAMPLE-004 confirmed the first concrete case: it has no Game, but a 369-line CompileEffect CLI using EffectImporter/EffectProcessor plus a 2,680-line six-effect wrapper library and 2,013 lines of HLSL. The unchanged original source builds and generates all six blobs. CNA OPENGLES3 parses the exact blobs and renders the BasicEffect blob, but CNA/sharp-runtime have no design-time Content Pipeline authoring API or effect-source compiler. SAMPLE-012 additionally proves an unchanged sample-owned processor assembly can generate exact runtime content outside CNA. Evidence: samples/StockEffects/missing.md and samples/GeneratedGeometry/missing.md.	Resolved for SAMPLE-004 on 2026-08-23: the owner selected the evidence-backed non-game/non-port boundary (option 1), with no alias, invented game or web demo. On 2026-08-24 the owner accepted byte-identical pregenerated XNB output as the faithful boundary for runtime samples such as SAMPLE-012; this does not declare a standalone design-time tool/library ported. Keep this decision open only for later rows that concretely require Content Pipeline authoring.
SAMPLES-DEC-003 — Skeletal/animation completeness	Four placeholders historically cite partial skeletal animation support. SAMPLE-005 retested the current stack and restored ReachGraphicsDemo::SkinnedDemo with official XNB content through bounded reader/Tag fixes, so it no longer supports the old omission claim.	After each remaining placeholder is retested, approve any genuinely large model/content/animation work if it is more than a bounded bug fix.
SAMPLES-DEC-004 — Retired platform services and hardware	SAMPLE-015 is the first measured case: its defining behavior is a 976-line WP7 XNA client plus a 547-line generated WCF proxy and an 818-line WCF service/host. The client registers an MPNS callback URI, sends one-way service calls and receives authoritative game state through XML push messages. The unchanged service builds on Mono; the current reference prefix lacks the WP7 SDK/phone assemblies, while CNA/sharp-runtime lack WCF and HttpNotificationChannel. Evidence: samples/TicTacToe/missing.md.	Resolved for SAMPLE-015 on 2026-08-24: the owner accepted an evidence-backed CNA non-port boundary and declined WCF/MPNS emulation. The existing local game is retained only as an explicitly labeled free reimplementation, never as an XNA port. Later Avatar/Xbox LIVE, Bing Maps, invites/presence, GPS and WP7 media cases still require their own audits and decisions.
SAMPLES-DEC-005 — Tools, WinForms, Silverlight, older XNA and duplicate variants	Forty-two directories were previously grouped away, and several numbered entries are tools/libraries rather than games. They now receive individual audits.	Decide after audit whether the project expands beyond XNA 4.0 games to faithful tool/library/older-version ports; never reject them merely because the old plan did.
SAMPLES-DEC-006 — Web feature gaps	Every successful port now requires a real browser build. XACT, microphone/network services, large content, persistent storage or a WebGL2 limitation may expose substantial work.	Choose the browser support boundary or authorize the measured CNA/sharp-runtime work; native-only completion is not allowed by default.
SAMPLES-DEC-007 — Original-reference environment	The local source has hundreds of projects and prior real-XNA evidence, but the earlier Linux route is not documented and the Win7 VM driver is currently unavailable.	Confirm the preferred reference route and any host/VM changes once the discovery task reports concrete options.

Per-directory audit queue

Existing means only the artifact state observed on 2026-08-22: port has a sample CMakeLists.txt, placeholder has a directory but no implementation, and absent has no sample directory. Focus preserves useful findings from the old plans without accepting their verdicts.

SAMPLE-001–030 — foundation, 2D and gameplay

Task	Upstream directory	Existing	Fresh audit focus	Status
SAMPLE-001	PrimitivesSample_4_0	port	Complete Windows XNA source/runtime comparison, zero-workaround review, OPENGLES3 native run and WEBGL2 Chrome run. Removed the non-original F1 overlay; fixed one-pixel primitive rasterization in CNA 76f1f6ebe and the faithful first-frame gamepad query's Linux startup delay in CNA 5b9287a41. Default Wine/DXVK exits during original-XNA startup; the retained reference wrapper uses verified WineD3D. Evidence: samples/PrimitivesSample/missing.md.	✅
SAMPLE-002	Primitives3DSample_4_0	port	Audited against the live XNA 4.0 original; restored the exact Position+Normal vertex, default lighting, HUD, input and disposal paths; fixed CNA generic custom-vertex upload/EasyGL declaration selection. Native OPENGLES3 and real-Chrome WEBGL2 rendering plus A/B/Y/Escape input gates pass. Evidence: samples/Primitives3D/missing.md.	✅
SAMPLE-003	TexturesAndColorsSample_4_0	port	Audited line by line against the XNA 4.0 C# source; replaced every primitive/BasicEffect/help-overlay workaround with the five original models, Clouds texture, DebugText font and official 13-technique compiled effect. All eight XNBs are byte-identical outputs of the official XNA pipeline. Fixed CNA startup XNB-reader registration and its public Emscripten stack contract. OPENGLES3 native and real-Chrome WEBGL2 runs render all 13 techniques and five models and accept Escape. Evidence: samples/TexturesAndColors/missing.md.	✅
SAMPLE-004	StockEffectsSample_4_0	absent	Confirmed as a non-game authoring package: a Content Pipeline effect-compiler CLI plus six educational stock-effect wrappers. Original compiler/library builds pass; all exact blobs parse in CNA and BasicEffect draws on OPENGLES3. On 2026-08-23 the owner selected the evidence-backed non-port boundary: retain the original build, do not alias CNA built-ins, and do not invent native/web behavior that upstream lacks. Evidence: samples/StockEffects/missing.md; decision: SAMPLES-DEC-002.	✅
SAMPLE-005	ReachGraphicsDemo_4_0	port	Line-by-line audit complete; all six demos plus title restored with the 22 official XNA-pipeline XNBs and no sample workaround. Fixed CNA base TextureReader registration, custom Model Tag ownership, EasyGL semantic vertex binding/VAO lifetime and GLES/WebGL base-vertex fallback. Original and OPENGLES3 native runs pass; system Chrome renders all seven WEBGL2 screens with working menu/back input, WebGL error 0 and no wasm exception. Evidence: samples/ReachGraphicsDemo/missing.md.	✅
SAMPLE-006	SpriteEffectsSample_4_0	port	Audited line by line against the live XNA 4.0 original; removed the handwritten GLSL/JSON effects, direct image substitutes and F1 overlay, and restored the eight byte-identical official-pipeline XNBs. Fixed CNA NormalizedByte4 XNB/upload support, stock-vertex-shader inheritance for pixel-only SpriteBatch effects and unassigned secondary texture slots. All five animated modes pass in the original, native OPENGLES3 and real-Chrome WEBGL2 with Space/Escape input. Evidence: samples/SpriteEffects/missing.md.	✅
SAMPLE-007	SpriteSheetSample_4_0	port	Audited against the live XNA 4.0 game, runtime type and custom processor; removed runtime repacking, loose images, omitted text and F1 overlay, then restored the three byte-identical official-pipeline XNBs. Fixed CNA's XNB reference dispatch for System.String collections, nullable SpriteBatch.Begin blend-state defaults and the Linux vendored-SDL cache key that had stranded existing builds on X11-only SDL. The live original, native-Wayland OPENGLES3 and real-Chrome WEBGL2 versions render both labels, rotating cat, animated glow, checkerboard and the exact 198x264 atlas; Escape passes and no sample workaround remains. Evidence: samples/SpriteSheet/missing.md.	✅
SAMPLE-008	ShapeRenderingSample_4_0	port	Audited line by line against the live Debug XNA 4.0 original; removed the F1 overlay, restored the exact game/renderer names, overloads, one-time guard, shared buffers, input and Debug-only call-site semantics. The original Wine/WineD3D, native Wayland OPENGLES3 and system-Chrome WEBGL2 versions render the same five colored line shapes on the rotating camera and accept Escape. No CNA/sharp-runtime defect or sample workaround remains. Evidence: samples/ShapeRendering/missing.md.	✅
SAMPLE-009	InputReporter_4_0	port	Audited line by line against the live XNA 4.0 original; removed the DejaVu font sidecars, loose texture substitutes and F1 overlay, then restored all 15 byte-identical official-pipeline XNBs and the exact C# control/draw flow. Fixed CNA's XNA backslash and case-insensitive content-path behavior generally. XNA and native OPENGLES3 baseline/Circular captures are pixel-identical; real-Chrome WEBGL2 verifies the complete browser gamepad mapping, two-second START/BACK charge switches, Space/Escape and faithful rendering with no runtime error. Evidence: samples/InputReporter/missing.md.	✅
SAMPLE-010	InputSequenceSample_4_0	port	Audited line by line against the live XNA 4.0 original; removed the loose PNGs, DejaVu font sidecars and F1 overlay, restored all 15 byte-identical official-pipeline XNBs including Miramonte Bold, and corrected enum labels, stable longest-first shallow move ordering, logical buffer capacity and original type names. The original and native OPENGLES3 captures are byte-identical for the baseline and all nine moves; system-Chrome WEBGL2 reproduces every move with pixel-identical game rendering and no runtime error. No CNA/sharp-runtime defect or sample workaround remains. Evidence: samples/InputSequence/missing.md.	✅
SAMPLE-011	SafeAreaSample_4_0	port	Audited line by line against the live Windows XNA 4.0 original; removed the loose texture/font substitutes and F1 overlay, restored the three byte-identical official-pipeline XNBs, and retained the original XBOX && DEBUG component branch instead of an always-on overlay. The original, native OPENGLES3 and system-Chrome WEBGL2 versions render the same 1280x720 title-safe labels, tiled background, cat and scrolling camera; A is correctly inert on current reference targets and Escape exits. The WEBGL2 baseline is pixel-identical to XNA, and no CNA/sharp-runtime defect or workaround remains. Evidence: samples/SafeArea/missing.md.	✅
SAMPLE-012	GeneratedGeometrySample_4_0	port	Audited line by line against the live XNA 4.0 game and both custom processors; removed runtime geometry, loose BMP, F1-overlay and CullNone workarounds, restored the three byte-identical official-pipeline XNBs, and retained the original inactive WINDOWS_PHONE timing/fullscreen branch. A closed AOT reader loads the original reflective GeneratedGeometry.Sky object (processor-built Model + Texture2D), while terrain uses CNA's stock ModelReader and external texture path. The owner accepted exact pregenerated XNB output as the faithful runtime boundary. The real XNA original, native OPENGLES3 and system-Chrome WEBGL2 builds render the same animated lit/fogged terrain and far-plane skydome at 800x480 and no CNA/sharp-runtime gap remains. Evidence: samples/GeneratedGeometry/missing.md; decision: SAMPLES-DEC-002.	✅
SAMPLE-013	Platformer_4_0	port	Complete XNA 4.0 source/content audit: restored every gameplay, validation, touch/accelerometer and target branch; replaced loose substitutes with faithful XNB/audio products; removed the ContentManager workaround after the general CNA fix; real XNA, OPENGLES3 and system-Chrome WEBGL2 runs match. Evidence: samples/Platformer/missing.md.	✅
SAMPLE-014	Spacewar_4_0	port	Complete source/content audit against the live XNA 4.0 Windows original: ported both Retro and Evolved modes plus every screen, upgrade/victory path, scene, effect, model, cubemap, render-target and XACT path. All 157 checked-in runtime assets are byte-identical official-pipeline/XactBld output; no raw-model, loose-content, shader, input or help-overlay workaround remains. General CNA repairs cover XNB/cache/reference semantics, case-insensitive content, XACT banks including FACT-faithful complex-track cursor progression, and faithful EasyGL compiled-effect null/cube sampler behavior. Native OPENGLES3 and system-Chrome WEBGL2 builds render and play through original inputs without runtime errors; isolated and real-device native checks confirm the original title music. Evidence: samples/Spacewar/missing.md. REOPENED 2026-08-28. A rules sweep found one workaround the original audit did not record: the original's Settings.Load/Save call XmlSerializer on typeof(Settings) (Settings.cs:376/388), and the port replaced it with ~136 lines of hand-written XML reading and writing in src/Settings.cpp. sharp-runtimenext has System.Xml and System.Xml.Linq but no System.Xml.Serialization at all, so this is a genuine missing .NET type, not a translation choice -- and missing.md did not mention it, which is the actual violation: an undocumented workaround inside a ✅ row. It cannot be fixed by implementing XmlSerializer literally, because new XmlSerializer(typeof(T)) is run-time reflection and C++ has none; the realistic shape is the one the owner already chose for XNB in SAMPLE-044 -- a declared member list plus a generic serializer, as ReflectiveTypeReaderBuilder<T>. That is a new subsystem in sharp-runtimenext and is the owner's decision, so this row waits rather than growing one unasked. Everything else in the audit below stands.	🛑
SAMPLE-015	TicTacToe_4_0	port	Complete directory audit established that upstream has two separately deployed parts—a WP7 XNA client and a WCF/MPNS server—not a standalone local game. The unchanged server builds; the current reference lacks the WP7 SDK for the client, and MPNS is retired. On 2026-08-24 the owner declined WCF/MPNS emulation and accepted an evidence-backed CNA non-port conclusion. samples/TicTacToe remains only as a prominently labeled free reimplementation and is a port of neither original part. Its OPENGLES3 native and system-Chrome WEBGL2 builds under /rv/samples render and accept input, but are explicitly not original-parity claims. Evidence: samples/TicTacToe/missing.md; decision: SAMPLES-DEC-004.	✅
SAMPLE-016	BounceSample_4_0	port	Complete line-by-line audit of the WP7-only original restored the exact 100-sphere physics, accelerometer/emulator input, orientation handling, fullscreen 30 Hz settings, procedural Position/Normal geometry, lighting, shadows and original update quirks. Removed the invented tilt/help overlays, persistent keyboard tilt, alternate vertex format, reordered collision logic and sample-local light workaround. General CNA fixes restore the shipped XNA 4.0 DirectionalLight defaults and faithful deferred browser fullscreen. Native OPENGLES3 and system-Chrome WEBGL2 Release builds render and respond without runtime errors; the original cannot be rebuilt on this host because its XNA/WP7 targets and the VM driver are unavailable, so original evidence is source/project/document/asset based. Evidence: samples/Bounce/missing.md.	✅
SAMPLE-017	CollisionSample_4_0	port	Complete source/content/test audit restored the FPS font, gesture/phone branches, original type/method surfaces, disposal and named colors with no help/workaround path. The unchanged XNA game and its 420,000-case test suite run; the faithful C++ test port also passes all 420,000 cases. A general CNA fix restores the empty XNA ContentManager(IServiceProvider) root while preserving the CNAEXT convenience default. Original XNA, native OPENGLES3 and system-Chrome WEBGL2 captures cover all five groups plus orthographic projection and Escape; no runtime error remains. Evidence: samples/CollisionSample/missing.md.	✅
SAMPLE-018	PerPixelCollisionSample_4_0	port	Audited the whole physical directory against a live XNA 4.0 build of the unchanged Windows project. Removed the loose colour-keyed PNGs, the invented F1 help overlay and the RGBA literals; restored the two byte-identical official-pipeline XNBs, Color::Red/CornflowerBlue/White, the original type/member surface and the reference build's own safe-area arithmetic. Two general CNA fixes: Color gained the default constructor every XNA value type has (new Color[n]), and SpriteBatch stopped quantising sprite destinations to whole pixels -- XNA/FNA keep them in floats, so the falling blocks now land between pixels and their edges filter exactly as the original's do (0 blended pixels before the fix, 8475 after, against the original's 9384 over the same 60 frames). Person position is identical to XNA at the start and both clamps in the original, native OPENGLES3 and system-Chrome WEBGL2 builds, and the sprite is byte-identical there; recorded runs show real per-pixel hits plus rectangle overlaps that correctly do not hit. Evidence: samples/PerPixelCollision/missing.md.	✅
SAMPLE-019	RectangleCollisionSample_4_0	port	Audited the whole physical directory against a live XNA 4.0 build of the unchanged Windows project. The old port drew both sprites as solid magenta squares -- its PNGs were raw BMP conversions with no colour key at all -- so they were replaced by this sample's own byte-identical official-pipeline XNBs, proven by running its own content project rather than copying SAMPLE-018's. Also removed the invented F1 overlay and the RGBA literals, and re-derived the reference build's extended-precision safe-area arithmetic. Rectangle::Intersects is already character-for-character FNA's, so no CNA or sharp-runtime change was needed. Person position matches XNA at the start and both clamps in the original, native OPENGLES3 and system-Chrome WEBGL2, with a byte-identical sprite; and 180 s recordings confirm this tutorial's own behaviour -- every unambiguous rectangle overlap turns the background red even when the drawn pixels are clear of each other, the exact opposite of SAMPLE-018. Evidence: samples/RectangleCollision/missing.md.	✅
SAMPLE-020	TransformedCollisionSample_4_0	port	Audited the whole physical directory — both upstream solutions — against live XNA 4.0 builds of the unchanged Windows projects. The primary game gained Block.hpp, both IntersectPixels overloads and CalculateBoundingRectangle, its three byte-identical official-pipeline XNBs (the loose PNGs and the invented F1 overlay are gone) and the reference build's extended-precision safe-area arithmetic. The sample's second product, TransformedCollisionTest, was ported for the first time as its own sample directory — it has its own solution, Program.cs and content project, so unlike SAMPLE-017's unit tests it cannot be a second target beside the first. One sharp-runtime fix: List<T> could not be instantiated at all for an element type without operator==, because Contains/IndexOf/Remove are overrides; findValue now refuses at the call with NotSupportedException instead of at instantiation, as C#'s EqualityComparer<T>.Default has no such restriction (7 tests; 17847/17847). Vector2 gained the CNAEXT +=/-= pair. Person position is identical to XNA at the start and both clamps in the original, native OPENGLES3 and system-Chrome WEBGL2 (343/40/727 at y=399), and 180 s recordings show ~50 frames per run where the rotated spinner's arm sits well inside the person's rectangle with the background still blue. The mouse-driven second product takes identical input in all three builds and turns red at exactly the same nine of seventeen drag positions in every one of them. Evidence: samples/TransformedCollision/missing.md, samples/TransformedCollisionTest/missing.md.	✅
SAMPLE-021	PathDrawing_4_0	port	Audited the whole physical directory against a live XNA 4.0 build of the unchanged sources. Upstream is Windows-Phone-only, but unlike SAMPLE-016 it builds and runs here: everything it uses exists in the desktop profile, so the original's four unmodified files link into a Windows executable with only the entry point the WP7 targets generate. Removed all five of the previous port's documented deviations -- the invented mouse controls (CNA has the whole TouchPanel surface), the omitted SpriteFont/DrawString, the manual ground tiling, the reversed tank/path draw order and the dropped 30 Hz + fullscreen settings; four of its five stated root causes were Vulkan claims that do not hold on EasyGL. Content is this sample's own official-pipeline output built from the real Segoe UI Mono, shipped as the WindowsPhone XNBs the only upstream platform produces -- the desktop build differs solely in the container platform tag and the Silverlight mscorlib named by the SpriteFont's reader. The faithful translation needed no framework change at all, and the native OPENGLES3 frame is byte-identical to the XNA original's, 384000 of 384000 pixels. No host touch source exists in either build (measured: Wine gives the original no WM_TOUCH, SDL3's X11 backend synthesises no fingers even with its own hint set), so at the owner's request TouchPanel gained a CNAEXT opt-in that reports the left mouse button as a touch -- off by default, routed through the same entry points a real finger uses, ten tests, and enabled by one marked line here so a touch-only sample is playable with a pointer; the deviation is recorded in samples/PathDrawing/diff.md. Interaction is verified both ways: the tank drives 631.6 px along a path drawn with real touch events in system Chrome, and (102,109) -> (650,439) along one drawn with the mouse natively. Also fixed a Paeth bug in the browser harness's PNG decoder that had travelled since SAMPLE-018 and corrected SAMPLE-020's record accordingly. Evidence: samples/PathDrawing/missing.md.	✅
SAMPLE-022	Pathfinding_4_0	port	Audited all 42 upstream files -- two solutions and three projects -- against a live XNA 4.0 build of the unchanged Windows configuration. Removed all five of the previous port's documented deviations: the omitted HUD text, the omitted touch path, the hand-written XML parser standing in for Content.Load<MapData>(), the six SpriteBatch passes merged into one on a Vulkan claim that does not hold on EasyGL, and the RGBA literals replacing named colours. The PathfindingData class library is a third case beyond SAMPLE-004's non-port and SAMPLE-020's second product -- a runtime type the game cannot run without -- so the type is ported and the project file is not, recorded explicitly. The four maps now load from official XNBs through a closed AOT reader for ReflectiveReader<PathfindingData.MapData>, whose layout was pinned by decoding the container: a reflective value-type field is inlined with no reader index, so the two Points are read raw and only the barrier list carries one. All 13 XNBs are byte-identical to this sample's own pipeline output, including the campaign's first .tga assets. One sharp-runtime fix: Dictionary<TKey,_> now accepts a key that carries GetHashCode() without a std::hash specialization -- narrowly, so an existing selector contract test still stands (6 tests; 17853/17853). Native frames are byte-identical to XNA's at 384000/384000 on the start, mid-search and second-map frames; the three later frames differ only inside one box containing the moving tank, with 0 differing pixels outside it. Evidence: samples/Pathfinding/missing.md.	✅
SAMPLE-023	WaypointSample_4_0	port	Audited the whole physical directory against a live XNA 4.0 build of the unchanged Windows configuration. This is the sample SAMPLE-021 and SAMPLE-022 both borrowed Tank.cs and WaypointList.cs from, so all three were diffed first: 192/262 differing lines in Tank.cs and 82/94 in WaypointList.cs, three different files, nothing copied. Only this version's Tank is a real DrawableGameComponent added to Game.Components, and only this one has the Behaviors/ hierarchy the later two dropped -- all of it restored, as .hpp/.cpp pairs mirroring the original decomposition (the SAMPLE-013/014 arrangement, which is what lets Behavior and Tank reference each other). The old port had no font and no blank asset at all, so the HUD line and the four-line help text were simply absent, and it carried a TankBehaviorImpl.hpp with no upstream counterpart; all 5 XNBs are now byte-identical to this sample's own pipeline output. No framework change was needed. The start frame is byte-identical to XNA's at 409440/409440, and every other frame differs only inside one box containing the time-integrated cursor, with 0 differing pixels outside it. The timing-independent HUD band is byte-identical in all six frames, and cycling the behavior with B changes exactly the same 188 pixels in the original, the native port and the browser. Evidence: samples/WaypointSample/missing.md.	✅
SAMPLE-024	FlockingSample_4_0	port	The row's flag resolved: the old port had deliberately not reproduced an upstream defect -- Bird.Update applies the Y component of movement twice, so birds drift about twice as fast vertically -- and had ported the "evidently-intended" single application instead. The rule is not ambiguous and the owner confirmed it: if the XNA 4.0 original has bugs, CNA has them too. The quirk is reproduced line for line, and so are two more the old record never mentioned -- Flock.FlockParams's getter returns the property rather than the field (infinite recursion, never called) and SliderInputHelper measures the separation slider from the detection bar's X. All five other documented deviations are gone: the entire HUD (both sliders, both labels, the pulsing red tint, three button glyphs and their text) was simply absent because the port had no font and no glyph assets at all; the touch path, the analog-trigger slider fallback and TitleSafeArea bounds are restored. All 6 XNBs byte-identical, four from .tga. One cnanext fix: Vector2 gained *= and /=, the same C#-synthesised-operator gap SAMPLE-020 found for += (6 tests). The flock is randomly seeded and the label pulses on total game time, so no whole frame can match; the slider bars are drawn after the flock and are byte-identical in 4 of 5 frames, and the exactly-orange pixel count is 800 in the original, the native port and the browser in every frame. Evidence: samples/FlockingSample/missing.md.	✅
SAMPLE-025	ChaseAndEvadeSample_4_0	port	Audited the whole physical directory against a live XNA 4.0 build of the unchanged Windows configuration. The old port was 258 lines against the original's 717 -- a paraphrase. Both documented deviations are gone: the HUD state lines are restored, each drawn twice for its black drop shadow exactly as upstream does, and all three #if WINDOWS_PHONE regions are back, the campaign requiring inactive platform branches to be preserved rather than dropped as "out of scope". Neither the old port nor its record mentioned that the mouse pointer controls the cat in the original, smoothStop easing and all; that is upstream behaviour and is translated. One upstream quirk kept in place: a local in HandleInput shadows the field holding the mouse sprite's position. All 4 XNBs byte-identical, three from .tga, and the port loads "Tank" against an asset named tank through CNA's case-insensitive resolution. No framework change was needed. Both characters wander on a time-seeded Random, so no whole frame can match; the static half of the two HUD lines hashes 2ccb55c0 in the original, the native port and the browser alike, and on the frames where both builds were in the same AI state the state words are byte-identical too. Evidence: samples/ChaseAndEvade/missing.md.	✅
SAMPLE-026	AimingSample_4_0	port	Audited the whole physical directory against a live XNA 4.0 build of the unchanged Windows configuration. The old port was 174 lines against the original's 357 and carried four deviations, all now gone. The largest was the omitted additive spotlight pass: its own record admitted a faithful two-pass port "would render correctly on EasyGL" and kept the single-block workaround "for Vulkan-backend safety" -- EasyGL is this campaign's only renderer. Restored, along with all three #if WINDOWS_PHONE regions, the viewport X/Y offsets the original reads in five places, and the official .tga-sourced XNB in place of a hand-converted PNG (the record claimed CNA "does not support .xnb/TGA source assets", stale since SAMPLE-022). TurnToFace/WrapAngle were diffed against SAMPLE-025 first, as the handoff required: identical code, only the comment diagram differs. No framework change was needed. Nothing in this sample is random, so it is the first of six where whole frames match: start and settled are byte-identical at 409440/409440 and every pixel of all five frames is within 2. The additive pass is measured, not assumed -- the game clears to black, so lit-pixel counts are countable, and they are exactly equal to the original's in all four frames (63373 / 40050 / 61084 / 61148). Evidence: samples/AimingSample/missing.md.	✅
SAMPLE-027	FuzzyLogicSample_4_0	port	Full original/native/web parity. Whole sample re-ported from the 1298 unchanged C# lines as .hpp/.cpp pairs (the old port was 518 lines in one header); the four claimed omissions -- SpriteFont labels, touch input, gamepad weight selection and the Mouse->MouseEntity rename -- were all false and are gone. System::TimeSpan::operator+=/-= added to sharp-runtime with 6 tests. All 4 XNBs byte-identical to the official pipeline. HUD gate: the three weight bars saturate to 42/42/42, 85/42/42, 85/0/42, 85/0/85 in the XNA original, the native OPENGLES3 port and WEBGL2 in Chrome alike, and the label glyph cores are pixel-identical. Evidence: samples/FuzzyLogic/missing.md.	✅
SAMPLE-028	ColorReplacementSample_4_0	port	The .fx blocker was stale. CNA loads compiled XNA Effect bytecode through MojoShader on EasyGL (CNA_EASYGL_COMPILED_EFFECTS), so the sample is ported whole with its own unmodified ReplaceColor.fx compiled by the official pipeline -- nothing rewritten by hand. Four framework fixes: 3 missing XNB readers (EffectMaterialReader, DictionaryReader<string,object>, ExternalReferenceReader), XNA's protected Effect(Effect cloneSource) which CNA lacked (so EffectMaterial had ZERO parameters), and custom numeric format strings in sharp-runtime (ToString("0.000")), verified differentially against mono 28/28. A fifth framework defect surfaced after acceptance, reported by the owner: MojoShader applies D3D9's clip-space depth conversion and EasyGL's own shaders do not, so compiled-effect geometry was depth-tested on a different scale and swallowed the headlight lens and thin glass edges. Fixed by compensating the GL depth range for compiled-effect draws; the body mean colour now matches XNA to 0-1 of 255 per channel, against 2-9 before. Gate: the 4 overlay lines are byte-identical across XNA, native OPENGLES3 and WEBGL2 in Chrome (48/48), and the car body mean colour tracks TargetColor to within 2-9 of 255 per channel. No WindowsPhone target: the official pipeline refuses it. Evidence: samples/ColorReplacement/missing.md.	✅
SAMPLE-029	ParticleSample_4_0	port	Full original/native/web parity. Whole sample re-ported from the 1130 unchanged C# lines as .hpp/.cpp pairs. Five of six recorded deviations were false -- DrawableGameComponent + Components + DrawOrder, the tap gesture, the verbatim status text, the WINDOWS_PHONE branch, and above all the three separate Begin/End pairs with BlendState.Additive, whose own record admitted a faithful port works on EasyGL and kept the workaround anyway. The sixth was real: font.spritefont asks for Segoe UI, which the machine did not have (only the redistributable Segoe UI Mono); the owner supplied segoeui.ttf and it was registered with Wine, after which all 3 XNBs build byte-identical to the official pipeline. Gate is narrow by nature -- particles are random and overdraw the overlay -- but two full lines of Segoe UI text are byte-identical across 9600 px, and the browser gate pins the one line the plume never reaches against the original. Evidence: samples/ParticleSample/missing.md.	✅
SAMPLE-030	CameraShake_4_0	port	Compared against a live XNA 4.0 build. All eight recorded deviations are gone, including the never-root-caused "3D scene renders as white stripe (all CNA backends)", which does not reproduce: the port loads the official tank.fbx/Ground.x Model XNBs instead of hand-converted .model.json geometry, and the old entry's own arithmetic was computed on unscaled coordinates. No CNA change was needed. VibrationManager, gamepad input, touch gestures, TitleSafeArea and both model textures all restored. This sample is deterministic while idle, so the comparison is real: 88.9 % of pixels within 8 levels of the original and zero clusters of >40-level difference, and in both engines the camera returns byte-identically to its idle frame after a shake. All 6 XNBs byte-identical to the official pipeline. Evidence: samples/CameraShake/missing.md.	✅

SAMPLE-031–060 — effects, 3D, models, animation and audio

Task	Upstream directory	Existing	Fresh audit focus	Status
SAMPLE-031	BloomSample_4_0	port	Ported whole against a live XNA 4.0 build; every claim in the old placeholder record was stale (.fx, FBX and DrawableGameComponent all work). Three framework defects, all found here and all fixed in cnanext: EasyGL corrected a render target's row order TWICE on the SpriteBatch compiled-effect route and drew the whole scene upside down (plan_fx.md FX-118, the existing contract missed it because it drives the 3D route); a line's first glyph used FNA's Abs(kerning.X) where XNA clamps with Max(kerning.X, 0) and applies no Spacing -- measured on three fonts differing only in <Spacing>, all 27 MeasureString results now match; and DrawString still quantised glyph destinations to whole pixels after Draw had been fixed. Frozen-rotation whole-frame comparison: 100 % of pixels within 8 levels on the composited frame and the largest connected disagreement 2 px, with both blur buffers having no pixel more than 8 levels out and the second one's worst single-channel difference 1. All 8 XNBs byte-identical to the official Windows/Reach pipeline; the Xbox 360 HiDef build differs in every file. Evidence: samples/BloomSample/missing.md.	✅
SAMPLE-032	DistortionSample_4_0	port	Ported whole; the old .fx blocker was stale again. First sample in the campaign with its own content pipeline extension -- three models are built by DistorterModelProcessor, so DistortionPipeline.csproj is compiled and handed to BuildContent. Two properties of the ORIGINAL recorded rather than worked around: Distorters.fx exceeds ps_2_0's 64 instruction slots in a Debug build (EffectProcessor.DebugMode=Auto skips optimization), and DistorterMaterialProcessor names its effect relatively so the pipeline must run from the content directory. Two framework defects, both fixed in cnanext: NormalizedByte2 textures could not be loaded at all (the reader assumed four bytes per texel), and -- far wider than this sample -- a textured EffectMaterial pointed its parameters at freed memory, segfaulting inside dynamic_cast from ModelMesh::Draw for ANY model whose material carries a texture. Eight-frame whole-window comparison across every distorter and both Distort.fx techniques: five frames at 99.4-99.9 % of pixels within 8 levels, the two animating/textured ones at 90-93 %, and the full cycle returns to its opening frame to the pixel. All 9 XNBs byte-identical to the official Windows/Reach pipeline. Evidence: samples/DistortionSample/missing.md.	✅
SAMPLE-033	NonPhotoRealisticSample_4_0	port	Ported whole, all six presets and every technique both effects declare (Toon/Lambert/NormalDepth, and all five postprocess ones). One framework defect, fixed in cnanext: the compiled sprite route created and destroyed its vertex and index buffers every flush while recording them in one long-lived VAO, so the array object held a deleted element buffer for the next draw -- desktop GL tolerates it, WebGL 2 refuses the draw outright (glDrawElements: Insufficient buffer size), which made five of the six presets a black frame on WEBGL2 while the one preset that runs no postprocess rendered correctly (plan_fx.md FX-120). Two things that had hidden it are fixed too: the browser gate now subscribes to Chrome's Log domain, where WebGL driver errors actually arrive, and the silence of that draw route is recorded. Also confirms SAMPLE-032's toolchain finding: PostprocessEffect.Fx misses ps_2_0's 64-slot limit by ONE instruction in a Debug build. Frozen-rotation and frozen sketch jitter -- both needed, Pencil compares at 0.2 % without the second -- gives 97.3-98.8 % of pixels within 8 levels on all seven frames, the residue being 1-3 px clusters on the silhouette and on toon-shading band boundaries. All 6 XNBs byte-identical to the official Windows/Reach pipeline. Evidence: samples/NonPhotoRealistic/missing.md.	✅
SAMPLE-034	NormalMappingSample_4_0	port	Ported whole -- every field, both effect-parameter groups and every key binding. Its content needs the sample's own pipeline extension (NormalMappingModelProcessor: tangents/binormals, per-material NormalMapping.fx, normal maps to NormalizedByte4), and BuildConfiguration had to be measured again and came out the OPPOSITE way to SAMPLE-032/033: Debug builds, Release fails -- the optimizer folds pow(rDotV, SpecularPower), base possibly zero, through log(0) into an infinity literal and fxc rejects it with error X4579. One framework defect, fixed in cnanext: compiled-effect fragment shaders were translated at GLSL ES's mediump default, which guarantees only fp16 range, while a D3D9 shader computes in full 32-bit float. This pixel shader normalizes an interpolated WORLD-SPACE light vector, so dot(v, v) reached ~10^6, overflowed, and normalize returned zero -- taking diffuse AND specular to exactly zero while the model still drew, the camera still responded and AmbientLightColor still worked, so a full rotation of the light changed not one pixel and nothing errored (plan_fx.md FX-121, now a second MojoShader patch). Seven of the eight XNBs are byte-identical to the owner's own Windows 7 / VS2010 / XNA GS 4.0 build -- the model and all four textures, the entire custom-processor chain; the eighth differs by exactly the 16 bytes separating the two embedded source paths, bytecode identical. Frozen-light comparison at four angles gives 95.4-98.2 % of pixels within 8 levels, mean absolute difference 0.76-1.34 of 255, and frame mean brightness matching the original to 0.02 of a level -- the residue is unbiased speckle where a normal-map texel falls on the other side of a quantization boundary. Evidence: samples/NormalMappingEffect/missing.md.	✅
SAMPLE-035	PerPixelLightingSample_4_0	port	Ported whole -- all three source files, both effects, all five techniques, all five meshes, every key binding. Content is eight assets through STOCK importers only (no pipeline extension, unlike SAMPLE-032/034), built in Debug for all three targets; linking the original also needs Microsoft.Xna.Framework.Storage and .Avatar, which no earlier sample did. One framework defect, fixed in cnanext: a compiled effect's vertex COLOR output was not clamped on the GLSL ES profiles. Direct3D 9 clamps oD0/oD1 to [0,1] BEFORE interpolating; MojoShader's desktop path inherits that from gl_FrontColor, but the ES profiles fall through to a plain varying that nothing clamps. VertexLighting.fx reaches blue ~1.24 at a lit vertex, so CNA interpolated the unclamped value and saturated per fragment -- flat where D3D9 still has slope, a solid wedge over 4.8 % of the low-poly cone. Red and green matched the original EXACTLY and only blue differed, only above 1, which is what named the cause (plan_fx.md FX-122, a third MojoShader patch). Two math members were added for shapes C# derives automatically: Matrix::operator*= and a zeroing Quaternion() default constructor, both with tests. Agreement went from 95.2-98.1 % on the three low-poly frames to a uniform 99.37-99.40 % of pixels within 8 levels on all ten, the residue being 1-px silhouette and far-field grid-line rasterization. Evidence: samples/PerPixelLighting/missing.md.	✅
SAMPLE-036	VertexLightingSample_4_0	port	Ported whole -- all three source files, both effects, all five meshes, every key binding. PerPixelLighting's sibling: SampleCamera.cs and SampleGrid.cs are byte-identical to SAMPLE-035's EXCEPT the namespace line, so both C++ ports were carried over with that one line changed and each pair still differs by exactly two lines. Seven assets through stock importers, Debug, first try; linking the original needs Storage and .Avatar as SAMPLE-035 did. No framework change was needed -- the first compiled-effect sample in this campaign for which that is true, and it is not a coincidence: its VertexLighting.fx sums ambient and diffuse into a COLOR0 vertex output, exactly the shape FX-122 had been rendering wrong, and the clamp landed in the same session one sample earlier. All ten frames agree at 99.37-99.41 % of pixels within 8 levels; on the four FlatShaded frames the exact and within-8 counts are EQUAL, which is what a flat fill should give -- every differing pixel is an edge and there is no gradient to disagree about. Evidence: samples/VertexLighting/missing.md.	✅
SAMPLE-037	RimLighting_4_0	port	Both bypasses removed; the port now loads all four assets through Content.Load<T>(). The 2026-07-10 missing.md recorded Content.Load<TextureCube> and Content.Load<Model> as blockers and hand-built a mesh from .bin buffers plus a cube map from six PNGs; both readers exist in cnanext today, so the hand-converted assets, and an invented help.png overlay, are gone. Re-ported whole from the original's seven files. The upstream is a WINDOWS PHONE project whose shipped Program.cs is `#if WINDOWS
SAMPLE-038	ShadowMappingSample_4_0	port	Ported whole -- both shadow-map passes, every key binding. Exercises more of CNA at once than any earlier sample here and all of it worked first try: a SurfaceFormat.Single 2048x2048 render target with DepthFormat.Depth24, a compiled effect whose two techniques are switched per draw BY NAME, that render target bound back as an effect texture parameter for the second pass, BoundingFrustum.GetCorners + BoundingBox.CreateFromPoints driving the light's orthographic projection every frame, and SpriteBatch drawing the float target. Content is two models through the sample's own CustomEffectPipeline, each carrying TWO processor parameters (CustomEffect, Scale); sixteen XNBs come out of two source assets. One framework defect, fixed in cnanext: Direct3D 9 expands a sampled texture's missing channels -- one-channel to (R,1,1,1), two-channel to (R,G,1,1) -- and OpenGL does not, so the sample's own shadow-map preview was a RED square where the original's is white. CNA was FNA-faithful (FNA3D_Driver_OpenGL.c:378, no swizzle) but this campaign's oracle is XNA. GL_TEXTURE_SWIZZLE was NOT the mechanism: WebGL 2 does not have it -- measured in a real browser, texParameteri raises INVALID_ENUM -- and a swizzle fix would have split this campaign's own native and web targets, so the expansion is done in the sprite shader from the bound texture's format. Caching the uniform locations first broke WeightedBlendedTransparencyTest, because a SpriteBatch drawn with a custom ShaderEffect runs THAT program and a foreign uniform location is GL_INVALID_OPERATION; they are looked up per flush now. Proven identity elsewhere: SAMPLE-036's ten frames are byte-identical across the change, and a second test pins that a Color texture is untouched. Whole-frame agreement rose from 87.9 % to 92.2 %; the remainder is far-field minification, mean absolute difference 4.63/255 in the far third against 1.95 near the camera, where the floor's pixels are EXACTLY equal. Evidence: samples/ShadowMapping/missing.md.	✅
SAMPLE-039	BillboardSample_4_0	port	Ported whole -- the landscape, the custom compiled billboard effect, the two-pass opaque/fringe rendering, the wind and every key binding. No framework change was needed; CNA rendered it correctly on the first run. Three campaign firsts: the stock XImporter (a DirectX .x model), the HiDef profile end to end (Reach refuses the 82 668-triangle mesh part BY DESIGN, and the executable's embedded RuntimeProfile resource must say HiDef or the game dies in LoadContent), and no params array in the pipeline runner (Mono's mcs emits Array.Empty<T>(), which .NET 4.0 lacks). The apparent geometry defect was the content itself: VegetationProcessor scatters ~41 300 billboards from an unseeded random source, so every content build lays out a different landscape and the two engines were rendering different worlds. The tell was the part table (165 296/300/4 vertices vs 165 276/308/16, same total, different split), not the picture; once the original's own landscape.xnb and Billboard_0.xnb were shipped with the port, the part table matched exactly, which also clears CNA's XNB model reader. With the wind phase pinned in both engines the frames agree to 95.6 % within 8 levels across three phases, mean	diff
SAMPLE-040	InstancedModelSample_4_0	port	Ported whole -- all three instancing techniques, the custom two-technique compiled effect, the spiralling motion, the overlay and every key binding. The placeholder's claim that the sample was blocked on its custom InstancedModel.fx was stale: it renders correctly on the first run. HiDef, measured: the HardwareInstancing technique compiles vs_3_0, and the Reach content build refuses it in those words. One genuine framework gap, and it was not the shader -- XNA's generic DynamicVertexBuffer.SetData<T>(T[], int, int, SetDataOptions) existed in CNA for four built-in vertex types only, so a game's own per-instance stream (here an array of plain Matrix) could not be uploaded with streaming semantics at all; added with the raw path it needs and three tests, one of which was confirmed to fail with the source-pointer advance removed. Everything else was already correct, including EasyGL binding a compiled effect's BLENDWEIGHT0..3 to the second stream at divisor 1 (plan_fx.md FX-082). Comparison needed four hooks (CNA_SEED, CNA_TIME, CNA_FPS, CNA_TECHNIQUE) because nothing here is reproducible on its own; that CNA_SEED works proves sharp-runtime's System::Random matches .NET's sequence. XNA vs CNA 99.26 / 95.24 / 93.46 % within 8 levels at 2/8/20 s -- not drift: coverage tracks to 0.16 %, the centroid stays under half a pixel, and 99.6 % of differing pixels lie on an edge at every phase while edge density triples. All three techniques agree in both engines to the same two decimals. WEBGL2 built and gated in real Chrome, including that every technique draws the model. Evidence: samples/InstancedModel/missing.md.	✅
SAMPLE-041	LensFlareSample_4_0	port	Re-ported from scratch. The 2026-07-09 pass shipped a header-only port over a hand-converted terrain.model.json, added an F1 overlay the original does not have, and recorded three findings: two do not survive the official pipeline (the "near-plane clipping" terrain renders correctly, and ground.png IS bound -- the FBX material pulls it in, six XNBs from five listed assets) and the third, EasyGL ignoring ColorWriteChannels, was fixed since. terrain.fbx carries the processor parameter RotationX = -90 the old converter tried to reproduce by hand. The real finding is the occlusion query: XNA's PixelCount is a fragment tally, but OpenGL ES 3.0 and WebGL 2 have no target that produces one -- GL_ANY_SAMPLES_PASSED answers 0 or 1 -- so the sample's PixelCount/queryArea coverage ratio is 1/10000 and the glow and flares fade to nothing. Established by measurement, not inference: the query quad covers 9788 pixels when drawn visibly, and feeding the component that ratio makes the frame agree with the original to 99.74 % within 8 levels (mean 0.58/255, median 0, no signed bias). cnanext now resolves the target from the driver -- the same Mesa accepts GL_SAMPLES_PASSED under desktop GL 4.5 and reports 4096 for a covered 64x64 viewport, and refuses it under ES 3.2 (spikes/occlusion-count-spike/) -- adds OcclusionQuery::isPixelCountPreciseEXT(), corrects docs/occlusionquery-support.md, and gains a test that fails when the precision claim is falsified. Both existing EasyGL occlusion tests assert only > 0 and <= 0, which a boolean passes, which is why this went unnoticed. WEBGL2 built and gated in real Chrome. Evidence: samples/LensFlare/missing.md.	✅
SAMPLE-042	ShatterEffectSample_4_0	placeholder	Ported whole -- the model, the compiled shatter effect, the shatter clock and both key bindings. No framework change was needed. The placeholder's claim that ShatterEffect.fx had to be hand-translated to GLSL plus a .shader.json descriptor was stale twice over: compiled effects have worked since SAMPLE-032, and nothing is hand-translated. The row's real subject is ShatterProcessor, which splits every triangle into a disconnected copy and adds two processor-generated per-triangle channels -- TriangleCenter (TEXCOORD1) and RotationalVelocity (TEXCOORD2) -- feeding a five-channel vertex declaration into a compiled custom effect; CNA read the declaration, bound all five by semantic and ran the effect unchanged. Reach, unlike the two samples before it. With CNA_TIME pinning the clock in both engines the frames agree to 96.7 / 89.8 / 89.2 / 96.9 % within 8 levels at 0/0.5/1/2 s -- the campaign's lowest so far, and 98.3-99.7 % after a 4 px blur, which removes sub-pixel boundary noise but keeps any real displacement. Coverage tracks to 0.6 %, the intact model spans exactly rows 75-418 in both, the median per-pixel difference is 0, and 95-99 % of differing pixels lie on an edge: that is thousands of disconnected triangles disagreeing about boundary pixels, and the differing/covered ratio saturates at ~43 % instead of growing with time. WEBGL2 built and gated in real Chrome, including that the reassembled model is hash-identical to the start frame. Evidence: samples/ShatterEffect/missing.md.	✅
SAMPLE-043	Particles3DSample_4_0	placeholder	Ported whole -- five particle systems, the four-region circular-queue lifecycle, the custom 36-byte vertex type, the emitter, the projectiles and all three effects. The largest sample of the campaign (~1900 lines of C# in twelve files). The placeholder's ParticleEffect.fx blocker was stale, the fourth in a row. Three framework gaps, all XNA API shapes CNA had not needed yet: the windowed DynamicVertexBuffer.SetData<T>(offsetInBytes, …, SetDataOptions) the particle uploader requires; using VertexBuffer::SetData so the inherited whole-array overloads are not hidden by the derived class's own (C++ name lookup stops at the first declaring scope, and the sample calls the inherited form to restore a lost buffer); and Vector3::operator*=//=, which Vector2 already had. All tested, the windowed one confirmed to fail with the destination offset removed. Short2 and Color inherit CNA's polymorphic IPackedVectorT, so the vertex holds their raw packed values with static_asserts pinning the 36-byte layout. Comparison found a real XNA-vs-FNA difference: XNA's first update runs with ElapsedGameTime = 0 and its TotalGameTime lags one further step, so after N updates it has accumulated N-2 steps where CNA, following FNA's loop, has accumulated N. Agreement is 99.46 % at 60 updates and 87.7 % at 180 -- and at 180 the blur does not help and there is no edge enrichment, so the particles genuinely differ. The queue probe sizes it exactly: four of five systems hold identical queues and the trail differs by 6 particles in 806, precisely two frames of its emission rate. Superseded the same day: the owner ruled XNA 4.0 authoritative over FNA, Game::Tick() was changed to match (first update zero-elapsed, TotalGameTime advancing after Update), and SAMPLE-044 then scored 100.00 % on the same class of comparison -- so the percentages above describe CNA before that change. WEBGL2 built and gated in real Chrome. Evidence: samples/Particles3D/missing.md.	✅
SAMPLE-044	Particles2DPipeline_4_0	port	Re-ported from scratch. The previous header-only port opened its own notes with two admissions and this removes both: the four XML settings files were hand-translated into C++ construction code, and DrawableGameComponent/Components were dropped. Now the settings are built by the real pipeline (XmlImporter -> PassThroughProcessor, with the sample's own ParticleSettings assembly in PipelineAssemblies) and loaded from their .xnb. XNA reads those through an implicit ReflectiveReader<T>; CNA declared that path unsupported by design (XNB-42A); on the owner's decision cnanext now grows the layer itself -- ReflectiveTypeReaderBuilder<T> takes a field list declared once, derives the canonical reader name, dispatches each member by its C++ type, and registers the enum readers the table names. The sample declares its fields and nothing else. The reflective payload was decoded rather than guessed -- value types inline in declaration order, a reference type preceded by its 1-based reader index, ending on the file's last byte (847 of 847) with every value matching the XML. The registration key is the canonical name with the assembly qualifiers stripped, and the file's two EnumReaders must be registered too because the type-reader table resolves in full before any object is read. Result: 100.00 % agreement with the original at both 60 and 180 updates -- pixel-identical, twice -- which at once proves the settings came from the pipeline, that System::Random reproduces .NET's sequence, and that the particle engine is bit-faithful. Getting there required the game-clock change SAMPLE-043 found: on the owner's decision that XNA 4.0 is authoritative over FNA, Game::Tick() now runs the first update with ElapsedGameTime = 0 and advances TotalGameTime after Update rather than before, in both timing modes. WEBGL2 built and gated in real Chrome. Evidence: samples/Particles2DPipeline/missing.md.	✅
SAMPLE-045	XmlParticles_4_0	placeholder	Ported whole. It is SAMPLE-043's engine with one change, and that change is the row: ParticleSystem is concrete, driven by a settings asset name, so there are no per-effect subclasses at all and every value comes from XML the pipeline compiled. Three upstream files are byte-identical to SAMPLE-043's and the port reuses them unchanged. Second user of cnanext's ReflectiveTypeReaderBuilder<T>, and it taught the layer two things, both measured on real pipeline output: the wire order is serialized PROPERTIES first, then public fields -- this type's private [ContentSerializer] string that stands in for its [ContentSerializerIgnore] BlendState comes out ahead of every field, and decoding with the fields-first assumption gave nonsense until it was put first (then 574 of 574 bytes, every value matching the XML) -- and the builder gained TimeSpan plus .Custom(...) for a member the wire format does not map onto directly. The simulation is exact: at update 180 all five systems hold identical queues and identical clocks to the digit, which is the game-clock change SAMPLE-043 found and SAMPLE-044 landed doing its work. The frames agree to 99.43 % at 60 updates and 80.08 % at 180 -- and that residue is honestly characterised rather than explained away: a blur does not help, the differing pixels are LESS edge-prone than average, the median difference is one level and 98.5 % of pixels are within 32, which is dozens of overlapping translucent sprites each contributing a fraction of a level. WEBGL2 built and gated in real Chrome. Evidence: samples/XmlParticles/missing.md.	✅
SAMPLE-046	Graphics3DSample_4_0	port	Re-ported from scratch. The 2026-07-09 pass shipped a header-only port over a hand-converted model and recorded four findings; none survives. The official FbxImporter reads spaceship.fbx -- the file the old notes called unreadable binary FBX 6000 -- on the first try and pulls enemy.tga in as a tenth asset from the material; the ship then renders, so the "pre-existing EasyGL near-plane-clipping bug" was the hand-converted asset, exactly as SAMPLE-041's was; CNA's ComponentAdded ordering matches FNA and XNA (the sample adds its components before base.Initialize(), whose own loop initializes them), so the old AddComponent() workaround is gone; and Clear(Color) has cleared depth since Task 928. Two upstream defects are reproduced rather than repaired: Program.cs does not compile (it constructs Sample3DGraphics, while the class is Graphics3DSampleGame) and Buttons/Button.cs is the other half of the same abandoned rename, excluded by the .csproj -- so the Windows leg links a generated entry point, as SAMPLE-021 does. AnimationDef.xml is <None Include>: copied beside the content, parsed at run time with XDocument.Load, so the sample links SharpRuntime::Xml.Linq the way the project references System.Xml.Linq. Touch is real touch -- the port opts into CNA's mouse-touch emulation and the stock GestureDetector produces the FreeDrag/Pinch samples the original reads. Two framework fixes, and each is the built-in twin of a compiled-effect fix already in plan_fx.md. FX-123: D3D9 saturates a vertex shader's oD0/oD1 before interpolating, EasyGL's per-vertex-lit programs used plain unclamped varyings, and the isolation is the evidence -- with any ONE of the three directional lights the frame agrees with real XNA to 99.99 % within 8 levels at +-0.01 levels of bias, with all three it drops to 90.31 % and the model is uniformly +11.2/+14.3/+8.9 brighter, because only the accumulated sum crosses 1. FX-124: four per-pixel-lit fragment shaders normalize a world-space view vector at mediump, whose fp16 range this sample's 3500-unit camera overflows; one light and per-pixel lighting gave 90.62 % and a uniform -20 levels across R, G and B -- the signature of a lost grey specular term -- against 99.99 % at highp. Mesa does honour the qualifier; that was measured. Both are pinned by tests confirmed to fail when the fix is removed. After the fixes every state of the sample -- default, per-pixel, background, and two pinned animation frames -- agrees to 99.99 % within 8 levels and 100.00 % after a 4 px blur, the default state at a mean absolute difference of 0.030 of 255. WEBGL2 built and driven in real Chrome with the mouse dispatched as touch, its ship-luminance gate calibrated against the native frames so the pre-FX-123 value fails it. The mouse-touch opt-in is an owner-approved deviation recorded in samples/Graphics3D/diff.md, as rules.md requires. Evidence: samples/Graphics3D/missing.md.	✅
SAMPLE-047	PickingSample_4_0	port	Re-ported from scratch. The 2026-07-09 pass was header-only over five hand-converted .model.json models and recorded four findings; none survives. The official ModelProcessor binds the materials' own textures, so the "CNA's .model.json schema has no texture field" gap and the "flat, fully-saturated white shapes" it caused both evaporate: wood.tga, cat.tga and wedge_p2_diff_v1.tga are not rows in the content project at all -- the FbxImporter resolves them from each FBX's material -- and the build emits 10 .xnb from 7 listed assets. Content.Load<Model>("Table") needs no asset rename either: ContentManager::ResolveExistingAssetPath already matches a path component case-insensitively and refuses an ambiguous match. The near-plane artefact was not reproduced at any of three camera angles. GeometricPrimitive.cs is listed by neither .csproj and is dead code, as SAMPLE-046's Button.cs was. HiDef end to end, as the Windows project declares. One framework fix, FX-125 (cnanext a249358eb): Sphere01 carries a colour channel, so its stride is 36 and the processor sets VertexColorEnabled -- both engines agree, the material dump being byte-identical across all 11 meshes -- but SelectStockProgramShape dispatched on stride alone with cases for 20/24/32, so the mesh fell through to the unlit program and lost all shading. The isolation named it: with the vertex colour switched off the sphere agreed on 99.76 %, with it on 46.94 %, CNA up to 84 levels too dark. Two things had to be right and only measuring separated them -- the stride case, and that an attribute's location is its index in that program's own input table, so a location copied from the skinned program left aColor unbound while every summary number stayed byte-identical. Result: 97.35 % within 8 levels and 99.98 % within 32 at the angle the sample opens at, sphere 99.76 %, signed error +0.07/-0.04/-0.00. One residue is recorded rather than averaged away: at 240 deg and 300 deg the camera dips below the tabletop and XNA shades its underside black where CNA shades it dark brown, dropping agreement to 92.4 % with only 93.1 % within 32. Geometry, coverage, centroid, texture, UVs and the ambient term are all exact (ambient-only agrees on 99.99 %); the near plane, the cull mode, which light is enabled, and a mirrored transform are each excluded by measurement. Filed open as plan_fx.md FX-126. WEBGL2 built and driven in real Chrome, its sphere-lighting gate calibrated against the native frames so the pre-FX-125 value fails it, and its picking check exercising Unproject/Ray/BoundingSphere::Intersects end to end. Evidence: samples/PickingSample/missing.md.	✅
SAMPLE-048	TrianglePickingSample_4_0	port	Re-ported from scratch, and the generated picking sidecar is gone: the 2026-07-09 pass could not read the per-triangle data at all, so it emitted a TrianglePickingData.hpp holding the vertices as C++ source and filed DEFERRED item #25. The data now comes from the .xnb the real pipeline wrote. Second sample in the campaign with a ContentProcessor of its own: TrianglePickingProcessor chains to ModelProcessor and attaches a Dictionary<string, object> to Model.Tag holding every world-space triangle vertex as Vector3[] plus a BoundingSphere, so the runner compiles TrianglePickingPipeline.dll and hands it to BuildContent -- seven listed assets, 10 .xnb, Windows/Reach. Two framework gaps, both found by decoding the built Sphere.xnb's reader table rather than guessing. ArrayReader<Vector3> was never registered (cnanext 7b312232d) -- the template existed but no instantiation for any element type did, and since a reader table must resolve IN FULL before a single object is read, the whole model failed rather than just the array. And Model.Tag could not carry a dictionary (cnanext 0a32dba89): ReadTag accepted only a std::shared_ptr<System::Object>, and the one reader in the tree producing that shape is a test fixture, so Model.Tag had never carried real content. On the owner's decision the carrier is CNA::Content::ObjectDictionaryEXT, reached by dynamic_cast and read with a typed Get<T>, each entry keeping the type its own reader produced. Result: 98.23-98.25 % of pixels within 8 levels and 99.99 % within 32 at four pinned cursor positions -- and the stronger measurement is the picking itself: the white HUD text and the magenta wireframe of the picked triangle count 1048/0, 973/326, 401/0 and 985/27 in XNA against 1048/0, 973/326, 401/0 and 985/28 in CNA. The counts differ between legs, so the metric is not degenerate, and they match between engines to the pixel. The two engines pick the same triangle of the same model, which exercises the Tag data, the inverse world transform and the Moller-Trumbore test at once. WEBGL2 built and driven in real Chrome, its magentaPixels gate calibrated against the native frames (326 on the Cats box, 0 off every model) and measuring exactly those. Evidence: samples/TrianglePicking/missing.md.	✅
SAMPLE-049	HeightmapCollisionSample_4_0	port	Re-ported from scratch. The 2026-07-09 pass built the terrain at run time and constructed HeightMapInfo by hand, because it could run neither the sample's ContentProcessor nor read a Model.Tag; all three things the row asked about now come from the pipeline and all three are measured. Third sample with a ContentProcessor of its own and the first with a ContentTypeWriter: TerrainProcessor turns terrain.bmp into a grid mesh whose vertex heights are its pixels, converts it through the stock ModelProcessor and attaches a HeightMapInfoContent to Model.Tag. Two listed assets make four .xnb -- the processor's default TerrainTextureFilename resolves rocks.bmp beside the input, so the terrain texture is never a content-project row. HiDef is not optional and that is measured: the same content built for Reach fails, "Reach profile supports a maximum of 65535 primitives per draw call, but this ModelMeshPart contains 131072 triangles". XNA finds the runtime reader the writer names by reflecting over the game assembly; C++ has no reflection, so the port registers it under that same name in one line via the existing ContentTypeReaderManager::AddTypeCreator -- recorded in samples/HeightmapCollision/diff.md. Nothing was added to CNA for this sample. Result: 99.97-99.99 % of pixels within 8 levels and 100.00 % within 32 and after a 4 px blur at four pinned sphere positions, mean absolute difference 0.148 of 255 with no hook at all. And the collision values themselves -- what the row actually asks -- are exact: IsOnHeightmap and GetHeight over an 81-point grid agree at every point, bit-identical as float32, 0 ULP. That took care to state: as decimal text the two logs differ by up to 3e-05 because C#'s "R" and C's %.9g print the same float differently, and one ULP at that magnitude is 6.1e-05 -- comparing strings would have reported a difference that does not exist. WEBGL2 built and driven in real Chrome, where a rendered frame is itself the proof that processor, writer, .xnb and game-registered reader all worked, since the game throws otherwise; sphere 4425 px against 4426 native. One gate threshold was corrected rather than left to pass by luck. Evidence: samples/HeightmapCollision/missing.md.	✅
SAMPLE-050	SimpleAnimation_4_0	port	Re-ported from scratch. The 2026-07-11 pass had no content pipeline, so it hand-converted tank.fbx into a .model.json plus 24 _verts.bin/_idx.bin files and two PNGs, and then spent its write-up repairing that conversion -- a hand-computed ApplyRestTransforms() offset table, 12 index buffers rewritten to fix winding, per-mesh "texture" fields added by hand, an explicit 1280x720 back buffer and an invented F1 overlay. All of it is gone, replaced by the three .xnb the official pipeline wrote from one listed asset (tank.fbx through the stock FbxImporter/ModelProcessor; the two textures arrive because the FBX's materials name them). Reach, as the Windows project declares. Every one of the row's four questions is answered by measurement rather than inspection: the bone hierarchy was dumped out of the model -- 12 bones, four levels deep (tank_geo->l_engine_geo->l_steer_geo->l_front_wheel_geo), every one with a real translation and the tank body itself as Root, which is exactly what the old pass said the reader could not produce; winding and depth need nothing, since no index buffer is shipped any more and the port sets no render state, as the original sets none. Nothing was fixed in CNA or sharp-runtime for this sample. Everything here animates from gameTime.TotalGameTime, so a single CNA_TIME hook pins the instant both engines animate from; within each leg both engines go byte-identical still, across legs all eight hashes and the centroids differ. Result: 99.96-99.98 % of pixels within 8 levels and 100.00 % after a 4 px blur at four pinned instants, silhouette coverage matching to the third decimal. The same hook reaches the browser through the page's query string, so WEBGL2 in real Chrome is compared pixel for pixel with both native captures at the same instant: 99.74 % within 8 against real XNA and 99.77 % against native, 100.00 % after a blur, centroids within 0.05 px. The shipped bundle's own gate is calibrated by breaking what it watches -- forcing TextureEnabled off takes greenFraction from 23.35 % to 5.77 % while the silhouette barely moves, so the > 15 % threshold fails for exactly that defect. Evidence: samples/SimpleAnimation/missing.md.	✅
SAMPLE-051	CustomModelAnimation_4_0	placeholder	Ported from nothing -- the directory held a write-up and no code. The 2026-07-11 note called it blocked twice over by DEFERRED #13; none of the three reasons survives, and the biggest was a category error: ModelAnimationClip/ModelKeyframe and the four animation players are the SAMPLE's own 400 lines, not framework types CNA had to grow. Three projects build under the official pipeline -- a game library, two ContentProcessors and the game -- and three listed assets make 8 .xnb, HiDef, with the Kootenay font installed AND registered in the Wine prefix (SAMPLE-029's two-step). Two framework gaps, both named by decoding the real reader table first. (1) ReflectiveTypeReaderBuilder could register only the VALUE shape, right for an .xnb's root asset and wrong everywhere else: XNA writes a reference type with its own 1-based reader index in front, so the value-shaped reader read one index short and desynchronised the rest -- RegisterShared()/RegisterShared<TStored>() plus ListReader<Matrix> and ListReader<int>, neither ever registered. (2) FX-127: EasyGL refused a Vector4 BLENDINDICES, which this sample's own SkinnedModelProcessor deliberately writes and real XNA renders -- the format describes the BYTES, the shader register is a float4 either way; fixed by one read mode on every profile, and the CNAEXT shadow/prepass copies of that shader were caught by ShadowVisibilityTest. Compared on the DATA first: all 5388 dumped values -- both clip dictionaries, every keyframe's bone, tick and transform, the 58-entry bind pose and hierarchy -- are bit-identical as float32, 0 ULP (4210 lines differ only in "R" versus %.9g spelling, which a textual diff would have called 3060 defects). Then the pixels: 99.94-99.96 % within 8 levels and 100.00 % after a 4 px blur at three pinned instants. WEBGL2 in real Chrome draws both models, gated on a Dude-pixel count that only exists if both framework fixes landed; reverting FX-127 makes the sample abort, which is the recorded calibration. Evidence: samples/CustomModelAnimation/missing.md, samples/CustomModelAnimation/diff.md.	✅
SAMPLE-052	CustomModelClassSample_4_0	port	Re-ported from the real sample. The 2026-07-06 pass had replaced the point of the sample -- its own CustomModel/private ModelPart runtime graph -- with stock Model, copied a hand-converted .model.json plus 24 buffer sidecars from CameraShake, added an F1 overlay and then blamed the resulting white line on EasyGL near-plane clipping. All of that is gone. The unchanged sample-owned CustomModelProcessor runs in the official pipeline: one listed tank.fbx produces three byte-identical Reach XNBs, including its two material textures, and the port loads the real reflective root, closed private-part list, vertex/index buffers and effects. One framework gap, XNB-42B: ModelPart.Effect is [ContentSerializer(SharedResource = true)]; ReflectiveTypeReaderBuilder::SharedResourceField() now queues the same deferred fixup through ContentReader::ReadSharedResource, requires the stable RegisterShared() shape and has two focused tests. With time pinned at 10 s, native OPENGLES3 and real XNA are 99.9680 % within 8 levels and 99.9805 % within 32, MAE 0.000275708; the official geometry renders the recognizable lit tank with the original near plane and winding, disproving the old claim. WEBGL2 runs in real Chrome, renders and rotates the custom content graph, accepts Escape and reports no runtime/HTTP/fatal-console error. Evidence: samples/CustomModelClass/missing.md, samples/CustomModelClass/diff.md.	✅
SAMPLE-053	CustomModelEffectSample_4_0	placeholder	Ported from the real sample with no workaround. The old write-up called both the custom shader and the three chained ContentProcessors blockers. Instead, the unchanged upstream EnvironmentMappedModelProcessor → EnvironmentMappedMaterialProcessor → CubemapProcessor assembly was compiled and run through the official XNA 4.0 pipeline for Windows Reach/HiDef and Xbox Reach. The port retains the Windows Reach pipeline's four exact outputs: compiled EnvironmentMap.fx, processed saucer model, diffuse texture and generated mipmapped DXT1 cubemap. Reader-table inspection proves the intended ModelReader + EffectMaterialReader + type-erased external-reference path. One real framework defect, fixed as cnanext XNB-35A: ExternalReferenceReader hard-coded Texture2D where FNA reads object, so the genuine TextureCubeReader asset threw std::bad_any_cast; CNA now dispatches through the referenced XNB's concrete root reader and retains 2D/3D/cube effect textures, with a focused real-cube identity test. Frozen OPENGLES3 vs. Wine XNA comparisons at 1/3/7 seconds reach 97.913–99.247% within 8 levels, 99.611–99.881% within 32 and 99.614–99.954% after blur, with coverage within 0.003 percentage points. WEBGL2 builds and runs in real Chromium, shows the rotating reflective saucer, preserves the title, accepts Escape and reports no runtime/HTTP/fatal error. DEFERRED #18 remains only a possible general authoring-tool feature, not a sample blocker. Evidence: samples/CustomModelEffect/missing.md.	✅
SAMPLE-054	SkinningSample_4_0	placeholder	Ported whole, with no framework change and no workaround. The old note's central blocker was a category error: AnimationClip, Keyframe, AnimationPlayer and SkinningData are the sample's own library, not missing XNA APIs. The unchanged SkinnedModelProcessor ran through the official XNA 4.0 pipeline for Windows Reach (plus Windows HiDef and Xbox Reach checks); one listed dude.fbx produced five XNBs, all retained byte-identical. Its reader table names the expected ModelReader, SkinnedEffectReader and reflective SkinningData graph; the port supplies only the sample-owned AOT field registration through the generic seam repaired by SAMPLE-051. The original no-interpolation player, bind-pose reset, hierarchy/inverse-bind multiplication, camera, input and lighting are all retained. At pinned clip times 0.5/0.9 s, native OPENGLES3 vs. Wine XNA reaches 99.95/99.91 % within 8 levels and 100.00 % after a 4 px blur, with exact foreground bounds and centroids within 0.02 px; each pinned pair is byte-identical over two seconds while the two times differ. Real-Chrome WEBGL2 loads the reflective Tag, renders and animates the textured Dude, preserves the title, accepts Escape and has no runtime/HTTP/fatal error. DEFERRED #13 is no longer a blanket XNB/sample blocker; remaining samples must be retested individually. Evidence: samples/SkinningSample/missing.md, samples/SkinningSample/diff.md.	✅
SAMPLE-055	SkinnedModelExtensions_4_0	placeholder	Ported whole, including every Part 2 extension of the canonical skinning sample. The old blocker was the same category error SAMPLE-054 removed: the animation classes are sample-owned. The unchanged Windows Reach source and processor build and run under XNA 4.0; Windows HiDef and Xbox Reach content builds also succeed. The port retains named-bone lookup, split local/world/skin stages, PageUp/PageDown head control, Space arm control, the rigid baseball bat attached to L_Index1, SkinnedSphere[] from the original XML XNB and Enter/A wireframe toggling. Seven official outputs are retained byte-identical. One framework gap, fixed in cnanext 72262a33e: CNA implemented generic DictionaryReader, but did not register the standard primitive-only DictionaryReader<string,int> used by the processor's bone-name table; it now belongs to built-in primitive registration with focused decode/registry tests, rather than a game workaround. At pinned 0.5/0.9 s, native OPENGLES3 vs. Wine XNA reaches 99.95/99.92 % within 8 levels and 100.00 % after a 4 px blur, with exact foreground bounds and centroids within 0.02 px. Ordinary captures in both engines prove moving spheres and head/arm/bat manipulation. Real-Chrome WEBGL2 passes animation, sphere-toggle, bone-control, title, Escape, HTTP and error gates. Evidence: samples/SkinnedModelExtensions/{missing,diff}.md.	✅
SAMPLE-056	CPUSkinningSample_4_0	placeholder	Ported whole with the actual custom CPU model path, no framework change and no workaround. The unchanged XNA processor/writer builds dude_cpu.xnb with CpuVertex positions, normals, UVs, four weights/indices, an index buffer, shared BasicEffect and reflective animation graph; dude_gpu.xnb remains the parallel stock Model/SkinnedEffect control. All seven Windows Reach products are retained byte-identical. The C++ reader consumes that exact 21-reader contract and the runtime performs the original 12-field four-matrix blend, position/normal transforms, DynamicVertexBuffer discard upload and indexed draw every frame. Phone fullscreen/touch and Windows mouse branches, 30 Hz timing, FPS counter, camera and labels are retained. At pinned 0.5/0.9 s, native OPENGLES3 vs. Wine XNA reaches 99.99% within 8 levels on the CPU path (GPU: 99.96/99.97%) and 100% after blur, with identical model bounds; inside XNA CPU/GPU differs by at most one level, while CNA CPU/GPU is 99.97/99.98% within 8. Real-Chrome WEBGL2 passes animation, right-click CPU switching, drag, title, assets and error gates. The original .doc is retained byte-identical and rendered semantically as CPUSkinning.htm. Evidence: samples/CPUSkinning/{missing,diff}.md.	✅
SAMPLE-057	InverseKinematics_4_0	port	Freshly re-ported with the original stock model/content path and no sample workaround. The old port replaced Content.Load<Model>("cylinder") with CylinderModel.hpp plus raw buffers, kept converted JSON/PNG/font sidecars, invented an F1 overlay, renamed IKSample, and omitted the inactive Xbox HUD. All are corrected: the exact Windows HiDef cylinder.xnb, cat.xnb and font.xnb are byte-identical to the unchanged official build; the 20-link CCD hierarchy, ModelMesh/BasicEffect draw, constrained-billboard cat, full avatar Ready-guard path, Windows/Xbox HUD branches and keyboard/game-pad controls follow the C# line by line. The unchanged game builds but Wine cannot initialize discontinued XnaLiveProxy.exe; a retained one-line diagnostic copy removes only GamerServices component registration and proves the reference visual/input behavior with the real content. Release OPENGLES3 passes convergence, pause, single-step, movement, reset and Escape and reaches 99.90% within 8 levels vs XNA, 100% after 4 px blur. Real-Chrome WEBGL2 passes the renderer/title/assets/interaction/error gates and reaches 99.86% within 8, 100% after blur. No framework/runtime fix was required; the build helper gained an explicit GamerServices-only dependency instead of overlinking CNA_Net. Original HTML/JPEG/license files and historical root-only help.png are retained. Evidence: samples/InverseKinematics/missing.md.	✅
SAMPLE-058	ChaseCamera_4_0	port	Freshly re-ported on the original stock content path with no framework change or sample workaround. The old port replaced both Content.Load<Model> calls with RawModel.hpp plus converted JSON/PNG/raw buffers, changed ground culling for conversion-induced winding, invented an F1 overlay, flattened C# properties, omitted the phone branch and returned the wrong logical type name. All are corrected. The unchanged Windows Reach pipeline produces five byte-identical XNBs (two listed models plus their material textures and font); their ModelReader/BasicEffectReader graphs load, bind and render directly, so the raw loader, sidecars and CullNone toggle are gone. The complete camera spring, ship physics, independently sampled mouse regions, keyboard/game-pad paths, model traversal, HUD and 480x800 phone branch follow the source line by line. The unchanged Wine XNA build and native OPENGLES3 both exercise rest, thrust, steering, spring disable, reset, mouse thrust and Escape. Stable XNA vs OPENGLES3 reaches 99.09% within 8 levels and 100% after 4 px blur. Real-Chrome WEBGL2 passes context/title/assets/interaction/error gates and reaches 99.90% within 8, 100% after blur. Original HTML/license and historical root-only help.png are retained. Evidence: samples/ChaseCamera/missing.md.	✅
SAMPLE-059	Audio3DSample_4_0	port	Compare positional audio, looping and listener/emitter behavior; pass browser audio gate.	⬜
SAMPLE-060	SoundAndMusic_4_0	port	Compare sound/music state transitions and browser user-gesture behavior.	⬜

SAMPLE-061–083 — full games, UI and advanced samples

Task	Upstream directory	Existing	Fresh audit focus	Status
SAMPLE-061	MarbleMaze_4_0	port	Audit the selected original exercise endpoint, all game states, model conversion and controls.	⬜
SAMPLE-062	NetRumble_4_0	placeholder	Port full networking plus all four effects; verify multi-peer native behavior and web feasibility.	⬜
SAMPLE-063	HoneycombRush_4_0	port	Full game/original/native/web parity.	⬜
SAMPLE-064	HoneycombRushTrainingKit_4_0	absent	Reinspect every exercise/starter/end project; old “redundant” verdict is not accepted.	⬜
SAMPLE-065	NinjAcademy_4_0	port	Full game/original/native/web parity.	⬜
SAMPLE-066	ShipGame_4_0	placeholder	Port the whole game and all distinct effects, including point sprites; supplemental MonoGame only.	⬜
SAMPLE-067	CatapultWars_4_0	port	Full game/original/native/web parity.	⬜
SAMPLE-068	CatapultWarsTrainingKit_4_0	absent	Reinspect all exercises and advanced project; old “redundant” verdict is not accepted.	⬜
SAMPLE-069	CardsStarterKit_4_0	port	Audit the complete game/framework, AI, screens and rules; no omitted modes.	⬜
SAMPLE-070	RolePlayingGame_4_0_Win_Xbox	port	Restore simplified combat/screens and any animated content; compare the complete game.	⬜
SAMPLE-071	Yacht_4_0	port	Full game/original/native/web parity.	⬜
SAMPLE-072	GSMSample_4_0_WIN_XBOX	port	Audit the complete Game State Management sample and original project selection.	⬜
SAMPLE-073	SoccerPitchSample_4_0	port	Full original/native/web parity.	⬜
SAMPLE-074	TankOnAHeightMapSample_4_0	placeholder	Port multi-part tank bones and terrain; compare winding/depth with SAMPLE-030/050/076.	⬜
SAMPLE-075	NGSMSample_4_0	absent	Reinspect lobby/session code and its documented empty gameplay path; do not dismiss before audit.	⬜
SAMPLE-076	SplitScreenSample_4_0	placeholder	Port multi-part tank bones and split viewports; remove historical asset-generation gaps.	⬜
SAMPLE-077	DynamicMenu_4_0	port	Full menu/navigation/original/native/web parity.	⬜
SAMPLE-078	LocalizationSample_4_0	port	Verify cultures/resources/font/text behavior across native and browser builds.	⬜
SAMPLE-079	GesturesSample_4_0	port	Verify every gesture and browser pointer/touch mapping.	⬜
SAMPLE-080	TouchThumbsticksSample_4_0	port	Verify multi-touch controls natively and on real touch-capable browser input.	⬜
SAMPLE-081	PerformanceMeasuringSample_4_0	port	Preserve timing/query semantics; compare displayed measurements structurally.	⬜
SAMPLE-082	UISample_4_0	port	Full UI/control/original/native/web parity.	⬜
SAMPLE-083	SnowShovelSample_4_0	port	Full original/native/web parity.	⬜

SAMPLE-084–111 — phone, service, networking and tool candidates

Task	Upstream directory	Existing	Fresh audit focus	Status
SAMPLE-084	AccelerometerSample_4_0	port	Verify the original emulator keyboard branch and real sensor path; remove only port-invented behavior.	⬜
SAMPLE-085	AvatarAnimationBlendingSample_4_0	absent	Fresh API/content audit; no substitute avatar body. Route retired-service scope to DEC-004.	⬜
SAMPLE-086	AvatarMultipleAnimationsSample_4_0	absent	Fresh API/content audit; no substitute avatar body. Route retired-service scope to DEC-004.	⬜
SAMPLE-087	AvatarShadows_4_0	absent	Fresh API/content audit; no substitute avatar body. Route retired-service scope to DEC-004.	⬜
SAMPLE-088	BingMaps_4_0	absent	Reinspect API/service dependencies and any offline-testable logic; route scope to DEC-004.	⬜
SAMPLE-089	BingMapsPathFinding_4_0	absent	Reinspect mapping/path logic and service dependencies; route scope to DEC-004.	⬜
SAMPLE-090	BitmapFontMaker_4_0	absent	Audit as a WinForms tool rather than a game; route faithful tool scope to DEC-002/005.	⬜
SAMPLE-091	ClientServerSample_4_0	port	Remove GamerServices/network identity/event workarounds now that CNA claims fixes; test two processes.	⬜
SAMPLE-092	ContentManifestExtensions_4_0	absent	Audit the actual library/tool outputs and processor contracts; route to DEC-002.	⬜
SAMPLE-093	CurveEditor_4_0	absent	Audit as a WinForms curve tool and identify reusable XNA Curve behavior; route to DEC-005.	⬜
SAMPLE-094	CustomAvatarAnimation_4_0	absent	Fresh API/content audit; no substitute avatar body. Route retired-service scope to DEC-004.	⬜
SAMPLE-095	GeolocationSample_4_0	absent	Audit platform abstraction and emulator behavior; no invented GPS data. Route to DEC-004.	⬜
SAMPLE-096	InvitesSample_4_0	absent	Audit the exact Xbox LIVE account/invite/presence contract; route to DEC-004.	⬜
SAMPLE-097	MemoryMadnessLab_4_0	absent	Inspect every lab stage/document and identify runnable endpoints before classification.	⬜
SAMPLE-098	MicrophoneEchoSample_4_0	port	Compare microphone buffering/latency and pass real-browser permission/gesture testing.	⬜
SAMPLE-099	ModelImporterSample_4_0	absent	Audit importer UI/content behavior and route the measured pipeline/tool scope to DEC-002.	⬜
SAMPLE-100	NetworkPredictionSample_4_0	port	Remove the explicit options-packet substitute by implementing faithful SessionProperties behavior in CNA.	⬜
SAMPLE-101	ObjectPlacementOnAvatarSample_4_0	absent	Fresh API/content audit; no substitute avatar body. Route retired-service scope to DEC-004.	⬜
SAMPLE-102	Orientation_4_0	port	Confirm the old phone-hardware classification was wrong; full orientation/native/web parity.	⬜
SAMPLE-103	PeerToPeerSample_4_0	port	Verify genuine peer topology, events and two/multi-process behavior plus browser feasibility.	⬜
SAMPLE-104	PerformanceUtility_4_0	absent	Audit as a reusable library; identify dependent samples and faithful testable output.	⬜
SAMPLE-105	PushNotificationsSample_4_0	absent	Audit exact WP7 service/emulator contracts; route faithful platform scope to DEC-004.	⬜
SAMPLE-106	SavingEmbeddedImages_4_0	absent	Audit exact media-library behavior and assets; route faithful platform scope to DEC-004.	⬜
SAMPLE-107	TiltPerspective_4_0	port	Remove the invented keyboard-tilt scheme; preserve original sensor/fallback behavior exactly.	⬜
SAMPLE-108	WinFormsContentSample_4_0	absent	Audit XNA-in-WinForms hosting/content behavior; route faithful tool/hosting scope to DEC-005.	⬜
SAMPLE-109	WinFormsGraphicsSample_4_0	absent	Audit XNA-in-WinForms graphics hosting behavior; route faithful tool/hosting scope to DEC-005.	⬜
SAMPLE-110	WP7MusicManagement_4_0	absent	Audit media-library behavior and emulator branches; route platform scope to DEC-004.	⬜
SAMPLE-111	XnaGraphicsProfileChecker_4_0	absent	Audit the WinForms diagnostic and exact graphics-profile checks; route tool scope to DEC-005.	⬜

SAMPLE-112–153 — formerly grouped/ignored physical directories

These IDs are newly assigned in bytewise directory-name order. Do not renumber them after publication; the validator introduced by SAMPLES-INFRA-004 will pin the mapping.

Task	Upstream directory	Existing	Historical classification to re-check	Status
SAMPLE-112	AvatarAnimPack_4_0_BIN	absent	Avatar animation asset pack (binary).	⬜
SAMPLE-113	AvatarAnimPack_4_0_FBX	absent	Avatar animation asset pack (FBX).	⬜
SAMPLE-114	AvatarAnimPack_4_0_Maya	absent	Avatar animation/DCC asset pack (Maya).	⬜
SAMPLE-115	AvatarAnimPack_4_0_Mod_Tool	absent	Avatar animation/DCC asset pack (Mod Tool).	⬜
SAMPLE-116	AvatarRig_4_0_Max_2010	absent	Avatar DCC rig.	⬜
SAMPLE-117	AvatarRig_4_0_Maya_2009	absent	Avatar DCC rig.	⬜
SAMPLE-118	AvatarRig_4_0_SoftImage_Mod_Tool7_5	absent	Avatar DCC rig.	⬜
SAMPLE-119	BasicEffectShader_ARCHIVE_2_0	absent	XNA 2.0 shader archive; inspect code/tool relevance.	⬜
SAMPLE-120	ButtonImages	absent	Shared image resources; identify all consumers and completeness role.	⬜
SAMPLE-121	CardsStarterKit_4_0_VB	absent	Visual Basic variant; compare for content/behavior absent from the C# port.	⬜
SAMPLE-122	Catapult_ARCHIVE_2_0	absent	XNA 2.0 sample; compare with, but do not assume duplication of, CatapultWars.	⬜
SAMPLE-123	ControllerImages	absent	Shared controller resources; identify all consumers and completeness role.	⬜
SAMPLE-124	CustomIndeterminateProgressBarSample	absent	Silverlight control; inspect runnable/testable scope.	⬜
SAMPLE-125	GSMSample_4_0_Mango	absent	Mango variant; compare line by line with desktop GSM.	⬜
SAMPLE-126	GSMSample_4_0_Mango_VB	absent	Mango Visual Basic variant; inspect unique behavior/content.	⬜
SAMPLE-127	GSMSample_4_0_PHONE	absent	Phone variant; inspect unique behavior/content.	⬜
SAMPLE-128	LevelStarterKit	absent	Previously considered incomplete/Silverlight; inspect all files and runnable stages.	⬜
SAMPLE-129	LobbyChatImages	absent	Shared lobby/chat resources; identify consumers and completeness role.	⬜
SAMPLE-130	MaterialsAndLights_ARCHIVE_2_0	absent	XNA 2.0 graphics sample; inspect API/content value.	⬜
SAMPLE-131	Minjie_ARCHIVE_2_0	absent	XNA 2.0 sample; inspect complete source and assets.	⬜
SAMPLE-132	ModelViewerDemo_4_0_Mango	absent	Phone model viewer; inspect unique XNA behavior and controls.	⬜
SAMPLE-133	Movipa	absent	Third-party video sample; inspect XNA/API/content relevance.	⬜
SAMPLE-134	MultipassLighting_ARCHIVE_2_0	absent	XNA 2.0 effect sample; inspect reusable effect behavior.	⬜
SAMPLE-135	NonLinear-WP-SLApp-Navigation-Service	absent	Silverlight navigation sample; inspect runnable/testable scope.	⬜
SAMPLE-136	PaddleBattle_4_0_Mango	absent	Phone/Mango game; inspect as a distinct port candidate.	⬜
SAMPLE-137	PaddleBattle_4_0_Mango_VB	absent	Visual Basic phone variant; compare unique content/behavior.	⬜
SAMPLE-138	Pickture_ARCHIVE_2_0	absent	XNA 2.0 sample; inspect complete source and assets.	⬜
SAMPLE-139	PushRecipe_WP7_SL	absent	WP7/Silverlight push sample; inspect service and emulator behavior.	⬜
SAMPLE-140	RedistributableTTFs_ARCHIVE_3_1	absent	Font resource archive; identify sample consumers and licensing/build role.	⬜
SAMPLE-141	Riemers	absent	Third-party tutorial collection; inventory individual runnable projects before scope decision.	⬜
SAMPLE-142	RobotGame_ARCHIVE_2_0	absent	XNA 2.0 game sample; inspect complete source and assets.	⬜
SAMPLE-143	RolePlayingGame_4_0_Phone	absent	Phone variant; compare for unique behavior/content missing from SAMPLE-070.	⬜
SAMPLE-144	SilverlightMicrophoneSample	absent	Silverlight microphone sample; compare with XNA microphone APIs and web needs.	⬜
SAMPLE-145	SoundLab	absent	Standalone audio authoring tool; inspect formats/workflows used by samples.	⬜
SAMPLE-146	SpaceShooter_ARCHIVE_3_0	absent	XNA 3.0 game sample; inspect complete source and assets.	⬜
SAMPLE-147	SpriteBatchShader_ARCHIVE_2_0	absent	XNA 2.0 shader sample; inspect effect/compiler relevance.	⬜
SAMPLE-148	TiledSpritesSample_ARCHIVE_3_1	absent	XNA 3.1 sample; inspect complete source and assets.	⬜
SAMPLE-149	TombstoningSample	absent	WP7/Silverlight lifecycle sample; inspect state-persistence behavior.	⬜
SAMPLE-150	UnitConverterStarterKit	absent	Previously considered empty/incomplete; verify every file before classification.	⬜
SAMPLE-151	VectorRumble_ARCHIVE_2_0	absent	XNA 2.0 game sample; inspect complete source and assets.	⬜
SAMPLE-152	XNA-4-Racing-Game-Kit-master	absent	Governed only by plan_racing.md; execute it last, after every other sample/infrastructure outcome. Do not change that plan here.	↗
SAMPLE-153	XNA_XNB_Format	absent	XNB format documentation; assess relevance to faithful content loading/tooling.	⬜

Execution order

1. Finish SAMPLES-INFRA-002 through SAMPLES-INFRA-007 and prove the workflow with SAMPLE-001.
2. Audit one sample at a time. Prefer small existing ports first to expose systematic workaround patterns, then port currently-unblocked placeholders. Do not bulk-mark siblings complete.
3. When a sample exposes a bounded CNA or sharp-runtime defect, fix and test it immediately in the same session, then return to the sample and complete all gates.
4. When a genuinely large capability is confirmed, update the sample row with exact evidence, mark it 🛑, add it to the decision queue and ask the owner when available. Continue with other independent rows meanwhile.
5. Revisit all historically absent/ignored directories individually. A final non-port conclusion requires fresh file-level evidence and, for a scope choice, an explicit owner decision.
6. Keep web verification inside every sample task rather than postponing 153 browser builds to a final cleanup phase.
7. Start the separately governed Racing plan only after all other sample and infrastructure rows are resolved; Racing is the final port in the campaign.

Session report and commit contract

At the end of each sample session report:

• upstream projects/files and reference runtime used;
• cna-samples, cnanext and sharp-runtimenext files changed;
• workarounds removed and framework/runtime gaps fixed;
• intentional C++/asset-container deviations still present;
• native builds/tests and real-browser result;
• remaining blocker or owner decision, if any;
• commit hash from every touched repository.

Stage only explicit task files. One sample task uses one commit per touched repository, with the same SAMPLE-nnn identifier. Do not bundle unrelated cleanup and do not push unless the applicable repository instructions and owner authorization require it.