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:

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

cna-samples sets CNA_SHARP_RUNTIME_ROOT to ../sharp-runtime before adding ../cna as a subdirectory. CNA_SAMPLES_CNA_ROOT is the explicit override for an isolated equivalent CNA checkout; no symlink or source-tree rename is part of the build contract.

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. On 2026-08-31 the live host had /dev/vboxdrv and VirtualBox 7.2.8, and the Win7 SP1 guest plus Guest Additions booted. The saved automatic-login credential was invalid during the first attempt. After the owner supplied guest access, the offline VM completed all required SongProcessor exports; no credential was recorded, all VM network adapters remained disabled, and the guest shut down normally. Evidence is under /rv/tmp/samples/SAMPLES-DEC-007-Win7-SongProcessor/export/.

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-runtime 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 ../cna, add the required CNA tests and follow ../cna/AGENTS.md plus CHECKLIST.md.
.NET System.* behavior or primitive/runtime type	Implement/fix it in ../sharp-runtime, 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 ../cna + ../sharp-runtime 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.
⛔	Cancelled by explicit owner decision; no port will be produced for the recorded reason.
✅	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	85	SAMPLE-001–SAMPLE-003, SAMPLE-005–SAMPLE-063 and SAMPLE-065 except decision-blocked SAMPLE-014 and cancelled SAMPLE-015, plus SAMPLE-067–SAMPLE-074, SAMPLE-076–SAMPLE-084, SAMPLE-092, SAMPLE-098, SAMPLE-099 and SAMPLE-102
🛑 owner decision pending	50	The previously recorded decisions remain open; SAMPLE-149 and SAMPLE-150 additionally need retired Phone/Silverlight non-port, faithful compatibility-product, or explicitly scoped complete native/WEBGL2 modernization rulings. SAMPLE-150 also consumes the owner-controlled XML decision. SAMPLE-151 needs an authentic XNA2/XACT2, complete XNA4 modernization, or historical non-port ruling. SAMPLE-153 needs a historical internal-reference non-port, licensed archival-tool, or explicitly new CNA inspector ruling. See the decision table and per-sample evidence for the full boundaries.
⛔ cancelled	15	SAMPLE-004, SAMPLE-015, SAMPLE-064, SAMPLE-075, SAMPLE-085–SAMPLE-090 and SAMPLE-093–SAMPLE-097; all are evidence-backed non-port boundaries accepted by the owner. SAMPLE-090 and SAMPLE-093 were cancelled on 2026-09-09 as design-time WinForms tools; each left a framework gap behind in cnanext/misc/known_gaps.md, which is not cancelled with the row. SAMPLE-075 was cancelled on 2026-09-08 after its blockers were re-measured against current CNA: they reduce to one capability, a session directory plus an inbound-capable peer, which is new infrastructure rather than a port.
🛠 ready/in progress	2	SAMPLE-107 and SAMPLE-148 have complete native ports and WEBGL2 bundles; their real system-Chrome interaction gates are pending because the required browser extension/native-host route is unavailable. SAMPLE-070 left 🛑 on 2026-09-07 when its SAMPLES-DEC-008 blocker was resolved, and reached ✅ the same day; SAMPLE-071 reached ✅ on 2026-09-08 once its browser gate was found to be photographing a stale rectangle rather than the renderer dropping sprites.
🔎 active audit	0	every fresh non-Racing row has now been audited
⬜ not started	0	no fresh non-Racing row remains; SAMPLE-107 and SAMPLE-148 still await their external browser-control gates
↗ separate plan	1	SAMPLE-152 Racing remains last and is governed only by plan_racing.md
total rows	153	one per physical upstream directory

Every ⛔ row is an evidence-backed non-port boundary the owner accepted; the list is the status table above rather than a count repeated here, because it grows. Cancelling a row does not cancel what the row measured: a framework gap found through a cancelled sample stays open in cnanext/misc/known_gaps.md, and a defect stays open in cnanext/misc/known_bugs.md. 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	64
Placeholder directory without source/build target	27
No samples/ directory	62
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	✅	The dependency integration uses configurable CNA_SAMPLES_CNA_ROOT (default ../cna) with CNA_SHARP_RUNTIME_ROOT=../sharp-runtime and validates both checkouts before adding CNA. WEBGL2 remains Release and Emscripten pthreads are opt-in instead of globally forced, keeping ordinary bundles suitable for static hosting. Requalified with SAMPLE-001 on 2026-09-12: native Release OPENGLES3 built and exited cleanly through the original Escape path; WEBGL2 Release built and rendered the complete scene in Chrome 152; the 7,484,909-byte wasm has no custom/debug sections and its JavaScript has no SharedArrayBuffer/pthread path.
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 and used there, but their fresh 2026-09-13 rebuilds also prove that current-host font raster output is not byte-stable; keep each verified official XNB and record the regenerated hash and host-sensitive difference. 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 Effect authoring/compiler route. SAMPLE-012 proves an unchanged sample-owned processor assembly can generate exact runtime content outside CNA. SAMPLE-099 adds a 596-line design-time OBJ/MTL importer: the unchanged assembly builds and emits exact model-plus-external-texture XNBs, while its complete C++ runtime game loads, animates and renders those assets natively and in WebGL2. SAMPLE-090 is a separate WinForms authoring tool that emits a magenta-marker 32-bit BMP for XNA's FontTextureProcessor; live CNA consumes SpriteFont XNB/CNJ data but has no importer for that authored marker format. SAMPLE-141 adds three official XNA4-built model XNBs whose nullable shared-resource graphs CNA's canonical model-v2 sink cannot represent without a deliberate schema/runtime contract; the physical delivery has no program proving their consumption, so no dummy resource or asset edit was added. Evidence: samples/StockEffects/missing.md, samples/GeneratedGeometry/missing.md, samples/ModelImporterSample/missing.md, samples/BitmapFontMaker/missing.md and samples/Riemers/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 and SAMPLE-099; this does not declare a standalone design-time tool/library ported. Resolved for SAMPLE-090 on 2026-09-09 as a non-port; the missing marker-BMP SpriteFont importer is not cancelled with it and is now entry 2 of cnanext/misc/known_gaps.md. For SAMPLE-141, defer nullable CNB model-schema work until the owner authorizes a concrete product that requires those models. 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. SAMPLE-075 requires retired Xbox LIVE identity/matchmaking/invitations. SAMPLE-085–SAMPLE-087 require Microsoft's proprietary 71-bone Xbox Avatar bodies/presets; CNA's normal route is unavailable/no-op, its CNAEXT body is a substitute, and SAMPLE-087 additionally needs truthful EasyGL Alpha8 targets. SAMPLE-094 adds a complete custom-animation case: its unchanged 1,504-line Xbox game/library/processor stack and all seven official custom-animation/ground XNBs build, disproving a pipeline blocker, but the result still requires the genuine Avatar body, four built-in Stand datasets, profile/random appearance service, custom 71-bone matrix draw and facial expressions. SAMPLE-101 adds the distinct object-attachment case: its unchanged 361-line Xbox game and stock baseball-bat XNB build, but the demonstrated SpecialRight transform requires a ready authentic body, bind pose and four preset datasets; normal CNA exposes none of them and its extension owns a substitute skeleton. SAMPLE-088 is a 1,452-line online map client with imagery and geocoding. SAMPLE-089 is a distinct 2,612-line route game that adds ordered pushpins, Driving/Walking Routes requests, returned-road traversal, tank motion and indexed route rendering. Both exact sources refuse to compile without a key; Microsoft retired free Bing Maps Basic accounts and directs migrations to Azure Maps. Sharp Runtime lacks WebClient/GeoCoordinate/stream-load infrastructure, while the durable SAMPLE-089 route replacement additionally needs authenticated HTTP POST/GeoJSON support. SAMPLE-095 is a 932-line WP7 GPS car finder whose exact source and content builds pass; its live GeoCoordinateWatcher status, permission, moving position, speed/course/accuracy and lifecycle are the product. Live CNA explicitly records System.Device.Location as wholly unimplemented; SDL3 has no location API, so honest Android/Apple/browser/native providers plus permission/lifecycle and test seams are a separate subsystem. SAMPLE-096 isolates the retired LIVE boundary: its exact Windows build reaches real Guide sign-in/menu and rejects PlayerMatch without an eligible LIVE profile, while the product requires befriended identities, pull/push invitation delivery and JoinInvited; CNA's matching surfaces have no service or event producer. SAMPLE-110 adds Phone user-music ownership plus three deliberately different external-launcher lifecycle cases; ordinary CNA Song playback works, but GameHasControl is always true and the media/photo/web tasks do not exist. Evidence: samples/TicTacToe/missing.md, samples/NetworkStateManagement/missing.md, samples/AvatarAnimationBlending/missing.md, samples/AvatarMultipleAnimations/missing.md, samples/AvatarShadows/missing.md, samples/CustomAvatarAnimation/missing.md, samples/ObjectPlacementOnAvatar/missing.md, samples/BingMaps/missing.md, samples/BingMapsPathFinding/missing.md, samples/Geolocation/missing.md, samples/Invites/missing.md and samples/WP7MusicManagement/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. For SAMPLE-075, choose a reusable replacement identity/matchmaking/invite service, documented System-Link-only scope or non-port boundary. Resolved for SAMPLE-085–SAMPLE-087 on 2026-09-08 and for SAMPLE-094 on 2026-09-09: the owner accepted the Xbox-only non-port evidence for all four, so no CNA port will be produced. Two measurements survive those rows — SAMPLE-087's refused Alpha8 render target, now entry 1 of cnanext/misc/known_gaps.md, and SAMPLE-094's finding that AvatarRenderer has no entry point at all for caller-supplied bone matrices plus an expression, which any authorized Avatar backend must add first. For SAMPLE-101, accept Xbox-only/non-port evidence, approve the substitute/missing renderer capabilities as an explicit scope change, or authorize a faithful dataset/backend; its substitute option must define a truthful SpecialRight mapping, and it meets the same missing entry point. For SAMPLE-088–SAMPLE-089, accept separate non-port boundaries, provide eligible Bing Enterprise access through 2028, or authorize/provision Azure imagery/search/route migrations; either live route also needs secure credential/CORS policy and reusable native/browser HTTP work. Resolved for SAMPLE-095 on 2026-09-09: the owner accepted the WP7/location-hardware non-port boundary. System::Device::Location stays unbuilt and unscoped, and cnanext/docs/location-future-plan.md still designs only the Android and iOS paths, neither of which this campaign gates on. Resolved for SAMPLE-096 on 2026-09-09: the owner accepted the retired-LIVE non-port. The row's two framework findings were fixed first (cnanext 8296b7750); the reusable identity/friends/matchmaking/invite service remains unbuilt and is entry 4 of cnanext/misc/known_gaps.md. For SAMPLE-110, accept a Phone-only non-port, authorize reusable native/browser media/photo/web tasks plus automatic Guide and exact audio lifecycle, or explicitly define a narrower modernization.
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. SAMPLE-064 proves three distinct training stages rather than one duplicate. SAMPLE-097 adds two distinct Phone/Reach endpoints: a 2,667-line EX1 that the 82-page lab explicitly compiles and calls completely playable, and a separate 4,455-line EX2 that adds sound, animated/menu/loading/pause/high-score screens, persistence and phone tombstoning. All 19 compiled content items per stage build through the official XNA pipeline for Phone and Windows; content is not the blocker. SAMPLE-090 is a measured standalone WinForms authoring tool: a 660-line .NET 2 application enumerating Windows fonts, rasterizing with System.Drawing and saving a marker-formatted BMP through a desktop dialog. The unchanged project builds and its form/export dialog run under Mono, but libgdiplus does not reproduce a valid atlas; Sharp Runtime has neither WinForms nor System.Drawing, and a browser rewrite cannot silently reproduce local Windows font/GDI+ behavior. SAMPLE-093 is a distinct three-project, 6,868-line WinForms package: standalone Curve Editor, reusable CurveControl and a separate usage application. All exact sources build, both applications run with official XNA 4 under offline Wine, and its public save/load path round-trips the authentic IntermediateSerializer<Curve> XML. Live CNA already passes 82 Curve math tests plus 29 XNB/CNJ/CNB curve-content tests; the missing scope is the complete GDI+/WinForms editor/component rather than XNA curve behavior. SAMPLE-108 is another distinct working WinForms tool: it embeds one shared XNA GraphicsDevice in a Control, uses override-window Present, dynamically compiles arbitrary user-selected FBX/X through Microsoft.Build and the stock XNA pipeline, then displays the rotating Model. The unchanged Release/x86 application builds and its full Cats.fbx dialog/build/render path runs in offline Win7; CNA has many underlying Model/device pieces but not arbitrary native-control adoption, the rich Present overload or FBX/X source import, while Sharp Runtime has no WinForms/System.Drawing/Microsoft.Build. SAMPLE-109 is the complementary shared-device hosting demo: two WinForms GraphicsDeviceControls use event-driven SpriteFont content and idle-driven DrawUserPrimitives animation, while three comboboxes convert named GDI colours into live XNA vertex colours. Its unchanged Release/x86 solution and exact SpriteFont build; the left content control paints in offline Win7, while the second override-target control remains black under the VBoxSVGA reference even after repaint/resize, so that multi-HWND reference result is recorded as incomplete rather than claimed passed. SAMPLE-141 is five intact Riemers asset ZIPs (54 files) with local collection/screenshot context but no tutorial source, project, entry point or package-wide licence; 47/52 diagnostic assets build through XNA4 and 51/56 resulting XNBs convert to CNB, but those measurements cannot reconstruct five missing products. Evidence: samples/HoneycombRushTrainingKit/missing.md, samples/MemoryMadnessLab/missing.md, samples/BitmapFontMaker/missing.md, samples/CurveEditor/missing.md, samples/WinFormsContentSample/missing.md, samples/WinFormsGraphicsSample/missing.md and samples/Riemers/missing.md.	Resolved for SAMPLE-064 on 2026-09-05: the owner explicitly cancelled all three teaching stages, so no CNA port will be produced. Resolved for SAMPLE-097 on 2026-09-09: the owner cancelled both endpoints, so the two-products-versus-one question does not arise. The lifecycle service modules/phone provides is not cancelled with it and SAMPLE-065 still meets the same reference problem. For SAMPLE-141, choose an asset/support archive, provide and scope complete licensed tutorial sources/endpoints, or explicitly authorize newly designed demonstrations. Resolved for SAMPLE-090 and SAMPLE-093 on 2026-09-09: the owner cancelled both design-time WinForms tools, so no CNA port will be produced; the two framework gaps they measured were moved to cnanext/misc/known_gaps.md first and remain open there. For each of SAMPLE-108 and SAMPLE-109, choose evidence-backed non-port, faithful Windows desktop-tool scope plus a browser-gate ruling, or an explicitly modernized cross-platform UI/component/file-output contract. SAMPLE-093's XNA Content Pipeline IntermediateSerializer is not the System.Xml.Serialization.XmlSerializer issue in DEC-008. Never reject a row merely because the old plan did, and never invent a Game wrapper, reduced CLI, precompiled-model viewer or graph-only substitute for a tool.
SAMPLES-DEC-006 — Web feature gaps	Every successful port now requires a real browser build. SAMPLE-062, SAMPLE-075, SAMPLE-091, SAMPLE-096, SAMPLE-100 and SAMPLE-103 are concrete networking cases: native CNA has real ENet System Link and UDP discovery, but its Emscripten discovery is intentionally empty, a browser cannot accept inbound System Link peers, Player Match has no real transport, and none of the originals exposes a public direct-address path to CNA's outbound WebSocket client. NetRumble, ClientServerSample, NetworkPrediction and PeerToPeer need create/find/join plus packet gameplay; NetworkPrediction additionally requires cross-peer option replication to exercise prediction/smoothing, while PeerToPeer requires independently owned bidirectional state broadcast. Network State Management needs multi-peer lobby readiness and synchronized state transitions. Invites additionally needs browser-capable identity, friends, PlayerMatch and invitation delivery before its tank packets can begin. None can pass the browser gate without a session directory/broker, relay/address handoff and multi-peer browser qualification. SAMPLE-091, SAMPLE-100 and SAMPLE-103 are otherwise native-complete: all pass real two-process OPENGLES3 discovery/join and pixel-identical synchronized gameplay; SAMPLE-100 also proves CNA c195fe8ce replicates all four mutable SessionProperties values without an application packet, while SAMPLE-103 proves both peers independently move and broadcast their own tanks. SAMPLE-100's real-Chrome WEBGL2 build renders its menu and single-tab local host state for 600 frames without errors, but cannot run the B=find/join peer path; SAMPLE-103's clean WEBGL2 bundle builds with the same structural peer limitation. Evidence: samples/NetRumble/missing.md, samples/NetworkStateManagement/missing.md, samples/ClientServerSample/missing.md, samples/Invites/missing.md, samples/NetworkPrediction/missing.md and samples/PeerToPeer/missing.md.	For SAMPLE-062, SAMPLE-075, SAMPLE-091, SAMPLE-096, SAMPLE-100 and SAMPLE-103, authorize/design the browser broker/relay capability, or explicitly accept a native-only/non-port scope boundary. A menu-only build, fake local lobby or manual-IP sample workaround is not acceptable. SAMPLE-075 and SAMPLE-096 separately need the SAMPLES-DEC-004 retired-LIVE ruling. Other XACT, microphone, large-content and persistence cases still require their own evidence.
SAMPLES-DEC-007 — Original-reference environment	Resolved 2026-08-31. The Wine route cannot invoke XNA's Windows Media encoder, but the owner-supplied offline Win7 SP1 VM does. All network adapters were none. The unchanged original content projects completed through official XNA 4.0 SongProcessor for SAMPLE-060, 062, 063 and 064. SAMPLE-065's full project first stopped on an unrelated custom-pipeline platform mapping; a narrow project containing its exact original NinjAcademy_Music.wav/WavImporter/SongProcessor item then completed through the same official WindowsPhone/Reach pipeline. Seven XNB/WMA pairs were exported; every XNB has the expected Phone (m) or Windows (w) platform, SongReader/Int32Reader, matching stream name and duration, and every stream probes as valid WMA v2. The VM shut down normally. Evidence and reproducible credential-free scripts: /rv/tmp/samples/SAMPLES-DEC-007-Win7-SongProcessor/export/.	No owner choice remains for Song content. Use these authentic pairs when resuming SAMPLE-060/062/063/064/065. SAMPLE-062's browser multiplayer, SAMPLE-064's training-stage representation and SAMPLE-065's phone lifecycle/host remain separate decisions; do not conflate them with SongProcessor.
SAMPLES-DEC-008 — System.Xml.Serialization	SAMPLE-014 proved its old port replaced XmlSerializer(typeof(Settings)) with 136 lines of handwritten XML and was reopened. SAMPLE-066 adds EntityList and LightList Save/Load with six live XmlSerializer load call sites required for gameplay. SAMPLE-070 adds a larger reachable persistence case: its Save/Load menus have 20 XmlSerializer call sites (ten each direction) across ten object-graph routes spanning player position, world-entry lists, modified chests, party/player data and save descriptions. Live CNA already has the required storage APIs, so omitting persistence is not a storage limitation. Sharp Runtime has System.Xml/LINQ but no System.Xml.Serialization; C++ needs an explicit member-description mechanism for the reflection-driven .NET contract. Evidence: samples/Spacewar/missing.md, samples/ShipGame/missing.md, samples/RolePlayingGame/missing.md.	The owner chose "mark it and decide later" on 2026-08-28. Decide whether to implement a reusable XML serializer in sharp-runtimenext, or explicitly accept documented sample-specific parsers as owner-approved deviations. Do not add another handwritten parser autonomously.
SAMPLES-DEC-009 — Yacht complete-product boundary	SAMPLE-071 is two deployed products, not merely its offline dice game: a 39-source Windows Phone XNA client and a WCF server with ten operations, authoritative multiplayer state/AI/rules, a generated SOAP client, MPNS raw/toast push and phone lifecycle persistence. The unchanged client sources type-check with a labelled WP-SDK-only diagnostic shim; all 45 exact XNBs build; the unchanged service/console host builds and serves a real WSDL. Live CNA/Sharp Runtime already invalidate the old Guide/storage/timer excuses but have no System.ServiceModel, HttpNotificationChannel or PhoneApplicationService. The 19-file existing port omits the entire online client, server and several offline behaviors. Evidence: samples/Yacht/missing.md.	DECIDED by the owner on 2026-09-07: port it, both products. The first option -- a reusable WCF/SOAP and lifecycle implementation with the complete client and server -- and explicitly not a transport modernization, which was offered and declined once the measurement showed it was unnecessary. What Microsoft retired is MPNS alone, and MPNS is a relay: the sender is the sample's own server, the receiver is the sample's own client, and the phone needed a relay between them only because it had no reachable address. The WCF service is not hosted by anyone -- it is Server.exe, which the user runs, and which builds and answers SOAP on this machine today. Progress is in the SAMPLE-071 row.

SAMPLES-DEC-006 resolution for SAMPLE-062 (2026-09-05): the owner authorized a faithful native OPENGLES3/System-Link port and explicitly decided that no web port will be produced for NetRumble. This is a SAMPLE-062-only exception. It does not authorize a fake lobby, manual-address UI, reduced game or native-only completion of any other networking row.

SAMPLES-DEC-005 follow-up (2026-09-02): SAMPLE-149 is a complete pure Windows Phone 7.0 Silverlight application rather than an XNA game. Its defining product is the Phone application/page lifecycle and XAML control tree: transient tombstone restoration, durable isolated storage, navigation-instance reconstruction, render-deferred scroll/focus restoration and asynchronous data retrieval. The exact offline Win7 build selects the correct project but stops because that VM lacks the separate Silverlight-for-Phone v4 build targets. CNA and Sharp Runtime have healthy storage, HTTP and threading primitives but no Phone/Silverlight page, navigation, XAML, control, dispatcher or lifecycle stack. Choose an evidence-backed historical non-port, authorize a faithful compatibility product and authentic Phone reference gate, or explicitly scope a complete native/WEBGL2 modernization. Evidence: samples/TombstoningSample/missing.md.

SAMPLES-DEC-005 / SAMPLES-DEC-008 follow-up (2026-09-02): SAMPLE-150 is not the previously assumed empty delivery. It is a complete, localized 60-file Windows Phone 7 Silverlight unit-converter application with 6,581 C# and 937 XAML lines, eight categories/44 units, custom touch keypad and context menu, dynamic pivot pages, favorites, tombstoning and deferred startup. It has no XNA reference or game. Its exact offline Win7 build reaches the correct project but the VM lacks the separately required Silverlight-for-Phone v4 targets. A faithful or explicitly modernized product needs the Phone/Silverlight UI, navigation, touch, lifecycle, localization and visual contract; its packaged catalogue and durable favorites also use two reachable XmlSerializer routes that must consume the eventual owner-approved DEC-008 result rather than a sample parser. Evidence: samples/UnitConverterStarterKit/missing.md.

SAMPLES-DEC-002 / SAMPLES-DEC-005 follow-up (2026-09-02): SAMPLE-151 is a complete 79-file XNA 2.0 Windows/Xbox vector arena shooter: 7,676 runtime C# lines, four-player joining and gamepad control/vibration, collision/weapons/power-ups, complete screen flow, LineList rendering, four-pass bloom and a fourteen-cue/sixteen-wave XACT2 graph. The offline Win7 VM has XNA4 but not XNA2 targets. An isolated diagnostic migration compiles the entire runtime and all seven non-XACT content items with XNA4; restoring the unchanged XAP produces the exact version-incompatible XACT2 rejection, and no generated XGS/XWB/XSB banks are delivered or locally buildable. CNA converts the two fonts/two textures, retains the three Effect XNBs as the honest runtime route and passes 703 audio, 78 content and 66 relevant GLES3 tests (two renderer-specific skips). Choose an authentic XNA2/XACT2 compatibility and reference route, an explicitly complete XNA4/XACT3 modernization followed by full C++/native/WEBGL2 porting, or historical non-port. Direct WAV playback, a reduced line-renderer demo or NetRumble alias is not acceptable. Evidence: samples/VectorRumbleArchive/missing.md.

