Refresh RANGE with maintained CPU runtime, benchmarks and roadmap

Standalone RANGE presentation; Python package coming soon. Rebuilt Linux CPU wheel passed10 contract tests plus local single/batch API checks. CUDA benchmark record is historical and distinct from live CPU demo.

BENCHMARKS.md

@@ -0,0 +1,60 @@
+# RANGE benchmark record
+
+Updated 2026-09-12. These results describe compact screening of a staged corpus,
+not the live Space, rich explanations, disk ingestion, or a service guarantee.
+
+| Evidence | Articles/s | Workload and status |
+| --- | ---: | --- |
+| Maintained CPU, Phase24 | 489,759 | 10 million articles; qualified warm screening |
+| CUDA historical record, Phase60 | 1,833,059 | 10 million articles; exact outputs, stable timing |
+| Earlier installed CUDA, Phase61 | 1,809,133 | Separate qualified local installation |
+| Newer retained CUDA installed, Phase65 | 958,155 | Separate qualified local installation of Phase64 |
+
+Hardware: Intel i7-10750H, 10 CPU workers, Windows, RTX 2070 Max-Q (sm75) for CUDA.
+The CUDA figures include input staging/transfers, exact CPU fallback and output
+assembly within classification calls. Dataset loading, imports, configuration
+construction and result verification are outside timing. CPU figures cover warm
+compact screening, excluding loading and rich explanation construction.
+
+These are separate experiments. They do not establish a paired CPU/GPU speedup.
+The later Phase64 algorithm won its own controlled comparison, but that does not
+allow multiplying its improvement by the historical Phase60 peak. Session timing
+varied substantially; the cause of cross-session changes is not established.
+
+## Evidence identities
+
+The 10-million-row Arrow stage SHA-256 is
+769d7de4a8295f4ce3f3d7508774e57ebdeaf2de9b4f4d7e31d1bb5a84d2865f.
+
+Phase60's complete-call median was5.45536245 seconds versus6.17977660 for its
+Phase59 control. Its18 calls matched all nine output fields. Both arms passed
+the5% cycle-drift threshold; the same-run improvement was13.2789%.
+Its actual CUDA binary SHA-256 was
+dd943d9adac702e41c2bb0a2b58f78698498edd8a3dfab16cf9d224c8c6a83fa.
+Source checkpoint:8f3fa47, with the original failed finite-gate attempt retained
+in the internal append-only experiment record.
+
+Phase65 installed the Phase64 algorithm in a fresh target using existing
+dependencies. It measured958,155 articles/s versus956,701/s for its research
+control. The companion wheel SHA-256 was
+2269c6d41c8ca59bfd48468e5d0c9a00a7abab99297f0194e0227730a2e92643.
+
+## What is available
+
+The Space runs the maintained CPU/Rust rich-explanation demo. It does not execute
+the CUDA research engine. The Python package is coming soon; no public package
+release or general CUDA portability is claimed here. Current CUDA installation
+qualification is limited to the tested Windows CPython3.10/sm75 environment.
+
+## Research still open
+
+Release packaging and platform validation come first. Other opportunities include
+sharing work across more taxonomies, workload-based CPU/CUDA selection, direct
+StringZilla integration, other CUSMART methods, and state/compiler optimization
+trained on separate representative development data. These are proposals.
+
+Selected alternatives already tested include PFAC, Set Horspool, Wu-Manber,
+SOG-style filtering, SBOM and two CUSMART-listed methods (BNDM/Quick Search).
+Their tested adaptations did not replace the retained matcher. Phase81's two
+methods produced exact outputs but failed timing stability and were much slower.
+This does not reject all variants or all64 CUSMART algorithms.

CHANGELOG.md

@@ -7,8 +7,8 @@ versioning and uses Python's pre-release version syntax.
 
 ### Added
 
-- The public `range_news` Python namespace and **RANGE** product name: Rapid Analysis
-  of News for the General Economy.
+- The public `range_news` Python namespace and **RANGE** product name: Rapid Analysis
+  of News for the General Economy.
 - An exact CPU/Rust path for rich predictions, compact list screening, and Arrow screening.
 - A conservative, offline general-economy taxonomy covering monetary policy, inflation,
   labor markets, growth, rates, credit, fiscal policy, trade, supply disruptions,
@@ -17,40 +17,44 @@ versioning and uses Python's pre-release version syntax.
   ranking, and editable taxonomy copies.
 - Wheel and source-distribution verification on Windows and Linux CI.
 - Runnable README examples with visible output.
-- A Space-ready Gradio demo under `app/` with highlighted evidence, evidence JSON,
-  batch screening, downloadable outputs, named API endpoints, a multi-stage Docker
-  build, and a deterministic offline export manifest.
-- Separate deployment exports for local Docker and free Gradio/ZeroGPU hosting. The
-  hosted export vendors the runtime payload from an inspected CPython 3.10
-  manylinux2014 wheel while keeping prediction on the compiled CPU/Rust path.
+- A Space-ready Gradio demo under `app/` with highlighted evidence, evidence JSON,
+  batch screening, downloadable outputs, named API endpoints, a multi-stage Docker
+  build, and a deterministic offline export manifest.
+- Separate deployment exports for local Docker and free Gradio/ZeroGPU hosting. The
+  hosted export vendors the runtime payload from an inspected CPython 3.10
+  manylinux2014 wheel while keeping prediction on the compiled CPU/Rust path.
 - CI validation and a Linux container smoke test for the future Hugging Face Space.
 
-### Changed
-
-- The project is now named **RANGE** throughout its distribution, Python namespace,
-  native module, documentation, deployment identifiers, and demo.
-- The README now leads with the job-to-be-done, a working result, intended users,
-  an architecture overview, a mechanism-level speed explanation, API selection
-  guidance, and carefully qualified benchmark context.
-- The Space demo now separates article relevance from supported exposure, distinguishes
-  unresolved evidence paths visually, and includes a verified private-deployment
-  runbook.
-- The public package identity, examples, and documentation are no longer tied to the
-  Attention2Alpha project or a particular leveraged-ETF portfolio. This presentation
+### Changed
+
+- Refreshed the standalone RANGE Space with qualified CPU/CUDA benchmark context,
+  a package-coming-soon notice, a research roadmap and a rebuilt maintained CPU
+  runtime for Linux. Exported documentation omits monorepo-specific branding.
+
+- The project is now named **RANGE** throughout its distribution, Python namespace,
+  native module, documentation, deployment identifiers, and demo.
+- The README now leads with the job-to-be-done, a working result, intended users,
+  an architecture overview, a mechanism-level speed explanation, API selection
+  guidance, and carefully qualified benchmark context.
+- The Space demo now separates article relevance from supported exposure, distinguishes
+  unresolved evidence paths visually, and includes a verified private-deployment
+  runbook.
+- The public package identity, examples, and documentation are no longer tied to the
+  parent research project project or a particular leveraged-ETF portfolio. This presentation
   pass leaves the established default taxonomy semantics unchanged.
-- The package version is `0.1.0a1`, explicitly identifying a research alpha.
-- The hosted demo now rejects oversized or malformed requests before inference,
-  shares one bounded execution queue across its public endpoints, and hides internal
-  error details in production.
-- Evidence downloads now omit screened article text, retain a SHA-256 identifier and text
-  lengths, live in Gradio's managed cache, and become eligible for best-effort cleanup
-  after five minutes.
-- Hosted dependencies, Docker base images, and the Dockerfile frontend are pinned for
-  reproducible deployment builds. Managed networks can supply a trusted build root as
-  a temporary secret without disabling TLS verification.
+- The package version is `0.1.0a1`, explicitly identifying a research alpha.
+- The hosted demo now rejects oversized or malformed requests before inference,
+  shares one bounded execution queue across its public endpoints, and hides internal
+  error details in production.
+- Evidence downloads now omit screened article text, retain a SHA-256 identifier and text
+  lengths, live in Gradio's managed cache, and become eligible for best-effort cleanup
+  after five minutes.
+- Hosted dependencies, Docker base images, and the Dockerfile frontend are pinned for
+  reproducible deployment builds. Managed networks can supply a trusted build root as
+  a temporary secret without disabling TLS verification.
 
 ### Not included
 
 - No GPU backend.
-- No public or production hosted service, model download, live-data integration,
-  trading recommendation, release tag, or package-index publication.
+- No public or production hosted service, model download, live-data integration,
+  trading recommendation, release tag, or package-index publication.

Cargo.toml

@@ -7,13 +7,13 @@ publish = false
 license = "MIT"
 description = "Native engine for RANGE financial-news relevance screening"
 
-[lib]
-name = "_native"
-path = "rust/lib.rs"
-crate-type = ["cdylib"]
-
-[dependencies]
-aho-corasick = "1.1.5"
+[lib]
+name = "_native"
+path = "rust/lib.rs"
+crate-type = ["cdylib"]
+
+[dependencies]
+aho-corasick = "1.1.5"
 arrow-array = "59"
 arrow-schema = "59"
 pyo3 = { version = "0.29.2", features = ["extension-module"] }

DEPLOYMENT.md

