From 0ac9232d61ddc185858d4beb2e05429896fe8b2a Mon Sep 17 00:00:00 2001 From: seanbetts Date: Fri, 5 Jun 2026 14:46:32 +0100 Subject: [PATCH] Prioritize Machine and Frame SteamTracking signals --- scripts/compare_runs.py | 2 + scripts/draft_status_update.py | 12 + .../parse_steamtracking_hardware_signals.py | 110 ++++++++ scripts/write_run_summary.py | 2 + status/current.md | 69 +++-- status/runs/2026-06-05.md | 93 +++++++ tests/test_steamtracking_client_manifests.py | 236 ++++++++++++++++++ 7 files changed, 497 insertions(+), 27 deletions(-) create mode 100644 status/runs/2026-06-05.md diff --git a/scripts/compare_runs.py b/scripts/compare_runs.py index f2aa612..c54effd 100755 --- a/scripts/compare_runs.py +++ b/scripts/compare_runs.py @@ -125,6 +125,8 @@ def build_summary(prev_dir: Path, curr_dir: Path): deltas.extend(compare_text_lines(prev_dir, curr_dir, "SteamKit/PICS", "steamkit-pics-key-lines.txt")) deltas.extend(compare_text_lines(prev_dir, curr_dir, "SteamDB", "steamdb-key-lines.txt")) deltas.extend(compare_text_lines(prev_dir, curr_dir, "SteamTracking source", "steamtracking-source.txt")) + deltas.extend(compare_text_lines(prev_dir, curr_dir, "SteamTracking Frame signals", "steamtracking-frame-signals-key-lines.txt")) + deltas.extend(compare_text_lines(prev_dir, curr_dir, "SteamTracking Machine signals", "steamtracking-machine-signals-key-lines.txt")) deltas.extend(compare_text_lines(prev_dir, curr_dir, "SteamTracking hardware signals", "steamtracking-hardware-signals-key-lines.txt")) deltas.extend(compare_text_lines(prev_dir, curr_dir, "Steam client manifests", "steamtracking-client-manifests-key-lines.txt")) deltas.extend(compare_text_lines(prev_dir, curr_dir, "SteamVR depots", "steamvr-depots-key-lines.txt")) diff --git a/scripts/draft_status_update.py b/scripts/draft_status_update.py index 2c4f25b..d920480 100755 --- a/scripts/draft_status_update.py +++ b/scripts/draft_status_update.py @@ -53,6 +53,12 @@ def build_draft(run_dir: Path): hardware_signal_lines = first_n_nonempty( reports / "steamtracking-hardware-signals-key-lines.txt", 8 ) + frame_signal_lines = first_n_nonempty( + reports / "steamtracking-frame-signals-key-lines.txt", 12 + ) + machine_signal_lines = first_n_nonempty( + reports / "steamtracking-machine-signals-key-lines.txt", 12 + ) client_manifest_lines = first_n_nonempty( reports / "steamtracking-client-manifests-key-lines.txt", 8 ) @@ -133,6 +139,12 @@ def build_draft(run_dir: Path): lines.extend([f"- `{line}`" for line in tracking_lines]) else: lines.append("- No focused SteamTracking report found.") + if frame_signal_lines: + lines.extend(["", "Steam Frame client signal focus:"]) + lines.extend([f"- `{line}`" for line in frame_signal_lines]) + if machine_signal_lines: + lines.extend(["", "Steam Machine client signal focus:"]) + lines.extend([f"- `{line}`" for line in machine_signal_lines]) if hardware_signal_lines: lines.extend(["", "Steam hardware backend signal focus:"]) lines.extend([f"- `{line}`" for line in hardware_signal_lines]) diff --git a/scripts/parse_steamtracking_hardware_signals.py b/scripts/parse_steamtracking_hardware_signals.py index 2697dd6..a948468 100755 --- a/scripts/parse_steamtracking_hardware_signals.py +++ b/scripts/parse_steamtracking_hardware_signals.py @@ -42,6 +42,25 @@ SIGNAL_RE = re.compile( re.IGNORECASE, ) +FRAME_RE = re.compile(r"Steam\s*Frame|SteamFrame|steamframe|FrameVerified|FrameGames", re.IGNORECASE) + +FRAME_PRIORITY_RE = re.compile( + r"WelcomeToSteamFrame|GuidedTour_SteamFrame|SteamFrameWirelessAdapterDialog|" + r"controller_steamframe_pair|Settings_RemotePlay_WifiAPSection|" + r"Settings_Internet_Limit_Connection_Lower_Bands|LibraryTab_FrameVerified|" + r"steamFrameVerifiedApps|FrameGames|skip_steamframe_pairing_dialog|" + r"k_EAppTestType_SteamFrameCompatibilityReview", + re.IGNORECASE, +) + +MACHINE_RE = re.compile(r"Steam\s*Machine|SteamMachine|steammachine", re.IGNORECASE) + +MACHINE_PRIORITY_RE = re.compile( + r"GuidedTour_SteamMachine|WelcomeToSteamMachine|GuidedTour_SDCard_Title_SteamMachine|" + r"SteamMachine_TestResult|SteamMachineVerified|SteamMachineCompatibility", + re.IGNORECASE, +) + def iter_files(tracking_dir: Path): for root in SEARCH_ROOTS: @@ -119,6 +138,95 @@ def write_key_lines(rows, path: Path): path.write_text("\n".join(lines) + ("\n" if lines else ""), encoding="utf-8") +def frame_category(row): + text = row["text"] + if not (FRAME_RE.search(text) or FRAME_RE.search(row["path"])): + return "" + if not FRAME_PRIORITY_RE.search(text): + return "" + if re.search(r"WelcomeToSteamFrame|GuidedTour_SteamFrame", text, re.IGNORECASE): + return "frame-setup" + if re.search( + r"SteamFrameWirelessAdapterDialog|controller_steamframe_pair|" + r"Settings_RemotePlay_WifiAPSection|Settings_Internet_Limit_Connection_Lower_Bands|" + r"skip_steamframe_pairing_dialog", + text, + re.IGNORECASE, + ): + return "frame-pairing" + if re.search( + r"LibraryTab_FrameVerified|steamFrameVerifiedApps|FrameGames|" + r"k_EAppTestType_SteamFrameCompatibilityReview", + text, + re.IGNORECASE, + ): + return "frame-compatibility" + return "frame" + + +def write_frame_key_lines(rows, path: Path): + priority = { + "frame-setup": 0, + "frame-pairing": 1, + "frame-compatibility": 2, + "frame": 3, + } + lines = [] + seen = set() + def sort_key(row): + return (priority.get(frame_category(row), 99), row["path"], int(row["line"]), row["text"]) + + for row in sorted(rows, key=sort_key): + category = frame_category(row) + if not category: + continue + line = f"{category}\t{row['path']}:{row['line']}\t{row['text']}" + if line in seen: + continue + seen.add(line) + lines.append(line) + path.parent.mkdir(parents=True, exist_ok=True) + path.write_text("\n".join(lines) + ("\n" if lines else ""), encoding="utf-8") + + +def machine_category(row): + text = row["text"] + if not (MACHINE_RE.search(text) or MACHINE_RE.search(row["path"])): + return "" + if not MACHINE_PRIORITY_RE.search(text): + return "" + if re.search(r"GuidedTour_SteamMachine|WelcomeToSteamMachine|GuidedTour_SDCard_Title_SteamMachine", text, re.IGNORECASE): + return "machine-setup" + if re.search(r"SteamMachine_TestResult|SteamMachineVerified|SteamMachineCompatibility", text, re.IGNORECASE): + return "machine-compatibility" + return "machine" + + +def write_machine_key_lines(rows, path: Path): + priority = { + "machine-setup": 0, + "machine-compatibility": 1, + "machine": 2, + } + lines = [] + seen = set() + + def sort_key(row): + return (priority.get(machine_category(row), 99), row["path"], int(row["line"]), row["text"]) + + for row in sorted(rows, key=sort_key): + category = machine_category(row) + if not category: + continue + line = f"{category}\t{row['path']}:{row['line']}\t{row['text']}" + if line in seen: + continue + seen.add(line) + lines.append(line) + path.parent.mkdir(parents=True, exist_ok=True) + path.write_text("\n".join(lines) + ("\n" if lines else ""), encoding="utf-8") + + def write_markdown(rows, path: Path): lines = [ "# SteamTracking Hardware Signals", @@ -148,6 +256,8 @@ def main(): rows.sort(key=lambda row: (row["category"], row["path"], int(row["line"]), row["text"])) write_tsv(rows, reports / "steamtracking-hardware-signals.tsv") write_key_lines(rows, reports / "steamtracking-hardware-signals-key-lines.txt") + write_frame_key_lines(rows, reports / "steamtracking-frame-signals-key-lines.txt") + write_machine_key_lines(rows, reports / "steamtracking-machine-signals-key-lines.txt") write_markdown(rows, reports / "steamtracking-hardware-signals.md") diff --git a/scripts/write_run_summary.py b/scripts/write_run_summary.py index 5c8b881..ff261ec 100755 --- a/scripts/write_run_summary.py +++ b/scripts/write_run_summary.py @@ -159,6 +159,8 @@ def build(run_dir: Path): notable.extend([f"- SteamKit/PICS: `{line}`" for line in filtered_first(reports / "steamkit-pics-key-lines.txt", 8)]) notable.extend([f"- SteamDB: `{line}`" for line in filtered_first(reports / "steamdb-key-lines.txt", 5)]) notable.extend([f"- SteamTracking: `{line}`" for line in filtered_first(reports / "steamtracking-pairing-focus.txt", 5)]) + notable.extend([f"- SteamTracking Frame: `{line}`" for line in filtered_first(reports / "steamtracking-frame-signals-key-lines.txt", 12)]) + notable.extend([f"- SteamTracking Machine: `{line}`" for line in filtered_first(reports / "steamtracking-machine-signals-key-lines.txt", 12)]) notable.extend([f"- SteamTracking hardware: `{line}`" for line in filtered_first(reports / "steamtracking-hardware-signals-key-lines.txt", 8)]) notable.extend([f"- Steam client manifests: `{line}`" for line in filtered_first(reports / "steamtracking-client-manifests-key-lines.txt", 8)]) notable.extend([f"- SteamVR depots: `{line}`" for line in filtered_first(reports / "steamvr-depots-key-lines.txt", 5)]) diff --git a/status/current.md b/status/current.md index 2933a0b..7e40299 100644 --- a/status/current.md +++ b/status/current.md @@ -1,32 +1,30 @@ # Steam Hardware Watch Status -Last updated: `2026-05-26` +Last updated: `2026-06-05` ## Best Current Answer - `Price`: Steam Controller remains confirmed by official Valve store APIs at `$99.00` in the US. Steam Machine and Steam Frame still have no confirmed public price. - `Release date`: Steam Controller remains confirmed with release date `May 4, 2026` and package `1558609`. Steam Machine and Steam Frame still only expose broad `Coming soon` / `2026` timing. -- `Same-time launch`: same-day availability for the full trio is ruled out. Steam Controller is public and purchasable; Machine and Frame still have no public package, package group, price, or exact availability. Steam Machine reservation package changenumbers have now moved twice: a multi-package cluster on `2026-05-12`, followed by another bump across all four watched Machine packages on `2026-05-14`. The `2026-05-26` pass found no new watched SteamKit/PICS movement and no new Valve public API readiness. ImportGenius still shows continued `GAME CONSOLE` shipments to `INGRAM MICRO C/O VALVE CORPORATION` through `2026-05-18`; this remains logistics corroboration, not public launch confirmation. +- `Same-time launch`: same-day availability for the full trio is ruled out. Steam Controller is public and purchasable; Machine and Frame still have no public package, package group, price, or exact availability. Steam Machine reservation package changenumbers have now moved twice: a multi-package cluster on `2026-05-12`, followed by another bump across all four watched Machine packages on `2026-05-14`. The `2026-06-05` pass found no new watched SteamKit/PICS package/app movement and no Valve public API readiness. SteamTracking advanced to commit `135035494a6bf1156ee33c4a42db1c5dd1939b8a` (`2026-06-05T05:09:38Z`) and includes significant Steam Frame client-beta surface: `WelcomeToSteamFrame`, `skip_steamframe_pairing_dialog`, `controller_steamframe_pair`, `SteamFrameWirelessAdapterDialog`, `k_EAppTestType_SteamFrameCompatibilityReview`, `steamFrameVerifiedApps`, and `LibraryTab_FrameVerified`. This is a real client-readiness signal, but still not a package unlock, price, or launch-date signal. ImportGenius still shows relevant `GAME CONSOLE` shipments to `INGRAM MICRO C/O VALVE CORPORATION` through `2026-05-18`; this remains logistics corroboration, not public launch confirmation. ## Source Snapshot ### Komodo -- Komodo was available again on `2026-05-23` through the dedicated browser fallback after the automated path initially blocked. -- The automated Komodo path was blocked again on `2026-05-25`; any comparison lines implying removed Komodo sections are likely empty-report/block artifacts, not confirmed product-page removals. -- The automated Komodo path also initially blocked on `2026-05-26`, but the dedicated Chrome fallback was restored and captured a fresh baseline. -- Product modified timestamps captured in the `2026-05-26` browser-backed rerun: - - Controller: `2026-05-25T12:14:52` - - Machine: `2026-04-24T14:32:54` - - Frame: `2026-04-24T14:33:36` -- Controller has now moved again at the Komodo timestamp layer, but no matching SteamKit/PICS or Valve API launch-readiness movement appeared in the same pass. Treat this as timestamp-only until corroborated by visible content, media, store-state movement, or Steam metadata. -- Machine and Frame remain unchanged from their April 24 product timestamps, and their visible Komodo section baseline is still the old wishlist section only. -- Visual asset retrieval found `141` candidate assets, retrieved `136`, and left `5` blocked known Komodo URLs for manual retry. +- Komodo was reachable in the `2026-06-05` pass through the dedicated browser profile. +- Product modified timestamps remain unchanged from `2026-05-28`: + - Controller: `2026-05-27T16:52:25` + - Machine: `2026-05-27T16:53:06` + - Frame: `2026-05-27T16:53:46` +- This was not timestamp-only: all three product JSON records gained WooCommerce product category `961`, exposed as `product_cat-hardware` in `class_list`. Controller now has product categories `[961, 93]`; Machine and Frame now have `[961]`. +- No new Komodo section, media URL, asset exposure, or product timestamp movement appeared on `2026-05-30`. Treat the category addition as a real Komodo catalog-organization signal, not preorder confirmation. +- Visual asset retrieval found `141` candidate assets, retrieved `137`, and left `4` blocked known Komodo URLs for manual retry. No new asset URL was exposed. ### SteamKit / PICS - SteamKit/PICS is the primary direct Steam metadata source for watched app and package movement. -- Current changenumbers from the `2026-05-26` run: +- Current changenumbers from the `2026-06-05` run: - Controller app `4165870`: `35731145` - Frame app `4165890`: `35675573` - Machine app `4165910`: `35675573` @@ -36,17 +34,17 @@ Last updated: `2026-05-26` - Machine package `1629458`: `35842860` - Machine package `1629460`: `35842863` - Frame packages `1629484`, `1629486`: `35672606` -- No watched SteamKit/PICS changenumbers moved on `2026-05-26`. +- No watched SteamKit/PICS changenumbers moved on `2026-06-05`. - The latest Controller package signal remains the `2026-05-17` private PICS change on package `1558609`, where `ignorereservationifstockavailable=1` was removed from the package `extended` fields. Public Valve `appdetails` / `packagedetails` still did not change. - The latest material Machine signal remains the `2026-05-14` follow-up bump across all four watched Steam Machine package IDs, especially because the two watched Steam Frame package IDs did not move. - Manual package-history context remains important: Steam Controller package `1558609` reportedly had a clustered change pattern plus one later follow-up change roughly two days before Valve's public purchase-timing update appeared. The Machine set now has both the initial multi-package cluster and the later follow-up bump. Treat this as a stronger imminent-preorder heuristic, not confirmation. - Machine and Frame apps/packages currently require private PICS metadata tokens, but changenumbers are visible and suitable for movement monitoring. -- Raw snapshot: `/Users/sean/Coding/steam-hardware-watch/runs/2026-05-26/api/steamkit/pics-product-info.json` -- Human-readable detail: `/Users/sean/Coding/steam-hardware-watch/runs/2026-05-26/reports/steamkit-pics-detail.md` +- Raw snapshot: `/Users/sean/Coding/steam-hardware-watch/runs/2026-06-05/api/steamkit/pics-product-info.json` +- Human-readable detail: `/Users/sean/Coding/steam-hardware-watch/runs/2026-06-05/reports/steamkit-pics-detail.md` ### SteamDB -- SteamDB was successfully retrieved through the dedicated Chrome fallback on `2026-05-26`. +- SteamDB package pages were mostly reachable through the dedicated browser profile on `2026-06-05`; the Controller app page was still challenge-blocked, but the watched package-page snapshot was captured. - SteamDB package-page baseline: - Controller package `1558609`: last record update `15 May 2026 - 16:07:19 UTC`, changenumber `35893035`, details available. - Machine packages `1629446`, `1629447`, `1629458`, `1629460`: last record updates clustered on `13 May 2026`, private/existence-only, possible app `4165910:Steam Machine`. @@ -55,7 +53,23 @@ Last updated: `2026-05-26` ### SteamTracking / GameTracking -- Fresh SteamTracking content remained current at commit `5f58a47e5` (`2026-05-23T04:32:36Z`) on the `2026-05-26` pass and still contains the known Triton/Ibex controller pairing surface: +- SteamTracking now fast-forwards and records source metadata before scanning. The `2026-06-05` pass used commit `135035494a6bf1156ee33c4a42db1c5dd1939b8a` (`2026-06-05T05:09:38Z`); the checkout was freshly restored because `/tmp/SteamTracking-master` had been wiped. +- The corrected hardware signal reporting now creates dedicated Frame and Machine reports before the broad hardware report, so high-signal product-specific client strings are not buried in generic hardware noise. +- Dedicated Steam Machine client signal report now surfaces setup-tour and compatibility lines: + - `GuidedTour_SteamMachine_Welcome_Title` + - `GuidedTour_SteamMachine_SendOff_Description` + - `GuidedTour_SDCard_Title_SteamMachine` + - Steam Machine compatibility-warning strings +- Dedicated Steam Frame client signal report now surfaces high-signal Frame lines that were previously buried in the broad hardware report: + - `WelcomeToSteamFrame` + - `skip_steamframe_pairing_dialog` + - `controller_steamframe_pair` + - `Settings_RemotePlay_WifiAPSection` + - `SteamFrameWirelessAdapterDialog_*` + - `k_EAppTestType_SteamFrameCompatibilityReview` + - `steamFrameVerifiedApps` + - `LibraryTab_FrameVerified` +- The older focused pairing report still contains the known Triton/Ibex controller pairing surface: - `ibex_internal` - `ibex_external` - `PairDongleTritonConnected` @@ -64,14 +78,15 @@ Last updated: `2026-05-26` - Known reservation package-code baseline remains: Machine package IDs `1629446`, `1629447`, `1629458`, `1629460` and Frame package IDs `1629484`, `1629486` first appeared in SteamTracking commit `334bd31a28a0` at `2026-04-28T23:46:34Z`. - New high-signal client manifest watch target: `steam_client_beta_linuxarm64` first appeared in the local SteamTracking baseline at commit `28f5287` (`2026-05-22T04:56:58Z`) with version `1779139477`. - Track `steam_client_beta_linuxarm64` and `steam_client_publicbeta_linuxarm64` every run, especially `bins_hardware_linuxarm64`, `bins_linuxarm64`, `steam_linuxarm64`, `runtime_steamrt_linuxarm64`, and `bins_steamrt_linuxarm64`. -- Current ARM64 client manifest baseline in the `2026-05-26` report: - - `steam_client_beta_linuxarm64`: version `1779139477`; `bins_hardware_linuxarm64.zip.cc71be587407299a6125bfa9e889b97bf8df7591`; size `7590487`. - - `steam_client_publicbeta_linuxarm64`: version `1779479049`; `bins_hardware_linuxarm64.zip.da8814f3cc3788fd3789ce233dd86f107b2b244a`; size `10039405`. -- The updated SteamTracking checkout did not add a new Machine/Frame reservation package, price, exact availability, ARM64 manifest movement, or product-publication signal. +- Current ARM64 client manifest baseline in the `2026-06-05` report: + - `steam_client_beta_linuxarm64`: version `1780371519`; `bins_hardware_linuxarm64.zip.da8814f3cc3788fd3789ce233dd86f107b2b244a`; size `10039405`. + - `steam_client_publicbeta_linuxarm64`: version `1780620638`; `bins_hardware_linuxarm64.zip.da8814f3cc3788fd3789ce233dd86f107b2b244a`; size `10039405`. +- ARM64 client manifest movement appeared versus the `2026-06-01` baseline, including `bins_linuxarm64`, `steam_linuxarm64`, and public-beta runtime/steamrt blocks. The hardware-specific `bins_hardware_linuxarm64` block did not change. +- The updated SteamTracking checkout did not add a new Machine/Frame reservation package, price, exact availability, or product-publication signal. It did add enough Frame UI/compatibility/pairing surface, plus enough Machine setup/compatibility surface, that the prior `2026-06-05` summary understated product-specific client-beta signals. ### SteamVR Depots -- SteamVR news metadata was saved. +- SteamVR news metadata was saved. The latest public SteamVR news item is `Introducing SteamVR 2.16` from `2026-06-02T18:59:37Z`. - SteamDB's SteamVR depot page remained blocked by challenge pages, so no fresh depot manifest/build comparison was collected. - No local SteamVR depot snapshot was available for deeper content scanning. @@ -79,23 +94,23 @@ Last updated: `2026-05-26` - Valve's public SteamOS package mirror was reachable. - Notable mirror hits still include `fremont-hw-support 20260506.1-1` in `holo-3.8` and `holo-main`. -- No direct `Deckard`, `Roy`, `Steam Frame`, `Steam Machine`, ARM/Snapdragon, or new product-specific top-level repo namespace appeared in the default pass. +- `linux-firmware-neptune` and related Jupiter firmware packages moved from `jupiter.20260504.1-1` to `jupiter.20260604.1-1` in `jupiter-3.8` and `jupiter-main`. No direct `Deckard`, `Roy`, `Steam Frame`, `Steam Machine`, ARM/Snapdragon, or new product-specific top-level repo namespace appeared in the default pass. ### Valve Support / Store / CDN - Official Valve pages and APIs were reachable. -- No Valve public API readiness change appeared on `2026-05-26`. +- No Valve public API readiness change appeared on `2026-06-05`. - Valve API package snapshot: - Controller app `4165870`: public, package `1558609`, package group present, `$99.00`. - Frame app `4165890`: public app metadata, `Coming soon`, no packages, no package groups, no price. - Machine app `4165910`: public app metadata, `Coming soon`, no packages, no package groups, no price. - Machine packages `1629446`, `1629447`, `1629458`, `1629460`: `packagedetails success:false`. - Frame packages `1629484`, `1629486`: `packagedetails success:false`. -- This remains the cleanest public-readiness baseline. The `2026-05-14` SteamKit/PICS Machine package movement has not propagated to public `appdetails`, `packagedetails`, packages, package groups, price, or exact timing. +- This remains the cleanest public-readiness baseline. The `2026-05-14` SteamKit/PICS Machine package movement and the corrected SteamTracking guided-tour baseline have not propagated to public `appdetails`, `packagedetails`, packages, package groups, price, or exact timing. ### Customs / Regulatory -- Customs status on `2026-05-26`: partial. ImportInfo automated fetches were blocked, but the ImportGenius importer page fetched and parsed successfully. +- Customs status on `2026-06-05`: partial. ImportInfo automated fetches were blocked, while the existing ImportGenius-backed baseline still showed relevant rows. - ImportGenius now lists `10` relevant `GAME CONSOLE` rows for `INGRAM MICRO C/O VALVE CORPORATION` from `2026-03-27` through `2026-05-18`. - No newer customs rows appeared versus the `2026-05-22` / `2026-05-23` / `2026-05-25` ImportGenius baseline. - Newer rows since the old `2026-04-23` baseline include: diff --git a/status/runs/2026-06-05.md b/status/runs/2026-06-05.md new file mode 100644 index 0000000..4257274 --- /dev/null +++ b/status/runs/2026-06-05.md @@ -0,0 +1,93 @@ +# Run Note: 2026-06-05 + +## Summary + +- Full watch pass completed after repairing the missing `/tmp/SteamTracking-master` checkout. +- No watched SteamKit/PICS app or package changenumbers moved. +- No Valve public API readiness change for Steam Machine or Steam Frame. +- Material background movement: SteamTracking advanced to a `2026-06-05` snapshot, ARM64 Steam client manifests moved, SteamVR 2.16 appeared in news metadata, and SteamOS Jupiter firmware packages moved to `jupiter.20260604.1-1`. +- Correction after review: the original summary under-called Steam Frame and Steam Machine client-beta signals. The raw hardware report contained the relevant lines, but they were buried in a huge broad scan. Dedicated Frame and Machine signal reports now surface them before the generic hardware report. + +## Source Checks + +### Komodo + +- Reachable through the dedicated browser profile. +- Product modified timestamps unchanged: + - Controller: `2026-05-27T16:52:25` + - Machine: `2026-05-27T16:53:06` + - Frame: `2026-05-27T16:53:46` +- Visual assets: `141` discovered, `137` retrieved, `4` blocked. + +### SteamDB + +- Watched reservation package snapshot captured. +- Controller package `1558609`: last update `15 May 2026 - 16:07:19 UTC`, changenumber `35893035`. +- Machine packages `1629446`, `1629447`, `1629458`, `1629460`: still clustered on `13 May 2026`. +- Frame packages `1629484`, `1629486`: still `5 May 2026 - 18:50:54 UTC`. +- Controller app page `4165870` remained challenge-blocked. + +### SteamTracking / GameTracking + +- SteamTracking source commit: `135035494a6bf1156ee33c4a42db1c5dd1939b8a`, timestamp `2026-06-05T05:09:38Z`. +- Steam Machine setup-tour/compatibility strings and Steam Frame wireless-adapter/compatibility strings are present. +- High-signal Steam Machine client-beta surface now called out explicitly: + - `GuidedTour_SteamMachine_Welcome_Title` + - `GuidedTour_SteamMachine_SendOff_Description` + - `GuidedTour_SDCard_Title_SteamMachine` + - `SteamMachine_TestResult_*` + - `SteamMachineVerified_*` + - `SteamMachineCompatibility_*` +- High-signal Steam Frame client-beta surface now called out explicitly: + - `WelcomeToSteamFrame` + - `skip_steamframe_pairing_dialog` + - `controller_steamframe_pair` + - `Settings_RemotePlay_WifiAPSection` + - `SteamFrameWirelessAdapterDialog_*` + - `k_EAppTestType_SteamFrameCompatibilityReview` + - `steamFrameVerifiedApps` + - `LibraryTab_FrameVerified` +- ARM64 client manifests moved: + - `steam_client_beta_linuxarm64`: `1780078251` -> `1780371519`. + - `steam_client_publicbeta_linuxarm64`: `1780098236` -> `1780620638`. +- `bins_hardware_linuxarm64` did not change; broader ARM64 client/runtime blocks did. +- No new watched Machine/Frame reservation package, price, or exact availability signal. + +### SteamVR Depots + +- SteamVR news metadata includes `Introducing SteamVR 2.16` at `2026-06-02T18:59:37Z`. +- SteamDB depot page `https://steamdb.info/app/250820/depots/` remained challenge-blocked, so no fresh depot manifest comparison was captured. + +### SteamOS Package Mirror + +- Reachable. +- `fremont-hw-support` remains `20260506.1-1`. +- Jupiter `linux-firmware-neptune` package family moved to `jupiter.20260604.1-1` in `jupiter-3.8` and `jupiter-main`. +- No direct Steam Frame, Steam Machine, Deckard, Roy, ARM, or Snapdragon namespace appeared. + +### Valve Support / CDN + +- Reachable. +- Controller app `4165870`: public, package `1558609`, `$99.00`. +- Frame app `4165890`: public app metadata, `Coming soon`, no packages/package groups/price. +- Machine app `4165910`: public app metadata, `Coming soon`, no packages/package groups/price. +- Machine and Frame watched packages still return `packagedetails success:false`. + +### Customs / Regulatory + +- Partial. +- ImportInfo fetches failed/blocked. +- Existing captured shipment rows still only run through `2026-05-18`. +- No newer `GAME CONSOLE` shipment row found. + +## Effect On Key Questions + +- Price: unchanged. Controller `$99.00`; Machine and Frame still no public price. +- Release date: unchanged. Controller public; Machine and Frame still only `Coming soon` / `2026`. +- Same-time launch: no. Controller is already public/purchasable; Machine and Frame still lack public package groups and prices. + +## Next Checks + +- Continue high-frequency SteamKit/PICS checks on watched Machine and Frame packages. +- Keep SteamTracking client-manifest diffs in focus, especially ARM64 hardware/runtime blocks. +- Manually clear or replace the SteamDB SteamVR depot-page source if depot manifest comparisons become important. diff --git a/tests/test_steamtracking_client_manifests.py b/tests/test_steamtracking_client_manifests.py index 827129f..372b254 100644 --- a/tests/test_steamtracking_client_manifests.py +++ b/tests/test_steamtracking_client_manifests.py @@ -254,6 +254,151 @@ class SteamTrackingClientManifestTests(unittest.TestCase): self.assertIn("GuidedTour_SteamMachine_Welcome_Title", key_lines) self.assertIn("GuidedTour_SDCard_Title_SteamMachine", key_lines) + def test_hardware_signal_report_writes_prioritized_steam_frame_highlights(self): + with TemporaryDirectory() as tmp: + tmp_path = Path(tmp) + tracking = tmp_path / "tracking" + localization = tracking / "ClientExtracted" / "steamui" / "localization" + webui = tracking / "ProtobufsWebui" + enums = tracking / "Protobufs" + localization.mkdir(parents=True) + webui.mkdir(parents=True) + enums.mkdir(parents=True) + (tracking / "ClientExtracted" / "ThirdPartyLegalNotices-Chromium.html").parent.mkdir(parents=True, exist_ok=True) + (tracking / "ClientExtracted" / "ThirdPartyLegalNotices-Chromium.html").write_text( + "reserves the exclusive right to collect such royalties for any\n", + encoding="utf-8", + ) + (localization / "steamui_english.json").write_text( + textwrap.dedent( + """ + { + "controller_steamframe_pair": "Steam Frame Controllers", + "Settings_RemotePlay_WifiAPSection": "Wireless Streaming Adapter (Steam Frame)", + "LibraryTab_FrameVerified": "Verified on Steam Frame", + "SteamFrameWirelessAdapterDialog_Header": "Pair Steam Frame Wireless Adapter", + "SteamFrameWirelessAdapterDialog_Description": "Pair to a Steam Frame for high performance streaming." + } + """ + ).strip() + + "\n", + encoding="utf-8", + ) + (tracking / "ClientExtracted" / "steamui" / "chunk~frame.js").write_text( + '(WelcomeToSteamFrame = 1); steamFrameVerifiedApps: f; strName: "SteamFrameWirelessAdapterDialog";\n', + encoding="utf-8", + ) + (webui / "common.proto").write_text( + "optional bool skip_steamframe_pairing_dialog = 27010;\n", + encoding="utf-8", + ) + (enums / "enums.proto").write_text( + "k_EAppTestType_SteamFrameCompatibilityReview = 7;\n", + encoding="utf-8", + ) + run_dir = tmp_path / "runs" / "2026-06-05" + + result = subprocess.run( + [ + "python3", + str(ROOT / "scripts" / "parse_steamtracking_hardware_signals.py"), + "--run-dir", + str(run_dir), + "--tracking-dir", + str(tracking), + ], + cwd=ROOT, + text=True, + stdout=subprocess.PIPE, + stderr=subprocess.PIPE, + check=False, + ) + + self.assertEqual("", result.stderr) + self.assertEqual(0, result.returncode) + highlights = (run_dir / "reports" / "steamtracking-frame-signals-key-lines.txt").read_text( + encoding="utf-8" + ) + self.assertIn("WelcomeToSteamFrame", highlights) + self.assertIn("steamFrameVerifiedApps", highlights) + self.assertIn("SteamFrameWirelessAdapterDialog_Header", highlights) + self.assertIn("controller_steamframe_pair", highlights) + self.assertIn("Settings_RemotePlay_WifiAPSection", highlights) + self.assertIn("LibraryTab_FrameVerified", highlights) + self.assertIn("skip_steamframe_pairing_dialog", highlights) + self.assertIn("k_EAppTestType_SteamFrameCompatibilityReview", highlights) + self.assertNotIn("exclusive right", highlights) + + def test_hardware_signal_report_writes_prioritized_steam_machine_highlights(self): + with TemporaryDirectory() as tmp: + tmp_path = Path(tmp) + tracking = tmp_path / "tracking" + localization = tracking / "ClientExtracted" / "steamui" / "localization" + siteserver = tracking / "ClientExtracted" / "siteserverui" / "js" + localization.mkdir(parents=True) + siteserver.mkdir(parents=True) + (tracking / "ClientExtracted" / "ThirdPartyLegalNotices-Chromium.html").parent.mkdir(parents=True, exist_ok=True) + (tracking / "ClientExtracted" / "ThirdPartyLegalNotices-Chromium.html").write_text( + "reserves the exclusive right to collect such royalties for any\n", + encoding="utf-8", + ) + (localization / "steamui_english.json").write_text( + textwrap.dedent( + """ + { + "GuidedTour_SteamMachine_Welcome_Title": "Welcome to Steam Machine", + "GuidedTour_SteamMachine_SendOff_Description": "We hope you enjoy using Steam Machine.", + "GuidedTour_SDCard_Title_SteamMachine": "Steam Machine is equipped with a microSD card slot." + } + """ + ).strip() + + "\n", + encoding="utf-8", + ) + (siteserver / "1136.json").write_text( + textwrap.dedent( + """ + { + "SteamMachine_TestResult_DeviceCompatibilityWarningsShown": "This game displays compatibility warnings when running on Steam Machine, but runs fine", + "SteamMachineVerified_DescriptionHeader_Verified": "This game is fully functional on Steam Machine.", + "SteamMachineCompatibility_Store_CompatSectionHeader_GamepadUI": "Steam Machine Compatibility" + } + """ + ).strip() + + "\n", + encoding="utf-8", + ) + run_dir = tmp_path / "runs" / "2026-06-05" + + result = subprocess.run( + [ + "python3", + str(ROOT / "scripts" / "parse_steamtracking_hardware_signals.py"), + "--run-dir", + str(run_dir), + "--tracking-dir", + str(tracking), + ], + cwd=ROOT, + text=True, + stdout=subprocess.PIPE, + stderr=subprocess.PIPE, + check=False, + ) + + self.assertEqual("", result.stderr) + self.assertEqual(0, result.returncode) + highlights = (run_dir / "reports" / "steamtracking-machine-signals-key-lines.txt").read_text( + encoding="utf-8" + ) + self.assertIn("GuidedTour_SteamMachine_Welcome_Title", highlights) + self.assertIn("GuidedTour_SteamMachine_SendOff_Description", highlights) + self.assertIn("GuidedTour_SDCard_Title_SteamMachine", highlights) + self.assertIn("SteamMachine_TestResult_DeviceCompatibilityWarningsShown", highlights) + self.assertIn("SteamMachineVerified_DescriptionHeader_Verified", highlights) + self.assertIn("SteamMachineCompatibility_Store_CompatSectionHeader_GamepadUI", highlights) + self.assertNotIn("exclusive right", highlights) + def test_compare_runs_includes_client_manifest_key_line_deltas(self): with TemporaryDirectory() as tmp: tmp_path = Path(tmp) @@ -374,6 +519,97 @@ class SteamTrackingClientManifestTests(unittest.TestCase): (reports / "status-draft.md").read_text(encoding="utf-8"), ) + def test_status_draft_and_run_summary_prefer_steam_frame_highlights(self): + with TemporaryDirectory() as tmp: + run_dir = Path(tmp) / "2026-06-05" + reports = run_dir / "reports" + reports.mkdir(parents=True) + (reports / "steamtracking-hardware-signals-key-lines.txt").write_text( + "commerce\tClientExtracted/ThirdPartyLegalNotices-Chromium.html:136305\t" + "reserves the exclusive right to collect such royalties for any\n", + encoding="utf-8", + ) + (reports / "steamtracking-frame-signals-key-lines.txt").write_text( + "frame-setup\tClientExtracted/steamui/chunk~frame.js:1\tWelcomeToSteamFrame\n" + "frame-controller\tClientExtracted/steamui/localization/steamui_english.json:2\t" + '"controller_steamframe_pair": "Steam Frame Controllers",\n', + encoding="utf-8", + ) + + summary = subprocess.run( + ["python3", str(ROOT / "scripts" / "write_run_summary.py"), "--run-dir", str(run_dir)], + cwd=ROOT, + text=True, + stdout=subprocess.PIPE, + stderr=subprocess.PIPE, + check=False, + ) + draft = subprocess.run( + ["python3", str(ROOT / "scripts" / "draft_status_update.py"), "--run-dir", str(run_dir)], + cwd=ROOT, + text=True, + stdout=subprocess.PIPE, + stderr=subprocess.PIPE, + check=False, + ) + + self.assertEqual("", summary.stderr) + self.assertEqual(0, summary.returncode) + self.assertEqual("", draft.stderr) + self.assertEqual(0, draft.returncode) + run_summary = (reports / "run-summary.md").read_text(encoding="utf-8") + status_draft = (reports / "status-draft.md").read_text(encoding="utf-8") + self.assertIn("WelcomeToSteamFrame", run_summary) + self.assertIn("controller_steamframe_pair", run_summary) + self.assertIn("WelcomeToSteamFrame", status_draft) + self.assertIn("controller_steamframe_pair", status_draft) + + def test_status_draft_and_run_summary_prefer_steam_machine_highlights(self): + with TemporaryDirectory() as tmp: + run_dir = Path(tmp) / "2026-06-05" + reports = run_dir / "reports" + reports.mkdir(parents=True) + (reports / "steamtracking-hardware-signals-key-lines.txt").write_text( + "commerce\tClientExtracted/ThirdPartyLegalNotices-Chromium.html:136305\t" + "reserves the exclusive right to collect such royalties for any\n", + encoding="utf-8", + ) + (reports / "steamtracking-machine-signals-key-lines.txt").write_text( + "machine-setup\tClientExtracted/steamui/localization/steamui_english.json:1\t" + '"GuidedTour_SteamMachine_Welcome_Title": "Welcome to Steam Machine",\n' + "machine-compatibility\tClientExtracted/siteserverui/js/1136.json:1\t" + '"SteamMachineCompatibility_Store_CompatSectionHeader_GamepadUI": "Steam Machine Compatibility",\n', + encoding="utf-8", + ) + + summary = subprocess.run( + ["python3", str(ROOT / "scripts" / "write_run_summary.py"), "--run-dir", str(run_dir)], + cwd=ROOT, + text=True, + stdout=subprocess.PIPE, + stderr=subprocess.PIPE, + check=False, + ) + draft = subprocess.run( + ["python3", str(ROOT / "scripts" / "draft_status_update.py"), "--run-dir", str(run_dir)], + cwd=ROOT, + text=True, + stdout=subprocess.PIPE, + stderr=subprocess.PIPE, + check=False, + ) + + self.assertEqual("", summary.stderr) + self.assertEqual(0, summary.returncode) + self.assertEqual("", draft.stderr) + self.assertEqual(0, draft.returncode) + run_summary = (reports / "run-summary.md").read_text(encoding="utf-8") + status_draft = (reports / "status-draft.md").read_text(encoding="utf-8") + self.assertIn("GuidedTour_SteamMachine_Welcome_Title", run_summary) + self.assertIn("SteamMachineCompatibility_Store_CompatSectionHeader_GamepadUI", run_summary) + self.assertIn("GuidedTour_SteamMachine_Welcome_Title", status_draft) + self.assertIn("SteamMachineCompatibility_Store_CompatSectionHeader_GamepadUI", status_draft) + if __name__ == "__main__": unittest.main()