SAMPLES-DEC-005 follow-up (2026-09-02): SAMPLE-153 is Microsoft's 27-page XNA4 compiled content-format reference plus an already-C++ 2,842-line VS2010 console inspector, not a C# game. The example registers 57 readers but only logs fields, rejects all compressed XNBs and ReflectiveReader, and does not resolve shared-resource object graphs; live CNA already provides the reusable None/LZX/LZ4, 16-platform, shared-fixup, custom/reflective and real-runtime paths and passes 263/263 focused tests. The delivery has no separate redistribution licence, while the document grants internal/reference use rather than public repackaging. An offline unchanged build was prepared but could not run after the host restart because WinRE sees the VM's 31GB C: system volume as RAW; no repair write was attempted and the VM was cleanly powered off with every NIC still none. Choose internal historical non-port, provide a licence and preserve the original inspector after VM recovery, or explicitly authorize a newly designed CNA XNB inspection CLI with a new stable output/test contract. Do not invent a Game or fork CNA's loader into the sample. Evidence: samples/XnaXnbFormat/missing.md.

SAMPLES-DEC-005 follow-up (2026-09-01): SAMPLE-121 is the official Visual Basic translation of the already-complete C# Cards Starter Kit. All 47 logical source pairs, both content-project contracts and authentic runtime behavior agree; the rebuilt 89-file HiDef XNB tree and two deterministic reference states are byte-identical. The only distinctions are VB compiler/project identity (BlackJackGame, nested root namespace, Module, WithEvents, public Main) and non-runtime project artwork. Choose one shared language-neutral C++ product, retained VB language/reference support data, or a separate target that deliberately preserves that language identity. Evidence: samples/CardsStarterKitVB/missing.md.

SAMPLES-DEC-005 follow-up (2026-09-01): SAMPLE-122 is a complete, distinct XNA 2.0 pumpkin-distance game rather than an earlier CatapultWars stage. Its unchanged source reaches exactly eight bounded XNA2-to-XNA4 storage/SpriteBatch migration diagnostics, and all eight textures plus its SpriteFont pass the official XNA4 pipeline and current CNA conversion. The unchanged XACT2 project is rejected by XNA4 BuildXact as version-incompatible, while no authentic XNA2 compiler, XACT2 builder or original binary output is locally available. Choose a prerequisite-backed faithful XNA2 port with an explicit migration contract, an explicitly modernized XNA4/XACT3 product, or an evidence-backed historical-game archive/non-port boundary. Evidence: samples/CatapultArchive/missing.md.

SAMPLES-DEC-005 follow-up (2026-09-01): SAMPLE-123 contains only four distinct 512×512 RGBA controller renders and the license, with no project, code, usage document or runtime behavior. No exact copy or filename/directory reference exists elsewhere in the collection; InputReporter's generic “connected-controller images” comment refers to its own eight unrelated 29–50px HUD fragments. All four unchanged PNGs pass the official XNA4 Texture2D pipeline, current CNA conversion and 9/9 focused content tests. Choose resource-pack non-port, retained shared support data, or an explicitly scoped native/WEBGL2 controller-gallery product. Evidence: samples/ControllerImages/missing.md.

SAMPLES-DEC-005 follow-up (2026-09-02): SAMPLE-124 is a complete Windows Phone 7 Silverlight application demonstrating a 455-line relative-animation control and 4.4-second, five-rectangle compositor-thread progress template, not an XNA Game. The offline/headless Win7 build reaches the unchanged project but lacks the Windows Phone Silverlight v4 MSBuild targets explicitly required by the readme, so no original runtime claim is made. Live CNA/Sharp contains none of the required System.Windows/Phone control, visual-state, storyboard or animation stack. SAMPLE-139 PushRecipe reuses all 212 normalized logical control lines and a semantically identical style, but remains a distinct service/client product. Choose Silverlight non-port, shared support data, or an explicitly scoped native/browser UI-control modernization. Evidence: samples/CustomIndeterminateProgressBar/missing.md.

SAMPLES-DEC-005 follow-up (2026-09-02): SAMPLE-125 is a materially revised Mango generation of Game State Management rather than an alias of complete SAMPLE-072. Fourteen of fifteen mapped sources changed and nine C# units are new; they add a reusable library split, InputAction, screen activate/deactivate/unload semantics, isolated XML screen-stack persistence, runtime type/factory restoration and Phone touch/tombstoning state. Only two of five assets/XNBs are identical; the unchanged 800x480 Windows product builds and passes a nine-state original run, and all five content items pass current CNA conversion. The offline Win7 XNA installation explicitly lacks Windows Phone project support, while live CNA/Sharp lacks PhoneApplicationService lifecycle and general reflection is a permanent Sharp Runtime deviation. Choose a shared Mango upgrade, a distinct Mango/Phone product with approved lifecycle and closed AOT factory semantics, or retained distinct reference/support data. Evidence: samples/GameStateManagementMango/missing.md.

SAMPLES-DEC-005 follow-up (2026-09-02): SAMPLE-126 is the 24-unit Visual Basic generation of SAMPLE-125 with identical six-project compile sets and byte-identical source content, but it is not behaviorally or platform-metadata identical. Exact Win7 /vbruntime* assemblies prove ten public setters where C# uses restricted setters, a nine-byte EnabledGestures setter that omits C#'s active-screen TouchPanel synchronization, _Position rather than Position, and reachable enum text 1/2 rather than Dromedary/Llama; both probe output and captured frames verify the latter. Its Phone manifest targets 7.1 rather than 7.0, adds five capabilities and changes title/token, ProductID and thumbnail. The exact Windows solution builds with zero warnings/errors, both nine-state reference runs exit cleanly, all five Win7 XNBs convert and 13/13 CNA tests pass; Phone remains unsupported by the installed XNA environment. Choose one C#-canonical shared Mango product, a separate VB-faithful product, or retained distinct language/platform support data together with SAMPLE-125's lifecycle/factory ruling. Evidence: samples/GameStateManagementMangoVB/missing.md.

SAMPLES-DEC-005 follow-up (2026-09-02): SAMPLE-127 is the distinct 14-unit pre-Mango Phone 7.0 generation, not an alias for SAMPLE-072 or SAMPLE-125. Eight sources differ from the completed base port: full-screen 480x800/30 Hz setup, tap-only padded menus, hardware Back navigation, no pause or explicit exit/back entries, and binary isolated-storage stack persistence using assembly-qualified runtime types. Sharp Runtime now supplies the storage/stream/binary primitives, but its permanent no-reflection boundary still requires an explicitly approved closed AOT type registry and portable lifecycle/Back mapping. The offline Win7 Build reaches the exact unsupported-XNA-Phone diagnostic; the malformed original solution separately lacks Content configuration mappings, and a host Windows run cannot supply Phone/XAP isolated-storage application identity. All five format-reference XNBs convert and 13/13 CNA content tests pass. Choose a distinct faithful Phone product, a canonical merged GSM generation, or retained historical support/non-port data. Evidence: samples/GameStateManagementPhone/missing.md.

SAMPLES-DEC-005 follow-up (2026-09-02): SAMPLE-128 is a complete Windows Phone 7 Silverlight bubble-level application, not an XNA game: all ten C# units, two XAML files and six localized resource tables are named by a Phone/XAP project with zero XNA references. Its product includes calibrated 25-sample sensor filtering, seven-way orientation, two theme-aware level UIs, adaptive angle text, bubble physics, six shell-name localizations and complete Phone lifecycle. Live CNA's real accelerometer foundation passes 89 executable tests (two real-hardware routes are skipped), while Sharp resources and isolated storage pass 8/8 and 63/63; neither repository owns the Silverlight/Phone UI, navigation, application-bar, dispatcher/storyboard or XAP stack, and Sharp lacks the exact IsolatedStorageSettings dictionary. The unchanged offline Win7 build honestly stops on the absent Phone Silverlight v4 targets required by the readme. Choose historical non-port, reusable support data only, or an explicitly scoped complete native/WEBGL2 application modernization; never invent an XNA wrapper or reduced bubble. Evidence: samples/LevelStarterKit/missing.md.

SAMPLES-DEC-005 follow-up (2026-09-02): SAMPLE-129 is a complete licensed six-file lobby/chat resource pack, not a runnable sample. Its five 64×64 RGBA icons represent voice available, muted, talking, local and ready states. Four are byte-identical compiled inputs of SAMPLE-062 NetRumble and its code selects them from real gamer voice/readiness state; the local house icon is collection-unique and unused. SAMPLE-075 owns four semantically parallel but distinct 28×28 icons. All five unchanged pack images build through the official XNA 4 Windows/Reach TextureProcessor, convert 5/5 through live CNA and pass 9/9 focused content tests. Choose resource-pack non-port, retained shared support data or a newly scoped lobby-status visualizer; do not invent a fake lobby or claim either network game as this directory's product. Evidence: samples/LobbyChatImages/missing.md.

SAMPLES-DEC-005 follow-up (2026-09-02): SAMPLE-130 is a complete XNA 2 Shader Series game, not merely an effect archive. Its 1,464 C# and 376 HLSL lines draw nine material instances, five mesh types and up to eight point lights with per-material diffuse/specular textures and Phong lighting. Fourteen of fifteen unchanged content items pass the official XNA4 Release pipeline; both material effects parse and bind on real GLES3, while the colour-only point-light effect is rejected solely for its obsolete ps_1_1 profile. The defining lesson, however, is XNA2 EffectPool propagation of seven HLSL shared declarations from one base effect into nine clones. XNA4/FNA expose no public EffectPool, and CNA/MojoShader deliberately give clones independent parameter storage. Per-clone fan-out would rewrite the main algorithm, while adding EffectPool is a legacy API/product decision. Choose a deliberately isolated legacy compatibility product, explicit XNA4 modernization including the measured point-effect profile migration and shared-state replacement, or historical non-port. Evidence: samples/MaterialsAndLightsArchive/missing.md.

SAMPLES-DEC-005 follow-up (2026-09-02): SAMPLE-131 is a complete XNA 2 strategy game, not a partial board/AI lesson. Its 3,311 C# lines implement a 10×10 Reversi-style product with one-player depth-three minimax, two-player input, six lit models, ten-frame drop animation, three result screens and an eight-cue XACT graph over nine source waves. All nineteen unchanged sources reach only the old GraphicsDevice.RenderState API when compiled against XNA4, and all sixteen visual runtime XNBs build and convert through CNA. The exact XACT2 project is the material blocker: XNA4 rejects its version, while no original banks or local XNA2 builder are available. Choose an authentic XNA2/XACT2 route plus the measured graphics-state migration, an explicit full XNA4/XACT3 modernization, or historical-game non-port; never omit/rewrite the authored cue graph silently. Evidence: samples/MinjieArchive/missing.md.

SAMPLES-DEC-005 follow-up (2026-09-02): SAMPLE-132 is a complete Windows Phone 7.1 Silverlight/XNA hybrid, not an ordinary tank-viewer Game. Its 2,077 C# and 330 XAML lines define seven navigated pages, 28 controls, 16 two-way bindings, dependency-property/Storyboard camera transitions, UI-to-texture compositing, shared-device lifecycle, touch orbit/pinch, five tank animations, renderer toggles and three editable lights. The sample-owned pipeline builds all six Phone XNBs; five stock items convert through CNA, while the custom reflective Sky uses the same closed AOT-reader boundary as SAMPLE-012. The offline Win7 solution builds the pipeline assembly but lacks Phone 7.1 Silverlight targets, and CNA/Sharp have none of the defining Phone/XAML/sharing stack. Choose faithful compatibility scope, explicit complete native/WEBGL2 modernization or historical non-port; never substitute a tank-only Game. Evidence: samples/ModelViewerDemoMango/missing.md.

SAMPLES-DEC-005 follow-up (2026-09-02): SAMPLE-133 is a complete XNA 2 moving-image puzzle game, not a video-texture demonstration. Its seven runtime/pipeline projects, 29,259 C# lines and 45,442 XML lines implement ten normal stages, ten movies, free-play configuration, save slots, layered scene animation, non-continuous tile texture coordinates, skinned animation, particles and an eleven-cue XACT2 graph. Unchanged runtime sources expose the expected removed XNA2 graphics/effect surface against XNA4. After only two explicitly isolated diagnostic migrations, the official XNA4 pipeline builds all 126 non-XACT items into 138 dependency-complete XNBs; the exact XACT2 project is rejected as incompatible. Live CNA validates 93 generic products and honestly refuses 45 sample-defined reader/tag, legacy-effect and collection graphs that a future closed C++ port must own. Choose an authentic XNA2/XACT2 route, an explicitly scoped complete XNA4 modernization including equivalent audio, or historical-game non-port. Evidence: samples/Movipa/missing.md.

SAMPLES-DEC-008 follow-up (2026-09-02): SAMPLE-133 adds a fourth reachable persistence product. SaveData serializes seven public properties for stage, play count, score, best result, time displays and file name while ignoring its TimeSpan convenience properties; normal-mode file selection loads, saves, deletes and advances those records. This object is smaller than SAMPLE-070's generic graphs, but it still uses the same public System.Xml.Serialization.XmlSerializer contract. Do not add a sample-specific parser while the owner's shared serializer ruling remains pending.

SAMPLES-DEC-005 follow-up (2026-09-02): SAMPLE-134 is a distinct complete XNA 2 Shader Series product, not a duplicate of SAMPLE-130. It shares twelve source assets and the namespace-only camera, but its 1,640 C# and 330 HLSL lines implement ambient-plus-additive multi-pass batching for 30 initial/300 maximum moving point lights, with one light per SM2 draw or up to twelve per SM3 draw. Nine cloned material effects rely on five XNA2 shared parameters propagated through the removed EffectPool; CNA/FNA's XNA4 clones are correctly independent. All 46 source diagnostics are known XNA2 API families. XNA4 Release builds 14/15 exact content items, exact ps_1_1 PointLightMesh alone needs a profile migration, and both material shaders parse/bind on real GLES3. Choose an isolated legacy compatibility product, explicit complete XNA4 modernization or historical non-port; never replace the pool with hidden per-clone fan-out. Evidence: samples/MultipassLightingArchive/missing.md.

SAMPLES-DEC-005 follow-up (2026-09-02): SAMPLE-135 is a pure Windows Phone 7 Silverlight navigation recipe with zero XNA references. Its 40-file delivery contains a separate two-page baseline app that demonstrates repeated-instance back-stack growth, a 362-line reusable singleton service, and a four-page corrected app that drives recursive Back navigation, cancellation, opacity, application-bar, query binding and tombstoning behavior. The exact 11-page document was rendered and fully inspected. Both unchanged app solutions select the correct Phone projects and stop on the missing Silverlight Phone v4 targets; both also reference an undelivered WindowsPhoneLogger.dll. Live CNA/Sharp have no Phone page/frame/navigation/XAP stack. Choose an evidence-backed historical non-port, complete retired-platform compatibility product, or explicit native/WEBGL2 modernization preserving both independently runnable applications and the library; never substitute a generic router, URI-list unit test or invented XNA Game. Evidence: samples/NonLinearNavigationService/missing.md.

SAMPLES-DEC-005 follow-up (2026-09-02): SAMPLE-136 is a complete Phone 7.1 Silverlight/XNA hybrid whose documentation explicitly makes mixed UI/rendering the product. Its 972 C# and 130 XAML lines provide a real Play/checkbox page, persistent two-way-bound sound setting, Phone lifecycle, shared GraphicsDevice mode and UIElementRenderer score composition over the touch-only 800×480 Pong game. All five unchanged Texture2D/SoundEffect items build through the official WindowsPhone/Reach pipeline, convert 5/5 and pass 17/17 focused CNA tests; content is not the blocker. The unchanged host build lacks Phone 7.1 targets, and the C# delivery additionally retains a measured PinballBattleLib path typo. Live CNA/Sharp have no defining Phone/Silverlight/XNA sharing stack. Choose historical non-port, full retired-platform compatibility or an explicit complete native/WEBGL2 hybrid modernization; never substitute a Pong-only Game, hard-coded score sprites or fake settings UI. Evidence: samples/PaddleBattle/missing.md.

SAMPLES-DEC-005 follow-up (2026-09-02): SAMPLE-137 is the complete Visual Basic delivery of SAMPLE-136's Phone 7.1 hybrid: eight source/shell assets, three semantic XAML trees and all five rebuilt WindowsPhone/Reach XNBs match, with 5/5 CNA conversion and 17/17 focused tests passing. It is not merely interchangeable packaging. The VB project fixes the C# PinballBattleLib path, has distinct Phone/assembly identity, and exact Microsoft-compiled gameplay proves CInt collision-coordinate rounding (2,-2) where C# truncates (1,-1) at position (1.6,-1.6). Choose the joint hybrid-platform boundary and C#-canonical, VB-canonical, separately faithful or reference-only identity; never silently duplicate or normalize the product. Evidence: samples/PaddleBattleVB/missing.md.

SAMPLES-DEC-005 follow-up (2026-09-02): SAMPLE-138 is a complete XNA 2 sliding-picture puzzle, not a generic board lesson. Its 4,473 runtime C# lines implement five 3×3–10×10 one/two-sided modes, study/shuffle/play/completion states, row/column shifts, independent chip/board rotation, eleven photographs, a tangent-generating/tagging model processor, anisotropic shader and five-cue XACT2 graph. The unchanged source reaches exactly 20 bounded XNA2→XNA4 API diagnostics. Official XNA4 Release builds all 22 non-XACT items; the exact two-pass effect parses/binds on real GLES3, while XACT2 is rejected as version-incompatible. CNA converts 20 items and honestly refuses native CNB representations for EffectReader and the chip model's required Front/Back String tags. Choose an authentic XNA2/XACT2 route, explicit complete XNA4/audio modernization or historical-game non-port; never drop audio, two-sided behavior or model tags. Evidence: samples/PicktureArchive/missing.md.

SAMPLES-DEC-004 / SAMPLES-DEC-005 follow-up (2026-09-02): SAMPLE-139 is a complete non-XNA product comprising a 2,574-line Phone Silverlight client, 1,408-line reusable MPNS message library and 2,497-line WPF server plus 1,537 total XAML lines, two WCF services and a 22-page recipe. The unchanged message library and server build, and the server runs all five WPF pattern tabs headlessly after both service hosts open; the Phone client stops at the absent Phone Silverlight targets. It reuses all 212 normalized lines and the semantic style of SAMPLE-124's progress control, but shares only two generic scaffold files with focused SAMPLE-105. Live CNA/Sharp has none of the Phone shell/channel/schedule, Silverlight, WPF, WCF, MEF or settings stack. Choose a historical non-port, faithful retired-platform route or explicitly scoped complete modern two-product system; never substitute a fake channel, local echo, server-only target or invented Game. Evidence: samples/PushRecipeWP7SL/missing.md.

SAMPLES-DEC-005 follow-up (2026-09-02): SAMPLE-140 is Microsoft's complete licensed XNA Game Studio font support pack, not a runnable sample. Its 28 exact TrueType SFNTs all cover U+0020–U+007E, render successfully and pass the official XNA 4.0 Windows/Reach SpriteFont pipeline; CNA converts all 28 XNBs to self-contained 95-character CNBs and 23/23 focused real-GLES3 content/runtime tests pass. Across the source collection, 171 of 220 SpriteFont declarations in 67 sample directories reference nine supplied families, and no duplicate TTF exists elsewhere. The document permits original-format redistribution as part of an XNA game but does not deliver a project, code, entry point or viewer. Choose licensed shared-support archive/non-port, explicit design-time packaging under those terms or a newly scoped gallery product; never invent a game from the audit preview. Evidence: samples/RedistributableTTFsArchive/missing.md.

SAMPLES-DEC-002 / SAMPLES-DEC-005 / SAMPLES-DEC-008 follow-up (2026-09-02): SAMPLE-142 is Microsoft's complete licensed XNA 2 Robot Game Kit: two Windows/Xbox solutions, 109 C# units / 36,622 lines, two campaign stages, split-screen versus, advanced particles, animation, collision, normal/specular mapping, post-processing and a 55-cue XACT2 graph (52 mapped by the game). Its 358-item main content project includes 253 animation, 35 particle, four collision-tag and three shader-model custom-processor routes; 31 loose gameplay/particle-list XML files also use System.Xml.Serialization.XmlSerializer at runtime. The now-working offline Win7 VM contains the exact source but only XNA4, no XNA2 SDK and no retained executable/XNB/XACT products. Unchanged runtime source reaches 117 XNA2→XNA4 diagnostics. XNA4 builds 63/65 stock candidates into 126 XNBs, rejects two legacy effect sources and the exact XACT2 project, and cannot honestly stand in for the excluded 296 custom/XACT items. CNA converts 124 diagnostic products and passes 156/156 focused real-GLES3 tests; typed/dictionary model tags already work, so no runtime workaround was added. Choose an authentic XNA2/XACT2 route with exact processor products, an explicitly complete XNA4/effect/audio modernization, or historical-game non-port. Separately qualify the owner-managed shared serializer after the owner declares it ready; XML alone does not resolve the older-XNA and content decisions. Evidence: samples/RobotGameArchive/missing.md.

SAMPLES-DEC-002 / SAMPLES-DEC-005 / SAMPLES-DEC-008 follow-up (2026-09-02): SAMPLE-143 is a materially distinct Windows Phone 7 edition of Role Playing Game, not a duplicate directory of SAMPLE-070. Only 64 of 140 C# units match exactly; gesture input, 800x480/30 Hz presentation, scaling, map unload/reload state, isolated storage and direct SoundEffect audio are Phone-specific. Its 1,032-item content generation has 992 differing shared assets. The offline Win7/XNA4 VM has no Phone targets, but the official pipeline host generated 1,031 exact XNBm products and stopped only on unavailable Arial Narrow for DebugFont. CNA converts all 750 stock products, refuses the 281 unregistered sample-owned readers without lying and passes 156/156 focused real-GLES3 tests. The current desktop C++ port's runtime parsing of those 281 source XML files remains the forbidden SAMPLE-070 workaround. Choose a separate Phone target, an explicitly complete merged generation or historical Phone non-port, plus an exact DebugFont/custom-reader boundary. Its 34 live XmlSerializer construction sites also extend DEC-008; do not assess the owner-managed XML branch until the owner declares it ready. Evidence: samples/RolePlayingGamePhone/missing.md.

SAMPLES-DEC-005 follow-up (2026-09-02): SAMPLE-144 is a complete Windows Phone 7.0 Silverlight recorder application, not an ordinary XNA Game and not an alias of SAMPLE-098. Its 369 C# and 77 XAML lines define Phone lifecycle/frame setup, one portrait page, a three-button ApplicationBar and exact record/stop/play state transitions; only the capture/playback core uses XNA Microphone, FrameworkDispatcher, raw SoundEffect and SoundEffectInstance. The unchanged offline Win7 Release build selects the exact project and stops at the absent Phone Silverlight v4 targets required by its readme. Live CNA's actual audio path passes 198/198 focused tests, and the retained SAMPLE-098 Chrome result proves real getUserMedia permission, non-flat capture and 600 WebGL2 frames; microphone fidelity is not the blocker. CNA/Sharp have no System.Windows/ Microsoft.Phone XAML/page/ApplicationBar/lifecycle/XAP stack. Choose historical non-port, complete retired-platform compatibility or an explicitly scoped full native/WEBGL2 recorder modernization; never substitute a generic Game, HTML mock-up or SAMPLE-098's waveform product. Evidence: samples/SilverlightMicrophoneSample/missing.md.