@@ -1,202 +1,204 @@
-# Run RANGE locally or deploy it free on Hugging Face
-
-RANGE supports two deployments from the same Gradio app:
-
-| Route | Best for | Runtime |
-| --- | --- | --- |
-| Local Docker | Private local use and a portable container | Docker with the compiled CPU/Rust engine |
-| Private Hugging Face Space | A shareable demo without a paid plan | Gradio on the free ZeroGPU runtime, with the same CPU/Rust engine |
-
-The Hugging Face route does **not** turn RANGE into a GPU application. Its real
-`/analyze` and `/batch` endpoints remain on CPU and never request a GPU allocation.
-The app contains one unused `@spaces.GPU` function solely because the free ZeroGPU
-runtime requires a decorated function.
-
-Free ZeroGPU hosting is currently available to eligible personal accounts in good
-standing, with a verified email, an account older than 30 days, and no more than two
-hosted ZeroGPU Spaces. Hugging Face can change these limits. See the
-[ZeroGPU documentation](https://huggingface.co/docs/hub/spaces-zerogpu) before a new
-deployment.
-
-## Prepare the repository
-
-Run these commands from `dataset/news_relevance/range_news` on the `codex` branch.
-The existing project environment is sufficient for validation:
-
-```powershell
-conda activate attention2alpha
-python app/validate_space.py
-python app/export_space.py `
-  --target docker `
-  --output build/huggingface-space `
-  --force
-```
-
-The exporter writes only below `build/` and replaces a directory only when its
-manifest proves that it is an earlier RANGE export.
-
-## Route A: run the Docker app locally
-
-```powershell
-docker build `
-  --tag range-news-space:0.1.0a1 `
-  build/huggingface-space
-
-docker run --rm --name range-news-space `
-  --publish 127.0.0.1:7860:7860 `
-  range-news-space:0.1.0a1
-```
-
-Open `http://127.0.0.1:7860`. Stop the container with `Ctrl+C`.
-
-The Docker bundle is self-contained source: it builds the Rust extension, installs
-the package and Gradio, and runs as an unprivileged user. It does not need a Hugging
-Face account or network access for inference.
-
-If downloads fail with an `UnknownIssuer` certificate error on a managed network,
-export that network's trusted root certificate as a PEM file and add
-`--secret "id=build_ca,src=C:\path\to\trusted-root.pem"` to the Docker build command.
-The certificate is available only while dependencies download and is not copied into
-the image. Do not disable TLS verification or add a trusted-host exception.
-
-## Route B: build the free Hugging Face bundle
-
-Hugging Face does not compile the Rust extension for this route. Export the portable
-CPython 3.10 manylinux2014 wheel from the Docker build first:
-
-```powershell
-docker build `
-  --platform linux/amd64 `
-  --target wheel-export `
-  --output "type=local,dest=build/manylinux2014-wheel" `
-  build/huggingface-space
-
-$Wheels = @(Get-ChildItem `
-  -LiteralPath build/manylinux2014-wheel `
-  -Filter "range_news-0.1.0a1-cp310-cp310-manylinux_2_17_x86_64.manylinux2014_x86_64.whl")
-
-if ($Wheels.Count -ne 1) {
-  throw "Expected exactly one portable RANGE x86_64 wheel."
-}
-$Wheel = $Wheels[0]
-
-python app/export_space.py `
-  --target zerogpu `
-  --wheel $Wheel.FullName `
-  --output build/huggingface-zerogpu-space `
-  --force
-```
-
-The second export contains Gradio Space metadata, the app, package documentation and
-source, and a runtime copy extracted from the validated wheel. Gradio Spaces install
-`requirements.txt` before copying repository files, so a relative wheel reference
-cannot work during their build. Vendoring the inspected wheel payload keeps the build
-self-contained without publishing the package and makes the native extension available
-after the source copy. The requirements file installs RANGE's small Python
-dependencies; the platform supplies Gradio, `spaces`, and `huggingface_hub`.
-
-Before uploading, inspect `build/huggingface-zerogpu-space`. Do not add credentials,
-private dataset rows, licensed articles, caches, or machine-specific paths. A public
-Space exposes this bundle as a public repository, including the app source, bundled
-RANGE source and native runtime, package documentation, and default taxonomy. Review
-the uploaded revision history as well as the latest files before changing visibility.
-
-## Create and upload the private Space
-
-Use a small deployment environment to keep Hub tooling separate from the research
-environment. Create it once; skip the first command when it already exists:
-
-```powershell
-conda create --name range-news-hf-deploy --yes python=3.10
-conda activate range-news-hf-deploy
-python -m pip install `
-  "huggingface_hub>=1.16,<2" `
-  "gradio-client==2.6.1" `
-  "pip-system-certs>=5,<6"
-hf auth login
-hf auth whoami --format json
-```
-
-`pip-system-certs` lets the Python CLI use the Windows certificate store, including
-institution-managed certificate authorities.
-
-Create the private Gradio Space on the free ZeroGPU hardware and upload the prepared
-directory:
-
-```powershell
-$SpaceId = "Brianferrell787/range-news"
-
-hf repos create $SpaceId `
-  --type space `
-  --sdk gradio `
-  --flavor zero-a10g `
-  --private
-
-hf upload $SpaceId build/huggingface-zerogpu-space . `
-  --repo-type space `
-  --commit-message "Deploy private RANGE 0.1.0a1 demo"
-```
-
-Do not run the upload if creation fails. For an existing Space, first verify that its
-repository is private, its SDK is Gradio, and its hardware is ZeroGPU.
-
-## Verify the live deployment
-
-```powershell
-hf spaces wait $SpaceId --timeout 30m
-hf spaces logs $SpaceId --build -n 200
-hf spaces logs $SpaceId -n 200
-hf spaces info $SpaceId --expand sdk,runtime --format json
-```
-
-Open `https://huggingface.co/spaces/Brianferrell787/range-news` and test all three
-single-article examples plus the batch example. The Space can sleep when idle, so the
-first request may include a cold start.
-
-Private API calls use the token already stored by `hf auth login`:
-
-```python
-from gradio_client import Client
-from huggingface_hub import get_token
-
-client = Client("Brianferrell787/range-news", token=get_token())
-client.view_api()
-```
-
-The generated `agents.md` points coding agents to the API schema, which lists the
-named `/analyze` and `/batch` endpoints.
-
-## Privacy and performance boundaries
-
-- Do not add an HF token as a Space secret; RANGE needs no runtime credential.
-- Text submitted to the hosted demo is processed on Hugging Face infrastructure. Do
-  not submit confidential or unlicensed material.
-- The interface and named API endpoints reject more than 100 rows, more than 20,000
-  characters or 80,000 UTF-8 bytes in one article, and more than 200,000 characters
-  or 800,000 UTF-8 bytes across a batch. Use the package's compact or Arrow API for
-  large datasets. Batch rows must have exactly four columns. Publication timestamps
-  are capped at 128 characters, while article IDs and sources are capped at 256
-  characters each. Metadata across the batch is capped at 64,000 characters and
-  256,000 UTF-8 bytes, and combined article and metadata cell content is capped at
-  264,000 characters and 1,056,000 UTF-8 bytes. These caps do not count JSON framing
-  or Gradio's transport envelope. A separate 4 MiB server limit covers the complete
-  HTTP request body before JSON parsing.
-- Downloaded evidence identifies the screened article by text length and SHA-256 hash
-  instead of copying the screened text. RANGE removes leading and trailing whitespace
-  before screening. Download files become eligible for best-effort
-  deletion after five minutes, cleanup runs once a minute, and a Space restart may
-  remove them sooner. They are not durable or private storage.
-- Production responses hide internal error details. Use the Space logs to diagnose a
-  failure; do not expose a traceback or exception text in the browser.
-- Package benchmark rates describe the native batch engine on the recorded hardware,
-  not the latency or throughput of this shared two-core hosted demo.
-- A `relevant` result means the configured financial and economic policy accepted the
-  article. It is not sentiment, materiality, a return forecast, or investment advice.
-
-## Planned Python 3.12 migration
-
-The current alpha bundle uses CPython 3.10. Python 3.12 support is a planned follow-up,
-not part of this deployment. Because RANGE includes a compiled Rust extension, that
-migration must update and test the package metadata, build image, native wheel, Space
-runtime, exported bundle, and clean-install checks together. Do not change only the
-Space metadata or try to load the existing `cp310` wheel in Python 3.12.
+# Run RANGE locally or deploy it free on Hugging Face
+
+RANGE supports two deployments from the same Gradio app:
+
+| Route | Best for | Runtime |
+| --- | --- | --- |
+| Local Docker | Private local use and a portable container | Docker with the compiled CPU/Rust engine |
+| Private Hugging Face Space | A shareable demo without a paid plan | Gradio on the free ZeroGPU runtime, with the same CPU/Rust engine |
+
+The Hugging Face route does **not** turn RANGE into a GPU application. Its real
+`/analyze` and `/batch` endpoints remain on CPU and never request a GPU allocation.
+The app contains one unused `@spaces.GPU` function solely because the free ZeroGPU
+runtime requires a decorated function.
+
+Free ZeroGPU hosting is currently available to eligible personal accounts in good
+standing, with a verified email, an account older than 30 days, and no more than two
+hosted ZeroGPU Spaces. Hugging Face can change these limits. See the
+[ZeroGPU documentation](https://huggingface.co/docs/hub/spaces-zerogpu) before a new
+deployment.
+
+## Prepare the repository
+
+Run these commands from `dataset/news_relevance/range_news` on the `codex` branch.
+The existing project environment is sufficient for validation:
+
+```powershell
+python -m venv .venv
+.\.venv\Scripts\Activate.ps1
+python -m pip install '.[demo]'
+python app/validate_space.py
+python app/export_space.py `
+  --target docker `
+  --output build/huggingface-space `
+  --force
+```
+
+The exporter writes only below `build/` and replaces a directory only when its
+manifest proves that it is an earlier RANGE export.
+
+## Route A: run the Docker app locally
+
+```powershell
+docker build `
+  --tag range-news-space:0.1.0a1 `
+  build/huggingface-space
+
+docker run --rm --name range-news-space `
+  --publish 127.0.0.1:7860:7860 `
+  range-news-space:0.1.0a1
+```
+
+Open `http://127.0.0.1:7860`. Stop the container with `Ctrl+C`.
+
+The Docker bundle is self-contained source: it builds the Rust extension, installs
+the package and Gradio, and runs as an unprivileged user. It does not need a Hugging
+Face account or network access for inference.
+
+If downloads fail with an `UnknownIssuer` certificate error on a managed network,
+export that network's trusted root certificate as a PEM file and add
+`--secret "id=build_ca,src=C:\path\to\trusted-root.pem"` to the Docker build command.
+The certificate is available only while dependencies download and is not copied into
+the image. Do not disable TLS verification or add a trusted-host exception.
+
+## Route B: build the free Hugging Face bundle
+
+Hugging Face does not compile the Rust extension for this route. Export the portable
+CPython 3.10 manylinux2014 wheel from the Docker build first:
+
+```powershell
+docker build `
+  --platform linux/amd64 `
+  --target wheel-export `
+  --output "type=local,dest=build/manylinux2014-wheel" `
+  build/huggingface-space
+
+$Wheels = @(Get-ChildItem `
+  -LiteralPath build/manylinux2014-wheel `
+  -Filter "range_news-0.1.0a1-cp310-cp310-manylinux_2_17_x86_64.manylinux2014_x86_64.whl")
+
+if ($Wheels.Count -ne 1) {
+  throw "Expected exactly one portable RANGE x86_64 wheel."
+}
+$Wheel = $Wheels[0]
+
+python app/export_space.py `
+  --target zerogpu `
+  --wheel $Wheel.FullName `
+  --output build/huggingface-zerogpu-space `
+  --force
+```
+
+The second export contains Gradio Space metadata, the app, package documentation and
+source, and a runtime copy extracted from the validated wheel. Gradio Spaces install
+`requirements.txt` before copying repository files, so a relative wheel reference
+cannot work during their build. Vendoring the inspected wheel payload keeps the build
+self-contained without publishing the package and makes the native extension available
+after the source copy. The requirements file installs RANGE's small Python
+dependencies; the platform supplies Gradio, `spaces`, and `huggingface_hub`.
+
+Before uploading, inspect `build/huggingface-zerogpu-space`. Do not add credentials,
+private dataset rows, licensed articles, caches, or machine-specific paths. A public
+Space exposes this bundle as a public repository, including the app source, bundled
+RANGE source and native runtime, package documentation, and default taxonomy. Review
+the uploaded revision history as well as the latest files before changing visibility.
+
+## Create and upload the private Space
+
+Use a small deployment environment to keep Hub tooling separate from the research
+environment. Create it once; skip the first command when it already exists:
+
+```powershell
+conda create --name range-news-hf-deploy --yes python=3.10
+conda activate range-news-hf-deploy
+python -m pip install `
+  "huggingface_hub>=1.16,<2" `
+  "gradio-client==2.6.1" `
+  "pip-system-certs>=5,<6"
+hf auth login
+hf auth whoami --format json
+```
+
+`pip-system-certs` lets the Python CLI use the Windows certificate store, including
+institution-managed certificate authorities.
+
+Create the private Gradio Space on the free ZeroGPU hardware and upload the prepared
+directory:
+
+```powershell
+$SpaceId = "Brianferrell787/range-news"
+
+hf repos create $SpaceId `
+  --type space `
+  --sdk gradio `
+  --flavor zero-a10g `
+  --private
+
+hf upload $SpaceId build/huggingface-zerogpu-space . `
+  --repo-type space `
+  --commit-message "Deploy private RANGE 0.1.0a1 demo"
+```
+
+Do not run the upload if creation fails. For an existing Space, first verify that its
+repository is private, its SDK is Gradio, and its hardware is ZeroGPU.
+
+## Verify the live deployment
+
+```powershell
+hf spaces wait $SpaceId --timeout 30m
+hf spaces logs $SpaceId --build -n 200
+hf spaces logs $SpaceId -n 200
+hf spaces info $SpaceId --expand sdk,runtime --format json
+```
+
+Open `https://huggingface.co/spaces/Brianferrell787/range-news` and test all three
+single-article examples plus the batch example. The Space can sleep when idle, so the
+first request may include a cold start.
+
+Private API calls use the token already stored by `hf auth login`:
+
+```python
+from gradio_client import Client
+from huggingface_hub import get_token
+
+client = Client("Brianferrell787/range-news", token=get_token())
+client.view_api()
+```
+
+The generated `agents.md` points coding agents to the API schema, which lists the
+named `/analyze` and `/batch` endpoints.
+
+## Privacy and performance boundaries
+
+- Do not add an HF token as a Space secret; RANGE needs no runtime credential.
+- Text submitted to the hosted demo is processed on Hugging Face infrastructure. Do
+  not submit confidential or unlicensed material.
+- The interface and named API endpoints reject more than 100 rows, more than 20,000
+  characters or 80,000 UTF-8 bytes in one article, and more than 200,000 characters
+  or 800,000 UTF-8 bytes across a batch. Use the package's compact or Arrow API for
+  large datasets. Batch rows must have exactly four columns. Publication timestamps
+  are capped at 128 characters, while article IDs and sources are capped at 256
+  characters each. Metadata across the batch is capped at 64,000 characters and
+  256,000 UTF-8 bytes, and combined article and metadata cell content is capped at
+  264,000 characters and 1,056,000 UTF-8 bytes. These caps do not count JSON framing
+  or Gradio's transport envelope. A separate 4 MiB server limit covers the complete
+  HTTP request body before JSON parsing.
+- Downloaded evidence identifies the screened article by text length and SHA-256 hash
+  instead of copying the screened text. RANGE removes leading and trailing whitespace
+  before screening. Download files become eligible for best-effort
+  deletion after five minutes, cleanup runs once a minute, and a Space restart may
+  remove them sooner. They are not durable or private storage.
+- Production responses hide internal error details. Use the Space logs to diagnose a
+  failure; do not expose a traceback or exception text in the browser.
+- Package benchmark rates describe the native batch engine on the recorded hardware,
+  not the latency or throughput of this shared two-core hosted demo.
+- A `relevant` result means the configured financial and economic policy accepted the
+  article. It is not sentiment, materiality, a return forecast, or investment advice.
+
+## Planned Python 3.12 migration
+
+The current alpha bundle uses CPython 3.10. Python 3.12 support is a planned follow-up,
+not part of this deployment. Because RANGE includes a compiled Rust extension, that
+migration must update and test the package metadata, build image, native wheel, Space
+runtime, exported bundle, and clean-install checks together. Do not change only the
+Space metadata or try to load the existing `cp310` wheel in Python 3.12.

PACKAGE_README.md

@@ -20,6 +20,12 @@ RANGE answers three practical questions for each article:
 
 It runs on CPU, makes no network request during inference, and does not depend on an embedding model, an external API, or an LLM. The `0.1.0a1` source and CI artifacts are prepared for review but are **not published to PyPI**.
 
+A separate optional GPU research companion now has local Windows CPython3.10/sm75
+installation qualification for bulk Arrow screening. See the
+[GPU research installation and results](https://huggingface.co/spaces/Brianferrell787/range-news/blob/main/BENCHMARKS.md)
+for the local artifacts, measured performance and supported scope. The CPU
+installation below remains the maintained package default.
+
 ## See it in 30 seconds
 
 Install from this checkout:
@@ -116,7 +122,16 @@ The result is low-overhead, predictable CPU screening with a rich Python path av
 
 ### Research benchmark context
 
-In our fastest recorded CPU test, RANGE screened **457,735 articles/second in a 500,000-article run** and **395,017 articles/second in a 10,000,000-article run**. We measured this with a specially optimized RANGE build on one Intel i7-10750H Windows laptop using 10 CPU workers. These are the fastest recorded results for the screening step alone. They do not include file loading or the rest of a data pipeline, and performance varies with hardware, article length, and screening rules.
+**Python package coming soon.** The maintained CPU implementation recorded
+**489,759 articles/s** in a qualified 10-million-article warm screening run.
+CUDA research recorded a historical qualified **1,833,059 articles/s** on that
+workload size; the newer retained CUDA installation separately measured
+**958,155 articles/s**. These are different sessions, not a paired speedup.
+
+Measurements used an Intel i7-10750H Windows laptop with 10 CPU workers and an
+RTX 2070 Max-Q for CUDA. Timings cover compact screening, including CUDA
+transfers/fallback/assembly, but exclude loading and initialization. They are
+not hosted-demo performance. See the Space's BENCHMARKS.md for provenance.
 
 ## Choose the right API
 

README.md

@@ -23,6 +23,8 @@ tags:
 
 **Rapid Analysis of News for the General Economy**
 
+**Python package coming soon. CPU today, optional CUDA for bulk screening.**
+
 RANGE checks timestamped financial news, identifies whether it matches the current
 financial and economic rules, shows any supported broad-market connection, and
 explains exactly which words and rules produced the result.
@@ -76,23 +78,48 @@ eligible for deletion after five minutes, and the app makes a best-effort cleanu
 once a minute. The host may remove it sooner when the Space restarts. Save a file
 promptly if you need it, and do not rely on the download link as an archive.
 
-## Why it is fast
+## Measured speed. Clear boundaries.
+
+| Implementation | Articles / second | Measurement |
+| --- | ---: | --- |
+| CUDA research record | **1,833,059** | Qualified warm screening of 10 million articles |
+| Maintained CPU implementation | **489,759** | Qualified warm screening of 10 million articles |
+| Newer retained CUDA installation | **958,155** | Separate local installed-package qualification |
+
+Measured on an Intel i7-10750H Windows laptop with 10 CPU workers; CUDA used an
+RTX 2070 Max-Q. These are separate experiments, not a same-run CPU/GPU speedup.
+The CUDA peak belongs to an earlier qualified implementation; later sessions
+varied substantially. Do not combine its peak with later percentage gains.
+
+Screening timings exclude file loading, imports, initialization and verification.
+CUDA timings include transfers, exact CPU fallback and result assembly.
+The live demo uses a different CPU environment and rich explanations, so these
+figures are not its throughput or a service guarantee.
+
+[Read the benchmark record](https://huggingface.co/spaces/Brianferrell787/range-news/blob/main/BENCHMARKS.md)
+
+## Python package coming soon
+
+We are preparing RANGE for straightforward Python installation, with CPU support
+and an optional CUDA backend. Public package release, clean installation across
+supported platforms and broader GPU compatibility are still ahead.
+The current Space lets you explore the engine today.
 
-RANGE is a compiled screening engine rather than an open-ended language model:
+## What we want to try next
 
-- Rust Aho-Corasick automata scan many configured phrases together.
-- Rayon distributes independent articles across CPU workers.
-- Worker-local buffers are reused instead of rebuilt for every row.
-- Common ASCII news text uses a specialized normalization path, while frozen Unicode
-  tables keep fallback behavior deterministic.
-- Compact and Arrow package APIs represent the common no-match case sparsely.
+- **Finish the release:** clean installs, supported platforms, documentation and
+  validation of the exact wheels people will use.
+- **Share work across taxonomies:** build on successful two-taxonomy experiments,
+  then extend packaging and memory scheduling for more rule sets.
+- **Choose CPU or CUDA by workload:** measure small batches, large batches and
+  routing overhead before introducing automatic selection.
+- **Target remaining matching ideas:** direct StringZilla integration and other
+  CUSMART methods remain candidates, not demonstrated improvements.
+- **Train optimizations on separate data:** investigate corpus-trained automata
+  and fresh compiler profiles using representative development articles.
 
-In our fastest recorded CPU test, RANGE screened **457,735 articles/second in a
-500,000-article run** and **395,017 articles/second in a 10,000,000-article run**.
-We measured this with a specially optimized RANGE build on one Intel i7-10750H Windows
-laptop using 10 CPU workers. These are the fastest recorded results for the screening
-step alone. Loading data, running a complete pipeline, and using the hosted demo will
-be slower. Speed varies with hardware, article length, and screening rules.
+Recent alternatives did not beat the retained matcher. We keep negative results
+and require exact outputs before considering a speed improvement.
 
 ## What the result means
 

SPACE_BUNDLE_MANIFEST.json

@@ -1,21 +1,21 @@
 {
   "files": {
     ".gitattributes": "30af955bc8b9589ff13954efae1020fb4fcbd3e2114ce2530c1e19a198331490",
-    "CHANGELOG.md": "04441fe7ba8cc83498bf014cda1b29bcb6f7c148cfbbe3452dc7a9dea9af85ef",
+    "BENCHMARKS.md": "7035a05f986a6c28a91262d34e499ae3d2612931673a82d7ad778f1bad9c15da",
+    "CHANGELOG.md": "63ef44e35ad6fbc3184d93141e0494eeb18a0289c5adda22ab1b0f8abebaa35b",
     "CITATION.cff": "acf3bf2c922c2afd0f8cc336024f525d9334c4b94b83efaa96dc36a1df5c6198",
     "Cargo.lock": "64eaf82038b21074bf9d6b30e00bf05536958b08463dbe4a4c9a88a86e28a2d8",
-    "Cargo.toml": "f58a8af353ccba4309f9ddddc3e138634093ab2545bfef5214b6a08815d37d59",
-    "DEPLOYMENT.md": "2d005b4059d06bc5e722d67acfe33b97a1b631ac9537e69721e0920b26ba2c0d",
+    "Cargo.toml": "962f3ed0cdcf18aafd4b83f3073fb087934472a8f718f87a37885318804ba665",
+    "DEPLOYMENT.md": "b370e9b8c3f2b3118b2298a21dda028b1aad9b5b588cf00235ffbaedd4bd6dde",
     "LICENSE": "98564786fde1cf443f2b761bc9c3b329dcac3528b3c383a66b25101ee9670585",
-    "PACKAGE_README.md": "e6fe56bcb6c0cf24a6c7b3859527ab043c341a7c40b5eb3f919a9bccab33382c",
-    "README.md": "423104b0ef72e4e605c4facf10681f0741d43eb8a70ea6932fc945e84d474048",
-    "app.py": "138adcabfb167a19a499d3c0f80bfa63b565c61c3fac1e1d31c04f12bcc5e622",
-    "docs/attention2alpha-compatibility-review.md": "c6e28e67b5528c5683efa6cb98603a9f46e42430c96bee6da4a3a5af9bf94c13",
-    "docs/performance.md": "9d4c99009993527e49f2ce3bb38d3156f1b7e1425723f0093c7873c544261b24",
-    "docs/readme-research.md": "f69255682495de999875c91a8c4dee2e59e1b185877920cf4c85f0ccd49053f3",
-    "docs/release.md": "ce56bb5c7f456a710c90bed63ce2dfe90632d1b0208cc16d06e0b37ad0470bbe",
-    "docs/taxonomy.md": "899b86c816ead8cd9bae9b58f96d0d21a1439cc778e6b61e7c17644a64dc1abf",
-    "docs/technical-signoff.md": "4c1efa828b2460ff5092f07df30319ca7775ec3118ccdfc573aaa5b2980928c5",
+    "PACKAGE_README.md": "0652c0f42333f96de7a7f35c5fa15d2a20a496df7c0f5cfa78ab63e2ebffbdb0",
+    "README.md": "0b2a476a20c8502e0274c01c643f6d5152aeafe92a2f3f70a4b16a80b280bd4a",
+    "app.py": "d666b475abadbb723baa1cc5f1ef5ca981e682f4839e448547febfac1a614845",
+    "docs/performance.md": "b25202cb154bb2bcdef48c14af8cedc821a2dd298fe32d53608d4dcc0f1f7fbb",
+    "docs/readme-research.md": "2f8e2f3e7ed2dc386995ae6c9abca89b7e910209716ad31102f633a9a2bb7fe7",
+    "docs/release.md": "e449a9001d97b20ea1f9b505d9982eec5b97ec068cae3e0574a498949ac0363e",
+    "docs/taxonomy.md": "c1a33b8efd93a87d3ccfc413a879f11a088290ec9859a5c4254cf88d86e21998",
+    "docs/technical-signoff.md": "ba912d29e0ba23d1c8d42ad5616663b811b610a98af9941ed770de1a89ea88a8",
     "examples.py": "94da2be9d8e523a54b6aae6fbd365c5e3456e836b120e4a4a0bd78acb5969d10",
     "examples/app.py": "53c76cc3834e73435483db6fbf89d8125a0f7aa590269d880cffdaa8e40097f5",
     "examples/benchmark_hf.py": "5df4e9d756a6447eb5f462ac7b72aaf2a8c1d92558a58620e5abb51e97e62bca",
@@ -23,12 +23,12 @@
     "examples/quickstart.py": "19bdd779ec202957c72c2b49e7bf778a13ea1b94d0a52f1bba5521810eb71626",
     "pyproject.toml": "d40182524a367d9ad2d08892450b4bcecfb2133c92bf45867c4e8f4a05910300",
     "requirements.txt": "94f5ee00edc14a89e5bf6f5fcb90261cde4a57dc3ebc20e0639e68ec504cc220",
-    "rust/core.rs": "9ec890063a3485ab90f9f517a0e8c17b4ba52d66d937f2b9f6cf521889590f1a",
+    "rust/core.rs": "db6d48765f3a551bf81bc0fd6b471306a587f75e265c35f2f277b3115ffba172",
     "rust/generated/python_whitespace.bin": "6c314375b6c075589b515139e50068d72c0cbd7daf4246e555a9dcfc9748ecc9",
     "rust/generated/unicode_index.bin": "fe152ac184aa77c40d0f040ba725140b17d845bae9fae255b2b3d3c43bb79c8f",
     "rust/generated/unicode_meta.txt": "d7b7f5d807b712597a04e8cf1394c1734962c4e042057cc7fca85f5173919d38",
     "rust/generated/unicode_pool.bin": "109a8da1563408ad1da82919a5dfa1ab9fa18870f0f4d22e2818857b5a4fc30f",
-    "rust/lib.rs": "f6a2205062c2272b13b925deb1883ff1fab10aa5e40a46695bfe96a5626b5753",
+    "rust/lib.rs": "6d099c6cbc33b85bd7633a790f2b8d3a0296d74d604fbabf14806634e538fb0a",
     "src/range_news/__init__.py": "816ba0ee72545cc03d6e5183d46530acd026e67f4b38d6d972a1abd520eb899d",
     "src/range_news/_core/__init__.py": "7e6c8615e347bca422f9b1e6e10160ac277c346956adf9e86a8a08419f879e96",
     "src/range_news/_core/accelerated/__init__.py": "ed04df1ca0da8254d9558201c6172969626aced74864842c5a17068ce87a6999",
@@ -59,7 +59,7 @@
     "vendor/range_news/_core/configs/default.yml": "6e443b14b9e7c4524e8dbdd3035726627345d01d02cc21de7a53a133dea5802c",
     "vendor/range_news/_core/indicator.py": "488178693d90e7a7f329b40309eb4583908d5a990cd0b293b272c5fbb192f3a4",
     "vendor/range_news/_core/models.py": "e152077ecd18c31eed76b150e234934180a5ffad061d2bf26e35229160cf2733",
-    "vendor/range_news/_native.cpython-310-x86_64-linux-gnu.so": "45e05c00ab729ead671436ed8bd392c016dfa1e44ef42fdfade758902b1519d1",
+    "vendor/range_news/_native.cpython-310-x86_64-linux-gnu.so": "e05b832a8b33169dd988b4bc88a36bfb1f5b40f70676a09ecda727961d123c9c",
     "vendor/range_news/_taxonomy_impl.py": "db6802ef00114e33bbb47b2d71886f037e151f397ae82258d1a6760f43bdfed1",
     "vendor/range_news/api.py": "1d165a3211fad9a9de1c274320dc21e787303fcd1a37599e399ba82881d4886d",
     "vendor/range_news/backends.py": "7a25879d21ed9992aeecc9dc5f4093de00ae68c117646b132140d663987829ca",
@@ -73,7 +73,7 @@
   "runtime_package": "vendor/range_news",
   "sdk": "gradio",
   "source_wheel": "range_news-0.1.0a1-cp310-cp310-manylinux_2_17_x86_64.manylinux2014_x86_64.whl",
-  "source_wheel_sha256": "c72a0f0d174e028f0a3db338c13e1dbf3e905ff2f67bacc0b3966a2386c2681b",
+  "source_wheel_sha256": "48581327a16ef46a6da9dbf7f00a296b7037dd7ba1b3af3e9108a945729174b7",
   "target": "zerogpu",
   "version": "0.1.0a1"
 }

app.py

@@ -1,14 +1,14 @@
-"""Space-ready Gradio demo for explainable financial-news relevance screening."""
+"""Space-ready Gradio demo for explainable financial-news relevance screening."""
 
 from __future__ import annotations
 
-import dataclasses
-import hashlib
-import html
-import json
-import os
-import sys
-import uuid
+import dataclasses
+import hashlib
+import html
+import json
+import os
+import sys
+import uuid
 from collections.abc import Mapping, Sequence
 from datetime import datetime
 from enum import Enum
@@ -16,21 +16,21 @@ from functools import lru_cache
 from pathlib import Path
 from typing import Any
 
-import gradio as gr
-from starlette.middleware import Middleware
-from starlette.middleware.body_limit import RequestBodyLimitMiddleware
-from gradio.utils import get_upload_folder
-
-VENDORED_PACKAGE_ROOT = Path(__file__).resolve().parent / "vendor"
-if VENDORED_PACKAGE_ROOT.is_dir():
-    sys.path.insert(0, str(VENDORED_PACKAGE_ROOT))
-
-try:
-    import spaces
+import gradio as gr
+from starlette.middleware import Middleware
+from starlette.middleware.body_limit import RequestBodyLimitMiddleware
+from gradio.utils import get_upload_folder
+
+VENDORED_PACKAGE_ROOT = Path(__file__).resolve().parent / "vendor"
+if VENDORED_PACKAGE_ROOT.is_dir():
+    sys.path.insert(0, str(VENDORED_PACKAGE_ROOT))
+
+try:
+    import spaces
 except ModuleNotFoundError:  # Local installs and the Docker image do not need it.
     spaces = None
 
-from range_news import RelevanceEngine, __version__
+from range_news import RelevanceEngine, __version__
 
 from examples import ARTICLE_EXAMPLES, BATCH_ROWS, SINGLE_EXAMPLES
 
@@ -46,23 +46,23 @@ if spaces is not None:
 
 GRADIO_MAJOR = int(gr.__version__.split(".", 1)[0])
 THEME = gr.themes.Soft(primary_hue="teal", neutral_hue="slate")
-MAX_BATCH_ROWS = 100
-EXPECTED_BATCH_COLUMNS = 4
-MAX_ARTICLE_CHARS = 20_000
-MAX_ARTICLE_BYTES = 80_000
-MAX_TIMESTAMP_CHARS = 128
-MAX_TIMESTAMP_BYTES = 512
-MAX_ARTICLE_ID_CHARS = 256
-MAX_ARTICLE_ID_BYTES = 1_024
-MAX_SOURCE_CHARS = 256
-MAX_SOURCE_BYTES = 1_024
-MAX_BATCH_CHARS = 200_000
-MAX_BATCH_BYTES = 800_000
-MAX_BATCH_METADATA_CHARS = 64_000
-MAX_BATCH_METADATA_BYTES = 256_000
-MAX_BATCH_CONTENT_CHARS = MAX_BATCH_CHARS + MAX_BATCH_METADATA_CHARS
-MAX_BATCH_CONTENT_BYTES = MAX_BATCH_BYTES + MAX_BATCH_METADATA_BYTES
-MAX_HTTP_REQUEST_BYTES = 4 * 1024 * 1024
+MAX_BATCH_ROWS = 100
+EXPECTED_BATCH_COLUMNS = 4
+MAX_ARTICLE_CHARS = 20_000
+MAX_ARTICLE_BYTES = 80_000
+MAX_TIMESTAMP_CHARS = 128
+MAX_TIMESTAMP_BYTES = 512
+MAX_ARTICLE_ID_CHARS = 256
+MAX_ARTICLE_ID_BYTES = 1_024
+MAX_SOURCE_CHARS = 256
+MAX_SOURCE_BYTES = 1_024
+MAX_BATCH_CHARS = 200_000
+MAX_BATCH_BYTES = 800_000
+MAX_BATCH_METADATA_CHARS = 64_000
+MAX_BATCH_METADATA_BYTES = 256_000
+MAX_BATCH_CONTENT_CHARS = MAX_BATCH_CHARS + MAX_BATCH_METADATA_CHARS
+MAX_BATCH_CONTENT_BYTES = MAX_BATCH_BYTES + MAX_BATCH_METADATA_BYTES
+MAX_HTTP_REQUEST_BYTES = 4 * 1024 * 1024
 EVIDENCE_HEADERS = [
     "evidence path",
     "matched text",
@@ -81,98 +81,103 @@ BATCH_HEADERS = [
     "why",
 ]
 
-CSS = """
-html, body {width: 100%; margin: 0 !important; overflow-x: clip;}
-.gradio-container {
-  width: 100% !important;
-  max-width: none !important;
-  margin: 0 !important;
-  padding: 0 0 2rem !important;
-}
-.hero-host {
-  width: 100vw !important;
-  max-width: none !important;
-  margin-inline: calc(50% - 50vw) !important;
-  padding: 0 !important;
-  border: 0 !important;
-  box-sizing: border-box !important;
-}
-.hero {
-  position: relative;
-  width: 100%;
-  margin: 0;
-  overflow: hidden;
-  box-sizing: border-box;
-  border-block: 1px solid var(--border-color-primary);
-  border-inline: 0;
-  background:
-    radial-gradient(circle at 92% 15%, rgba(13, 148, 136, 0.18), transparent 34%),
-    radial-gradient(circle at 8% 88%, rgba(37, 99, 235, 0.12), transparent 30%),
-    linear-gradient(145deg, var(--background-fill-primary), var(--background-fill-secondary));
-  box-shadow: 0 18px 48px rgba(15, 23, 42, 0.08);
-}
-.hero-inner {
-  width: min(calc(100% - 2rem), 1180px);
-  margin-inline: auto;
-  padding: clamp(2.2rem, 5vw, 4.5rem) clamp(1.25rem, 4vw, 3.2rem);
-  box-sizing: border-box;
-  text-align: center;
-}
-.hero-eyebrow,
-.hero h1,
-.hero-expansion,
-.hero-copy,
-.benchmark-note {
-  width: 100%;
-  text-align: center !important;
-}
-.hero-eyebrow {
-  margin: 0 0 0.8rem;
-  color: #0f766e;
+CSS = """
+html, body {width: 100%; margin: 0 !important; overflow-x: clip;}
+.gradio-container {
+  width: 100% !important;
+  max-width: none !important;
+  margin: 0 !important;
+  padding: 0 0 2rem !important;
+}
+.hero-host {
+  width: 100vw !important;
+  max-width: none !important;
+  margin-inline: calc(50% - 50vw) !important;
+  padding: 0 !important;
+  border: 0 !important;
+  box-sizing: border-box !important;
+}
+.hero {
+  position: relative;
+  width: 100%;
+  margin: 0;
+  overflow: hidden;
+  box-sizing: border-box;
+  color: #f1f5f9;
+  border-block: 1px solid #1e3448;
+  border-inline: 0;
+  background:
+    radial-gradient(circle at 92% 15%, rgba(13, 148, 136, 0.18), transparent 34%),
+    radial-gradient(circle at 8% 88%, rgba(37, 99, 235, 0.12), transparent 30%),
+    linear-gradient(145deg, #101f30, #123b43);
+  box-shadow: 0 18px 48px rgba(15, 23, 42, 0.08);
+}
+.hero-inner {
+  width: min(calc(100% - 2rem), 1180px);
+  margin-inline: auto;
+  padding: clamp(2rem, 4vw, 3rem) clamp(1.25rem, 4vw, 3.2rem);
+  box-sizing: border-box;
+  text-align: center;
+}
+.hero-eyebrow,
+.hero h1,
+.hero-expansion,
+.hero-copy,
+.benchmark-note {
+  width: 100%;
+  text-align: center !important;
+}
+.hero-eyebrow {
+  margin: 0 0 0.8rem;
+  color: #7de8d5;
   font-size: 0.78rem;
   font-weight: 750;
   letter-spacing: 0.12em;
   text-transform: uppercase;
 }
-.hero h1 {
-  max-width: 960px;
-  margin: 0 auto;
-  font-size: clamp(3.4rem, 10vw, 7rem);
-  line-height: 0.92;
-  letter-spacing: -0.065em;
-}
-.hero-expansion {
-  max-width: 960px;
-  margin: 1rem auto 0;
-  font-size: clamp(1.08rem, 2.5vw, 1.55rem);
-  font-weight: 720;
-  line-height: 1.35;
-}
-.hero-copy {
-  max-width: 900px;
-  margin: 1rem auto 0;
-  font-size: clamp(1rem, 1.5vw, 1.16rem);
-  line-height: 1.65;
-  opacity: 0.88;
-}
-.speed-grid {
-  display: grid;
-  grid-template-columns: repeat(3, minmax(0, 1fr));
-  gap: 0.75rem;
-  max-width: 900px;
-  margin: 1.6rem auto 0;
-}
-.speed-stat {
-  padding: 0.9rem 1rem;
-  border: 1px solid var(--border-color-primary);
-  border-radius: 14px;
-  background: var(--background-fill-primary);
-  text-align: center;
-}
-.speed-stat strong {display: block; font-size: clamp(1.2rem, 2.6vw, 1.75rem); line-height: 1.15;}
-.speed-stat span {display: block; margin-top: 0.25rem; font-size: 0.8rem; line-height: 1.35; opacity: 0.72;}
-.benchmark-note {max-width: 900px; margin: 0.75rem auto 0; font-size: 0.86rem; line-height: 1.5; opacity: 0.72;}
-.trust-row {display: flex; justify-content: center; flex-wrap: wrap; gap: 0.55rem; margin-top: 1.25rem;}
+.hero h1 {
+  max-width: 960px;
+  margin: 0 auto;
+  font-size: clamp(3.4rem, 9vw, 6.2rem);
+  line-height: 0.92;
+  letter-spacing: -0.065em;
+}
+.hero-expansion {
+  max-width: 960px;
+  margin: 1rem auto 0;
+  font-size: clamp(1.08rem, 2.5vw, 1.55rem);
+  font-weight: 720;
+  line-height: 1.35;
+}
+.hero-copy {
+  max-width: 900px;
+  margin: 1rem auto 0;
+  font-size: clamp(1rem, 1.5vw, 1.16rem);
+  line-height: 1.65;
+  opacity: 0.88;
+}
+.speed-grid {
+  display: grid;
+  grid-template-columns: repeat(3, minmax(0, 1fr));
+  gap: 0.75rem;
+  max-width: 900px;
+  margin: 1.6rem auto 0;
+}
+.speed-stat {
+  padding: 0.9rem 1rem;
+  border: 1px solid var(--border-color-primary);
+  border-radius: 14px;
+  background: var(--background-fill-primary);
+  text-align: center;
+}
+.hero h1, .hero-expansion, .hero-copy, .hero .benchmark-note, .hero .speed-stat span {color: #edf8f7 !important;}
+.hero .speed-stat, .hero .trust-pill {background: rgba(255,255,255,0.06); border-color: rgba(255,255,255,0.2); color: #f1f5f9;}
+.hero .package-pill {background: #a4f4da; color: #12352f; border-color: #a4f4da;}
+.hero .speed-stat strong {color: #a4f4da;}
+.speed-stat strong {display: block; font-size: clamp(1.2rem, 2.6vw, 1.75rem); line-height: 1.15;}
+.speed-stat span {display: block; margin-top: 0.25rem; font-size: 0.8rem; line-height: 1.35; opacity: 0.72;}
+.benchmark-note {max-width: 900px; margin: 0.75rem auto 0; font-size: 0.86rem; line-height: 1.5; opacity: 0.72;}
+.trust-row {display: flex; justify-content: center; flex-wrap: wrap; gap: 0.55rem; margin-top: 1.25rem;}
 .trust-pill {
   padding: 0.36rem 0.68rem;
   border: 1px solid var(--border-color-primary);
@@ -181,26 +186,26 @@ html, body {width: 100%; margin: 0 !important; overflow-x: clip;}
   font-size: 0.82rem;
   font-weight: 650;
 }
-.value-grid {
-  display: grid;
-  grid-template-columns: repeat(3, minmax(0, 1fr));
-  gap: 0.8rem;
-  width: min(calc(100% - 2rem), 1120px);
-  max-width: 1120px;
-  margin: 1.15rem auto 1.35rem;
-}
-.content-shell {
-  width: min(calc(100% - 2rem), 1120px) !important;
-  max-width: 1120px !important;
-  margin-inline: auto !important;
-  align-self: center !important;
-}
-.value-card {
+.value-grid {
+  display: grid;
+  grid-template-columns: repeat(3, minmax(0, 1fr));
+  gap: 0.8rem;
+  width: min(calc(100% - 2rem), 1120px);
+  max-width: 1120px;
+  margin: 1.15rem auto 1.35rem;
+}
+.content-shell {
+  width: min(calc(100% - 2rem), 1120px) !important;
+  max-width: 1120px !important;
+  margin-inline: auto !important;
+  align-self: center !important;
+}
+.value-card {
   padding: 1rem 1.05rem;
   border: 1px solid var(--border-color-primary);
-  border-radius: 14px;
-  background: var(--background-fill-primary);
-  text-align: center;
+  border-radius: 14px;
+  background: var(--background-fill-primary);
+  text-align: center;
 }
 .value-card strong {display: block; margin-bottom: 0.25rem; font-size: 0.95rem;}
 .value-card span {font-size: 0.88rem; line-height: 1.45; opacity: 0.78;}
@@ -266,107 +271,135 @@ mark.evidence-observed {background: #bfdbfe;}
   font-size: 0.88rem;
   line-height: 1.5;
 }
-@media (max-width: 760px) {
-  .speed-grid, .value-grid, .result-grid {grid-template-columns: 1fr;}
-  .hero-inner {padding: 1.8rem 1.25rem 2rem;}
-  .speed-stat {text-align: center;}
-  .status-card {min-height: auto;}
-}
+@media (max-width: 760px) {
+  .speed-grid, .value-grid, .result-grid {grid-template-columns: 1fr;}
+  .hero-inner {padding: 1.8rem 1.25rem 2rem;}
+  .speed-stat {text-align: center;}
+  .status-card {min-height: auto;}
+}
 """
 
 ABOUT = """
-## What RANGE does
-
-RANGE is a **deterministic screening layer** for timestamped economic and financial
-news. It answers two related questions separately:
-
-1. Did the article pass the configured financial and economic relevance screen?
-2. Did that evidence support a configured broad-market exposure?
-
-It also preserves the exact text, offsets, rules, time-valid identities, and
-relationships behind the result. The screening logic is deterministic and versioned.
-
-### From article to result
-
-```text
-article + publication time
-  → literal phrase and identifier matches
-  → context, identity, and effective-date checks
-  → accepted / review / rejected evidence paths
-  → article relevance + supported broad-market exposure
-```
-
-### Why it is fast
-
-- **Compile once, scan together.** Rust Aho-Corasick automata check many configured
-  phrases in one pass instead of running a Python loop for every rule.
-- **Use the CPU cores.** Rayon processes independent articles in parallel.
-- **Avoid repeated allocation.** Worker-local scratch buffers are reused across rows.
-- **Optimize common news text.** ASCII input takes a specialized path while frozen
-  Unicode tables preserve deterministic fallback behavior.
-- **Keep empty results cheap.** Compact list and Arrow interfaces return sparse facts
-  rather than building a rich Python object for every no-match row.
-
-In our fastest recorded CPU test, RANGE screened **457,735 articles/second in a
-500,000-article run** and **395,017 articles/second in a 10,000,000-article run**.
-We measured this with a specially optimized RANGE build on one Intel i7-10750H Windows
-laptop using 10 CPU workers. These are the fastest recorded results for the screening
-step alone. Loading data, running a complete pipeline, and using the hosted demo will
-be slower. Speed varies with hardware, article length, and screening rules.
-
-### What it is not
-
-This demo does not infer sentiment, forecast returns, recommend a position, or use an
-LLM. A `relevant` result means the article passed the bundled financial and economic
-relevance policy; evidence-path state and supported exposure are reported separately.
-Neither result means the news is bullish, bearish, material, complete, or predictive
-of returns.
-
-The hosted demo is intended for short evaluation inputs. The downloadable package APIs
-are the appropriate interface for large datasets.
+## Financial news, with the evidence attached
+
+RANGE screens timestamped articles for economic and financial relevance, maps
+supported evidence to broad-market exposures, and shows exactly why it made each
+decision. It is a deterministic engine: the same text, timestamp and taxonomy
+produce the same result.
+
+### Follow every decision
+1. Normalize the text while preserving its original locations.
+2. Match configured phrases and identifiers.
+3. Apply context checks and names valid on the publication date.
+4. Return relevance, supported market connections and the complete evidence trail.
+
+### Built for volume
+The CPU engine uses compiled Rust multi-pattern matching and parallel workers.
+The optional CUDA research engine distributes normalization and matching across
+the GPU, overlaps transfers with work, and preserves exact CPU handling where needed.
+Compact Arrow results avoid creating a large Python object for every article.
+
+### Your taxonomy, your rules
+RANGE's bundled taxonomy covers economic and financial news. Taxonomies are
+versioned configuration: add topics, aliases, context rules and relationships
+without retraining a language model. New taxonomies still need correctness and
+performance checks; their speed is not guaranteed by the default benchmark.
+
+### What you are trying here
+This live demo runs on CPU and returns rich explanations. Its small batches are
+for exploring decisions. The high-throughput benchmarks measure compact bulk
+screening, including GPU transfers and CPU fallback where applicable.
+
+A relevant result means the configured screen accepted the article. It does not
+infer sentiment, predict returns, or recommend a trade. No LLM, API key or model
+download is required for inference.
 """
 
-HERO_HTML = """
-<section class="hero">
-  <div class="hero-inner">
-    <p class="hero-eyebrow">Fast · consistent · shows its work</p>
-    <h1>RANGE</h1>
-    <p class="hero-expansion">Rapid Analysis of News for the General Economy</p>
-    <p class="hero-copy">
-      RANGE quickly checks financial news for economic and broad-market relevance.
-      It tells you whether an article matches, which broad market or index it relates to, and
-      the exact words and rule behind the result—without using an LLM or sending the
-      article to an external API.
-    </p>
-    <div class="speed-grid" aria-label="Recorded CPU benchmark highlights">
-      <div class="speed-stat"><strong>457,735</strong><span>articles screened per second in a 500,000-article test</span></div>
-      <div class="speed-stat"><strong>395,017</strong><span>articles screened per second in a 10-million-article test</span></div>
-      <div class="speed-stat"><strong>Clear reasons</strong><span>Every result includes the matched words and rule</span></div>
-    </div>
-    <p class="benchmark-note">Measured with a specially optimized RANGE build on one Intel i7-10750H Windows laptop using 10 CPU workers. These are the fastest recorded results for the screening step alone. Loading data, running a complete pipeline, and using the hosted demo will be slower. Speed varies with hardware, article length, and screening rules.</p>
-    <div class="trust-row" aria-label="Product characteristics">
-      <span class="trust-pill">Rust-accelerated on CPU</span>
-      <span class="trust-pill">Screening rules you can customize</span>
-      <span class="trust-pill">Exact matched text and rules</span>
-    </div>
-  </div>
-</section>
-<section class="value-grid" aria-label="What RANGE returns">
-  <div class="value-card"><strong>Article relevance</strong><span>Whether the article matches the financial and economic topics in the current rules.</span></div>
-  <div class="value-card"><strong>Related market</strong><span>Broad market, S&amp;P 500, Nasdaq-100, or Russell 2000—when the article supports the connection.</span></div>
-  <div class="value-card"><strong>Evidence trail</strong><span>Matched words → rule → name valid on the publication date → market connection.</span></div>
-</section>
+PERFORMANCE = """
+## Measured speed. Clear boundaries.
+
+| Implementation | Articles / second | Measurement |
+| --- | ---: | --- |
+| CUDA research record | **1,833,059** | Qualified warm screening of 10 million articles |
+| Maintained CPU implementation | **489,759** | Qualified warm screening of 10 million articles |
+| Newer retained CUDA installation | **958,155** | Separate local installed-package qualification |
+
+Measured on an Intel i7-10750H Windows laptop with 10 CPU workers; CUDA used an
+RTX 2070 Max-Q. These are separate experiments, not a same-run CPU/GPU speedup.
+The CUDA peak belongs to an earlier qualified implementation; later sessions
+varied substantially. Do not combine its peak with later percentage gains.
+
+Screening timings exclude file loading, imports, initialization and verification.
+CUDA timings include transfers, exact CPU fallback and result assembly.
+The live demo uses a different CPU environment and rich explanations, so these
+figures are not its throughput or a service guarantee.
+
+[Read the benchmark record](https://huggingface.co/spaces/Brianferrell787/range-news/blob/main/BENCHMARKS.md)
+
+## Python package coming soon
+
+We are preparing RANGE for straightforward Python installation, with CPU support
+and an optional CUDA backend. Public package release, clean installation across
+supported platforms and broader GPU compatibility are still ahead.
+The current Space lets you explore the engine today.
+
+## What we want to try next
+
+- **Finish the release:** clean installs, supported platforms, documentation and
+  validation of the exact wheels people will use.
+- **Share work across taxonomies:** build on successful two-taxonomy experiments,
+  then extend packaging and memory scheduling for more rule sets.
+- **Choose CPU or CUDA by workload:** measure small batches, large batches and
+  routing overhead before introducing automatic selection.
+- **Target remaining matching ideas:** direct StringZilla integration and other
+  CUSMART methods remain candidates, not demonstrated improvements.
+- **Train optimizations on separate data:** investigate corpus-trained automata
+  and fresh compiler profiles using representative development articles.
+
+Recent alternatives did not beat the retained matcher. We keep negative results
+and require exact outputs before considering a speed improvement.
+"""
+
+HERO_HTML = """
+<section class="hero">
+  <div class="hero-inner">
+    <p class="hero-eyebrow">Fast · consistent · shows its work</p>
+    <h1>RANGE</h1>
+    <p class="hero-expansion">Rapid Analysis of News for the General Economy</p>
+    <p class="hero-copy">Find the financial news that matters to your rules.<br>
+      Screen articles, trace market connections, and see the exact evidence behind
+      every decision.</p>
+    <div class="trust-row" aria-label="Product characteristics">
+      <span class="trust-pill package-pill">Python package coming soon</span>
+      <span class="trust-pill">No LLM required</span>
+      <span class="trust-pill">Customizable taxonomies</span>
+    </div>
+    <div class="speed-grid" aria-label="Recorded bulk screening benchmarks">
+      <div class="speed-stat"><strong>1.83M</strong><span>articles/s · CUDA research record</span></div>
+      <div class="speed-stat"><strong>489,759</strong><span>articles/s · maintained CPU result</span></div>
+      <div class="speed-stat"><strong>Exact evidence</strong><span>Matched text, rules and market connections</span></div>
+    </div>
+    <p class="benchmark-note">Separate qualified 10-million-article screening runs on one Windows laptop.
+      CUDA peak is historical; later installed CUDA measured 958,155 articles/s.
+      This live demo runs on CPU. See Performance &amp; roadmap for conditions.</p>
+  </div>
+</section>
+<section class="value-grid" aria-label="What RANGE returns">
+  <div class="value-card"><strong>Screen the article</strong><span>Find economic and financial topics covered by your configured rules.</span></div>
+  <div class="value-card"><strong>Connect the evidence</strong><span>See supported broad-market and index relationships, with time-valid identities.</span></div>
+  <div class="value-card"><strong>Inspect the reason</strong><span>Follow each result back to the original words and the rule that accepted them.</span></div>
+</section>
 """
 
 INITIAL_STATUS_HTML = """
 <div class="status-card status-empty" role="status" aria-live="polite">
   <span class="status-label">Screening result</span>
   <h3>Your result will appear here</h3>
-  <p>RANGE reports article relevance and supported broad-market exposure as two
+  <p>RANGE reports article relevance and supported broad-market exposure as two
   separate outputs.</p>
   <div class="result-grid">
     <div class="result-cell"><strong>Article relevance</strong><span>Relevant · No configured match</span></div>
-    <div class="result-cell"><strong>Related market</strong><span>Shown only when the article supports a connection</span></div>
+    <div class="result-cell"><strong>Related market</strong><span>Shown only when the article supports a connection</span></div>
   </div>
   <p class="boundary-note">This is a relevance screen—not sentiment, materiality, a
   return forecast, or investment advice.</p>
@@ -374,90 +407,90 @@ INITIAL_STATUS_HTML = """
 """
 
 
-def _text_size(value: str, *, label: str) -> tuple[int, int]:
-    """Return character and UTF-8 sizes with a public-safe Unicode error."""
-
-    characters = len(value)
-    try:
-        utf8_bytes = len(value.encode("utf-8"))
-    except UnicodeEncodeError as exc:
-        raise gr.Error(f"{label} contains invalid Unicode text.") from exc
-    return characters, utf8_bytes
-
-
-def _validate_article_size(text: str, *, label: str = "Article") -> tuple[int, int]:
-    """Validate public-request bounds before the engine sees article text."""
-
-    characters, utf8_bytes = _text_size(text, label=label)
-    if characters > MAX_ARTICLE_CHARS:
-        raise gr.Error(f"{label} exceeds the {MAX_ARTICLE_CHARS:,}-character limit.")
-    if utf8_bytes > MAX_ARTICLE_BYTES:
-        raise gr.Error(f"{label} exceeds the {MAX_ARTICLE_BYTES:,}-byte UTF-8 limit.")
-    return characters, utf8_bytes
-
-
-def _bounded_metadata(
-    value: Any,
-    *,
-    label: str,
-    max_characters: int,
-    max_bytes: int,
-    required: bool = False,
-) -> tuple[str, int, int]:
-    """Normalize one metadata value after enforcing its raw request bounds."""
-
-    if value is None:
-        raw_value = ""
-    elif isinstance(value, str):
-        raw_value = value
-    else:
-        raise gr.Error(f"{label} must be text.")
-
-    characters, utf8_bytes = _text_size(raw_value, label=label)
-    if characters > max_characters:
-        raise gr.Error(f"{label} exceeds the {max_characters:,}-character limit.")
-    if utf8_bytes > max_bytes:
-        raise gr.Error(f"{label} exceeds the {max_bytes:,}-byte UTF-8 limit.")
-
-    cleaned = raw_value.strip()
-    if required and not cleaned:
-        raise gr.Error(f"Enter {label.lower()}.")
-    return cleaned, characters, utf8_bytes
-
-
-def _batch_cell_text(value: Any, *, label: str) -> str:
-    """Accept ordinary table scalars without stringifying nested objects."""
-
-    if value is None:
-        return ""
-    if isinstance(value, str):
-        return value
-    if isinstance(value, (bool, int, float)):
-        return str(value)
-    raise gr.Error(f"{label} must be plain text or a number.")
-
-
-def _validate_batch_dimensions(row_count: int, column_count: int) -> None:
-    """Reject oversized or malformed tables before their cells are copied."""
-
-    if row_count > MAX_BATCH_ROWS:
-        raise gr.Error(
-            f"The interactive demo is capped at {MAX_BATCH_ROWS} rows per request."
-        )
-    if column_count != EXPECTED_BATCH_COLUMNS:
-        raise gr.Error(
-            "Batch input must have exactly four columns: "
-            "article_id, timestamp, source, and text."
-        )
-
-
-def _local_error_details_enabled() -> bool:
-    """Allow detailed tracebacks only through an explicit non-Space opt-in."""
-
-    requested = os.environ.get("RANGE_LOCAL_SHOW_ERROR", "").strip().casefold()
-    if requested not in {"1", "true", "yes", "on"}:
-        return False
-    return not any(os.environ.get(name) for name in ("SPACE_ID", "SPACE_HOST"))
+def _text_size(value: str, *, label: str) -> tuple[int, int]:
+    """Return character and UTF-8 sizes with a public-safe Unicode error."""
+
+    characters = len(value)
+    try:
+        utf8_bytes = len(value.encode("utf-8"))
+    except UnicodeEncodeError as exc:
+        raise gr.Error(f"{label} contains invalid Unicode text.") from exc
+    return characters, utf8_bytes
+
+
+def _validate_article_size(text: str, *, label: str = "Article") -> tuple[int, int]:
+    """Validate public-request bounds before the engine sees article text."""
+
+    characters, utf8_bytes = _text_size(text, label=label)
+    if characters > MAX_ARTICLE_CHARS:
+        raise gr.Error(f"{label} exceeds the {MAX_ARTICLE_CHARS:,}-character limit.")
+    if utf8_bytes > MAX_ARTICLE_BYTES:
+        raise gr.Error(f"{label} exceeds the {MAX_ARTICLE_BYTES:,}-byte UTF-8 limit.")
+    return characters, utf8_bytes
+
+
+def _bounded_metadata(
+    value: Any,
+    *,
+    label: str,
+    max_characters: int,
+    max_bytes: int,
+    required: bool = False,
+) -> tuple[str, int, int]:
+    """Normalize one metadata value after enforcing its raw request bounds."""
+
+    if value is None:
+        raw_value = ""
+    elif isinstance(value, str):
+        raw_value = value
+    else:
+        raise gr.Error(f"{label} must be text.")
+
+    characters, utf8_bytes = _text_size(raw_value, label=label)
+    if characters > max_characters:
+        raise gr.Error(f"{label} exceeds the {max_characters:,}-character limit.")
+    if utf8_bytes > max_bytes:
+        raise gr.Error(f"{label} exceeds the {max_bytes:,}-byte UTF-8 limit.")
+
+    cleaned = raw_value.strip()
+    if required and not cleaned:
+        raise gr.Error(f"Enter {label.lower()}.")
+    return cleaned, characters, utf8_bytes
+
+
+def _batch_cell_text(value: Any, *, label: str) -> str:
+    """Accept ordinary table scalars without stringifying nested objects."""
+
+    if value is None:
+        return ""
+    if isinstance(value, str):
+        return value
+    if isinstance(value, (bool, int, float)):
+        return str(value)
+    raise gr.Error(f"{label} must be plain text or a number.")
+
+
+def _validate_batch_dimensions(row_count: int, column_count: int) -> None:
+    """Reject oversized or malformed tables before their cells are copied."""
+
+    if row_count > MAX_BATCH_ROWS:
+        raise gr.Error(
+            f"The interactive demo is capped at {MAX_BATCH_ROWS} rows per request."
+        )
+    if column_count != EXPECTED_BATCH_COLUMNS:
+        raise gr.Error(
+            "Batch input must have exactly four columns: "
+            "article_id, timestamp, source, and text."
+        )
+
+
+def _local_error_details_enabled() -> bool:
+    """Allow detailed tracebacks only through an explicit non-Space opt-in."""
+
+    requested = os.environ.get("RANGE_LOCAL_SHOW_ERROR", "").strip().casefold()
+    if requested not in {"1", "true", "yes", "on"}:
+        return False
+    return not any(os.environ.get(name) for name in ("SPACE_ID", "SPACE_HOST"))
 
 
 @lru_cache(maxsize=1)
@@ -495,10 +528,10 @@ def _jsonable(value: Any) -> Any:
     return value
 
 
-def _download_file(payload: Any, *, suffix: str) -> str:
-    cache_root = Path(get_upload_folder())
-    cache_root.mkdir(parents=True, exist_ok=True)
-    path = cache_root / f"relevance-{uuid.uuid4().hex}{suffix}"
+def _download_file(payload: Any, *, suffix: str) -> str:
+    cache_root = Path(get_upload_folder())
+    cache_root.mkdir(parents=True, exist_ok=True)
+    path = cache_root / f"relevance-{uuid.uuid4().hex}{suffix}"
     if suffix == ".jsonl":
         lines = [json.dumps(row, ensure_ascii=False, sort_keys=True) for row in payload]
         path.write_text("\n".join(lines) + "\n", encoding="utf-8")
@@ -695,44 +728,44 @@ def _status_card(prediction) -> str:
         '<div class="result-grid">'
         '<div class="result-cell"><strong>Article relevance</strong>'
         f"<span>{html.escape(badge)}</span></div>"
-        '<div class="result-cell"><strong>Related market</strong>'
+        '<div class="result-cell"><strong>Related market</strong>'
         f"<span>{html.escape(exposure_value)}</span></div>"
         "</div>"
-        f"<p><strong>Why RANGE returned this:</strong> {html.escape(prediction.why)}</p>"
+        f"<p><strong>Why RANGE returned this:</strong> {html.escape(prediction.why)}</p>"
         f"{exposure_note}"
         '<p class="boundary-note">Relevant means the article passed the configured '
         "screen. It does not mean bullish, bearish, material, or predictive.</p>"
-        f'<p class="small-note">RANGE {html.escape(__version__)} · '
+        f'<p class="small-note">RANGE {html.escape(__version__)} · '
         f"taxonomy {html.escape(_engine().taxonomy.version)} · "
         f"CPU workers {_engine().workers}</p>"
         "</div>"
     )
 
 
-def _audit_payload(prediction) -> dict[str, Any]:
-    decision = _jsonable(prediction)
-    article = decision.get("article") if isinstance(decision, dict) else None
-    if not isinstance(article, dict):
-        raise RuntimeError("RANGE produced an invalid evidence record.")
-
-    article_text = prediction.article.text
-    encoded_text = article_text.encode("utf-8")
-    article.pop("text", None)
-    article.update(
-        {
-            "text_sha256": hashlib.sha256(encoded_text).hexdigest(),
-            "text_characters": len(article_text),
-            "text_utf8_bytes": len(encoded_text),
-            "text_normalization": "leading_and_trailing_whitespace_removed",
-        }
-    )
-    return {
-        "summary": prediction.summary(),
-        "package_version": __version__,
-        "backend": _jsonable(_engine().backend_info),
-        "taxonomy": _engine().taxonomy.describe(),
-        "decision": decision,
-    }
+def _audit_payload(prediction) -> dict[str, Any]:
+    decision = _jsonable(prediction)
+    article = decision.get("article") if isinstance(decision, dict) else None
+    if not isinstance(article, dict):
+        raise RuntimeError("RANGE produced an invalid evidence record.")
+
+    article_text = prediction.article.text
+    encoded_text = article_text.encode("utf-8")
+    article.pop("text", None)
+    article.update(
+        {
+            "text_sha256": hashlib.sha256(encoded_text).hexdigest(),
+            "text_characters": len(article_text),
+            "text_utf8_bytes": len(encoded_text),
+            "text_normalization": "leading_and_trailing_whitespace_removed",
+        }
+    )
+    return {
+        "summary": prediction.summary(),
+        "package_version": __version__,
+        "backend": _jsonable(_engine().backend_info),
+        "taxonomy": _engine().taxonomy.describe(),
+        "decision": decision,
+    }
 
 
 def analyze_article(
@@ -744,47 +777,47 @@ def analyze_article(
     """Screen one timestamped article for configured financial-news relevance.
 
     Returns a plain-language result, highlighted evidence, an application-ready
-    summary, rule path, detailed evidence data, Mermaid source, and a download.
+    summary, rule path, detailed evidence data, Mermaid source, and a download.
     """
 
-    if not isinstance(text, str):
-        raise gr.Error("Article text must be text.")
-    _validate_article_size(text)
-    cleaned_text = text.strip()
-    if not cleaned_text:
-        raise gr.Error("Enter non-empty article text.")
-    resolved_timestamp, _, _ = _bounded_metadata(
-        timestamp,
-        label="Publication timestamp",
-        max_characters=MAX_TIMESTAMP_CHARS,
-        max_bytes=MAX_TIMESTAMP_BYTES,
-        required=True,
-    )
-    resolved_id, _, _ = _bounded_metadata(
-        article_id,
-        label="Article ID",
-        max_characters=MAX_ARTICLE_ID_CHARS,
-        max_bytes=MAX_ARTICLE_ID_BYTES,
-    )
-    resolved_source, _, _ = _bounded_metadata(
-        source,
-        label="Source",
-        max_characters=MAX_SOURCE_CHARS,
-        max_bytes=MAX_SOURCE_BYTES,
-    )
-
-    try:
-        prediction = _engine().predict(
-            cleaned_text,
-            timestamp=resolved_timestamp,
-            article_id=resolved_id or None,
-            source=resolved_source or "demo",
-        )
-    except (TypeError, ValueError) as exc:
-        raise gr.Error(
-            "The article or publication timestamp is invalid. "
-            "Use an ISO 8601 timestamp such as 2025-01-15T09:30:00-05:00."
-        ) from exc
+    if not isinstance(text, str):
+        raise gr.Error("Article text must be text.")
+    _validate_article_size(text)
+    cleaned_text = text.strip()
+    if not cleaned_text:
+        raise gr.Error("Enter non-empty article text.")
+    resolved_timestamp, _, _ = _bounded_metadata(
+        timestamp,
+        label="Publication timestamp",
+        max_characters=MAX_TIMESTAMP_CHARS,
+        max_bytes=MAX_TIMESTAMP_BYTES,
+        required=True,
+    )
+    resolved_id, _, _ = _bounded_metadata(
+        article_id,
+        label="Article ID",
+        max_characters=MAX_ARTICLE_ID_CHARS,
+        max_bytes=MAX_ARTICLE_ID_BYTES,
+    )
+    resolved_source, _, _ = _bounded_metadata(
+        source,
+        label="Source",
+        max_characters=MAX_SOURCE_CHARS,
+        max_bytes=MAX_SOURCE_BYTES,
+    )
+
+    try:
+        prediction = _engine().predict(
+            cleaned_text,
+            timestamp=resolved_timestamp,
+            article_id=resolved_id or None,
+            source=resolved_source or "demo",
+        )
+    except (TypeError, ValueError) as exc:
+        raise gr.Error(
+            "The article or publication timestamp is invalid. "
+            "Use an ISO 8601 timestamp such as 2025-01-15T09:30:00-05:00."
+        ) from exc
 
     audit = _audit_payload(prediction)
     explanation = _engine().explain(prediction, format="text", detail="audit")
@@ -801,43 +834,43 @@ def analyze_article(
     )
 
 
-def _rows(value: Any) -> list[list[Any]]:
-    """Return a small four-column table after validating its shape up front."""
-
-    if value is None:
-        return []
-
-    shape = getattr(value, "shape", None)
-    if shape is not None:
-        try:
-            dimensions = tuple(int(part) for part in shape)
-        except (TypeError, ValueError) as exc:
-            raise gr.Error("Batch input must be a two-dimensional table.") from exc
-        if len(dimensions) != 2:
-            raise gr.Error("Batch input must be a two-dimensional table.")
-        _validate_batch_dimensions(dimensions[0], dimensions[1])
-        if hasattr(value, "values") and hasattr(value.values, "tolist"):
-            converted = value.values.tolist()
-        elif hasattr(value, "tolist"):
-            converted = value.tolist()
-        else:
-            raise gr.Error("Batch input must be a two-dimensional table.")
-        if not isinstance(converted, list):
-            raise gr.Error("Batch input must be a two-dimensional table.")
-        rows: Sequence[Any] = converted
-    else:
-        if not isinstance(value, Sequence) or isinstance(
-            value, (str, bytes, bytearray)
-        ):
-            raise gr.Error("Batch input must be a two-dimensional table.")
-        _validate_batch_dimensions(len(value), EXPECTED_BATCH_COLUMNS)
-        rows = value
-
-    for index, row in enumerate(rows):
-        if not isinstance(row, Sequence) or isinstance(row, (str, bytes, bytearray)):
-            raise gr.Error(f"Batch row {index + 1} must contain four cells.")
-        _validate_batch_dimensions(len(rows), len(row))
-    return [list(row) for row in rows]
+def _rows(value: Any) -> list[list[Any]]:
+    """Return a small four-column table after validating its shape up front."""
+
+    if value is None:
+        return []
+
+    shape = getattr(value, "shape", None)
+    if shape is not None:
+        try:
+            dimensions = tuple(int(part) for part in shape)
+        except (TypeError, ValueError) as exc:
+            raise gr.Error("Batch input must be a two-dimensional table.") from exc
+        if len(dimensions) != 2:
+            raise gr.Error("Batch input must be a two-dimensional table.")
+        _validate_batch_dimensions(dimensions[0], dimensions[1])
+        if hasattr(value, "values") and hasattr(value.values, "tolist"):
+            converted = value.values.tolist()
+        elif hasattr(value, "tolist"):
+            converted = value.tolist()
+        else:
+            raise gr.Error("Batch input must be a two-dimensional table.")
+        if not isinstance(converted, list):
+            raise gr.Error("Batch input must be a two-dimensional table.")
+        rows: Sequence[Any] = converted
+    else:
+        if not isinstance(value, Sequence) or isinstance(
+            value, (str, bytes, bytearray)
+        ):
+            raise gr.Error("Batch input must be a two-dimensional table.")
+        _validate_batch_dimensions(len(value), EXPECTED_BATCH_COLUMNS)
+        rows = value
+
+    for index, row in enumerate(rows):
+        if not isinstance(row, Sequence) or isinstance(row, (str, bytes, bytearray)):
+            raise gr.Error(f"Batch row {index + 1} must contain four cells.")
+        _validate_batch_dimensions(len(rows), len(row))
+    return [list(row) for row in rows]
 
 
 def analyze_batch(data: Any):
@@ -847,103 +880,103 @@ def analyze_batch(data: Any):
     or Arrow APIs for high-throughput datasets.
     """
 
-    normalized: list[tuple[str, str, str, str]] = []
-    total_text_characters = 0
-    total_text_bytes = 0
-    total_metadata_characters = 0
-    total_metadata_bytes = 0
-    for index, row in enumerate(_rows(data)):
-        raw_article_id, raw_timestamp, raw_source, raw_text = (
-            _batch_cell_text(cell, label=f"Batch row {index + 1}, column {offset + 1}")
-            for offset, cell in enumerate(row)
-        )
-        article_id, id_characters, id_bytes = _bounded_metadata(
-            raw_article_id,
-            label=f"Batch row {index + 1} article ID",
-            max_characters=MAX_ARTICLE_ID_CHARS,
-            max_bytes=MAX_ARTICLE_ID_BYTES,
-        )
-        timestamp, timestamp_characters, timestamp_bytes = _bounded_metadata(
-            raw_timestamp,
-            label=f"Batch row {index + 1} publication timestamp",
-            max_characters=MAX_TIMESTAMP_CHARS,
-            max_bytes=MAX_TIMESTAMP_BYTES,
-        )
-        source, source_characters, source_bytes = _bounded_metadata(
-            raw_source,
-            label=f"Batch row {index + 1} source",
-            max_characters=MAX_SOURCE_CHARS,
-            max_bytes=MAX_SOURCE_BYTES,
-        )
-        text_characters, text_bytes = _validate_article_size(
-            raw_text, label=f"Batch row {index + 1} article"
-        )
-        text = raw_text.strip()
-
-        metadata_characters = id_characters + timestamp_characters + source_characters
-        metadata_bytes = id_bytes + timestamp_bytes + source_bytes
-        total_metadata_characters += metadata_characters
-        total_metadata_bytes += metadata_bytes
-        total_text_characters += text_characters
-        total_text_bytes += text_bytes
-        total_content_characters = total_metadata_characters + total_text_characters
-        total_content_bytes = total_metadata_bytes + total_text_bytes
-
-        if total_metadata_characters > MAX_BATCH_METADATA_CHARS:
-            raise gr.Error(
-                "Batch metadata exceeds the "
-                f"{MAX_BATCH_METADATA_CHARS:,}-character aggregate limit."
-            )
-        if total_metadata_bytes > MAX_BATCH_METADATA_BYTES:
-            raise gr.Error(
-                "Batch metadata exceeds the "
-                f"{MAX_BATCH_METADATA_BYTES:,}-byte aggregate UTF-8 limit."
-            )
-        if total_text_characters > MAX_BATCH_CHARS:
-            raise gr.Error(
-                f"Batch article text exceeds the {MAX_BATCH_CHARS:,}-character "
-                "aggregate limit."
-            )
-        if total_text_bytes > MAX_BATCH_BYTES:
-            raise gr.Error(
-                f"Batch article text exceeds the {MAX_BATCH_BYTES:,}-byte "
-                "aggregate UTF-8 limit."
-            )
-        if total_content_characters > MAX_BATCH_CONTENT_CHARS:
-            raise gr.Error(
-                "Combined batch article and metadata content exceeds the "
-                f"{MAX_BATCH_CONTENT_CHARS:,}-character limit."
-            )
-        if total_content_bytes > MAX_BATCH_CONTENT_BYTES:
-            raise gr.Error(
-                "Combined batch article and metadata content exceeds the "
-                f"{MAX_BATCH_CONTENT_BYTES:,}-byte UTF-8 limit."
-            )
-
-        if not any((article_id, timestamp, source, text)):
-            continue
-        if not text:
-            raise gr.Error(f"Batch row {index + 1} has no article text.")
-        if not timestamp:
-            raise gr.Error(f"Batch row {index + 1} has no timestamp.")
-        normalized.append(
-            (article_id or f"row-{index}", timestamp, source or "demo", text)
-        )
+    normalized: list[tuple[str, str, str, str]] = []
+    total_text_characters = 0
+    total_text_bytes = 0
+    total_metadata_characters = 0
+    total_metadata_bytes = 0
+    for index, row in enumerate(_rows(data)):
+        raw_article_id, raw_timestamp, raw_source, raw_text = (
+            _batch_cell_text(cell, label=f"Batch row {index + 1}, column {offset + 1}")
+            for offset, cell in enumerate(row)
+        )
+        article_id, id_characters, id_bytes = _bounded_metadata(
+            raw_article_id,
+            label=f"Batch row {index + 1} article ID",
+            max_characters=MAX_ARTICLE_ID_CHARS,
+            max_bytes=MAX_ARTICLE_ID_BYTES,
+        )
+        timestamp, timestamp_characters, timestamp_bytes = _bounded_metadata(
+            raw_timestamp,
+            label=f"Batch row {index + 1} publication timestamp",
+            max_characters=MAX_TIMESTAMP_CHARS,
+            max_bytes=MAX_TIMESTAMP_BYTES,
+        )
+        source, source_characters, source_bytes = _bounded_metadata(
+            raw_source,
+            label=f"Batch row {index + 1} source",
+            max_characters=MAX_SOURCE_CHARS,
+            max_bytes=MAX_SOURCE_BYTES,
+        )
+        text_characters, text_bytes = _validate_article_size(
+            raw_text, label=f"Batch row {index + 1} article"
+        )
+        text = raw_text.strip()
+
+        metadata_characters = id_characters + timestamp_characters + source_characters
+        metadata_bytes = id_bytes + timestamp_bytes + source_bytes
+        total_metadata_characters += metadata_characters
+        total_metadata_bytes += metadata_bytes
+        total_text_characters += text_characters
+        total_text_bytes += text_bytes
+        total_content_characters = total_metadata_characters + total_text_characters
+        total_content_bytes = total_metadata_bytes + total_text_bytes
+
+        if total_metadata_characters > MAX_BATCH_METADATA_CHARS:
+            raise gr.Error(
+                "Batch metadata exceeds the "
+                f"{MAX_BATCH_METADATA_CHARS:,}-character aggregate limit."
+            )
+        if total_metadata_bytes > MAX_BATCH_METADATA_BYTES:
+            raise gr.Error(
+                "Batch metadata exceeds the "
+                f"{MAX_BATCH_METADATA_BYTES:,}-byte aggregate UTF-8 limit."
+            )
+        if total_text_characters > MAX_BATCH_CHARS:
+            raise gr.Error(
+                f"Batch article text exceeds the {MAX_BATCH_CHARS:,}-character "
+                "aggregate limit."
+            )
+        if total_text_bytes > MAX_BATCH_BYTES:
+            raise gr.Error(
+                f"Batch article text exceeds the {MAX_BATCH_BYTES:,}-byte "
+                "aggregate UTF-8 limit."
+            )
+        if total_content_characters > MAX_BATCH_CONTENT_CHARS:
+            raise gr.Error(
+                "Combined batch article and metadata content exceeds the "
+                f"{MAX_BATCH_CONTENT_CHARS:,}-character limit."
+            )
+        if total_content_bytes > MAX_BATCH_CONTENT_BYTES:
+            raise gr.Error(
+                "Combined batch article and metadata content exceeds the "
+                f"{MAX_BATCH_CONTENT_BYTES:,}-byte UTF-8 limit."
+            )
+
+        if not any((article_id, timestamp, source, text)):
+            continue
+        if not text:
+            raise gr.Error(f"Batch row {index + 1} has no article text.")
+        if not timestamp:
+            raise gr.Error(f"Batch row {index + 1} has no timestamp.")
+        normalized.append(
+            (article_id or f"row-{index}", timestamp, source or "demo", text)
+        )
 
     if not normalized:
         raise gr.Error("Add at least one complete batch row.")
-    try:
+    try:
         predictions = _engine().predict_batch(
             [row[3] for row in normalized],
             timestamps=[row[1] for row in normalized],
             article_ids=[row[0] for row in normalized],
             sources=[row[2] for row in normalized],
         )
-    except (TypeError, ValueError) as exc:
-        raise gr.Error(
-            "A batch row is invalid. Check that every publication timestamp is "
-            "valid ISO 8601 text."
-        ) from exc
+    except (TypeError, ValueError) as exc:
+        raise gr.Error(
+            "A batch row is invalid. Check that every publication timestamp is "
+            "valid ISO 8601 text."
+        ) from exc
 
     summaries = [prediction.summary() for prediction in predictions]
     table = [
@@ -972,62 +1005,62 @@ def analyze_batch(data: Any):
 def build_demo() -> gr.Blocks:
     """Build the human-facing UI and named Gradio API endpoints."""
 
-    blocks_options: dict[str, Any] = {
-        "title": "RANGE",
-        "fill_width": True,
-        "delete_cache": (60, 300),
-    }
-    if GRADIO_MAJOR < 6:
-        blocks_options.update(css=CSS, theme=THEME)
-
-    def build_content() -> None:
-        with gr.Tab("Screen one article"):
+    blocks_options: dict[str, Any] = {
+        "title": "RANGE",
+        "fill_width": True,
+        "delete_cache": (60, 300),
+    }
+    if GRADIO_MAJOR < 6:
+        blocks_options.update(css=CSS, theme=THEME)
+
+    def build_content() -> None:
+        with gr.Tab("Screen one article"):
             gr.Markdown(
                 "### Check an article\n"
                 "Paste the text and add its publication time. Time is required so "
-                "RANGE can apply time-valid names and relationships; it is not "
+                "RANGE can apply time-valid names and relationships; it is not "
                 "used to forecast prices."
             )
             with gr.Row():
                 with gr.Column(scale=5):
-                    article = gr.Textbox(
-                        label="Article text",
-                        lines=13,
-                        value=SINGLE_EXAMPLES[0][0],
-                        placeholder="Paste a headline, excerpt, or full article...",
-                        max_length=MAX_ARTICLE_CHARS,
-                    )
+                    article = gr.Textbox(
+                        label="Article text",
+                        lines=13,
+                        value=SINGLE_EXAMPLES[0][0],
+                        placeholder="Paste a headline, excerpt, or full article...",
+                        max_length=MAX_ARTICLE_CHARS,
+                    )
                     with gr.Row():
                         timestamp = gr.Textbox(
                             label="Publication timestamp",
-                            value=SINGLE_EXAMPLES[0][1],
-                            info="Required · ISO 8601; include an offset when known.",
-                            max_length=MAX_TIMESTAMP_CHARS,
+                            value=SINGLE_EXAMPLES[0][1],
+                            info="Required · ISO 8601; include an offset when known.",
+                            max_length=MAX_TIMESTAMP_CHARS,
                         )
                     with gr.Accordion("Optional article metadata", open=False):
                         gr.Markdown(
-                            "Article ID and source make exported records easier to join "
+                            "Article ID and source make exported records easier to join "
                             "back to your data. They do not change text matching."
                         )
                         with gr.Row():
-                            article_id = gr.Textbox(
-                                label="Article ID",
-                                value=SINGLE_EXAMPLES[0][2],
-                                max_length=MAX_ARTICLE_ID_CHARS,
-                            )
-                            source = gr.Textbox(
-                                label="Source",
-                                value=SINGLE_EXAMPLES[0][3],
-                                max_length=MAX_SOURCE_CHARS,
-                            )
+                            article_id = gr.Textbox(
+                                label="Article ID",
+                                value=SINGLE_EXAMPLES[0][2],
+                                max_length=MAX_ARTICLE_ID_CHARS,
+                            )
+                            source = gr.Textbox(
+                                label="Source",
+                                value=SINGLE_EXAMPLES[0][3],
+                                max_length=MAX_SOURCE_CHARS,
+                            )
                     analyze = gr.Button("Check relevance", variant="primary")
                 with gr.Column(scale=4):
                     status = gr.HTML(INITIAL_STATUS_HTML)
                     with gr.Accordion("Developer output and download", open=False):
-                        summary = gr.JSON(label="Application-ready summary")
-                        result_file = gr.File(
-                            label="Download evidence record (article text omitted)"
-                        )
+                        summary = gr.JSON(label="Application-ready summary")
+                        result_file = gr.File(
+                            label="Download evidence record (article text omitted)"
+                        )
 
             example_options: dict[str, Any] = {
                 "examples": SINGLE_EXAMPLES,
@@ -1054,9 +1087,9 @@ def build_demo() -> gr.Blocks:
                 interactive=False,
                 label="Evidence and rule path",
             )
-            with gr.Accordion("Why RANGE returned this result", open=True):
+            with gr.Accordion("Why RANGE returned this result", open=True):
                 explanation = gr.Textbox(lines=16, label=None)
-            with gr.Accordion("Evidence record (article text omitted)", open=False):
+            with gr.Accordion("Evidence record (article text omitted)", open=False):
                 audit_json = gr.Code(language="json", lines=24, label=None)
             with gr.Accordion("Mermaid evidence-flow source (developer)", open=False):
                 diagram = gr.Code(language="markdown", lines=20, label=None)
@@ -1074,10 +1107,10 @@ def build_demo() -> gr.Blocks:
                     diagram,
                     result_file,
                 ],
-                api_name="analyze",
-                scroll_to_output=True,
-                concurrency_limit=1,
-                concurrency_id="range-cpu",
+                api_name="analyze",
+                scroll_to_output=True,
+                concurrency_limit=1,
+                concurrency_id="range-cpu",
             )
 
         with gr.Tab("Batch demo (up to 100)"):
@@ -1120,11 +1153,11 @@ def build_demo() -> gr.Blocks:
             screen.click(
                 fn=analyze_batch,
                 inputs=batch_input,
-                outputs=[batch_results, batch_metrics, batch_file],
-                api_name="batch",
-                concurrency_limit=1,
-                concurrency_id="range-cpu",
-            )
+                outputs=[batch_results, batch_metrics, batch_file],
+                api_name="batch",
+                concurrency_limit=1,
+                concurrency_id="range-cpu",
+            )
 
         with gr.Tab("How it works"):
             gr.Markdown(ABOUT)
@@ -1134,39 +1167,42 @@ def build_demo() -> gr.Blocks:
                 "API documentation and `agents.md` instructions for coding agents."
             )
 
-        gr.Markdown(
-            "---\n"
-            '<div class="privacy-note"><strong>Research alpha · privacy notice.</strong> '
-            "RANGE records configured evidence; it does not provide investment "
+        with gr.Tab("Performance & roadmap"):
+            gr.Markdown(PERFORMANCE)
+
+        gr.Markdown(
+            "---\n"
+            '<div class="privacy-note"><strong>Research alpha · privacy notice.</strong> '
+            "RANGE records configured evidence; it does not provide investment "
             "advice or a forecast. In a hosted Space, submitted text and generated "
             "downloads are processed temporarily on the Space host. Do not submit "
-            "private, licensed, or confidential text unless you have permission.</div>"
-        )
-
-    with gr.Blocks(**blocks_options) as demo:
-        gr.HTML(HERO_HTML, elem_classes=["hero-host"])
-        with gr.Column(elem_classes=["content-shell"]):
-            build_content()
-    return demo
+            "private, licensed, or confidential text unless you have permission.</div>"
+        )
+
+    with gr.Blocks(**blocks_options) as demo:
+        gr.HTML(HERO_HTML, elem_classes=["hero-host"])
+        with gr.Column(elem_classes=["content-shell"]):
+            build_content()
+    return demo
 
 
 demo = build_demo()
 
 
 if __name__ == "__main__":
-    launch_options: dict[str, Any] = {
-        "server_name": os.environ.get("GRADIO_SERVER_NAME", "0.0.0.0"),
-        "server_port": int(os.environ.get("GRADIO_SERVER_PORT", "7860")),
-        "show_error": _local_error_details_enabled(),
-        "app_kwargs": {
-            "middleware": [
-                Middleware(
-                    RequestBodyLimitMiddleware,
-                    max_body_size=MAX_HTTP_REQUEST_BYTES,
-                )
-            ]
-        },
-    }
+    launch_options: dict[str, Any] = {
+        "server_name": os.environ.get("GRADIO_SERVER_NAME", "0.0.0.0"),
+        "server_port": int(os.environ.get("GRADIO_SERVER_PORT", "7860")),
+        "show_error": _local_error_details_enabled(),
+        "app_kwargs": {
+            "middleware": [
+                Middleware(
+                    RequestBodyLimitMiddleware,
+                    max_body_size=MAX_HTTP_REQUEST_BYTES,
+                )
+            ]
+        },
+    }
     if GRADIO_MAJOR >= 6:
         launch_options.update(css=CSS, theme=THEME)
-    demo.queue(api_open=False, max_size=32).launch(**launch_options)
+    demo.queue(api_open=False, max_size=32).launch(**launch_options)

docs/attention2alpha-compatibility-review.md

@@ -1,46 +0,0 @@
-# Attention2Alpha compatibility-change safety review
-
-Status: **safe to retain; no revert recommended**
-
-Scope: non-package files changed in PR #157 while preparing the standalone RANGE
-package and its validation gates.
-
-This review distinguishes narrow compatibility and correctness repairs from changes to
-the trading or learning objective. The reviewed edits do not alter the RANGE
-taxonomy and do not redefine Attention2Alpha reward, order execution, portfolio
-accounting, replay semantics, or the policy-learning objective.
-
-## File review
-
-| file | change | safety assessment |
-| --- | --- | --- |
-| `attention2alpha/data_split.py` | preserves opaque string split keys instead of coercing them to timestamps | correct for fraction-mode and synthetic indexes; timestamp inputs retain existing handling |
-| `attention2alpha/embeddings/embedding_base.py` | serializes optional configuration objects without importing full optional stacks; makes checkpoint-probe publication failure-safe; clarifies validation errors | reduces import coupling and prevents a stale probe from describing an incomplete artifact |
-| `attention2alpha/embeddings/embedding_flair.py` | supports legacy and lightweight adapters and validates persisted round-trip probes on legacy loads | compatibility hardening; production `nn.Module` behavior remains supported |
-| `attention2alpha/environments/leveraged_etf_portfolio_env.py` | permits validation with W&B disabled while re-raising failures when an active run exists | reporting-path resilience only; no trade or reward calculation changes |
-| `attention2alpha/state_features.py` | uses `min(2, window)` for rolling standard deviation | fixes the invalid `window=1, min_periods=2` case while preserving behavior for windows of two or more |
-| `attention2alpha/train_eval.py` | filters loader keyword arguments against legacy signatures, restores fallback metadata, and reuses the production order-matrix builder for simple adapters | compatibility and best-effort reporting improvements; no training-objective change |
-
-## Risk notes
-
-The W&B guard catches a broad exception because W&B versions expose different
-uninitialized-run failures. It re-raises when `wandb.run` exists, so failures during an
-active tracked run are not silently hidden. A future cleanup may narrow the exception
-after the supported W&B range is frozen, but the current behavior is safe for this PR.
-
-The one-period rolling-volatility change is mathematically well-defined: sample
-standard deviation remains `NaN` until enough observations exist, but Pandas no longer
-rejects an impossible `min_periods` setting.
-
-## Evidence
-
-The repository deterministic suite exercises checkpoint serialization, round-trip
-validation, train/eval compatibility, state features, and environment guards. The
-package workflow is separate and verifies that the RANGE wheel does not import the
-Attention2Alpha package.
-
-## Decision
-
-Keep the changes. When RANGE moves to a dedicated repository, copy only the package
-and `app/` sources; these monorepo compatibility repairs remain part of Attention2Alpha
-history rather than becoming dependencies of the standalone package.

docs/performance.md

@@ -1,6 +1,6 @@
 # Performance and architecture
 
-RANGE is optimized as an exact information-retrieval system. It is not a language
+RANGE is optimized as an exact information-retrieval system. It is not a language
 model and it does not use an external inference service.
 
 ## Shipping path
@@ -80,4 +80,4 @@ The strongest portable claim for `0.1.0a1` is architectural:
 
 > Relevance replaces per-pattern Python work and neural inference with compiled
 > multi-pattern CPU retrieval, parallel article processing, and sparse or columnar
-> result paths while preserving a traceable evidence contract.
+> result paths while preserving a traceable evidence contract.

docs/readme-research.md

@@ -30,7 +30,7 @@ was to extract durable communication patterns rather than copy rankings or wordi
 
 | observed pattern | application in Relevance |
 | --- | --- |
-| one-sentence value proposition | “Fast financial-news screening that shows its work.” |
+| one-sentence value proposition | “Fast financial-news screening that shows its work.” |
 | show a useful result early | the README opens with real quickstart stdout |
 | put runnable code before exhaustive reference | a complete one-article example appears near the top |
 | explain performance mechanistically | Rust, automata, Rayon, sparse output, and Arrow are mapped to their practical effects |
@@ -44,7 +44,7 @@ was to extract durable communication patterns rather than copy rankings or wordi
 ## Marketing standard
 
 The README is intentionally specific rather than superlative. It explains why the
-system can be fast and traceable, but it does not claim to be the fastest system in all
+system can be fast and traceable, but it does not claim to be the fastest system in all
 settings. It shows the output contract before implementation details and keeps
 limitations close to the value proposition.
 

docs/release.md

@@ -1,19 +1,19 @@
-# RANGE 0.1.0a1 release-candidate contract
+# RANGE 0.1.0a1 release-candidate contract
 
-This directory is the authoritative source for the **RANGE** research alpha.
+This directory is the authoritative source for the **RANGE** research alpha.
 
 ## Identity
 
-- Product: `RANGE`
-- Distribution: `range-news`
-- Import namespace: `range_news`
+- Product: `RANGE`
+- Distribution: `range-news`
+- Import namespace: `range_news`
 - Version: `0.1.0a1`
 - Supported runtime: CPython 3.10
 - Supported backend: CPU
 - License: MIT
 - Publication state: not published
 
-The distribution name is descriptive while the product name remains RANGE.
+The distribution name is descriptive while the product name remains RANGE.
 
 ## Required artifacts
 
@@ -30,7 +30,7 @@ A candidate build must produce:
 
 ## Required validation
 
-CI is deliberately small and manually invoked. The `range-news-release-candidate`
+CI is deliberately small and manually invoked. The `range-news-release-candidate`
 workflow has only two jobs:
 
 1. **Linux package + Space smoke** validates source syntax, the Space scaffold, the
@@ -41,13 +41,13 @@ workflow has only two jobs:
    metadata and contents, clean installations, public contracts, PyArrow support, and
    README output.
 
-The broader Attention2Alpha and historical acceleration suites are not package-release
+The broader parent research project and historical acceleration suites are not package-release
 gates. They remain available through the separate manual/main-only `repository-tests`
 workflow.
 
 ## Why the workflow is manual
 
-While RANGE remains inside a larger private monorepo, every feature-branch push can
+While RANGE remains inside a larger private monorepo, every feature-branch push can
 otherwise produce duplicate `push` and `pull_request` runs. Manual invocation keeps the
 PR readable and conserves hosted-runner minutes while preserving the checks that matter
 before publication or final technical sign-off.
@@ -73,7 +73,7 @@ Publishing requires a separate, explicit human decision after:
 
 `0.1.0a1` makes a narrow claim:
 
-> An exact, CPU-first, research-alpha package for traceable financial-news relevance
+> An exact, CPU-first, research-alpha package for traceable financial-news relevance
 > screening against a versioned general-economy taxonomy.
 
 It does not claim complete semantic recall, investment usefulness, universal

docs/taxonomy.md

@@ -1,12 +1,12 @@
 # The bundled general-economy taxonomy
 
-The default policy in RANGE is a conservative, offline taxonomy for economic and
+The default policy in RANGE is a conservative, offline taxonomy for economic and
 financial-news screening. It is not a portfolio definition and it is not a sentiment
 or trading model.
 
 ## Decision layers
 
-Each article is processed through four traceable layers:
+Each article is processed through four traceable layers:
 
 1. **Observation** — literal text spans are matched by effective-dated aliases,
    normalized phrases, context-qualified acronyms, or conjunction rules.
@@ -64,7 +64,7 @@ guess a security or broad benchmark when no explicit relationship exists.
 
 ## Direction neutrality
 
-RANGE answers whether evidence is connected to a maintained economic or market
+RANGE answers whether evidence is connected to a maintained economic or market
 concept. It does not infer whether the evidence is:
 
 - bullish or bearish;
@@ -103,7 +103,7 @@ documented America/New_York convention.
 ## Inspect the taxonomy
 
 ```python
-from range_news import GeneralEconomyTaxonomy
+from range_news import GeneralEconomyTaxonomy
 
 taxonomy = GeneralEconomyTaxonomy()
 
@@ -117,7 +117,7 @@ print(taxonomy.lexical_rule_ids)
 ## Copy and edit the complete bundle
 
 ```python
-from range_news import RelevanceEngine, copy_default_taxonomy
+from range_news import RelevanceEngine, copy_default_taxonomy
 
 path = copy_default_taxonomy("my_taxonomy")
 # Edit my_taxonomy/taxonomy.yml and my_taxonomy/catalogs/*.yml.
@@ -143,7 +143,7 @@ Unknown fields fail closed. Existing files are not overwritten unless
 new immutable taxonomy objects and never mutate the bundled default.
 
 ```python
-from range_news import GeneralEconomyTaxonomy
+from range_news import GeneralEconomyTaxonomy
 
 
 def add_indicator(builder):

docs/technical-signoff.md

@@ -1,4 +1,4 @@
-# RANGE 0.1.0a1 technical sign-off
+# RANGE 0.1.0a1 technical sign-off
 
 This document defines the bounded technical sign-off for the unpublished research
 alpha. It does not authorize publication, tagging, release creation, Space deployment,
@@ -6,22 +6,22 @@ or merge.
 
 ## Identity
 
-- Product: **RANGE**
-- Distribution: `range-news`
-- Python namespace: `range_news`
-- Native Rust crate: `range_news_native`
+- Product: **RANGE**
+- Distribution: `range-news`
+- Python namespace: `range_news`
+- Native Rust crate: `range_news_native`
 - Version: `0.1.0a1`
 - Runtime: CPython 3.10
 - Shipping backend: exact CPU/Rust
 
-Shipping source, wheels, and source distributions must not contain retired package
-identifiers. The repository URL may retain the parent repository's historical name;
-that is not a package identity.
+Shipping source, wheels, and source distributions must not contain retired package
+identifiers. The repository URL may retain the parent repository's historical name;
+that is not a package identity.
 
 ## Required current-head evidence
 
 Technical sign-off intentionally has only two required jobs. Manually run the
-`range-news-release-candidate` workflow on the exact commit being reviewed and require:
+`range-news-release-candidate` workflow on the exact commit being reviewed and require:
 
 1. **Linux package + Space smoke** — source validation, Rust lock/format checks, wheel
    and source-distribution construction, metadata and archive inspection, clean
@@ -32,8 +32,8 @@ Technical sign-off intentionally has only two required jobs. Manually run the
    metadata/archive inspection, clean installs, package contracts, PyArrow coverage,
    and README output verification.
 
-The full Attention2Alpha deterministic suite and historical acceleration suite are not
-RANGE package sign-off gates. They remain available in `repository-tests` for a
+The full parent research project deterministic suite and historical acceleration suite are not
+RANGE package sign-off gates. They remain available in `repository-tests` for a
 manual run and execute after integration to `main`.
 
 A success recorded for an older commit is not sufficient.

rust/lib.rs

@@ -200,7 +200,7 @@ fn facts_to_record_batch(rows: Vec<FactRow>) -> Result<RecordBatch, String> {
     RecordBatch::try_new(Arc::new(Schema::new(fields)), columns).map_err(|error| error.to_string())
 }
 
-#[pyclass(frozen, module = "range_news._native")]
+#[pyclass(frozen, module = "range_news._native")]
 struct NativeArrowCompactFactScanner {
     inner: NativeCompactFactScanner,
 }
@@ -276,13 +276,13 @@ impl NativeArrowCompactFactScanner {
                 let batch_rows: Result<Vec<FactRow>, String> = pool.install(|| {
                     (0..batch.num_rows())
                         .into_par_iter()
-                        .map_init(ScanScratch::default, |scratch, index| {
-                            let epoch = timestamps.value_microseconds(index)?;
-                            Ok(scan_one(
-                                &inner.automaton,
-                                &inner.pattern_consumers,
-                                &inner.consumers,
-                                &inner.exact_specs,
+                        .map_init(ScanScratch::default, |scratch, index| {
+                            let epoch = timestamps.value_microseconds(index)?;
+                            Ok(scan_one(
+                                &inner.automaton,
+                                &inner.pattern_consumers,
+                                &inner.consumers,
+                                &inner.exact_specs,
                                 &inner.aliases,
                                 &inner.lexical,
                                 &inner.contexts,
@@ -309,9 +309,9 @@ impl NativeArrowCompactFactScanner {
 
         let record_batch = facts_to_record_batch(result.map_err(PyValueError::new_err)?)
             .map_err(PyValueError::new_err)?;
-        Ok(PyRecordBatch::new(record_batch))
-    }
-}
+        Ok(PyRecordBatch::new(record_batch))
+    }
+}
 
 #[pymodule]
 fn _native(module: &Bound<'_, PyModule>) -> PyResult<()> {

vendor/range_news/_native.cpython-310-x86_64-linux-gnu.so

@@ -1,3 +1,3 @@
 version https://git-lfs.github.com/spec/v1
-oid sha256:45e05c00ab729ead671436ed8bd392c016dfa1e44ef42fdfade758902b1519d1
-size 15250792
+oid sha256:e05b832a8b33169dd988b4bc88a36bfb1f5b40f70676a09ecda727961d123c9c
+size 15254376