SAMPLES-DEC-004 follow-up (2026-09-01): SAMPLE-105 now supplies the focused MPNS case. Its unchanged WinForms sender and WindowsPhone/Reach content build in the offline Win7 VM, while the actual product still requires service-issued HttpNotificationChannel URIs, foreground raw and toast callbacks, and Windows Phone shell toast/tile behavior. The owner must separately choose evidence-backed non-port, a faithful reusable service plus shell integration, or an explicitly modernized two-product notification contract. Evidence: samples/PushNotifications/missing.md.

SAMPLES-DEC-004 follow-up (2026-09-01): SAMPLE-106 isolates the Windows Phone photo-library boundary. Its unchanged Phone/Reach pipeline builds all four exact XNBs, and live CNA passes 77/77 focused native XNB/JPEG/MediaLibrary/Guide tests. WEBGL2 still has no Pictures user folder, so the normal MediaLibrary.SavePicture chain necessarily throws; additionally, CNA's current EndShowMessageBox throws while pending instead of honoring XNA's documented blocking contract unless sample code manually renders a CNAEXT overlay. Choose evidence-backed Phone-only non-port, authorize a reusable browser/native media-save contract plus automatic Guide integration, or explicitly approve and define a narrower modernization. Evidence: samples/SavingEmbeddedImages/missing.md.

SAMPLES-DEC-004 follow-up (2026-09-01): SAMPLE-110 isolates Windows Phone music ownership and external-task lifecycle. Its unchanged official content project builds an authentic Song XNB/WMA; the XNB is byte-identical to SAMPLE-060's qualified Song and 68/68 focused CNA Song/MediaPlayer/ Guide tests pass. The product still requires GameHasControl to represent user music and distinct video-launcher, photo-chooser and web-browser deactivate/reactivate playback behavior; all three Phone tasks are absent, while Guide UI is caller-rendered through extensions. Choose evidence-backed Phone-only non-port, authorize reusable platform tasks plus automatic Guide/audio lifecycle across native and browser targets, or explicitly approve a defined modernization. Evidence: samples/WP7MusicManagement/missing.md.

SAMPLES-DEC-005 follow-up (2026-09-01): SAMPLE-111 is a standalone C++/CLI WinForms utility that compares GraphicsAdapter.IsProfileSupported with a full independent native D3D9 caps/format audit and exports the detailed HTML/plain-text result. Its documentation requires VC++ 2010 and the DirectX SDK; the offline VM lacks VCTargetsPath, cl.exe, vcvarsall.bat and the VC MSBuild props, so the unchanged Release/Win32 build cannot proceed. Live CNA passes 33/33 focused adapter and renderer-capability tests and has real D3D9 profile probes plus a separate cross-renderer RendererCapabilityProfile, but neither turns a WEBGL2 report into the original D3D9 diagnosis. Choose evidence-backed non-port, provide the original prerequisites and authorize a faithful Windows/native-only exception, or explicitly authorize a distinct CNA capability-viewer modernization. Evidence: samples/XnaGraphicsProfileChecker/missing.md.

SAMPLES-DEC-004 / SAMPLES-DEC-005 follow-up (2026-09-01): SAMPLE-112 is a licensed asset-only delivery: 21 distinct STRB animation binaries, an Ms-PL RTF and one UTF-16BE PowerShell script, with no project, code, documentation or declared consumer. The script names a missing AvatarAssetConverter_e.exe and invokes an undefined variable. Live CNA has no STRB contract; 76/76 focused normal/substitute-boundary Avatar tests pass offscreen, but the normal renderer remains unavailable/no-op and its CNAEXT renderer is not authentic. Choose an evidence-backed non-port/archive, classify the pack as retained future-backend support data, or authorize a format-backed importer plus explicitly modernized preview product. Evidence: samples/AvatarAnimPackBIN/missing.md.

SAMPLES-DEC-004 / SAMPLES-DEC-005 follow-up (2026-09-01): SAMPLE-113 is the valid source counterpart to the binary pack: 21 distinct 9.4–9.8 MB Kaydara FBX 6.1 Avatar animations and an Ms-PL RTF, with no project, source, documentation or standalone consumer. A documentation-backed diagnostic fed every unchanged file through the official XNA 4.0 FbxImporter and exact CustomAvatarAnimationProcessor; all 21 produced deterministic Xbox360/HiDef XNB v5/LZX output. Content validity/pipeline work is therefore not a blocker. Choose evidence-backed archive/non-port, retained support data for SAMPLE-094/future faithful Avatar work, or an explicitly new 21-clip preview product with authentic-versus-substitute renderer scope. Evidence: samples/AvatarAnimPackFBX/missing.md.

SAMPLES-DEC-004 / SAMPLES-DEC-005 follow-up (2026-09-01): SAMPLE-114 is the editable Maya 2009 companion: 21 substantial ASCII scenes plus 220 TGA textures, ten swatches and an Ms-PL RTF. Every scene has 104 joints, 30 meshes, one BASE__Skeleton and 202–238 animation curves; all 21 names pair with the validated SAMPLE-113 FBX pack. There is no project or runtime product, while authentic scene export requires absent proprietary Maya Unlimited 2009/Mayatomr. Choose archive/ non-port, retained authoring support data, or an explicit modern-DCC migration/tool plus any newly defined preview scope. Evidence: samples/AvatarAnimPackMaya/missing.md.

SAMPLES-DEC-004 / SAMPLES-DEC-005 follow-up (2026-09-01): SAMPLE-115 is the documented Softimage Mod Tool 7.5 counterpart: 21 substantive OLE Compound Document .exp scenes, 125 valid textures/screenshots, an HTML workflow and an Ms-PL RTF. Its instructions define project-relative texture loading, bone-plotting and Crosswalk 3.3 FBX export; all 21 scene names pair exactly with the validated SAMPLE-113 FBX pack. Authentic export requires the absent retired proprietary Softimage/Crosswalk environment, and upstream supplies no runtime product. Choose archive/non-port, retained editable authoring support data, or an explicit modern-DCC migration/tool plus any newly defined preview scope. Evidence: samples/AvatarAnimPackModTool/missing.md.

SAMPLES-DEC-004 / SAMPLES-DEC-005 follow-up (2026-09-01): SAMPLE-116 is one reusable Autodesk 3ds Max 2010 base rig rather than another finished animation pack. Its 239 files include a substantive 8.56 MB OLE .max scene, 220 TGA textures, ten swatches and illustrated HTML export instructions; the texture/swatch hash multiset exactly matches SAMPLE-114. The documented FBX 2009.0 path uses baked animation, skin/morph deformation and geometry-as-bones, but authentic export requires absent proprietary 3ds Max. Upstream supplies no runtime product. Choose archive/ non-port, retained editable authoring support data, or an explicit modern-DCC migration/tool plus any newly defined preview scope. Evidence: samples/AvatarRigMax2010/missing.md.

SAMPLES-DEC-004 / SAMPLES-DEC-005 follow-up (2026-09-01): SAMPLE-117 is the reusable Maya 2009 base rig corresponding to SAMPLE-114's finished Maya animations. Its 234 files include one 178,173-line scene, 220 TGA textures, ten swatches and illustrated FBX 2009.2 instructions. The base and every authored scene have 104 joints, 30 meshes and one BASE__Skeleton; the base has six animation curves versus 202–238 per finished clip, and their 230 texture/swatch payloads match exactly. Authentic export requires absent proprietary Maya Unlimited 2009/Mayatomr. Choose archive/ non-port, retained editable authoring support data, or an explicit modern-DCC migration/tool plus any newly defined preview scope. Evidence: samples/AvatarRigMaya2009/missing.md.

SAMPLES-DEC-004 / SAMPLES-DEC-005 follow-up (2026-09-01): SAMPLE-118 is the reusable Softimage Mod Tool 7.5 base rig corresponding to SAMPLE-115. Its 128 files include one 6.44 MB OLE .exp scene, 119 rig textures and the full illustrated authoring workflow. Documentation and every picture are byte-for-byte identical to the animation pack; the base and all 21 authored scenes share the 30-stream container/version identity, while their internal model sizes distinguish the clean rig from finished clips. Authentic export requires absent retired Softimage/Crosswalk. Choose archive/non-port, retained editable authoring support data, or an explicit modern-DCC migration/tool plus any newly defined preview scope. Evidence: samples/AvatarRigSoftimageModTool75/missing.md.

SAMPLES-DEC-005 follow-up (2026-09-01): SAMPLE-119 is only a licensed three-file XNA 2.0 educational delivery: one 685-line monolithic BasicEffect shader, HTML documentation and an Ms-PL RTF, with no project, compiler, blob or runtime product. It is materially different from the XNA 4/FNA shader and uses twelve vs_1_1, eight ps_1_1 and four ps_2_0 compile entries. The official XNA 4 pipeline predictably rejects it because ps_1_x is no longer supported; current CNA XNA 4 BasicEffect/content/C API/render gates pass. Choose archive/non-port, historical support data, or an explicit legacy-shader compiler/tool/product scope. Evidence: samples/BasicEffectShaderArchive/missing.md.

SAMPLES-DEC-002 / SAMPLES-DEC-005 follow-up (2026-09-02): SAMPLE-146 is a complete XNA 3.0 Windows/Xbox space-combat game, not a partial tutorial: 4,670 runtime C# lines, 304 custom- processor lines and 1,076 HLSL lines implement flight/combat/AI, collision/damage, win/lose, HUD, audio, bloom, a planet/atmosphere/sky and eleven particle configurations. The processor assembly compiles unchanged against XNA4, while the unchanged game reaches removed ResolveTexture2D and RenderState types before member binding; a complete scan retains the further legacy state, vertex-stream, point-sprite and Effect-pass sites. Microsoft's XNA4 Particle3DSample replaces the defining one-vertex/PSIZE point renderer with indexed billboard quads, and its BloomSample replaces back-buffer resolve with a scene RenderTarget2D. After only isolated effect-compiler migrations, the exact 29-row project builds 38 XNBs through XNA4 and all eleven compiled effects parse; seven full shader-pair effects bind on real GLES3, while the legacy particle pair precisely fails because its hardware point-coordinate fragment input has no vertex output. CNA validates 24 generic CNBs and truthfully refuses eleven raw effects plus three custom-material models; 90/90 focused content tests and 32/33 EasyGL effect tests pass with one unrelated known skip. Choose an isolated authentic XNA3 compatibility product, a complete XNA4 modernization following the official precedents, or historical-game non-port. Evidence: samples/SpaceShooterArchive/missing.md.

SAMPLES-DEC-005 follow-up (2026-09-02): SAMPLE-147 is only a complete three-file pre-XNA4 educational SpriteBatch shader archive: one 135-line HLSL source, documentation and an Ms-PL RTF, with no project, compiled Effect, executable or runtime product. The directory says ARCHIVE_2_0, while the documentation itself carries XNA_30 metadata, so no false exact-version identity is claimed. Its Windows branch normalizes pixel/texture coordinates and its Xbox branch uses five vfetch instructions to expand one sprite vertex into four corners; both belong to the old undocumented SpriteBatch/shader interface. The unchanged source is rejected by the official XNA4 compiler only because ps_1_x is retired. Microsoft's materially different XNA4 SpriteEffect.fx is byte-identical to FNA after newline normalization, its exact compiled blob parses and binds on real GLES3, and 5/5 compiled SpriteBatch tests plus focused custom-uniform, viewport and flip render gates pass. Choose archive/non-port, historical support data or an explicit legacy-shader/compiler/product scope. Evidence: samples/SpriteBatchShaderArchive/missing.md.

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	Code/behavior was 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. Content defect closed 2026-09-06: the unchanged content project now goes through XNA 4.0's own BuildContent for Windows/Reach, and the port ships that product -- hudFont.xnb, 13,486 bytes, an XNBw container with a 128x64 DXT3 sheet, 95 glyphs, LineSpacing = 18 -- with the hudfont.cnj and loose PNG deleted and the WEBGL2 .data package exactly 13,486 bytes. The reference executable was re-run on that same font (its IL first confirmed to draw the HUD with one DrawString over a three-line string), and the two engines' HUD blocks agree on 99.89 % of pixels exactly, MAE 0.161/255, glyph ink tops on rows 53/71/89 in both. One measurement trap recorded: capture the XNA reference on a screen larger than the window, or Wine's decoration leaves an 800x460 client, XNA presents its 480-row back buffer squashed into it, and the HUD's line pitch reads 17 instead of the XNB's 18 -- indistinguishable from a font-metric defect and not one. Native OPENGLES3 cycles all five primitives, the colour and the wireframe toggle to a clean exit. The 2026-09-12 WEBGL2 requalification uses a 7,597,469-byte Release WASM with Emscripten threads disabled; it runs from ordinary static HTTP in real Chrome with crossOriginIsolated = false for 600 frames, every control changes the frame, and no runtime or fatal console error occurs. No framework change was needed. Evidence: samples/Primitives3D/missing.md.	✅
SAMPLE-003	TexturesAndColorsSample_4_0	port	Line-by-line XNA 4.0 audit is complete with the five original models, 13-technique compiled effect, camera, grid, HUD, input and SampleGrid's public IDisposable::Dispose() lifecycle. Runtime content consists only of eight pregenerated Microsoft XNA 4.0 XNBs; Clouds.xnb is the corrected official ten-mip output and the loose PNG is absent. Release OPENGLES3 and non-threaded WEBGL2 pass all 13 techniques, five models and exit behavior; the real-Chrome run has no relevant errors. Evidence: samples/TexturesAndColors/missing.md.	✅
SAMPLE-004	StockEffectsSample_4_0	samples/StockEffects	Owner-selected Content Pipeline-only port completed 2026-09-12. The upstream package has no Game, so the port provides its real runnable product — the four-file CompileEffect CLI using CNA's XNA-shaped EffectImporter and EffectProcessor — and intentionally creates neither a native game demo nor a web target. The educational wrapper library is not replaced with aliases to CNA built-ins. Porting fixed two general CNA defects instead of adding sample workarounds: stock-effect shader-array sampler masks now match XNA (1,1,3,3,1,1), and DirectionalLight now has the parameter-bound XNA/FNA behavior. Release CompileEffect built and compiled all six original .fx sources; every output matches XNA's byte length and container/mask header. Full byte identity is not claimed because the retained XNA tool embeds HLSL compiler 9.26 output and the available June 2010 compiler is 9.29. Evidence: samples/StockEffects/missing.md; translation boundary: samples/StockEffects/diff.md.	✅
SAMPLE-005	ReachGraphicsDemo_4_0	port	Requalified against the unchanged XNA source and pipeline: original XNA, native OPENGLES3 Release and non-threaded WEBGL2 Release all exercise the title plus six real-content demos. Namespace/type identities and the inactive phone branch match upstream; explicit AOT reader registration is documented, all current artifacts are reproducible, and the web bundle is published. Evidence: samples/ReachGraphicsDemo/missing.md.	✅
SAMPLE-006	SpriteEffectsSample_4_0	port	Requalified on 2026-09-13 against the unchanged live XNA 4.0 original and custom pipeline: all eight XNBs are byte-identical, the original SpriteEffects namespace is restored, and no loose image/shader, overlay or renderer workaround is present. Fresh Release OPENGLES3 and non-threaded Release WEBGL2 products exercise all five animated modes, Space/A transitions and Escape/Back exit; system Chrome reports WebGL2, zero GL/runtime errors and successful bundle requests. Reproducible artifacts are current; the web publication was pushed in samples.libcna.com at 485c0d7. Evidence: samples/SpriteEffects/missing.md; C++ adaptation: samples/SpriteEffects/diff.md.	✅
SAMPLE-007	SpriteSheetSample_4_0	port	Requalified on 2026-09-13 from the unchanged 35-file source through the custom processor, original XNA runtime, Release OPENGLES3 and non-threaded Release WEBGL2. The three canonical XNBs match across products; animation and Escape/Back pass; static labels and atlas are pixel-identical across all runtimes. No code or dependency change was needed. The verified web bundle is published and pushed in samples.libcna.com at e807c3b. Evidence: samples/SpriteSheet/missing.md.	✅
SAMPLE-008	ShapeRenderingSample_4_0	port	Requalified on 2026-09-13 from the exact 16-file source. Restored the omitted Phone timing/fullscreen branch; XNA IL proves 7 Debug and 0 Release renderer calls. Fresh XNA Debug, OPENGLES3 Debug/Release/Phone and non-threaded WEBGL2 Debug/Release gates verify the exact five rotating colored shapes, blank Release semantics, Escape/Back and zero runtime/GL errors. The static-host bundle uses Release code generation with the selected original Debug semantic symbol, has no DWARF/pthreads, and was browser-gated after gallery copying at site commit 0a068c8. No framework fix, content, stub or workaround was needed. Evidence: samples/ShapeRendering/missing.md; build-profile adaptation: samples/ShapeRendering/diff.md.	✅
SAMPLE-009	InputReporter_4_0	port	Freshly requalified on 2026-09-13 from the exact 31-file source. All resource strings and original asset identifiers are preserved; no code change or workaround was needed. Fresh XNA and Release OPENGLES3 captures are pixel-identical. Non-threaded Release WEBGL2 passes keyboard, complete standard-gamepad, two-second charge-switch, exit, WebGL and error gates in Chrome; the verified site copy is identical. All 15 official XNBs remain: the current pipeline reproduces all 9 textures byte-for-byte, while 6 host-sensitive Arial rebuild differences are recorded rather than replacing the verified font XNBs. Evidence: samples/InputReporter/missing.md.	✅
SAMPLE-010	InputSequenceSample_4_0	port	Freshly requalified on 2026-09-13 from the exact 30-file upstream directory; the old snapshot's missing solutions, HTML and license were restored. The unchanged port preserves all nine moves, stable longest-first shallow matching, logical buffer capacity and original timeouts without a workaround or code change. Fresh XNA and Release OPENGLES3 baseline plus all nine move captures are pixel-identical. Non-threaded Release WEBGL2 passes all moves, Escape, HTTP, WebGL and error gates in Chrome, with pixel-identical game pixels; its verified site copy is identical. All 15 official XNBs remain: the current pipeline reproduces 14 textures byte-for-byte, while the host-sensitive Miramonte font difference is recorded rather than replacing the verified XNB. Evidence: samples/InputSequence/missing.md.	✅
SAMPLE-011	SafeAreaSample_4_0	port	Freshly requalified from the corrected exact 16-file upstream root: the source, content projects and Windows/Xbox branches match, including the original XBOX && DEBUG diagnostic component instead of an always-on overlay. The real XNA pipeline reproduces both textures exactly; Segoe UI Mono rasterization is host-sensitive, so the verified official font XNB is retained with the regenerated hash recorded. XNA, Release OPENGLES3 and non-threaded Release WEBGL2 render a pixel-identical 1280x720 baseline, A is inert, Right scrolls and Chrome reports no error; the exact gallery copy passes again. No sample, CNA or sharp-runtime code change, workaround or missing dependency was needed. 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	Complete after a general CNA Doppler repair and fresh native/browser verification. The port and seven stock XNBs remain exact; CNA previously multiplied the completed Doppler ratio by the sample's global scale 0.1, changing stationary animal sounds to pitch 0.1 instead of XNA's 1.0. CNA commit e1d3aa5d5 follows Microsoft XNA 4.0 KernelSoundEffectInstance.Apply3D IL; its two new regressions are red/green and all 95 SoundEffectInstanceTest.* cases pass. Clean Release OPENGLES3 records real 44.1 kHz stereo and restores the dog rest interval (old post-start activity 99.83% with no silence; fixed 84.82% with a 0.61 s silent run). Clean WEBGL2 builds and the owner confirmed the corrected animal sounds in-browser after serving the worker bundle with the required COOP/COEP headers. SharpRuntime commit eebebd86 remains the general Double dependency. Evidence: samples/Audio3D/missing.md.	✅
SAMPLE-060	SoundAndMusic_4_0	port	Complete with the authentic Song contract and owner-approved desktop pointer access. All five source/assembly units retain the 480x800 fullscreen, 30 Hz timing, eleven DrawableGameComponent controls, four drags, SoundEffect/Song state transitions and device/emulator volume branch. One marked, off-by-default CNAEXT opt-in maps the left mouse button into the unchanged TouchPanel path; no parallel mouse API, Escape/F1 control or loose-content path was added. The ten checked-in Phone/Reach XNBs plus WMA are byte-identical official XNA output. A deterministic Ogg-FLAC sibling preserves the WMA's decoded PCM bit-for-bit for SDL3_mixer without changing the XNB or content identity. General CNA fixes provide Microsoft.Devices.Environment (a66fc61b5) and nested external-media resolution for XNA backslash asset names (0a6158e4f, 13 focused tests). The unchanged XNA audit host loads/renders the authentic Windows pair; the original Release OPENGLES3 and real-Chrome WEBGL2 gates exercise every control with real stereo audio. A clean native requalification drives every button/drag directly through the new mouse-touch opt-in without the former evidence shim and records real stereo audio; a clean WEBGL2 bundle builds, and the owner confirmed pointer operation plus audible sound and music in-browser. Evidence: samples/SoundAndMusic/{missing,diff}.md.	✅

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

Task	Upstream directory	Existing	Fresh audit focus	Status
SAMPLE-061	MarbleMaze_4_0	port	Owner-approved mouse-to-touch requalification is complete; the final EX2_Polishing/End restoration remains intact. All 24 game sources plus the custom processor and its assembly metadata were audited; screen persistence, isolated high scores, async Guide naming, accelerometer/emulator/calibration branches, native background loading, collision, audio and the full menu/gameplay/pause flow are retained. One marked, off-by-default CNAEXT opt-in maps desktop pointer input into the unchanged TouchPanel contact/gesture path; no parallel mouse API is introduced. Emscripten loads gameplay assets on the WebGL-context thread because Firefox cannot create the model's WebGL buffers from the Phone sample's background loader; the native path remains threaded. The official XNA pipeline produced 26 Windows and 26 Phone Reach XNBs; the checked-in Phone set is byte-identical and restores the real Content.Load<Model>/Model.Tag Dictionary<string,List<Vector3>> path. RawMesh, JSON/raw buffers, loose PNG/WAV/font data, hard-coded collision/markers, culling repair, STL persistence, fixed player name, omitted calibration and F1 UI are gone. General fixes: cnanext 17b5a90a0 (typed Tag dictionaries), 71576a7b9 (threaded EasyGL content/frame context ownership and Wasm wiring), sharp-runtimenext 4a49afb0 (opt-in Wasm threads), meta-gl eaf0788 (safe thread-local GL initialization). Fresh OPENGLES3 and Firefox WEBGL2 builds pass; Firefox reaches rendered gameplay without console errors, and the owner confirmed native arrow-key control. The unchanged phone source/content builds; Wine cannot provide a real phone host, and the now-bootable VM is deferred on its invalid saved guest-login credential, accurately recorded without claiming a visual original run. Evidence: samples/MarbleMaze/{missing,diff}.md.	✅
SAMPLE-062	NetRumble_4_0	port	The owner-approved native-only OPENGLES3 port is complete. All 49 original C# source units are represented by the C++ port, with only necessary ownership/reference/event/reflection translations recorded in diff.md; all four official effects, 28 textures, three fonts, 15 sounds, six verbatim XML particle graphs and the authentic 366.085-second One Step Beyond.xnb/WMA output are retained. The particle graphs deserialize through shared Sharp Runtime XmlSerializer(Stream&), not a sample parser. A reused-PacketWriter packet-length defect was fixed and regression-tested in CNA (1704c3273); the required streamed XML and DirectoryInfo.GetFiles surfaces were added and fully tested in Sharp Runtime (bfc826e1). Fresh native OPENGLES3 build and runtime qualification pass. Two independent processes completed real System-Link create/find/join, displayed both players in the lobby, marked both ready and rendered synchronized two-ship gameplay. No WEBGL2 target or browser artifact exists by the explicit SAMPLE-062-only owner decision. Evidence: samples/NetRumble/{missing,diff}.md; decision: SAMPLES-DEC-006.	✅
SAMPLE-063	HoneycombRush_4_0	port	Completed the full 31-source EX2 Windows Phone/Reach endpoint. Replaced all loose PNG/WAV/font substitutes with 47 official-pipeline XNBs, including the authentic Win7 SongProcessor XNB/WMA pairs, and retained both verbatim XML inputs. Restored real XML parsing, native background threads, Guide keyboard input, isolated storage, screen serialization, genuine touch, fullscreen/timing and every menu/gameplay/audio path. The touch-only UI opts into CNA's owner-approved mouse-to-touch extension. Emscripten performs the two gameplay asset loads on the WebGL context-owning game thread because Firefox otherwise remains indefinitely on Loading; native keeps the original threads. Debug/Release OPENGLES3 and real Chrome WEBGL2 pass the full title/instructions/load/gameplay/move+smoke/pause/resume route. Firefox WEBGL2 separately passes title/instructions/load/gameplay/smoke with ordinary mouse events and no recorded runtime error. Neither browser uses a touch shim or CDP touch emulation. Evidence: samples/HoneycombRush/{missing,diff}.md.	✅
SAMPLE-064	HoneycombRushTrainingKit_4_0	absent	Fresh audit proves this is a distinct staged multi-platform lab, not redundant with SAMPLE-063. Starter is a 41-unit phone/Reach game, Ex1 adds Windows/HiDef keyboard/storage/scaling paths, and final Ex2 adds phone/Windows/Xbox gamepad, safe-area, Guide and debug-tool deltas. The offline Win7 XNA pipeline completed the exact final 50-item Windows/HiDef project and exported authentic XNB/WMA pairs for both Songs, eliminating the codec blocker. On 2026-09-05 the owner explicitly cancelled this row and decided that none of its three teaching stages will be ported. No port or workaround was added; the audit and original-build evidence remain available. Evidence: samples/HoneycombRushTrainingKit/missing.md; decision: SAMPLES-DEC-005.	⛔
SAMPLE-065	NinjAcademy_4_0	port	Re-ported whole: all 33 game units, the four NinjAcademyCommonTypes units and the content the four NinjAcademyPipeline units build. The upstream declares only a Windows Phone platform (Debug and Release) and takes its lifecycle from Microsoft.Phone.Shell, so the game cannot be executed on this host; the official pipeline can, and all 47 .xnb are byte-identical to its Content-phone output, including both reflective objects and the Win7-produced Song. Its lossless .oga companion is generated from the original WAV rather than the lossy WMA, so it decodes bit-identically to the PCM the pipeline itself consumed. Every 2026-07 deviation is gone -- tombstoning, NameEntryScreen, plain-file high scores, InputState mouse synthesis, synchronous loading, hand-translated XML and the F1 overlay -- and ExtensionMethods.cs, CompareScores, InitializeMapping the two C# events now use System::EventHandler with += and sender, Stack/Dictionary/ArgumentOutOfRangeException replace their STL stand-ins, and the upstream spelling SubCreateBambooSliceComponets are restored. Five framework defects, all fixed in cnanext: a reflective Point field could not be read (22e89f18f); a visible Guide withheld nothing from the game, so a tap outside the box re-triggered the menu entry behind it and terminated on "A message box is already pending" -- and the release of the answering click still reached the game, starting a second content load whose screen had already lost the saved state, which is why resume showed a score of 0; Game's ordered component lists were written by the XNA loading-thread pattern while a frame iterated them (3/8 runs aborted before the fix, 0/8 after); and Game kept calling a component removed mid-frame, which MainMenuScreen's own every-frame rebuild of its loading screen made reproducible (4/4 aborts without the fix); and GameComponentCollection did not hold the strong reference XNA's Collection<IGameComponent> does, which is what let the abandoned screens' components dangle at all -- an ownership-taking Add overload replaced the sample-side bookkeeping the first pass had kept. Native OPENGLES3 drives the whole game to a clean exit -- countdown, shuriken, sword slash, pause/resume/quit, high scores -- and with a seeded State.txt the real Guide message box resumes into a HUD reading Score: 1200 with three of five hearts. WEBGL2 runs in real Chrome over 600 frames with no runtime or fatal console error, and Firefox 140 ESR is checked independently. Evidence: samples/NinjAcademy/{missing,diff}.md.	✅
SAMPLE-066	ShipGame_4_0	37 units	Full port of both runtime projects: ShipGame (28 .cs) and BoxCollider (9 .cs). Content is the official XNA 4.0 Content Pipeline output -- 159 XNBs plus sounds.xgs, Wave Bank.xwb, Sound Bank.xsb and ten loose level/light/ship XML files -- built from the unchanged ShipGameContentWindows.contentproj with the unchanged NormalMappingModelProcessor. Native OPENGLES3 and real-Chrome WEBGL2 both run intro, ship selection, level selection, gameplay and the end screen; the native frames match the retained original captures. Five framework defects found and fixed in cnanext, none worked around: FX-129 a compiled pass's shader pair silently not becoming the bound program, FX-130 a D3D9 pixel-shader input no vertex shader writes, FX-131 a short SetData shrinking the buffer a later draw may read, FX-132 a 1e10 shader constant breaking MojoShader's float printer on wasm32, and FX-133 the patch series that could not be applied twice. Evidence: samples/ShipGame/missing.md, samples/ShipGame/diff.md; decision: SAMPLES-DEC-008.	✅
SAMPLE-067	CatapultWars_4_0	port	Restored from the complete EX2 endpoint with no sample workaround. All 21 original game units retain the screen manager, XML-driven animation, touch gestures, vibration, 30 Hz/fullscreen phone setup, human/AI state machines, background Thread, GameComponent audio manager and isolated-storage screen persistence. The unchanged Phone/Reach project builds 33 exact XNBs plus its XML copy item; the two authentic Moire SpriteFonts, 25 textures and six SoundEffects replace every loose substitute. The unchanged C# endpoint also compiles (a labelled haptics-only diagnostic shim supplies the unavailable Phone SDK assembly), but no local Phone host exists, so no visual-original claim is made. One renderer defect found and fixed in cnanext 599d14e54: a worker EasyGL content context was left current after handoff; a real-GL worker-XNB/two-later-frames regression now protects the owner context. Native Release OPENGLES3 traverses menu, instructions/background load, gameplay, real FreeDrag/DragComplete fire, pause and clean exit. Real-Chrome threaded WEBGL2 uses browser touch, reaches the same screens, runs 600 post-interaction frames on an actual WebGL 2 context and reports zero exceptions, rejections or asset errors. The generic sample Emscripten helper now opts blocking Game::Run() executables into CNA's explicit Asyncify interface without altering the synchronous cna_c_api_wasm contract. Mouse input added at the owner's request on 2026-09-06 -- one CNAEXT TouchPanel::setMouseTouchEmulationEnabledEXT(true) in the constructor, off by default in the framework and with no second input path in any screen, so this touch-only phone game is playable on the desktop; a real pointer drives menu, instructions, FreeDrag aiming and DragComplete firing -- natively in both artifact trees and in real Chrome, where the original touch gate still passes unchanged on the same rebuilt bundle. Evidence: samples/CatapultWars/{missing,diff}.md. Firefox abort closed on 2026-09-06 and the row reopened by what it was hiding. The bare Aborted(Assertion failed) was an Emscripten 6.0.3 regression (#27018), not a CNA, runtime or sample defect: Firefox ESR 140 has no Atomics.waitAsync, so a loader pthread's proxied GL call notified the MAIN thread's mailbox by postMessage, and 6.0.3's worker.onmessage asserted on that message instead of processing it. Upstream fixed it in #27336 / release 6.0.4; on the owner's decision the machine's emsdk was upgraded 6.0.3 -> 6.0.9 and the whole web tree, SDL prebuilt included, rebuilt with it (content .data byte-identical). A new BiDi-driven Firefox gate then passes five runs -- gameplay, FreeDrag aiming, DragComplete fire, 600 frames, no abort, no page error -- and both Chrome gates still pass on the same bundle with unchanged menu hashes. What it revealed was fixed the same day in cnanext cde325ecd: textures loaded on the background thread were intermittently empty (Firefox 2/5 runs, Chrome 1/5) because EasyGL's thread-context lease was a no-op under __EMSCRIPTEN__ while OFFSCREEN_FRAMEBUFFER proxies every GL call into one shared browser-thread context, so a loader's bind/upload pair could be split by the frame's own binds. The lease body is now common to both platforms, with only the binding handover native-only. The functional gate cannot see that defect, so every run is sampled by pixel at three patches that must not be black: 3 of 10 pre-fix runs were defective and 0 of 20 post-fix runs are, with all 20 also passing the full gate; native Release OPENGLES3 was rebuilt and re-captured, and EasyGL_ThreadContextLease_Exclusion now pins the invariant the bug violated. Owner test pending (asked 2026-09-07): the owner will run this one in person when at the computer; every automated gate above passes, but do not treat that verdict as given until then. Artifact root pruned on the owner's instruction the same day, 2.1 GB -> 207 MB: pruning keeps the products, so the in-person test is unaffected. This root had two native trees -- a stale Debug cna-native-opengles3 from 16:24 and the gated Release cna-native-opengles3-release from 20:47 -- and the tool deletes a non-canonical tree whole, so the Release executable was promoted into the canonical tree first and is what the root now retains (the two trees' Content/ were verified identical). MANIFEST.md records the rest.	✅
SAMPLE-068	CatapultWarsTrainingKit_4_0	absent	Ported all seven independent upstream runnable products; the old redundant verdict was wrong. The six exercise solutions remain distinct ports for Health Bar, Second Human, Shot Angle, Shot Guide, Supply Crate and All Features, and the separate advanced Scrolling Screen is a seventh port. Together they retain damage/health zones, one/two-human flow, angle-limited aiming, ballistic guide dots, crate destruction and split-ammo/projectiles, the combined mode, and the scaled pan/flick/pinch/projectile-follow camera. All seven unchanged C# Phone/Reach projects compile (with the same labelled haptics-only diagnostic shim as SAMPLE-067); no local Phone host exists, so no visual-original claim is made. Their official pipeline outputs contain 251 exact files in total and are byte-identical to every checked-in Content/ tree; the common 469-file source kit and tutorial are retained. All seven pass native Debug and Release OPENGLES3 builds and interactive Release runs with exit 0. Targeted native evidence covers both human turns, guide dots, crate destruction/split ammo and transformed-camera fire/follow. All seven threaded WEBGL2 bundles run in real Chrome/WebGL 2 through browser-touch gameplay and 600 post-interaction frames with zero exceptions, rejections or HTTP errors. No CNA/sharp-runtime fix or sample workaround was needed. Evidence: samples/CatapultWarsTrainingHealthBar/{missing,diff}.md, samples/CatapultWarsTrainingSecondHuman/{missing,diff}.md, samples/CatapultWarsTrainingShotAngle/{missing,diff}.md, samples/CatapultWarsTrainingShotGuide/{missing,diff}.md, samples/CatapultWarsTrainingSupplyCrate/{missing,diff}.md, samples/CatapultWarsTrainingAllFeatures/{missing,diff}.md, samples/CatapultWarsTrainingScrollingScreen/{missing,diff}.md. Reopened 2026-09-07 (🛠) by the SAMPLE-067 findings, not by anything new here. All seven bundles date from 2026-08-31, i.e. they were linked by Emscripten 6.0.3 and against the pre-fix EasyGL lease, and all seven start the same background loading thread. They therefore carry both defects SAMPLE-067 uncovered: the 6.0.3 mailbox assertion that aborts in any browser without Atomics.waitAsync (never tested here -- the recorded browser evidence is Chrome-only), and the unserialized loader/frame GL that silently empties background-loaded textures. All seven were rebuilt on emsdk 6.0.9 + cnanext cde325ecd and re-gated: 28 browser runs, all green -- 14 in Firefox (new BiDi-driven gate, 2 per product, every one reaching gameplay through a real touch drag with moduleAbort: null and atomicsWaitAsync: "undefined", i.e. the configuration that used to abort) and 14 in Chrome with no exception, rejection or HTTP error. Because the empty-texture defect is invisible to every functional check, all 28 gameplay frames were also compared by pixel with scripts/check-missing-textures.py, an instrument calibrated on a known-defective SAMPLE-067 frame it flags at 111 patches: 0 of 28 defective. All seven native Release OPENGLES3 binaries were rebuilt on the fixed renderer and re-captured interactively to a clean exit=0. No sample change was needed; the port itself was never at fault. Artifact root pruned 2026-09-07, and re-swept the same day once the prune tool learned the multi-product xna4-build/<Product>/ layout it had been skipping. It stays 1.3 GB because seven products are seven of everything: 7 stripped native OPENGLES3 executables with their content, 7 complete WEBGL2 bundles and 7 original builds. MANIFEST.md records it.	✅
SAMPLE-069	CardsStarterKit_4_0	port	Complete 47-file game/framework audit restored every AI/rule/screen/audio/serialization method and inactive phone/Xbox branch, replacing loose substitutes with all 89 byte-identical official HiDef XNBs. The unchanged Windows/HiDef original, final Debug and Release OPENGLES3 builds, and the real-Chrome WEBGL2 bundle all pass Play, bet, Deal, Stand/result, pause/return and clean exit; Chrome additionally passes Theme Red→Blue, real WebGL2, audio/content loading and 600 rAF cycles with no runtime error. No CNA/sharp-runtime change or sample workaround remains. Evidence: samples/CardsStarterKit/missing.md; language mechanics: samples/CardsStarterKit/diff.md. Firefox verified 2026-09-07: this sample creates no background loading thread, so neither SAMPLE-067 defect can reach it -- measured rather than assumed, by running the unchanged 2026-08-31 bundle (Emscripten 6.0.3, pre-fix renderer) in Firefox 140 ESR over WebDriver BiDi: menu, Play, betting, chip, Deal, a resolved hand and 600 further frames, with moduleAbort: null, no page error and atomicsWaitAsync: "undefined", i.e. the configuration that aborts SAMPLE-067. No rebuild was needed. Artifact root pruned the same day.	✅
SAMPLE-070	RolePlayingGame_4_0_Win_Xbox	port	The SAMPLES-DEC-008 blocker is closed and the port is complete. System::Xml::Serialization::XmlSerializer exists in sharp-runtimenext, so the save/load routes go through it instead of a handwritten RPG parser, and every item the 2026-08-31 audit listed as remaining is gone. A basename sweep over the original tree now finds no RolePlayingGame/RolePlayingGameData class without a counterpart, and no source file still carries a "simplified adaptation" header. Restored in this pass: the session save/load half of Session.cs with PartySaveData/PlayerSaveData/SaveGameDescription over CNA StorageDevice/Guide, its document measured with a probe compiled against the real RolePlayingGameDataWindows.dll under the XNA 4.0 Wine prefix rather than guessed; the real combat system (Combatant, CombatantPlayer, CombatantMonster, ArtificialIntelligence, CombatAction and its five concrete actions, and CombatEngine itself -- turn order, the delay state machine, adjacent targeting, rising damage/healing numbers, selection rings, flee odds, victory/loss/fled); ListScreen<T> and the fourteen screens that were absent; and the eight that were text stand-ins (DialogueScreen, the NpcScreen<T> family, ChestScreen, InnScreen, LevelUpScreen, RewardsScreen, GameOverScreen, LoadingScreen). AudioManager is the original XACT component again -- Content/Audio carries the official compiled RPGAudio.xgs/Wave Bank.xwb/Sound Bank.xsb and CNA's AudioEngine/SoundBank/WaveBank load them (27 cues), so the loose-.wav substitute is gone; Content/ is 1,004 XNBs plus those three banks and zero PNG/XML/WAV/JSON substitutes. The game adds the GamerServicesComponent the original adds. Three defects the web target exposed were fixed with it: ListScreen<T> needed the template keyword the standard requires on fifteen dependent Load<T> calls, AudioManager/CombatEngine each declared a static inline unique_ptr<Self> inside their own class (deleter instantiated on an incomplete type), and CombatEngine::EndCombat leaked one engine per combat by calling release() to avoid destroying the object it was running inside -- it now retires the engine into a second pointer that the next StartNewCombat frees. Native Release OPENGLES3 builds clean. The threaded WEBGL2 bundle (11.7 MB .wasm, 64.7 MB .data = 1,007 packaged files) passes a headless-Chrome gate: cross-origin isolated, real WebGL 2.0 (OpenGL ES 3.0 Chromium), 600 post-interaction rAF callbacks, zero exceptions, rejections and HTTP errors, with keyboard-driven captures of the main menu, the quest details and quest log a new session opens, the map after both are dismissed, StatisticsScreen on the character-management key, the QuestNpcScreen the party leader walks into, and the in-session menu. An earlier version of the gate looked like it had found a defect -- Space left the frame unchanged -- and scripts/probe-space.sh proved it was the gate: Space delivered four ways (CDP rawKeyDown, CDP keyDown with text, and a page-dispatched KeyboardEvent on the window and on the canvas) opens a fully populated StatisticsScreen every time. The old gate walked first, which reaches the quest destination NPC, so a static QuestNpcScreen was swallowing the key -- and its byte-identical frames were the giveaway, since the animated map can never produce two matching captures. Evidence: samples/RolePlayingGame/{missing,diff}.md, evidence/cna-web-webgl2-qualified/. The interactive native OPENGLES3 run is done, and it reaches the one thing no browser gate can: the save path, because Emscripten has no StorageDevice for the sample to write through. scripts/capture-native.sh walks the same screens natively and saves a game; scripts/capture-native-load.sh starts a second process and loads it back. The document lands at <XDG_DATA_HOME>/game/RolePlayingGame/AllPlayers/SaveGame1.xml beside its SaveGameDescription1.xml, in the original's layout, and its content is the state the captures show rather than a plausible-looking one -- Maps/Map001 at tile (9,10) facing South, currentQuestIndex 1 at InProgress after the first quest completed, Kolatt at level 2 with 40 experience, 10 party gold and both equipment asset names. The fresh process brings that party back at level 2 with 40/150 experience and the restored weapon and armour values, so the ten XmlSerializer routes round-trip through StorageDevice/StorageContainer rather than merely writing something. Both native scripts drive the game by frame comparison, not by sleeping: the first attempt reused the web gate's fixed timings and the native build loads content several times faster, so the same Escape presses walked past more popups and the run ended up in the quest log while it believed it was in the save menu. Two environment facts came out of it and are recorded in missing.md with the measurements behind them -- SDL_VIDEODRIVER=x11 is the setting that keeps an SDL3 window off the owner's screen and unsetting WAYLAND_DISPLAY does nothing at all (a four-row probe of this binary: the x11 driver wins over a set WAYLAND_DISPLAY, while clearing that variable changes nothing because SDL3 connects to the default wayland-0 socket in XDG_RUNTIME_DIR regardless, so a driverless run comes up on the owner's compositor -- the renderer log separates them, 8x MSAA on the real GPU against 4x on llvmpipe), and a rootless Xwayland has no composited root pixmap, so import -window root, per-window import/xwd and ffmpeg -f x11grab all fail on :0 while the same capture works on an Xvfb. The Firefox gate passes too, on Firefox 140 ESR over WebDriver BiDi: cross-origin isolated, WebGL 2, 600 post-interaction rAF callbacks, nine distinct frame hashes, moduleAbort null and no page errors -- notable because this Firefox has no Atomics.waitAsync, which is what the 6.0.3 emscripten mailbox assertion needed to abort a threaded bundle, and the 6.0.9 toolchain carries the upstream fix. Neither SAMPLE-067 defect can reach this sample -- it starts no background loading thread (zero Thread in the original, zero std::thread in the port) and the bundle is built with emsdk 6.0.9. Evidence: evidence/cna-native-opengles3-qualified/, evidence/cna-web-webgl2-firefox/.	✅
SAMPLE-071	Yacht_4_0	port	Both products are ported. SAMPLES-DEC-009 was decided by the owner on 2026-09-07 -- port both, and explicitly do not modernize the transport, because measuring showed it unnecessary: what Microsoft retired is MPNS, a relay between two halves of this sample, while the WCF service is Server.exe, which the user runs and which builds and answers SOAP on this machine today. The client is 40 files/8,711 lines against the original's 30/8,925, and a basename sweep finds no type without a counterpart; the server is its own executable as it is in the original. Content/ is the official 45 XNBs and nothing else, replacing 42 hand-made substitutes. Three inventions are gone: an F1 help overlay, a parallel mouse input path beside the gestures, and a MessageBoxScreen the original does not have -- it calls Guide.BeginShowMessageBox in six places and five had simply been dropped. The SOAP contract was measured off the original service rather than read out of its WSDL (it runs here under mono): schema fetched, a hand-written Register accepted, replies captured -- evidence/soap-oracle/. That settled two things a specification would not have: the payload wraps Message in a second Message because the outer one is XmlSerializer's root, and byte[] means a raw Guid from NewGame but a serialized Message from the other three. The ported server answers the original's own request character for character, and its available-games payload is structurally identical to the captured one. Both halves were played against each other: lobby, New Game, and a board carrying the server's own AI1/AI2/AI3 waiting for players. The offline game plays natively -- rules, board, ROLL, five dice, counter X3 to X2. Framework work, none of it worked around in the sample: IXmlSerializable, Base64/BinHex/WriteFullEndElement in the XML stack, and System.ServiceModel (channel and host) in sharp-runtime; a Microsoft::Phone module in CNA with PhoneApplicationService and HttpNotificationChannel plus its sending half. Two upstream faults are reproduced and recorded: the server AI's dice range, and its Sum guard that makes Choice, four of a kind and full house always score zero. The web build is qualified too. What had looked like a renderer dropping half the board was the gate photographing a stale rectangle: the game asks for fullscreen, a browser grants that only on a user gesture, and the canvas resized from 480x800 to the headless screen's 800x600 the moment the gate pressed Enter. Re-measuring the clip per capture exposed two real defects behind it, both fixed in cnanext rather than in the sample: Sdl3Window threw Couldn't find any matching video modes and killed the game on any display without a 480x800 video mode, and the focused platform test target had not linked for some time. The third finding went to the owner rather than into the sample: with the window shaped differently from the backbuffer, GraphicsDevice.Viewport reported EasyGL's FixedHeightDynamicWidth size (measured 1067x800 for a 480x800 backbuffer) where XNA and FNA report the backbuffer, moving every Viewport.Width-anchored element. The owner made Letterbox the default on 2026-09-08 (cnanext f13701188), and both products were re-captured unchanged afterwards. The gate now runs on a 480x800 screen, the screen this game was written for, and the browser board matches the native one sprite for sprite through a roll that takes (ROLLS X3 to X2). Evidence: samples/Yacht/{missing,diff}.md, evidence/soap-oracle/, evidence/cna-web-webgl2-qualified/, evidence/cna-native-opengles3-qualified/.	✅
SAMPLE-072	GSMSample_4_0_WIN_XBOX	port	Re-ported completely with no sample workaround. All 15 original C# units retain the screen stack, transitions, four-player keyboard/gamepad state, touch/gesture plumbing, multicast menu/message-box events, per-screen ContentManager lifetimes, debug tracing, slow loading boundary, random gameplay motion, inactive Windows Phone selection rule and every menu/pause/confirmation path. The old seven merged headers, std::function callbacks, shared-content simplification, omitted touch/trace code, loose PNG/font sidecars, substitute fonts and invented F1 overlay are gone. The five checked-in Reach XNBs are byte-identical to the unchanged official pipeline output. The unchanged XNA executable, Debug and Release OPENGLES3 builds, and real-Chrome WEBGL2 bundle all traverse the same nine-state menu/options/gameplay/pause/quit/exit sequence; both native builds exit 0, while Chrome uses real WebGL2, completes 600 additional frames and reports no exception, rejection or asset/HTTP error. No CNA/sharp-runtime fix was needed. Evidence: samples/GameStateManagement/missing.md.	✅
SAMPLE-073	SoccerPitchSample_4_0	port	Re-ported completely with no sample workaround. All ten original units restore the exact 24/40-byte vertex layouts, independent 10x10/30x30 pitch UVs, procedural planes/sphere, multipass Alpha-Blend/Alpha-Test markings, shadow, camera, FPS/status text, GamePad Back and Touch Released behavior. The loose PNG/font substitutes, omitted plane helper, shared-UV format, Escape/mouse/F1 paths, fixed aspect and manually wired content manager are gone; all six checked-in Phone/Reach XNBs are byte-identical official-pipeline output. A general EasyGL fix plus a real-GL regression makes DualTextureEffect consume both texture-coordinate usages (black before, red after). The unchanged source diagnostic, Debug and Release OPENGLES3, and real-Chrome WEBGL2 builds render the same 480x800 scene; Chrome's real touch toggles Alpha-Test and 600 further rAFs complete with no exception, rejection or relevant HTTP error. Evidence: samples/SoccerPitch/missing.md.	✅
SAMPLE-074	TankOnAHeightMapSample_4_0	port	Re-ported completely with no sample workaround. The stale blocker was disproved by live CNA's authentic XNB ModelReader: bone hierarchy, mesh-parent bones and custom Model.Tag payloads work. All three original runtime units plus the custom processor/writer surface were audited; the port restores the generated textured terrain, exact bilinear height/normal sampling, surface-aligned tank, four animated wheel bones, original input, chase-camera clamp, lighting and fog. The five checked-in Windows/HiDef XNBs are byte-identical outputs of the unchanged official pipeline and custom processor; there are no loose assets or sidecars. The unchanged XNA executable, Debug/Release OPENGLES3 and real-Chrome WEBGL2 pass start, forward and turn-plus-forward. Chrome obtains WebGL 2, completes 600 additional frames and reports no runtime error. Evidence: samples/TankOnHeightmap/missing.md.	✅
SAMPLE-075	NGSMSample_4_0	absent	Freshly audited; the old non-game dismissal is disproved. The unchanged 26-source Windows/Reach original and all ten official XNBs build; the original runs through menu, loading, placeholder gameplay, pause, return and clean exit. Its actual product is the complete create/find/join, profile/Guide, lobby readiness/voice/invite, session ownership/error and synchronized-transition UI. Live CNA has real native System Link, but browser discovery/hosting is explicitly unavailable and this sample has no direct-address route; PlayerMatch is intentionally synthetic with stub LIVE identity and no invite service. A fake lobby or menu-only web build is not acceptable. No C++ port or workaround was added. Evidence: samples/NetworkStateManagement/missing.md; decisions: SAMPLES-DEC-004 and SAMPLES-DEC-006. CANCELLED by the owner on 2026-09-08. The re-audit that day measured the boundary rather than restating it: every one of the nineteen XNA Net/GamerServices members this sample uses already exists in CNA, the retired-LIVE half is one predicate (ENetBackend::RealNetworkingEnabled admits only SystemLink), and the browser half is half a permanent platform constraint (no raw datagram in a browser, so discovery is empty and a tab cannot listen) and half missing infrastructure. Both reduce to one capability -- a session directory queryable without LAN broadcast plus an inbound-capable peer -- which is new CNA infrastructure, not a port of anything Microsoft shipped with the sample; unlike SAMPLE-071, where the retired MPNS was a relay and the service was the sample's own Server.exe, there is no upstream broker here. Estimated at 26-46 h for this sample alone, and dominated by an unproven unknown: ENet has never been run in a browser in this project at all. The owner declined to build it.	⛔
SAMPLE-076	SplitScreenSample_4_0	placeholder	Re-ported completely with no sample workaround. The stale .model.json blocker is disproved by live CNA's authentic XNB ModelReader: the official tank.xnb provides the full named-bone hierarchy and mesh-parent assignments. The complete Windows/HiDef translation restores both independent viewports/cameras, two-pixel borders, all nine cached animation bones, original wheel/steer/turret/cannon/hatch formulas, per-mesh BasicEffect setup, platform branch and input. All three checked-in XNBs are byte-identical unchanged official-pipeline output; no loose assets or sidecars remain. The unchanged XNA executable and Debug/Release OPENGLES3 builds render the same two animated views and exit cleanly. Real-Chrome WEBGL2 obtains WebGL 2, renders both viewports, completes 600 further frames and reports no runtime error. Evidence: samples/SplitScreen/missing.md.	✅
SAMPLE-077	DynamicMenu_4_0	port	Re-ported completely with no sample workaround. All 15 original C# units are represented with the original interfaces, class/namespace decomposition, properties, events, touch-only menu input, GamePad Back, 30 Hz/fullscreen/orientation behavior, fresh-per-tap random hue, control algorithms and transitions. All eleven checked-in Phone/Reach XNBs are byte-identical official-pipeline output; the two XML-authored polymorphic menu graphs now load through ordinary Content.Load instead of handwritten C++. General CNA commit 96b56b0e4 adds inherited-member composition and resolving-only abstract reflective readers with ten passing focused tests. The unchanged original Windows diagnostic and real-Chrome WEBGL2 cover all three pages, four progress advances and the Page 1 index action; Chrome obtains WebGL 2, completes 600 further frames and reports no runtime error. Visual RMSE against XNA is 0.034–0.050%, on the browser captures -- which is what missing.md says and what re-measurement on 2026-09-08 confirms to the digit. Native page coverage was added on 2026-09-08. This sample is touch-only and the port did not enable TouchPanel::setMouseTouchEmulationEnabledEXT, so a desktop run could not leave Page 1 and the native evidence covered Page 1 only -- while this row credited it with the browser's coverage, and three byte-identical copies of Page 1 sat in evidence/cna-native-opengles3/ under the names of Pages 2, 3 and 4. The seam is now taken (recorded in diff.md, same seam and reason as SAMPLE-071), the native capture walks the browser's own route, and the duplicates are deleted. Native now matches XNA at RMSE 9.9e-05 on every page -- tighter than the browser -- the difference being at most one level out of 255 on 0.098 % of pixels, in the same places each frame. Evidence: samples/DynamicMenu/{missing,diff}.md.	✅
SAMPLE-078	LocalizationSample_4_0	port	Re-ported completely with no sample workaround. The original namespace/class split, implicit 800x480 presentation, automatic platform culture, strongly typed generated-resource surface, exact three-string/flag layout, full-name/language/default content fallback and narrow ContentLoadException catch are restored. The manual SPACE cycle, F1/help overlay, loose PNG/font/JSON assets and sample-local fallback table are gone. All eight checked-in Windows/Reach XNBs are byte-identical offline Win7 XNA Game Studio output; the unchanged custom processor scanned all .resx text to build the multilingual font. General fixes: CNA initializes unset game culture defaults from platform locales (0b41d8a6f) and normalizes loose-reader failures (cd6587084); Sharp Runtime supplies exact culture identity metadata (e429f728) and a reflection-free AOT ResourceManager (67e61a63). The unchanged XNA reference and Debug/Release OPENGLES3 pass all six cultures. Real-Chrome WEBGL2 obtains WebGL 2, selects ja-JP, renders Japanese text/flag, completes 600 further frames and reports no runtime error. Evidence: samples/LocalizationSample/missing.md.	✅
SAMPLE-079	GesturesSample_4_0	port	Re-ported completely with no sample workaround. The original TouchGestureSample::Game1/Sprite surface, fullscreen/implicit presentation, 30 Hz timing, TouchPanel-only Hold/Tap/DoubleTap/FreeDrag/Flick/Pinch behavior, GamePad Back exit, palette, hit testing, scale, friction and bounce formulas are restored. The parallel mouse implementation, Escape/F1 behavior, manual touch dimensions, runtime help image and loose PNG/font sidecars are gone. Both checked-in Phone/Reach XNBs are byte-identical official-pipeline output. The unchanged original reference and Debug/Release OPENGLES3 baseline are pixel-identical. Native two-finger qualification exercises every gesture; real-Chrome WEBGL2 obtains WebGL 2, repeats the full gesture sequence, returns Hold removal to the exact baseline, completes 600 further frames and reports no runtime error. Evidence: samples/GesturesSample/missing.md.	✅
SAMPLE-080	TouchThumbsticksSample_4_0	port	Re-ported completely with no sample workaround. The original namespace and six-class surface, 800x480/fullscreen Phone presentation, 30 Hz timing, raw TouchPanel-only dual-stick tracking, stick thresholds, movement/drag, aim/fire cadence, bullet lifecycle, enemy spawning/homing/collision, camera, starfield and border behavior are restored. Keyboard/mouse fallback, manual touch dimensions, Escape/F1 behavior, runtime help and loose Images/*.png content are gone. All four checked-in Phone/Reach XNBs are byte-identical official-pipeline output. The unchanged XNA reference and Debug/Release OPENGLES3 render the exact same player pixels; native dual-finger qualification proves simultaneous movement/fire and clean release. Real-Chrome WEBGL2 obtains WebGL 2, tracks two simultaneous touch IDs, fires, completes 600 further frames and reports no runtime error. Evidence: samples/TouchThumbsticks/missing.md.	✅
SAMPLE-081	PerformanceMeasuringSample_4_0	port	Re-ported completely with no sample workaround. All 17 original C# units restore the lit position/normal sphere primitive, exact 50/200-sphere simulation and collision order, Windows/Phone input branches, complete FPS/TimeRuler instrumentation, debug console, manual culture-aware number formatter and SystemLink remote state machine. The flat vertices, loose font/checker/model sidecars, omitted tools, renamed members, fixed viewport and invented F1 overlay are gone. All three checked-in Windows/Reach XNBs are byte-identical unchanged official-pipeline output and preserve the original Segoe UI Mono font plus textured model material. The unchanged XNA executable, Debug/Release OPENGLES3 builds and real-Chrome WEBGL2 bundle render the same scene/UI and pass count/collision input. Chrome obtains WebGL 2, completes 60- and 600-frame canaries and reports no runtime error. Evidence: samples/PerformanceMeasuring/missing.md.	✅
SAMPLE-082	UISample_4_0	port	Re-ported completely with no sample workaround. All 25 original C# units restore the UserInterfaceSample namespace and class/file split, touch-only UI, 30 Hz/fullscreen Phone setup, independent background content lifetime, screen transitions, level paging, high-score scrolling, tracing and isolated-storage screen serialization. The mouse synthesis, manual touch dimensions, F1 overlay, loose assets/fonts, merged screens, dropped persistence, manual TimeSpan formatting and three invented latent-bug fixes are gone. All eleven checked-in Phone/Reach XNBs are byte-identical offline Win7 XNA Game Studio output. Sharp Runtime 17fb2241/efd685ca supplies general invariant TimeSpan g/G formatting. Debug/Release OPENGLES3 and real-Chrome WEBGL2 open both screens, page and scroll through real touch; Chrome obtains WebGL 2, completes 600 further frames and reports no runtime error. The upstream Phone game has no desktop XNA host; an all-source Win7 diagnostic records the exact application-isolated-storage boundary rather than claiming a false original screenshot. Evidence: samples/UISample/{missing,diff}.md.	✅
SAMPLE-083	SnowShovelSample_4_0	port	Re-ported completely with no sample workaround. The shared Windows/Phone source now restores the original SnowShovel::Game and private nested Snowflake, two independent random streams with C# evaluation order, three game states, waves/timing/collision sound, exact keyboard/game-pad/touch input and the complete Phone-only 30 Hz/fullscreen/accelerometer branch. The desktop sensor/mouse/F1 paths, hard-coded viewport, manual touch dimensions/time formatting, merged RNG and loose substitute content are gone. All five checked-in Windows/Reach XNBs are exact official-pipeline output; both Windows and Phone content targets build, and the Phone C++ branch compiles. The stale Initialize-time viewport claim is disproved on live CNA: the faithful query renders a full 480×800 frame without a framework change. Sharp Runtime 9c389f86 handles the original custom numeric formats and SAMPLE-083 follow-up 1f5bbbc2 preserves the mixed integer/Single route without widening. The unchanged XNA executable and Debug/Release OPENGLES3 builds pass pre-game, keyboard movement, scoring/sound branch, countdown, Game Over, restart and exit. Real-Chrome WEBGL2 obtains WebGL 2, uses real touch to move/score/restart, completes 600 further frames and reports no runtime error. Evidence: samples/SnowShovel/missing.md and samples/SnowShovel/diff.md.	✅

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

Task	Upstream directory	Existing	Fresh audit focus	Status
SAMPLE-084	AccelerometerSample_4_0	port	Re-ported completely with both original runtime branches and no sample workaround. The real ReadingChanged/Start/failure path and the emulator's exact normalized arrow-key vector are restored; fullscreen, 30 Hz timing, live viewport logic and GamePad-only exit replace the old desktop conveniences. Both checked-in Windows/Reach XNBs are byte-identical official output. General CNA commit 35268971c truthfully classifies browser builds as DeviceType::Emulator while preserving native real-sensor behavior. The unchanged-source XNA diagnostic proves emulator input and device event delivery. Debug/Release OPENGLES3 render the exact scene through the native no-hardware device path; real-Chrome WEBGL2 obtains WebGL 2, moves the asteroid with Right/Up, completes 600 further frames and reports no runtime error. Evidence: samples/AccelerometerSample/{missing,diff}.md.	✅
SAMPLE-085	AvatarAnimationBlendingSample_4_0	absent	Freshly audited; no substitute avatar port was added. The exact two-source Xbox360/HiDef original and its official SpriteFont XNB build. Its sample-owned 250 ms blend is portable, but the defining output is Microsoft's proprietary Xbox LIVE Avatar body plus four built-in 71-bone animation presets. Live CNA's normal XNA API intentionally returns an invalid random description, zero-length/zero-matrix animations, Unavailable renderer state and no-op draw; 47 focused tests verify that boundary. The only real-rendering route is an explicitly non-authentic CNAEXT substitute that the campaign rules forbid. Choose Xbox-only/non-port evidence, explicitly authorize that substitute scope, or authorize a faithful dataset and large normal-API backend under SAMPLES-DEC-004. Evidence: samples/AvatarAnimationBlending/missing.md. CANCELLED by the owner on 2026-09-09. The 2026-09-09 re-audit measured the boundary rather than restating it: the sample ships one project, XnaPlatform Xbox 360 and XnaProfile HiDef, with no Windows project at all, and its built executable is a PE32 assembly on CLR v2.0.50727 — the Xbox 360 Compact Framework — referencing Microsoft.Xna.Framework.Avatar, which exists only in the console reference assemblies retained in xbox-refs/. It cannot start on Windows, on Wine, or on the XNA 4.0 runtime installed here, so no reference capture is obtainable on any machine and there is not even a diagnostic boundary to record as SAMPLE-082 has. CNA's Avatar API is faithful to the Windows XNA assemblies (all-zero description, renderer permanently Unavailable, the 71-entry parent-bone table decoded from the reference assembly), which is true and beside the point, because the sample never ran on Windows XNA either. The defining output existed only on discontinued hardware.	⛔
SAMPLE-086	AvatarMultipleAnimationsSample_4_0	absent	Freshly audited as a distinct simultaneous-animation lesson; no substitute port was added. Its exact 392-line Xbox360/HiDef source and official XNB build. The portable algorithm discovers the right-arm subtree from the authentic 71-entry ParentBones, copies Celebrate over the body and overwrites that subtree from Wave, with two single-animation modes. Live CNA exposes the hierarchy but both presets are identical zero poses, renderer state is permanently Unavailable and normal Draw is a no-op; 47 focused tests verify that boundary. CNA's non-authentic CNAEXT path also cannot consume the sample's composed transform list. Choose Xbox-only/non-port evidence, explicitly authorize substitute/transform-draw scope, or authorize a faithful dataset and large normal-API backend under SAMPLES-DEC-004. Evidence: samples/AvatarMultipleAnimations/missing.md. CANCELLED by the owner on 2026-09-09, on the same measured boundary as SAMPLE-085 and one obstacle further. One project, XnaPlatform Xbox 360, no Windows counterpart; the built executable runs on CLR v2.0.50727 and references Microsoft.Xna.Framework.Avatar, so it cannot start here and no reference is obtainable. Beyond that: this sample's whole lesson is composing one pose from two, the XNA call for that (Draw(const std::vector<Matrix>&, AvatarExpression)) is a permanent no-op, and the excluded CNAEXT route DrawRealEXT(clipName, position, loop) takes a clip name rather than a bone list — so even the substitute path could not express the output. The inputs are empty too: AvatarAnimation allocates 71 zero matrices at TimeSpan::Zero, so Celebrate and Wave are the same zero pose.	⛔
SAMPLE-087	AvatarShadows_4_0	absent	Freshly audited as a distinct 16-avatar planar-shadow technique; no ground-only/substitute port was added. All four Xbox360/HiDef runtime units and three official LZX XNBs build. The portable pipeline flattens each independently animated Avatar with Matrix.CreateShadow, draws into a full-screen SurfaceFormat.Alpha8 target and has the exact custom ground effect darken sampled shadow pixels by 50%. Normal CNA avatars produce neither body nor capture. A real OPENGLES3 capability test additionally proves EasyGL refuses Alpha8 render targets rather than substituting Color; the same renderer backs WEBGL2. Choose Xbox-only/non-port evidence, explicitly authorize substitute visual plus truthful Alpha8 work, or authorize a faithful dataset and large normal-API backend under SAMPLES-DEC-004. Evidence: samples/AvatarShadows/missing.md. CANCELLED by the owner on 2026-09-09 on the same measured family boundary as SAMPLE-085/SAMPLE-086: one project at XnaPlatform Xbox 360, no Windows counterpart, a built executable on CLR v2.0.50727, no obtainable reference. A second blocker here is not about discontinued hardware and outlives this row: the technique needs a full-screen SurfaceFormat.Alpha8 render target, and CNA refuses one by design — SupportsSurfaceFormatAsRenderTargetEXT(Alpha8) is false, asserted by GraphicsCapabilityFloatRenderTargetTest.NonColourNonFloatFormatsAreNotRenderTargets on MOD-100 grounds. XNA substitutes silently instead, the behaviour MOD-107 records as a defect elsewhere here, so this is a knowing divergence that affects any future sample rendering into a single-channel target.	⛔
SAMPLE-088	BingMaps_4_0	absent	Freshly audited as a complete online Windows Phone map client; no cached screenshot/fake service was added. Six runtime units implement a 5x5 in-memory plane, 25 asynchronous imagery requests, Web Mercator math, touch pan, Aerial/Road switch and XML-geocoded recentering. All three exact Phone/Reach XNBs build and five unchanged support units type-check; the exact main source intentionally stops at #error until a developer supplies a Bing key. Microsoft has retired free Basic accounts and sunsets Enterprise in 2028. Live Sharp Runtime has URI/LINQ XML but no GeoCoordinate, WebClient async/cancel surface or XDocument.Load(Stream); WEBGL2 also needs authorized HTTPS credentials/CORS. Choose non-port evidence, eligible Bing access, or an owner-approved Azure Maps migration under SAMPLES-DEC-004. This sample does not use XmlSerializer. Evidence: samples/BingMaps/missing.md. CANCELLED by the owner on 2026-09-09. The 2026-09-09 re-audit narrowed the runtime gaps to four small items — XDocument.Load(Stream) (one overload; the type exists in modules/xml-linq), a WebClient OpenReadAsync/OpenReadCompleted/IsBusy/CancelAsync adapter over the existing modules/net-http, and GeoCoordinate — a few hours of the same shape as SAMPLE-071's IXmlSerializable work. The service is the blocker, and it is not SAMPLE-071's shape: Yacht's retired MPNS was a relay between two halves of the sample and the service itself was Server.exe, shipped in the box; BingMaps has no such half — its entire visible output is Microsoft's imagery and geocoding, nothing upstream can stand in, and the source refuses to compile without a key (#error at BingMapsSampleGame.cs:58). Free Basic accounts are retired and Enterprise is announced to sunset in 2028, so a port could be compiled but never qualified.	⛔
SAMPLE-089	BingMapsPathFinding_4_0	absent	Freshly audited as a distinct online road-routing game; no fake route/offline-map port was added. Nine runtime units add ordered pushpins, Driving/Walking Bing Routes requests, returned-road traversal, tank movement/rotation and indexed red route lines to the SAMPLE-088 viewer. All five exact Phone/Reach XNBs build and eight unchanged support units type-check; the exact main source intentionally stops at #error until a Bing key is supplied. Free Bing accounts are retired and Enterprise sunsets in 2028. A current Azure migration changes all three services and adds authenticated POST/GeoJSON route work beyond the shared WebClient/GeoCoordinate/XML gaps. Choose non-port evidence, eligible Bing access, or an authorized/provisioned Azure modernization under SAMPLES-DEC-004. This sample does not use XmlSerializer. Evidence: samples/BingMapsPathFinding/missing.md. CANCELLED by the owner on 2026-09-09, on SAMPLE-088's boundary with a third service on top. It calls Imagery/Map, Locations and Routes, so an Azure migration would replace all three and change the route representation. The 2026-09-09 re-audit found the runtime side smaller than recorded: XDocument, XElement and XNamespace all exist in modules/xml-linq, and HttpClient already has PostAsync/SendAsync with net-http-json and text-json, so authenticated POST and JSON are present, not missing. What is absent is SAMPLE-088's same short list. The blocker is the service: the whole visible output is Microsoft's map, geocoded destination and road geometry, nothing upstream can stand in, the free tier is retired and the paid tier ends in 2028.	⛔
SAMPLE-090	BitmapFontMaker_4_0	absent	Freshly audited as a standalone WinForms design-time utility; no fake game/CLI/alternate UI was added. Its three application units enumerate installed Windows fonts, preview style/size, rasterize an inclusive-minimum/exclusive-maximum character range with GDI+ AA/one-bit modes, crop glyph sides and export 16 per row into a magenta-marker 32-bit BMP for XNA's FontTextureProcessor. The unchanged .NET 2 project builds and its UI/save dialog run; Mono's exported atlas demonstrates libgdiplus is not a pixel-faithful Windows reference. Sharp Runtime has no WinForms/System.Drawing, live CNA has no marker-BMP SpriteFont importer, and browser font/file semantics need an explicit modernization or native-only ruling. Decide tool scope under SAMPLES-DEC-005 and authored-content scope under SAMPLES-DEC-002. Evidence: samples/BitmapFontMaker/missing.md. Cancelled by the owner on 2026-09-09 with the other design-time WinForms tools; no port will be produced. The gap it found outlives the row and is recorded as entry 2 of cnanext/misc/known_gaps.md: XNA has two routes into a SpriteFont and CNA has only one — FontDescriptionProcessor is present, FontTextureProcessor is absent, so a marker-separated bitmap from any source, not merely from this tool, is unimportable.	⛔
SAMPLE-091	ClientServerSample_4_0	port	Native port complete; browser scope decision pending. The full original was audited and the prior reduced port corrected: exact A/B create/find/join flow, per-gamer server/client branching, input/state packet layout, gamer events, labels, rendering and all official inputs are restored; Guide/sign-in and message formatting are retained, while the F1 overlay, loose PNG/font substitutes and sample-side network workarounds are gone. The unchanged original builds and reaches its real menu under the offline XNA host; all three official XNBs are byte-identical. CNA e20749761 repairs the real defect exposed by the port: native Join now completes the ENet handshake before returning and installs the remote Host identity, with a real-peer regression plus 294/294 Debug and Release net tests. Debug and clean Release OPENGLES3 builds pass real two-process discovery/join, authoritative client-input routing and pixel-identical host/client post-movement frames. The WEBGL2 bundle builds, but Emscripten discovery/hosting is deliberately empty and the original has no direct-address route, so defining browser multiplayer requires SAMPLES-DEC-006; no fake lobby was added. NATIVE-ONLY SCOPE ACCEPTED by the owner on 2026-09-09, and the row is ✅ on that scope. The browser half needs the session directory plus inbound-capable peer that SAMPLE-075's re-audit reduced both of its blockers to, and which the owner declined to build the same day; a browser cannot open a raw datagram socket or accept an inbound peer, so that half is not this sample's to solve. The same day's re-audit also found and fixed a truncated capture: the native frames were 1040x600 where the sample's own backbuffer is 1067x600, because the window sat at x=240 on a 1280-wide Xvfb and 27 columns lay off the screen — the window was correct, the capture was not. capture-cna-native-two-process.sh now places both windows, records their geometry and refuses a capture that is not 1067x600, and on the re-taken frames the sample's central claim holds: client and host are bit-identical, RMSE 0 (0) and AE 0. Evidence: samples/ClientServerSample/missing.md.	✅
SAMPLE-092	ContentManifestExtensions_4_0	absent	Port complete at the owner-approved DEC-002 runtime boundary; the design-time assembly is audited, not falsely relabeled as a CNA authoring-tool port. The unchanged importer/processor assembly builds and its exact project-dependency, compiled-name, copied-file and automatic List<string> contracts were reproduced for Windows/HiDef and Phone/Reach. The port retains the complete runnable SampleGame.Game1, its 30 Hz and phone branches, Path.HasExtension partition, StringBuilder text, input and lifecycle, and deploys all ten byte-identical official XNBs plus the five exact copied files. CNA e5ae0820e fixes the real framework gap by registering XNA's standard ListReader<string> pair; a fresh ContentManager regression loads the authentic 454-byte manifest and all 14 entries in Debug and Release. Isolated XNA, Release OPENGLES3 and real-Chrome WEBGL2 frames are pixel-identical; WebGL 2 completes a 600-frame canary with no runtime error. Evidence: samples/ContentManifestExtensions/missing.md; decision: SAMPLES-DEC-002.	✅
SAMPLE-093	CurveEditor_4_0	absent	Freshly audited as a complete design-time authoring package; no fake game, reduced CLI or alternate UI was added. Its three exact projects contain 6,868 C# lines: reusable WinForms CurveControl, standalone CurveEditor and a separate editable/noneditable usage app. All exact sources compile, both applications run with official XNA 4 under isolated offline Wine, CTRL+N creates a real curve and the usage app draws its documented red/green graphs. A diagnostic through the unchanged public Save/Load methods round-trips the authentic IntermediateSerializer<Curve> XML with three keys, tangents, continuity and non-default loops. Live CNA already passes 82/82 Curve math and 29/29 XNB/CNJ/CNB curve-content tests; Sharp Runtime has no WinForms/System.Drawing, and the mandatory browser route requires an explicit component/UI/file-workflow modernization or scope ruling. Evidence: samples/CurveEditor/missing.md; decision: SAMPLES-DEC-005. Cancelled by the owner on 2026-09-09 with the other design-time WinForms tools; no port will be produced, and none was begun — samples/CurveEditor/ holds only the upstream .htm, the licence and missing.md, with no src/ and no CMake registration, so the row carries no sample-side workaround by construction. The gap it found outlives the row and is recorded as entry 3 of cnanext/misc/known_gaps.md: CNA parses the <XnaContent><Asset Type=...> envelope for exactly one schema (.spritefont), so every other IntermediateSerializer XML asset is unimportable whatever produced it; the runtime Curve half is already complete.	⛔
SAMPLE-094	CustomAvatarAnimation_4_0	absent	Freshly audited as a complete custom-avatar pipeline and Xbox game; no substitute or ground-only port was added. The unchanged 1,504-line four-project stack compiles, including the custom processor that validates and reorders a 71-bone FBX rig, merges animation keyframes and imports facial-expression CSV. Official Xbox360/HiDef processing successfully produces all five custom animation XNBs plus both ground XNBs, so the historical content-pipeline blocker is disproved. The defining runtime still needs Microsoft's proprietary body/appearance service, four built-in Stand clips and AvatarRenderer.Draw of custom matrices/expressions; normal CNA is deliberately unavailable/no-op and the CNAEXT renderer is a non-authentic substitute. Choose Xbox-only/non-port evidence, explicitly authorize and specify substitute custom-matrix/expression scope, or authorize a faithful dataset/normal-API backend under SAMPLES-DEC-004. Re-audited 2026-09-09, three additions. (a) The substitute option is larger than a scope ruling: AvatarRenderer has exactly three draw entry points, the two that accept 71 matrices are validated permanent no-ops and discard the expression outright, and the only one that renders — DrawRealEXT(clipName, position, loop) — derives its own bones from a SkinnedModelEXT clip and takes no expression at all, so authorizing it needs a new entry point accepting caller-supplied matrices plus an AvatarExpression, which is framework work rather than sample work. (b) A faithful port would not be merely invisible but degenerate: every preset has Length == Zero, Update clamps CurrentPosition to it, and the game's own CurrentPosition == Length idle test therefore re-rolls PlayRandomIdle() every frame — which is also what the original executable does off Xbox, and why upstream ships no Windows game project. (c) Upstream defect to reproduce rather than repair: PlayRandomIdle uses random.Next((int)AnimationType.Idle4) = Next(3), so the fourth Stand idle is loaded by the i < 4 preset loop and never played. Evidence: samples/CustomAvatarAnimation/missing.md. Cancelled by the owner on 2026-09-09 as an Xbox-only non-port, with SAMPLE-085–SAMPLE-087; no CNA port will be produced. Finding (a) above is not cancelled with the row: it describes AvatarRenderer's own shape, so any future Avatar work — SAMPLE-101, SAMPLE-113 or an authorized backend — meets the same missing entry point.	⛔
SAMPLE-095	GeolocationSample_4_0	absent	Freshly audited as a live Windows Phone GPS car finder; no static/random/replayed product coordinates were added. All 932 C# lines retain high-accuracy watcher startup, permission/status and position events, movement threshold, full coordinate/accuracy/speed/course display, saved-location distance/initial-bearing math, North-up/direction-up compass, touch UI and binary lifecycle persistence. The exact source type-checks and the official pipeline builds all four XNBs for both Phone and Windows, so content is not the blocker. Live CNA/Sharp Runtime have none of System.Device.Location; CNA explicitly labels the subsystem unimplemented, and SDL3 supplies no GPS. Choose a WP7/location-hardware non-port, authorize real platform providers/permissions/test seam for native and WEBGL2, or explicitly approve a narrower platform gate under SAMPLES-DEC-004. This sample deliberately does not use XmlSerializer. Re-audited 2026-09-09, four additions. (a) The gap is textually narrow and semantically total: 28 of 932 lines name a System.Device.Location type, all in Game1.cs, and the 360-line touch UI is location-free (its Location tokens are TouchLocation); porting the other 904 lines yields a program whose status string reads Initializing forever. (b) cnanext/docs/location-future-plan.md is a real design sketch, but it plans an Android path and an iOS path and nothing else — neither of the two platforms this campaign gates on, so option 2 starts with design rather than implementation. (c) Of the gated pair the browser is the cheap half — W3C GeolocationCoordinates matches GeoCoordinate almost field for field, watchPosition matches the watcher, and the sample already handles the NaN course a stationary device reports (Game1.cs:162) — while native desktop has no match at all, since SDL3 exposes no geolocation and Linux would mean GeoClue2 over D-Bus, a new external dependency rather than a new backend behind an existing seam. (d) Upstream defect: Program.cs constructs Game1 while the class is SampleGame (Game1.cs:24); it is dead under `#if WINDOWS
SAMPLE-096	InvitesSample_4_0	absent	Freshly audited as a complete LIVE invitation lesson; no local fake invite or SystemLink remap was added. The unchanged 734-line Windows/Xbox game and all three official Windows/Reach XNBs build; the offline original reaches the real Games for Windows LIVE sign-in and menu, then truthfully rejects PlayerMatch creation without an eligible LIVE profile. The sample requires two befriended Creators Club identities: pull/push Guide invites both deliver InviteAccepted, whose handler leaves any current session and calls JoinInvited, then remote tank packets run. Live CNA has all API shapes and passes 295/295 network tests, but those tests/documentation prove PlayerMatch is transport-free, friends empty, Guide synthetic and no producer raises the invite event; WEBGL2 also lacks hosting/discovery. Choose a retired-LIVE non-port, authorize a reusable native/browser identity+friends+matchmaking+invite+relay service, or explicitly approve a non-faithful SystemLink modernization under SAMPLES-DEC-004/006. Re-audited 2026-09-09, three additions. (a) The retained captures support a comparison the first pass stopped short of: with Player1 signed in and offline, real XNA refuses Create(PlayerMatch, 4, 16) and the sample prints the profile/LIVE requirement on screen (03-offline-player-match-create.png, with 02-after-local-sign-in.png proving the profile and menu were reached), while CNA succeeded and handed back a PlayerMatch session with no port, no discovery and no peer that could ever arrive. Since the sample's whole failure UX is the caught exception's message, the port would have had nothing to say. (b) JoinInvited did not refuse either — it built such a session out of nothing — and nothing raises InviteAccepted, so the handler cannot run at all. (c) Unrelated framework defect found here: NetworkSession::InviteAccepted, MaxSupportedGamers and MaxPreviousGamers were marked CNAEXT though all three are real XNA 4.0 members (verified in the official Microsoft.Xna.Framework.Net.dll in the local GAC), and under CNA_STRICT_XNA_API that macro is [[deprecated]], so a consumer building in strict mode was rejected for using documented XNA API. All three were fixed in CNA on 2026-09-09 (cnanext 8296b7750): create/find/join-invited now throw GamerServicesNotAvailableException naming the missing service, EndJoinInvited refuses every result, and the three markers are gone. That does not unblock this row — the absent identity/matchmaking/invitation service is what blocks it, and it stays entry 4 of cnanext/misc/known_gaps.md — but a port would now show a truthful error where it previously showed none. Cancelled by the owner on 2026-09-09 as a retired-LIVE non-port; no CNA port will be produced. The two framework fixes it produced are not cancelled with it — they are already in cnanext 8296b7750 — and neither is the remaining gap, the absent identity/matchmaking/invitation service, which SAMPLE-107 and any future networked row meets too. Evidence: samples/Invites/missing.md.	⛔
SAMPLE-097	MemoryMadnessLab_4_0	absent	Freshly audited as a two-endpoint Windows Phone training lab; no stage was silently discarded and no reduced port was added. Its authoritative 82-page/158-step document makes EX1 a separately compiled, completely playable 12-source/2,667-line multi-touch memory game, then uses a distinct solution/content project for the 20-source/4,455-line EX2 endpoint with sound, animated doors, main/new-game/loading/pause/high-score screens, Guide name entry, isolated persistence, background loading and launch/deactivate/tombstone/activate/resume. Assets/ is input material, not a third product. All 19 exact compiled items of both endpoints build through XNA 4 for Phone/Reach and Windows/Reach (76 XNBs total); both verbatim level XML inputs are retained, and this is LINQ to XML rather than DEC-008 XmlSerializer. Choose both runnable targets versus final EX2 plus retained EX1 deltas under SAMPLES-DEC-005, and establish the authentic phone lifecycle/reference boundary shared with SAMPLE-065. Re-audited 2026-09-09; the recorded lifecycle blocker has largely gone. (a) The audit's "live CNA contains no PhoneApplicationService" was overtaken six days later by SAMPLE-071's own work — cnanext bbd9ef0ef added modules/phone, and Current, State, all four lifecycle events and all four event-args types are present with nine tests. The single absent member is StartupMode, used once (EX2/MemoryMadnessGame.cs:72) to open the main menu or the pause screen; CNA's model — no shell above the game, AttachEXT meaning a fresh start — makes a constant Launch the honest answer, so this is one property plus a two-value enum rather than a subsystem. The tombstoning reference problem is unchanged: nothing here can kill and resume the original. (b) The retained evidence covered content only, so the sources had never been compiled here; scripts/compile-original-sources.sh now type-checks both unchanged against the official XNA 4.0 assemblies. EX1 compiles clean (12 sources, MemoryMadnessEx1.dll c57d6970c5bb…); EX2 fails on Microsoft.Phone alone — 5 using sites and 4 event-args types, no other error — because this machine has Windows/x86 and Xbox360 reference sets and no Phone assemblies. (c) The level XML is a loose file read with XDocument.Load off disk, the 20th manifest item per configuration, and sharp-runtime's xml-linq module covers every member both endpoints use. (d) The two endpoints do not share content: seven of nineteen assets are different sounds and their LevelDefinitions.xml hashes differ, so "EX2 plus retained EX1 deltas" would drop content, not only code. Cancelled by the owner on 2026-09-09; no CNA port will be produced for either endpoint. Two measurements outlive the row: the phone lifecycle service is real and tested in modules/phone, so SAMPLE-065 and any other WP7 row starts from it rather than from nothing; and StartupMode is still the one absent member of it. Evidence: samples/MemoryMadnessLab/missing.md.	⛔
SAMPLE-098	MicrophoneEchoSample_4_0	port	Re-ported completely with no sample workaround. The original namespace/class, Windows/Phone branches, default-first microphone selection, 100 ms capture, 150 ms/0.5 circular echo mix, endian checks, A/B and touch input, status and BasicEffect waveform are restored; the invented F1 overlay, renamed surface, loose font atlas and runtime help are gone. The checked-in Windows/HiDef MyFont.xnb is byte-identical XNA Game Studio output, and the same content builds for Phone/Reach. The unchanged XNA executable passes Stopped/Started/Stopped and waveform behavior. Debug/Release OPENGLES3 plus 95 focused CNA audio tests pass; a routed native 440 Hz source proves capture/echo playback. Real-Chrome WEBGL2 begins at permission prompt, grants microphone access, starts through trusted A input, produces a non-flat/non-silent waveform, returns through B to the exact baseline hash, completes 600 further frames and reports no runtime error. Status re-audited 2026-09-09 and the ✅ holds, re-verified rather than re-asserted: the checked-in XNB is still byte-identical, the method-for-method correspondence with the 487-line original is complete, the focused audio tests are 98/98 today (the 95 above have grown by three, all passing), and the browser gate's own record still shows WebGL2, permission prompt→granted, 600 further frames, stopped==stoppedAgain by hash with started differing, and zero runtime exceptions — its single console 404 is /favicon.ico, correctly excluded. One difference between the native captures is real and is CNA's, not the port's: the HUD is Microphone.Name, and XNA shows PulseAudio Input where CNA shows Default Device, because CNA's SDL3 provider prepended a synthetic default device exactly as FNA does and XNA does not. Fixed in CNA the same day (cnanext 30bd6cf60) on the owner's ruling that CNA follows XNA faithfully and FNA only after it; not a line of the port changed, because the defect was never in it. That fix then broke native capture and the owner caught it: with the synthetic entry gone and the list sorted by SDL id alone, Microphone::Default (= All[0]) became the machine's second, unconnected microphone, so the sample echoed silence on native while the original and the WEBGL2 build kept working. 5f491663a puts the host's default first — identified through SDL, marked truthfully, still XNA's shape — and scripts/verify-native-echo.sh now proves the echo end to end: a 440 Hz tone into the app's own recording stream comes back out of its own playback stream at −21.1 dB, dominant ~440 Hz. This sample is also one of the 51 orphan help.png carriers and one of the headers with no @brief, both already end-of-campaign items. Evidence: samples/MicrophoneEcho/missing.md.	✅
SAMPLE-099	ModelImporterSample_4_0	absent	Port complete at the owner-approved DEC-002 runtime boundary with no sample workaround. The complete official package recovered the sole missing local file, the 2.2 MB Tank.obj; the unchanged 596-line OBJ/MTL importer assembly builds and processes 10,910 positions, 14,312 UVs, 10,910 normals, 12 groups/material selections and 21,610 triangles through XNA's ModelProcessor. Its model and two external-texture XNBs are byte-identical official Windows/Reach output. The C++ ObjImporterSample::ObjImporterGame retains exact loading, input, bone transforms, lighting, camera, projection and rotation. The unchanged XNA executable and Debug/Release OPENGLES3 runs render the same textured rotating tank and exit cleanly. Real-Chrome WEBGL2 renders the same content, completes 600 frames on WebGL 2 and reports no runtime error; 22 focused model/XNB/external-reference tests pass. The design-time assembly is audited and preserved, not falsely labelled as a CNA authoring-pipeline port. Evidence: samples/ModelImporterSample/missing.md; decision: SAMPLES-DEC-002.	✅
SAMPLE-100	NetworkPredictionSample_4_0	port	Native port complete; browser scope decision pending. The original namespace, classes, member decomposition, session lifecycle, gamer events, packet cadence, tank/turret controls, rolling averages, prediction, smoothing and host options are restored; the F1 overlay, loose PNG/font sidecars and explicit PacketKind/options-packet workaround are gone. Exact official Windows/Reach Font, Tank and Turret XNBs were freshly reproduced byte-identically. CNA c195fe8ce adds the XNA-shaped mutable SessionProperties collection plus reliable authoritative snapshots in welcome/update paths, with 29/29 focused and 289/289 broad network tests. The unchanged XNA source builds and reaches its authentic menu. Debug/Release OPENGLES3 pass a real two-process create/discover/join run: client movement synchronizes, all four host options replicate without an application packet, and the complete gameplay crop is pixel-identical. Real-Chrome WEBGL2 renders the exact menu and local host state, completes 600 frames and reports no runtime error, but Emscripten discovery remains empty and a browser cannot accept an inbound System Link peer, so B=find/join and cross-peer prediction cannot be qualified without SAMPLES-DEC-006. Evidence: samples/NetworkPrediction/missing.md.	🛑
SAMPLE-101	ObjectPlacementOnAvatarSample_4_0	absent	Freshly audited as a distinct moving-bone object-attachment lesson; no bat-only or substitute-Avatar port was added. The unchanged 361-line Xbox360/HiDef source compiles and its exact baseballbat.fbx builds to an authentic stock Model XNB. The game waits for a genuine ready Avatar, composes all 71 matrices as animation × bind pose × parent world, and attaches the bat to SpecialRight across four built-in presets. Live CNA passes 69/69 focused Avatar tests but intentionally exposes invalid random descriptions, zero preset poses, unavailable bind pose/body and no-op normal Draw; its CNAEXT renderer uses a different non-authentic skeleton/content contract. Choose Xbox-only/non-port evidence, explicitly authorize a substitute plus truthful hand-bone mapping, or authorize a faithful dataset/normal-API backend under SAMPLES-DEC-004. Evidence: samples/ObjectPlacementOnAvatar/missing.md.	🛑
SAMPLE-102	Orientation_4_0	port	Re-ported completely in the shipped scenario #1 with no sample workaround. The original namespace/class, 30 Hz timing, fullscreen request, Tap enablement, Back-only exit, centered draw and complete inactive scenario-#4 lock branch are restored; the old scenario switch, O/mouse/Escape/F1 additions, runtime text, windowed mode and loose content substitutes are gone. Both checked-in WindowsPhone/Reach XNBs are exact XNA Game Studio output. The unchanged-source XNA diagnostic, Debug/Release OPENGLES3 and real-Chrome WEBGL2 frames decode pixel-identically; WebGL 2 completes over 600 measured CNA draws with no runtime error. Focused runtime/content/graphics tests pass 44/24/77. Evidence: samples/Orientation/{missing,diff}.md.	✅
SAMPLE-103	PeerToPeerSample_4_0	port	Native port complete; browser scope decision pending. The complete original namespace/classes, 1067x600 presentation, Gamer Services sign-in, A/B create/find/join, blocking-call messages, events, independently simulated local tanks, InOrder peer broadcasts, remote state ingestion, inputs, movement, labels and error formatting are restored. The F1 overlay, loose PNG/font sidecars and reduced header-only port are gone; all three checked-in XNBs are exact official Windows/Reach output. The unchanged XNA source builds and reaches its authentic menu; its Create failure is isolated-host GFWL networking, not a source failure. Debug and clean Release OPENGLES3 pass a real two-process test on independent displays: client-owned and host-owned tank movements both replicate, and each resulting complete host/client frame is pixel-identical. CNA Net 303/303, Runtime 159 plus two skips, Gamer Services 368/368, focused content 135/135 and focused graphics 208 plus seven skips pass. A clean WEBGL2 bundle builds with explicit WebGL 2 link settings, but Emscripten discovery/hosting cannot execute the original B=find/join and multi-peer broadcast paths without the reusable broker/relay decision in SAMPLES-DEC-006; no fake peer or manual address workaround was added. Evidence: samples/PeerToPeer/missing.md.	🛑
SAMPLE-104	PerformanceUtility_4_0	port	Complete. The distinct runnable utility restores all 13 original C# units: cat/usage rendering, initially hidden FPS and TimeRuler, A/B/X controls, Tab and Tap/Flick command UI, pos parsing/echo, nested timing log, layout/formatting helpers and the Windows SystemLink remote state machine. Both exact official XNA-pipeline XNBs are byte-identical. The unchanged XNA reference plus Debug and clean Release OPENGLES3 runs exercise the full keyboard/console route and clean exit; their baseline captures are byte-for-byte identical, and Debug reaches the honest remote no-session result. sharp-runtimenext 281d84bd preserves the missing two-Single String.Format overload; 9cc96cd5 preserves the original explicit invariant-provider Single.Parse route; the complete gate passes 17,937/17,937 tests. The WEBGL2 bundle was rebuilt against current cnanext and passed the mandatory gate in the system Google Chrome launched from the terminal: real WebGL 2 context, 800x480 canvas, A/B/X, Tab and pos 300 200 each producing a visible change, 600 consecutive animation frames, and no page error, rejection, fatal console message or HTTP error. Measured against the native OPENGLES3 baseline rather than asserted: 99.921% of interior pixels identical, and 99.998% with the FPS/timing/bar readouts masked. The earlier "standalone Playwright/CDP is not an allowed substitute" note did not hold -- rules.md has no such rule and SAMPLE-065 had already passed its own gate this way; what was unavailable was one agent's browser-extension route. Evidence and exact remaining gate: samples/PerformanceUtility/missing.md.	✅
SAMPLE-105	PushNotificationsSample_4_0	absent	Freshly audited as two deployed products; no fake channel or sender-only target was added. The WP7/Reach XNA client creates/reuses an MPNS HttpNotificationChannel, displays its service-issued URI, receives foreground raw/toast events and binds background toast/tile delivery to the phone shell. The separate WinForms sender posts the exact XML/BinaryWriter payloads and historic headers to that URI. In the offline Win7 VM the unchanged sender builds/runs and the WindowsPhone/Reach SpriteFont builds; the client project itself needs an uninstalled Phone XNA extension, while real delivery additionally needs the retired Microsoft service and shell. Choose evidence-backed non-port, a faithful reusable service plus native/browser shell integration, or an explicit modernized notification product under SAMPLES-DEC-004. Evidence: samples/PushNotifications/missing.md.	🛑
SAMPLE-106	SavingEmbeddedImages_4_0	absent	Freshly audited as a Windows Phone media-library and Guide lesson; no draw-only screen, hidden WASM file or sample-local Guide overlay was added. The unchanged 334-line game/package and official Phone/Reach pipeline produce all four exact platform-m XNBs; CNA reads both 480x800 textures and both SpriteFonts, while 77/77 focused native XNB/JPEG/MediaLibrary/Guide tests pass. The mandatory WEBGL2 path has no Pictures user folder, so MediaLibrary.SavePicture necessarily throws, and current CNA cannot run the original immediate blocking BeginShowMessageBox/EndShowMessageBox sequence without caller-owned CNAEXT rendering. Choose a Phone-media non-port, a reusable browser/native media-save plus automatic Guide design, or an explicitly scoped modernization under SAMPLES-DEC-004. Evidence: samples/SavingEmbeddedImages/missing.md.	🛑
SAMPLE-107	TiltPerspective_4_0	port	Port and native qualification complete; mandatory real-Chrome gate pending on host browser integration. The line-by-line audit restores the original ParallaxSample, real accelerometer route and exact sinusoidal emulator fallback, touch-only recalibration, GamePad Back-only exit, 480x800 fullscreen/Guide settings, multisampled 25-ball simulation, custom 24-byte Position/Normal vertex layout and disposal behavior. Invented keyboard/mouse/Escape/F1/help paths, dummy texture coordinates and desktop setting substitutions are gone; no CNA or Sharp Runtime change was needed. The exact stone4.xnb was rebuilt offline with XNA 4.0 in the Win7 VM and renders in Debug and clean Release OPENGLES3 runs. A clean WEBGL2 bundle builds with effective WebGL 2 link settings, but Chrome remains unavailable through the required extension/native-host route; no substitute browser path was used. Evidence: samples/TiltPerspective/missing.md.	🛠
SAMPLE-108	WinFormsContentSample_4_0	absent	Freshly audited as a complete WinForms runtime-content authoring/viewer tool; no Game, CLI, precompiled-model viewer or glTF substitute was added. The 1,659-line .NET 4 x86 application embeds a reference-counted XNA GraphicsDevice in a Control, handles status/reset/paint/override-window Present, offers an arbitrary FBX/X Open dialog, constructs an in-memory MSBuild XNA content project, logs build errors, loads the temporary XNB through ContentManager and continuously rotates an automatically framed Model. The unchanged Release build and full Cats.fbx dialog → runtime Model.xnb/cat_0.xnb → textured render path pass in the offline Win7 VM. Live CNA has many Model/device primitives but lacks arbitrary native-Control adoption, the rich Present overload and FBX/X source import; Sharp Runtime lacks WinForms, System.Drawing and Microsoft.Build, and the mandatory browser product boundary is undefined. Choose evidence-backed non-port, faithful Windows desktop-tool/native-only scope, or an explicitly modernized cross-platform tool under SAMPLES-DEC-005. Evidence: samples/WinFormsContentSample/missing.md.	🛑
SAMPLE-109	WinFormsGraphicsSample_4_0	absent	Freshly audited as a distinct two-control WinForms/XNA hosting demonstration; no single-window Game or fake UI was added. One shared reference-counted GraphicsDevice services an event-driven SpriteFont/ContentManager control and an idle-driven BasicEffect/DrawUserPrimitives spinning-triangle control; three real comboboxes convert named GDI colours to the live XNA vertices. The unchanged .NET 4 x86 solution and official hudFont XNB build. In offline Win7 the left content control and selectors paint, but the second multi-control override-target path remains black under VBoxSVGA after clean restart, idle wait and resize, so the reference render is honestly incomplete. Live CNA has the ordinary drawing/content APIs but lacks arbitrary native-Control adoption and the rich Present overload; Sharp Runtime lacks WinForms/System.Drawing, and browser multi-surface/UI semantics require a decision. Choose evidence-backed non-port, faithful Windows/native-only control hosting, or explicit cross-platform modernization under SAMPLES-DEC-005. Evidence: samples/WinFormsGraphicsSample/missing.md.	🛑
SAMPLE-110	WP7MusicManagement_4_0	absent	Freshly audited as a Windows Phone music-ownership and external-task lifecycle lesson; no toggle-only screen or fake launcher was added. Its 677 C# lines poll MediaPlayer.GameHasControl, recover Play/Resume failures and distinguish video, photo-chooser and web-browser deactivate/reactivate behavior. The unchanged official content project builds exact Phone/Reach Font.xnb and Song XNB/WMA; the Song XNB is byte-identical to qualified SAMPLE-060, and 68/68 focused CNA tests pass. The game project needs an uninstalled Phone XNA extension, while live CNA hardcodes music control true, lacks all three Microsoft.Phone.Tasks launchers and requires caller-owned Guide rendering. Choose Phone-only non-port, reusable native/browser platform tasks plus exact audio/Guide lifecycle, or explicit modernization under SAMPLES-DEC-004. Evidence: samples/WP7MusicManagement/missing.md.	🛑
SAMPLE-111	XnaGraphicsProfileChecker_4_0	absent	Freshly audited as a standalone C++/CLI WinForms D3D9 diagnostic; no boolean-only probe, CLI rewrite or WebGL caps substitution was added. Its 1,103 source/header lines independently reproduce XNA Reach/HiDef requirements through native GetDeviceCaps/CheckDeviceFormat, compare against GraphicsAdapter.IsProfileSupported, render detailed HTML and copy plain text. The exact Release/Win32 project reaches MSBuild but this VM lacks all documented VC++ 2010 build tools; no runtime result is claimed. Live CNA passes 33/33 adapter/capability tests and has real DirectX9 probes plus a distinct cross-renderer capability report, but the original Windows driver diagnosis has no truthful mandatory-WEBGL2 product. Choose non-port, a prerequisite-backed Windows/native-only tool exception, or explicit CNA capability-viewer modernization under SAMPLES-DEC-005. Evidence: samples/XnaGraphicsProfileChecker/missing.md.	🛑

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	Freshly audited as a licensed binary Avatar-animation asset delivery; no invented viewer or decoder was added. All 23 files are retained: 21 distinct 10–17 KB STRB binaries, an Ms-PL RTF and a UTF-16BE conversion script. There is no project, source, documentation, entry point or declared consumer. The script targets male/custom/animation conversion but its AvatarAssetConverter_e.exe is absent and it invokes an undefined variable. Live CNA has no STRB contract; 76/76 focused Avatar tests pass offscreen, confirming the normal renderer remains unavailable/no-op and the real renderer is a non-authentic CNAEXT route. Choose evidence-backed archive/non-port, future faithful-backend support data, or an explicitly modernized importer/preview product under SAMPLES-DEC-004/005. Evidence: samples/AvatarAnimPackBIN/missing.md.	🛑
SAMPLE-113	AvatarAnimPack_4_0_FBX	absent	Freshly audited as a valid 21-animation source-FBX support delivery; no invented viewer or raw-FBX runtime path was added. Its 201 MB comprise 21 distinct Kaydara FBX 6.1 Avatar rigs plus an Ms-PL RTF, with no project, source, docs, entry point or UI. The basenames pair exactly with SAMPLE-112, but the missing converter prevents an unproven byte relationship; all five names shared with SAMPLE-094 have different FBX hashes. A documentation-backed diagnostic uses the official XNA 4.0 FbxImporter and exact custom-avatar processor: all 21 unchanged assets produce deterministic Xbox360/HiDef XNB v5/LZX objects, so content validity is not the blocker. Normal CNA Avatar rendering remains unavailable/no-op and its real path is a non-authentic CNAEXT substitute. Choose archive/non-port, retained future-backend support data, or an explicitly new preview product under SAMPLES-DEC-004/005. Evidence: samples/AvatarAnimPackFBX/missing.md.	🛑
SAMPLE-114	AvatarAnimPack_4_0_Maya	absent	Freshly audited as a complete Maya 2009 authoring companion; no invented game, parser or conversion was added. Its 252 files are 21 substantial Maya ASCII scenes, 220 valid TGA textures, ten swatches and an Ms-PL RTF. Every scene has 104 joints, 30 meshes, one BASE__Skeleton and 202–238 animation curves; all 21 names pair exactly with SAMPLE-113, whose FBX/XNA pipeline is already validated. Upstream has no project, docs, entry point or runtime UI, and authentic .ma export requires absent proprietary Maya Unlimited 2009/Mayatomr. Choose archive/non-port, retained editable support data, or an explicitly authorized modern-DCC migration/tool and preview scope under SAMPLES-DEC-004/005. Evidence: samples/AvatarAnimPackMaya/missing.md.	🛑
SAMPLE-115	AvatarAnimPack_4_0_Mod_Tool	absent	Freshly audited as a complete documented Softimage Mod Tool 7.5 authoring companion; no invented game, parser or conversion was added. Its 148 files comprise 21 substantive OLE .exp scenes, 106 TGA and 13 TIFF rig textures, six workflow screenshots, HTML instructions and an Ms-PL RTF. The docs prescribe project-relative loading, plotting Skin_Joints, first-frame positioning and exact Crosswalk 3.3 FBX export settings; all 21 names pair with SAMPLE-113, whose FBX/XNA pipeline is already validated. Upstream has no project, code, entry point or runtime UI, and authentic .exp export requires absent retired proprietary Softimage/Crosswalk. Choose archive/non-port, retained editable support data, or an explicitly authorized modern-DCC migration/tool and preview scope under SAMPLES-DEC-004/005. Evidence: samples/AvatarAnimPackModTool/missing.md.	🛑
SAMPLE-116	AvatarRig_4_0_Max_2010	absent	Freshly audited as a complete documented 3ds Max 2010 base rig; no invented game, parser or conversion was added. Its 239 files comprise one substantive 8.56 MB OLE .max scene, 220 TGA textures, ten swatches, three screenshots, HTML instructions and support/licence metadata. The texture/swatch hash multiset exactly matches SAMPLE-114. The docs prescribe external texture paths and exact FBX 2009.0 baking, skin/morph, bones, unit/axis and binary-format settings. Upstream has no project, code, entry point or runtime UI, and authentic .max export requires absent proprietary 3ds Max. Choose archive/non-port, retained editable support data, or an explicitly authorized modern-DCC migration/tool and preview scope under SAMPLES-DEC-004/005. Evidence: samples/AvatarRigMax2010/missing.md.	🛑
SAMPLE-117	AvatarRig_4_0_Maya_2009	absent	Freshly audited as the complete documented Maya 2009 base rig corresponding to SAMPLE-114; no invented game, parser or conversion was added. Its 234 files comprise one 178,173-line Maya scene, 220 TGA textures, ten swatches, an export screenshot, HTML instructions and an Ms-PL RTF. Base and all 21 finished scenes have 104 joints, 30 meshes and one BASE__Skeleton; the base has six animation curves versus 202–238 per clip, and all 230 texture/swatch hashes match. The docs prescribe exact FBX 2009.2 bake/deformation/filter/media/unit/axis/binary settings. Upstream has no runtime product, and authentic export requires absent Maya Unlimited 2009/Mayatomr. Choose archive/non-port, retained editable support data, or explicit modern-DCC migration/tool and preview scope under SAMPLES-DEC-004/005. Evidence: samples/AvatarRigMaya2009/missing.md.	🛑
SAMPLE-118	AvatarRig_4_0_SoftImage_Mod_Tool7_5	absent	Freshly audited as the complete documented Softimage Mod Tool 7.5 base rig corresponding to SAMPLE-115; no invented game, parser or conversion was added. Its 128 files comprise one substantive 6.44 MB OLE .exp scene, 106 TGA and 13 TIFF textures, six workflow screenshots, HTML instructions and an Ms-PL RTF. Documentation and all 119 pictures are byte-identical to SAMPLE-115; base and 21 authored scenes share the 30-stream OLE/version identity, while measured model-stream sizes distinguish them. Upstream has no runtime product, and authentic export requires absent retired Softimage/Crosswalk. Choose archive/non-port, retained editable support data, or explicit modern-DCC migration/tool and preview scope under SAMPLES-DEC-004/005. Evidence: samples/AvatarRigSoftimageModTool75/missing.md.	🛑
SAMPLE-119	BasicEffectShader_ARCHIVE_2_0	absent	Freshly audited as a complete three-file XNA 2 educational shader archive; no profile rewrite, modern alias or invented viewer was added. The 685-line monolithic BasicEffect source has twelve vs_1_1, eight ps_1_1 and four ps_2_0 compile entries behind one dynamic technique; HTML documents its twelve modes. It is materially different from the XNA 4/FNA source, and the official XNA 4 compiler predictably rejects it because ps_1_x is no longer supported. Upstream supplies no project, compiler, compiled blob or runtime product, while current CNA's XNA 4 BasicEffect/content/C API/offscreen render gates pass 46/46 plus focused probes. Choose archive/non-port, retained historical support data, or an explicitly scoped legacy-shader compiler/tool and native/WEBGL2 product under SAMPLES-DEC-005. Evidence: samples/BasicEffectShaderArchive/missing.md.	🛑
SAMPLE-120	ButtonImages	absent	Freshly audited as a complete licensed controller-image resource pack; no gallery, input visualizer or invented game was added. Its 17 files contain fourteen full-size RGBA/RLE controller-element TGAs, a 1,729×188 14-glyph SpriteFont strip, HTML mapping/import instructions and Ms-PL RTF, but no project, code, entry point or runtime UI. All fifteen unchanged images pass the official XNA 4 Windows/Reach pipeline as fourteen Texture2D XNBs plus one FontTextureProcessor SpriteFont XNB; current CNA consumes/transcodes all fifteen with 13/13 focused content tests passing. No exact copies exist elsewhere; Pathfinding/Flocking use only their own 20×20 A/B/X/Y derivatives and are already complete with exact XNBs. Choose resource-pack non-port, retained shared support data, or an explicitly scoped native/WEBGL2 asset product under SAMPLES-DEC-005. Evidence: samples/ButtonImages/missing.md.	🛑
SAMPLE-121	CardsStarterKit_4_0_VB	absent	Freshly audited as Microsoft's Visual Basic translation of the already-complete SAMPLE-069 product; no duplicate alias or second game copy was invented. All 47 logical source pairs have the same application strings and declared types except BlackJackGame casing; two extra VBCoreHelper modules supply VB numeric-cast mechanics, while compiled surfaces differ only by VB Module constructors, private WithEvents properties and Main visibility. Both content-project contracts match (89 HiDef/90 Phone items), all 89 rebuilt official HiDef XNBs are byte-identical, and the unchanged VB original passes the full bet/deal/stand/result/pause/menu path. Its deterministic $25-chip and returned-menu frames are byte-identical to the separately run C# original. Choose one shared language-neutral C++ product, retained VB support/reference data, or a separate target that explicitly preserves VB casing/root-namespace identity under SAMPLES-DEC-005. Evidence: samples/CardsStarterKitVB/missing.md.	🛑
SAMPLE-122	Catapult_ARCHIVE_2_0	absent	Freshly audited as a complete distinct XNA 2.0 pumpkin-distance game; it is not CatapultWars and no alias/partial rewrite was added. Its 1,002 C# lines implement six catapult/projectile states, three boost zones, crash/bounce physics, parallax/HUD, binary high-score storage and nine XACT cues over nine WAVs; a full hash comparison shares no source or runtime content with SAMPLE-067. The local XNA2 compiler/pipeline/XACT2 builder and original binaries are absent; XP was booted offline/headless but its Guest Control credentials are unknown, so no authentic runtime claim is made. All eight textures plus Tahoma SpriteFont pass the official XNA4 pipeline and current CNA conversion (9/9), while unchanged XACT2 Sounds.xap is explicitly rejected by XNA4 BuildXact as version-incompatible. Unchanged source reaches exactly eight bounded XNA2→XNA4 storage/SpriteBatch migration errors; live CNA passes 256 XACT/audio, 9 storage and 13 focused content tests, but exact XACT2 bank compatibility remains unproven. Choose a prerequisite-backed faithful older-XNA port, explicit XNA4/XACT3 modernization, or historical-game archive/non-port under SAMPLES-DEC-005. Evidence: samples/CatapultArchive/missing.md.	🛑
SAMPLE-123	ControllerImages	absent	Freshly audited as a complete licensed four-render resource pack; no gallery, input visualizer or InputReporter alias was invented. It has four 512×512 RGBA PNG views of a white Xbox 360 controller plus the license, but no project, code, content project, usage document or runtime behavior. A collection-wide hash/name scan finds no exact copy or reference; InputReporter's generic comment refers to its own eight unrelated 29–50px HUD fragments and its complete SAMPLE-009 port already uses their exact XNBs. All four unchanged images pass the official XNA4 Windows/Reach Texture2D pipeline, current CNA conversion and 9/9 focused content tests. Choose resource-pack non-port, retained shared support data or an explicitly scoped controller-gallery product under SAMPLES-DEC-005. Evidence: samples/ControllerImages/missing.md.	🛑
SAMPLE-124	CustomIndeterminateProgressBarSample	absent	Freshly audited as a complete Windows Phone 7 Silverlight control demonstration; no fake XNA game, reduced animation or HTML/CSS rewrite was added. Its 681 C# and 199 XAML lines implement a 455-line resize-relative animation adapter plus a 4.4-second compositor-thread template with five staggered cached rectangles, 12 timelines and 32 key frames; the button toggles both indeterminate state and visibility. The offline/headless Win7 build selects the unchanged project but stops on the absent Phone Silverlight v4 targets explicitly required by the readme, so no original runtime is claimed. Live CNA/Sharp has no System.Windows/Phone controls, visual-state, storyboard or animation stack. SAMPLE-139 PushRecipe reuses all 212 normalized logical control lines and a semantically identical style, but is a distinct product. Choose Silverlight non-port, shared historical support data or an explicitly scoped native/browser UI-control modernization under SAMPLES-DEC-005. Evidence: samples/CustomIndeterminateProgressBar/missing.md.	🛑
SAMPLE-125	GSMSample_4_0_Mango	absent	Freshly audited as a materially revised Mango/Phone Game State Management generation; no partial merge, alias or Phone substitute was added. Fourteen of fifteen mapped SAMPLE-072 sources changed and nine units are new, adding the reusable library split, InputAction, screen lifecycle/serializable stack, runtime type/factory restoration and Phone touch/tombstoning state; the existing port has none of its seven new runtime types. Only two of five assets/XNBs match SAMPLE-072. The unchanged 800x480 Windows product and all five official XNBs build, its nine-state reference path exits cleanly, all five items convert through CNA and 13/13 focused content tests pass. The offline Win7 XNA installation explicitly rejects Windows Phone projects, live CNA/Sharp lacks PhoneApplicationService, and Sharp's permanent no-reflection boundary requires an explicit closed AOT factory design. Choose a shared Mango upgrade, separate Mango/Phone product or retained distinct reference/support data under SAMPLES-DEC-005. Evidence: samples/GameStateManagementMango/missing.md.	🛑
SAMPLE-126	GSMSample_4_0_Mango_VB	absent	Freshly audited as the complete Visual Basic Mango generation; no alias, duplicate target or C# normalization was added. All 24 logical sources and six project compile sets pair with SAMPLE-125 and all six content files are byte-identical, but exact assemblies prove ten public-versus-restricted setter differences, omitted active-screen gesture propagation, _Position identity and reachable Preferred ungulate: 1/2 output rather than C# enum names. Its Phone 7.1 manifest also adds five capabilities and changes shell identity/artwork. Authentic Win7 /vbruntime* Windows MSBuild passes with 0 warnings/errors, both nine-state executions exit cleanly, all five Win7 XNBs convert and 13/13 focused tests pass; the installed XNA explicitly rejects Phone projects. Choose a C#-canonical shared Mango product, distinct VB-faithful product or retained language/platform reference under SAMPLES-DEC-005, together with SAMPLE-125's lifecycle/factory ruling. Evidence: samples/GameStateManagementMangoVB/missing.md.	🛑
SAMPLE-127	GSMSample_4_0_PHONE	absent	Freshly audited as a distinct pre-Mango Phone 7.0 product; no SAMPLE-072 alias, desktop controls, fake lifecycle or reflection workaround was added. Its complete 14-unit project has eight material source deltas: full-screen 480x800 at 30 Hz, tap-only padded menus, hardware Back navigation, no pause/explicit exit/back entries, and binary isolated-storage stack persistence through assembly-qualified types. Live Sharp now covers storage/streams/binary I/O, but faithful runtime type restoration still needs an approved closed AOT registry plus portable Phone lifecycle/Back semantics. Authentic Win7 Build reaches the unsupported-XNA-Phone diagnostic; Rebuild also proves the original solution lacks Content mappings, while a host run fails honestly without Phone/XAP application identity. Five format-reference XNBs convert and 13/13 CNA tests pass. Choose a distinct faithful Phone product, canonical merged GSM generation or historical non-port under SAMPLES-DEC-005. Evidence: samples/GameStateManagementPhone/missing.md.	🛑
SAMPLE-128	LevelStarterKit	absent	Freshly audited as a complete Windows Phone 7 Silverlight level application; no fake XNA game, reduced bubble or HTML/CSS rewrite was added. Its complete 2,195 C# / 233 XAML / 750 resource lines implement calibrated 25-sample sensor filtering, seven orientations, theme-aware surface/tube modes, adaptive angle text, bubble physics, six localized shell names and full Phone lifecycle. The project has zero XNA references. Live CNA's real accelerometer passes 89 executable focused tests (two hardware routes skipped), Sharp resources/storage pass 8/8 and 63/63, but the Silverlight/Phone UI/XAP stack and exact IsolatedStorageSettings contract are absent. Authentic offline Win7 Rebuild selects the unchanged project and stops on the missing Phone Silverlight targets explicitly required by its readme. Choose historical non-port, support/reference delivery or an explicitly scoped complete native/WEBGL2 modernization under SAMPLES-DEC-005. Evidence: samples/LevelStarterKit/missing.md.	🛑
SAMPLE-129	LobbyChatImages	absent	Freshly audited as a complete licensed lobby/chat resource pack; no gallery, fake lobby or network-sample alias was invented. It has five 64×64 RGBA state icons plus Ms-PL but no project, code, entry point, UI or usage document. Four icons are byte-identical compiled NetRumble inputs and its code selects them for voice/readiness; the local-house icon is unique and unused, while Network State Management owns distinct 28×28 semantic alternatives. All five unchanged PNGs pass the official XNA4 Windows/Reach Texture2D pipeline, current CNA conversion and 9/9 focused content tests. Choose resource-pack non-port, retained shared support data or an explicitly scoped status visualizer under SAMPLES-DEC-005. Evidence: samples/LobbyChatImages/missing.md.	🛑
SAMPLE-130	MaterialsAndLights_ARCHIVE_2_0	absent	Freshly audited as a complete XNA 2 Shader Series game; no per-clone parameter fan-out, shader-profile rewrite or reduced lighting scene was added. Its 1,464 C# and 376 HLSL lines draw nine material instances over five mesh types with up to eight point lights, diffuse/specular textures and Phong lighting. Fourteen of fifteen unchanged items build through XNA4 Release; both material effects parse/bind on real GLES3, 53/54 focused effect tests pass with one unrelated volume-sampler skip, and 17/17 content tests pass. The exact point-light effect alone needs a bounded ps_1_1→2.0 migration, but the defining behavior is removed XNA2 EffectPool propagation of seven shared declarations into nine clones; XNA4/FNA have no public pool and CNA/MojoShader correctly isolate clone values. Choose isolated legacy compatibility, explicit XNA4 modernization or historical non-port under SAMPLES-DEC-005. Evidence: samples/MaterialsAndLightsArchive/missing.md.	🛑
SAMPLE-131	Minjie_ARCHIVE_2_0	absent	Freshly audited as a complete XNA 2 strategy game; no audio-free port, loose-WAV replacement or unapproved XNA4 rewrite was added. Its 3,311 C# lines implement a 10×10 Reversi-style product with one-player depth-three/7,000-node minimax, two-player input, six BasicEffect models, falling pieces, camera controls, three result screens and an eight-cue/nine-wave XACT graph. All nineteen unchanged sources reach only one old RenderState error against XNA4, and all sixteen visual XNBs build/convert with 256/256 XACT and 9/9 content tests passing. The exact XACT2 project is materially required but XNA4 rejects its version and no original banks/local XNA2 builder exist. Choose authentic XNA2/XACT2 port, explicit XNA4/XACT3 modernization or historical non-port under SAMPLES-DEC-005. Evidence: samples/MinjieArchive/missing.md.	🛑
SAMPLE-132	ModelViewerDemo_4_0_Mango	absent	Freshly audited as a complete Windows Phone 7.1 Silverlight/XNA hybrid; no standalone tank Game, reduced UI or HTML/CSS substitute was added. Its 2,077 C# and 330 XAML lines define seven navigated pages, 12 buttons, 10 checkboxes, six sliders, 16 two-way bindings, dependency-property/Storyboard camera transitions, XNA UI-to-texture compositing, shared-device lifecycle, touch orbit/pinch, five tank animations, renderer settings and three editable lights. The custom pipeline builds all six exact Phone XNBs; five stock products convert through CNA and the reflective Sky has SAMPLE-012's established closed-reader shape. The Win7 solution lacks Phone 7.1 Silverlight targets, while CNA/Sharp lack the defining Phone/XAML/sharing stack. Choose faithful compatibility, complete native/WEBGL2 modernization or historical non-port under SAMPLES-DEC-005. Evidence: samples/ModelViewerDemoMango/missing.md.	🛑
SAMPLE-133	Movipa	absent	Freshly audited as a complete XNA 2 moving-image puzzle game; no reduced video demo, audio replacement, custom XML parser or unapproved XNA4 rewrite was added. Its 315 files include seven runtime/pipeline projects, 111 C# files / 29,259 lines, 37 scene/data XML files / 45,442 lines, ten normal stages, ten movies, custom scene/layout/movie/skinning readers and an eleven-cue XACT2 graph. After two isolated XNA4 diagnostic migrations, the official pipeline builds all 126 non-XACT items into 138 dependency-complete XNBs; exact XACT2 is rejected. CNA validates 93 generic products and truthfully refuses 45 sample-owned reader/tag, legacy-effect and collection graphs. A faithful port additionally depends on the shared XmlSerializer decision for normal-mode save slots. Choose authentic XNA2/XACT2, explicit complete XNA4 modernization or historical non-port under SAMPLES-DEC-005 and SAMPLES-DEC-008. Evidence: samples/Movipa/missing.md.	🛑
SAMPLE-134	MultipassLighting_ARCHIVE_2_0	absent	Freshly audited as a distinct complete XNA 2 Shader Series multipass-lighting product; no per-clone parameter fan-out, shader-profile rewrite or reduced scene was added. Its 1,640 C# and 330 HLSL lines draw eight material/mesh combinations, a floor and visible spheres for 30 initial/300 maximum moving lights, using an ambient depth-writing pass plus additive light passes. Nine material clones rely on five XNA2 shared scene parameters propagated through the removed EffectPool; XNA4/FNA/CNA clones are intentionally independent. All 46 unchanged-source errors are measured XNA2 API families. XNA4 Release builds 14/15 content items, the exact ps_1_1 point-light marker alone needs a profile migration, and both exact material effects parse/bind on real GLES3 with 53/54 focused effect and 17/17 content tests passing. Choose isolated legacy compatibility, explicit XNA4 modernization or historical non-port under SAMPLES-DEC-005. Evidence: samples/MultipassLightingArchive/missing.md.	🛑
SAMPLE-135	NonLinear-WP-SLApp-Navigation-Service	absent	Freshly audited as a complete Windows Phone 7 Silverlight navigation recipe; no fake Game, generic router or reduced URI-stack demo was added. Its 40 files contain two independently runnable apps plus a reusable 362-line service: the two-page baseline proves repeated-instance back-stack growth, while the four-page sample recursively navigates Back to an existing URI with cancellation guards, frame-opacity restoration, application-bar suppression, query binding, hardware-Back handling and tombstoning history. The exact 11-page document is fully rendered/inspected. Both unchanged app solutions select their correct projects and stop at missing Phone Silverlight v4 targets; both also reference an undelivered logger DLL. CNA/Sharp have no Phone page/frame/navigation/XAP stack. Choose historical non-port, full retired-platform compatibility or explicit two-product native/WEBGL2 modernization under SAMPLES-DEC-005. Evidence: samples/NonLinearNavigationService/missing.md.	🛑
SAMPLE-136	PaddleBattle_4_0_Mango	absent	Freshly audited as a complete Windows Phone 7.1 Silverlight/XNA hybrid; no standalone Pong Game, fake UI or loose-content substitute was added. Its 972 C# and 130 XAML lines implement a real Silverlight Play/checkbox page, persistent dependency-property settings, Phone lifecycle, shared GraphicsDevice mode and UIElementRenderer-composited live score text over touch-only XNA gameplay. All five exact Phone/Reach Texture2D/SoundEffect XNBs build, convert 5/5 and pass 17/17 focused CNA tests. The unchanged host lacks Phone 7.1 targets and also contains a measured PinballBattleLib path typo; CNA/Sharp have no defining Phone/Silverlight/XNA sharing stack. Choose historical non-port, complete retired-platform compatibility or explicit full native/WEBGL2 hybrid modernization under SAMPLES-DEC-005. Evidence: samples/PaddleBattle/missing.md.	🛑
SAMPLE-137	PaddleBattle_4_0_Mango_VB	absent	Freshly audited as the complete Visual Basic delivery of SAMPLE-136's Phone 7.1 Silverlight/XNA hybrid; no duplicate C++ target, C# alias or Pong-only substitute was added. All eight source/shell assets, three semantic XAML trees and five rebuilt WindowsPhone/Reach XNBs match; CNA converts 5/5 and passes 17/17 focused tests. The exact host-independent VB gameplay compiles, but direct Sprite.Bounds evidence proves VB CInt rounding (2,-2) where C# truncates (1,-1) at (1.6,-1.6). VB also fixes the C# bridge path and has distinct Phone/assembly identity. Choose the shared hybrid-platform boundary plus C#-canonical, VB-canonical, separately faithful or reference-only semantics/identity under SAMPLES-DEC-005. Evidence: samples/PaddleBattleVB/missing.md.	🛑
SAMPLE-138	Pickture_ARCHIVE_2_0	absent	Freshly audited as a complete XNA 2 sliding-picture puzzle; no audio-free puzzle, tag sidecar or generic-board substitute was added. Its 4,473 runtime C# lines implement five 3×3–10×10 one/two-sided modes, 30-second study per side, deterministic-sized shuffling, row/column shifts, independent chip/board rotations, eleven pictures and a 40-photo completion scene. Its custom processor generates tangents and writes required Front/Back mesh-part tags; its five-cue XACT2 graph is material. Unchanged source reaches 20 bounded XNA2→XNA4 API errors. Official XNA4 Release builds all 22 non-XACT XNBs, and the exact 20-parameter/two-pass effect parses/binds on real GLES3; XACT2 is rejected as version-incompatible. CNA converts 20 products and truthfully refuses lossy EffectReader/tagged-model CNB conversions; 47/47 focused tests pass. Choose authentic XNA2/XACT2, explicit complete XNA4/audio modernization or historical non-port under SAMPLES-DEC-005. Evidence: samples/PicktureArchive/missing.md.	🛑
SAMPLE-139	PushRecipe_WP7_SL	absent	Freshly audited as a complete non-XNA Phone Silverlight/WPF/WCF/MPNS product; no fake channel, local echo, server-only target or invented Game was added. Its 65 C# / 6,479 and 17 XAML / 1,537 lines implement the persistent Phone client, thread-safe MPNS library, two hosted services and five coordinated push patterns. The unchanged library/server build and all five authored 650×700 WPF tabs run headlessly; the Phone project stops on absent Silverlight targets. It reuses SAMPLE-124's exact normalized progress control/style but shares only two generic scaffold files with distinct SAMPLE-105. Choose historical non-port, faithful retired-platform route or a complete explicitly modernized two-product system under SAMPLES-DEC-004/005. Evidence: samples/PushRecipeWP7SL/missing.md.	🛑
SAMPLE-140	RedistributableTTFs_ARCHIVE_3_1	absent	Freshly audited as Microsoft's complete licensed 28-font XNA Game Studio support pack; no gallery, installer or invented game was added. All exact TrueType SFNTs render and cover U+0020–U+007E; all 28 build through the official XNA4 Windows/Reach SpriteFont pipeline, convert to self-contained 95-character CNA CNBs and pass 23/23 focused real-GLES3 tests. A collection scan finds 171/220 SpriteFont declarations across 67 directories naming nine supplied families, with no duplicate TTF elsewhere. The document permits original-format redistribution as part of an XNA game, but the pack has no project, code, entry point or runtime product. Choose licensed shared-support archive/non-port, explicit design-time packaging or a newly scoped gallery under SAMPLES-DEC-005. Evidence: samples/RedistributableTTFsArchive/missing.md.	🛑
SAMPLE-141	Riemers	absent	Freshly audited as five complete asset archives, not five delivered runnable tutorial products; no lesson/game, viewer, shader rewrite or screenshot reconstruction was invented. The 5 ZIPs contain 54 files / 13,160,500 bytes: 35 images, six audio files, six models, four effects, one SpriteFont, one MGCB and one raw XNA logo, but zero source/project/entry-point/licence files. The sole authored 2D MGCB has 12 items; official XNA4 builds 47/52 diagnostic candidates, exposing an invalid 24-bit WAV, an uncontracted Song conversion, two retired ps_1_1 effects and a missing clouds.jpg. CNA preserves the WAV rejection, converts 51/56 XNBs and passes 120/120 focused real-GLES3 tests; two EffectReader CNB conversions and three nullable-resource model graphs remain truthful deferred boundaries. Choose asset/support archive, complete licensed tutorial sources/endpoints or explicitly new demonstrations under SAMPLES-DEC-002/005. Evidence: samples/Riemers/missing.md.	🛑
SAMPLE-142	RobotGame_ARCHIVE_2_0	absent	Freshly audited as Microsoft's complete licensed XNA 2 Windows/Xbox robot-combat mini-game; no partial XNA4 rewrite, loose-content substitute or reduced viewer was added. Its 109 C# units / 36,622 lines implement two campaign stages, split-screen versus, animation, advanced particles, collision, normal/specular mapping, post-processing and 52 runtime XACT cues. The offline Win7 VM is available but has only XNA4 and no retained Robot Game build; unchanged sources expose 117 XNA2→XNA4 diagnostics. Official XNA4 builds 63/65 stock items into 126 XNBs, while two legacy effects and XACT2 are incompatible; 296 sample-processor/XACT items need an authentic XNA2 route or explicit full modernization. CNA converts 124 products and passes 156/156 focused real-GLES3 tests. Choose authentic XNA2/XACT2 plus exact custom outputs, complete XNA4 modernization, or historical non-port under SAMPLES-DEC-002/005; later qualify the owner-managed shared serializer under SAMPLES-DEC-008. Evidence: samples/RobotGameArchive/missing.md.	🛑
SAMPLE-143	RolePlayingGame_4_0_Phone	absent	Freshly audited as a materially distinct Windows Phone 7 generation; no desktop alias, reduced Phone game, handwritten serializer or asset substitute was added. Only 64/140 C# files match SAMPLE-070 exactly; the Phone product adds gesture input, 800x480/30 Hz scaling, map unload/reload state, isolated storage and a separate 1,032-item content generation where 992 shared assets differ. The offline Win7/XNA4 VM lacks Phone targets; the official pipeline builds 1,031/1,032 exact Phone XNBs and stops only on unavailable Arial Narrow for DebugFont. CNA builds all 750 stock products, truthfully refuses 281 sample readers and passes 156/156 focused real-GLES3 tests. Choose separate Phone, complete merged-generation or historical non-port scope plus exact DebugFont/custom-reader policy under SAMPLES-DEC-002/005; its 34 live XmlSerializer sites also join SAMPLES-DEC-008. Evidence: samples/RolePlayingGamePhone/missing.md.	🛑
SAMPLE-144	SilverlightMicrophoneSample	absent	Freshly audited as a complete Windows Phone 7.0 Silverlight recorder application; no generic Game, HTML mock-up, reduced recorder or SAMPLE-098 alias was added. Its 369 C# and 77 XAML lines implement Phone lifecycle/frame setup, a portrait page, three-button ApplicationBar, exact record/stop/play state machine, 500 ms mono capture and worker-thread raw-PCM playback. The unchanged offline Win7 build selects the exact project and stops at absent Phone Silverlight v4 targets. Live CNA passes 198/198 focused microphone/dispatcher/SoundEffect tests, and retained real-Chrome evidence proves getUserMedia permission, non-flat capture and 600 WebGL2 frames; XNA audio is not the blocker. CNA/Sharp lack the defining Phone/XAML/page/ApplicationBar/lifecycle/XAP stack. Choose historical non-port, complete compatibility or explicitly scoped full native/WEBGL2 modernization under SAMPLES-DEC-005. Evidence: samples/SilverlightMicrophoneSample/missing.md.	🛑
SAMPLE-145	SoundLab	absent	Freshly audited as a complete licensed audio resource pack, not the historically assumed authoring tool; no soundboard, editor or fake Game was added. Its 173 WAVs span eight categories; 172 are PCM16 and one is PCM24. The official XNA4 pipeline rejects only that PCM24 file and builds the other 172; CNA converts all 172 XNBs and passes 44/44 content plus 154/154 audio tests. A separate direct-source audit honestly records CNA's strict refusal of the PCM24 asset and six Whoosh files whose physical data exceed their declared RIFF forms, without mutating the sources. No exact hash or whole-name consumer exists elsewhere in the collection. Choose resource-pack non-port, retained support data or an explicitly scoped new gallery/editor plus normalization policy under SAMPLES-DEC-005. Evidence: samples/SoundLab/missing.md.	🛑
SAMPLE-146	SpaceShooter_ARCHIVE_3_0	absent	Freshly audited as a complete XNA 3.0 Windows/Xbox space-combat game; no partial shooter, particle substitute or hidden legacy-state shim was added. Its 4,670 runtime C#, 304 processor and 1,076 HLSL lines implement flight/combat/AI, collision/damage, win/lose, HUD, audio, bloom, planet/sky rendering and eleven particle configurations. The processor assembly compiles unchanged against XNA4, while the runtime reaches removed resolve/state types and the authoritative XNA4 particle/bloom samples prove defining quad-particle and render-target rewrites. After isolated compiler-only effect migrations, the exact 29-row project builds 38 XNBs; all eleven effects parse, seven full-pair effects bind on real GLES3, and the legacy point-sprite effect exposes its exact stage-link failure. CNA validates 24 generic CNBs and truthfully refuses eleven raw effects plus three custom-material models; 90/90 content and 32/33 EasyGL effect tests pass with one unrelated skip. Choose authentic XNA3 compatibility, complete XNA4 modernization or historical non-port under SAMPLES-DEC-002/005. Evidence: samples/SpaceShooterArchive/missing.md.	🛑
SAMPLE-147	SpriteBatchShader_ARCHIVE_2_0	absent	Freshly audited as a complete three-file pre-XNA4 educational shader archive; no profile-upgraded shader, CNA stock-effect alias or invented viewer was added. The directory says 2_0, but its own documentation carries XNA_30 metadata. Its 135-line HLSL uses an old Windows viewport/texture-normalization contract and an Xbox five-vfetch instancing branch; the readme warns that interface is undocumented. The unchanged shader reaches XNA4's precise ps_1_x retirement. The materially different official XNA4 SpriteEffect is byte-identical to FNA after normalization; its exact blob parses/binds on real GLES3, with 5/5 compiled SpriteBatch tests plus all custom-uniform, viewport and flip gates passing. Choose archive/non-port, historical support data or explicit legacy-shader compiler/product scope under SAMPLES-DEC-005. Evidence: samples/SpriteBatchShaderArchive/missing.md.	🛑
SAMPLE-148	TiledSpritesSample_ARCHIVE_3_1	port	Complete port and native qualification; mandatory real-Chrome GamePad interaction gate pending on host Browser integration. The bounded XNA4 migration replaces only the retired XNA3 Begin/save-state/mutable-sampler sequence with the documented SamplerState.LinearWrap contract and selects HiDef because authentic XNA4 Reach refuses wrap on this 100×50 NPOT texture. The exact official XNA4 XNB is retained. CNA commit 9ca0d4188 fixes SpriteBatch::Begin state pointers to be const-correct, removing the last const_cast workaround. The real OPENGLES3 behavior probe proves the 33ms B/A/X/Y repeat path and Back exit; the migrated XNA4 and CNA 800×480 frames match all 384,000 pixels. Debug/Release native and clean WEBGL2 builds pass, and system Chrome on isolated Xvfb renders the expected WebGL2 frame without runtime/shader errors. Browser GamePad qualification cannot use the required route because the extension/native-host manifest is absent; no standalone automation or input substitute was accepted. Evidence: samples/TiledSprites/missing.md.	🛠
SAMPLE-149	TombstoningSample	absent	Freshly audited as a complete pure Windows Phone 7.0 Silverlight tombstoning application; no Game wrapper, reduced dictionary probe or generic web form was added. Its application/page lifecycle, XAML control tree, navigation reconstruction, transient and isolated-storage state, render-deferred focus/scroll restoration and asynchronous RSS route depend on retired Phone/Silverlight surfaces absent from CNA and Sharp Runtime. The exact offline Win7 build reaches the correct Phone project but proves that VM lacks the separate Silverlight-for-Phone v4 targets. Live focused infrastructure passes 63 isolated-storage, 201 HTTP and 527 threading tests; no bounded runtime bug exists. Choose historical non-port, faithful Phone compatibility or an explicitly scoped complete native/WEBGL2 modernization under SAMPLES-DEC-005. Evidence: samples/TombstoningSample/missing.md.	🛑
SAMPLE-150	UnitConverterStarterKit	absent	Fresh audit disproves the old empty/incomplete classification: this is a complete localized Windows Phone 7 Silverlight application, not an XNA game, and no reduced calculator or generic web form was invented. Its 60 files contain 6,581 C# and 937 XAML lines implementing a custom touch keypad, culture-aware numeric formatting, eight categories/44 units, dynamic pivot-based selection, favorites with press-and-hold deletion, Phone navigation/tombstoning, background startup and theme/localization behavior. Two reachable XML routes load the catalogue and persist favorites. The exact offline Win7 build reaches the correct project and proves only that the VM lacks the separate Phone v4 targets; 63 isolated-storage, 706 globalization and 527 threading tests pass. Choose historical non-port, faithful Phone compatibility or a complete native/WEBGL2 modernization under SAMPLES-DEC-005, with the XML routes consuming the eventual owner-approved SAMPLES-DEC-008 contract. Evidence: samples/UnitConverterStarterKit/missing.md.	🛑
SAMPLE-151	VectorRumble_ARCHIVE_2_0	absent	Freshly audited as a complete XNA 2.0 Windows/Xbox vector arena shooter; no reduced shooter, loose-WAV audio rewrite or NetRumble alias was added. Its 7,676 runtime C# lines implement four-player joining/control/vibration, collision, weapons/power-ups, screen/menu/pause/game-over flow, LineList vector rendering, particles/starfield and four-pass bloom. The exact fourteen-cue/sixteen-wave XACT2 graph is material. The offline Win7 VM lacks XNA2 targets; an isolated XNA4 diagnostic compiles the entire runtime and all seven non-XACT products, then rejects only the version-incompatible XACT2 project. CNA converts the two fonts/two textures, keeps the three Effect XNBs on its honest runtime route and passes 703 audio, 78 content and 66 relevant real-GLES3 tests with two renderer-specific skips. Choose authentic XNA2/XACT2 compatibility, explicit complete XNA4/XACT3 modernization or historical non-port under SAMPLES-DEC-002/005. Evidence: samples/VectorRumbleArchive/missing.md.	🛑
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	Freshly audited as Microsoft's complete XNA4 XNB reference package, not a game awaiting C#→C++ translation; no invented Game, inferior duplicate loader or redistributed reference document was added. Its 27-page DOCX defines the XNA4 container/readers, and its already-C++ 2,842-line VS2010 inspector registers 57 readers but deliberately refuses compression and reflection while only logging shared-resource graphs. Live CNA already owns the broader None/LZX/LZ4, 16-platform, shared-fixup, custom/reflective runtime path and passes 263/263 focused tests; e3e72bcac only corrected the documented texture/audio support matrix. The prepared offline Win7 build was blocked after the host restart because WinRE sees the 31GB system C: as RAW; no repair write was attempted and the VM was cleanly powered off. The delivery has no separate redistribution licence and the DOCX permits internal/reference use. Choose historical internal-reference non-port, licensed archival preservation after VM recovery, or an explicitly new CNA inspector product under SAMPLES-DEC-005. Evidence: samples/XnaXnbFormat/missing.md.	🛑

Deferred to the end of the campaign

Item	Measured	What it needs
24 samples have undocumented headers	2026-09-09, over all 99 samples that have src/*.hpp: the median comment density is 28 %, but 24 carry no @brief at all and 18 sit below 5 %. Worst are Bounce, SpriteEffects and TexturesAndColors at 0 %; the CatapultWars family (eight directories), Spacewar and Platformer are at 2–3 %. SAMPLE-081 was documented on 2026-09-09 at the owner's instruction, which is what surfaced the pattern.	Owner's call whether the rest follow. Where the original C# carries /// documentation its intent transfers rather than being invented, which is both faithful and most of the work; SAMPLE-081 took roughly 175 @brief across fifteen headers. rules.md states no comment rule for samples, so this is a consistency question rather than a defect.
51 samples carry an unused help.png	2026-09-09, over every samples/*/: 51 of them hold a help.png, none referenced by any source or CMakeLists, 1.2 MB in total. They are the leftover of the F1 help overlay that the campaign removed as an invention -- the code really is free of it everywhere checked so far (SAMPLE-072, 073, 077, 078, 079), only the file stayed.	One git rm per sample, or one sweep. Left until the campaign finishes so it is one deliberate commit rather than noise inside 51 audits, and so an audit's diff stays about the sample. Recorded here to stop it being re-discovered per sample.
15 canonical web bundles are debug builds	Fresh 2026-09-13 scan of the 97 canonical cna-web-webgl2/samples/*/*_cna_samples.wasm products: 15 carry debug_info, average 101.51 MiB and total 1,522.63 MiB; the other 82 average 7.16 MiB and total 587.40 MiB. SAMPLE-009 through SAMPLE-011 are no longer in this set after their fresh non-threaded Release rebuilds and browser requalification. Current instances are SAMPLE-012, SAMPLE-067, all seven SAMPLE-068 products, SAMPLE-069, SAMPLE-072, SAMPLE-073, SAMPLE-074, SAMPLE-076 and SAMPLE-077.	Owner's decision, 2026-09-08: not now. Once every sample is resolved, walk them all again with the owner and regenerate those bundles from debug to release. Each one has to pass its own browser gate again afterwards — a bundle is a product, so this is a rebuild-and-requalify pass, not a cleanup. Roughly 1.5 GiB comes back. tools/prune-completed-sample.sh deliberately does not touch this: the bundle is a product and it keeps products.

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, cna and sharp-runtime 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.