diff --git a/.github/ISSUE_TEMPLATE/task.yml b/.github/ISSUE_TEMPLATE/task.yml new file mode 100644 index 000000000..4013e61cd --- /dev/null +++ b/.github/ISSUE_TEMPLATE/task.yml @@ -0,0 +1,52 @@ +name: Public contribution task +description: A bounded replay, chart, review comment, catalog note or documentation task +title: "[Task] " +labels: [eng-only] +body: + - type: markdown + attributes: + value: | + Claim one open task at a time by commenting `/claim`. A maintainer records + the claimant and assigns the issue when GitHub permits. `/claim` is a + coordination convention, not an automatic bot command or a permission grant. + Submit results through a fork PR under `incoming//`. + Publication and passing checks do not accept mathematics. + - type: dropdown + id: type + attributes: + label: Task type + options: [replay, chart, review-comment, catalog-stub, docs] + validations: + required: true + - type: textarea + id: source + attributes: + label: Exact public source + description: Give the existing inventory key or import ID, repository, path, full 40-character commit, and SHA-256. Link the public bytes. No Drive-only source. + validations: + required: true + - type: textarea + id: deliverable + attributes: + label: Bounded deliverable and verification + description: Say what can be completed, how it is checked, and where uncertainty remains. Use the existing docs/public-math inventory; do not make a second catalog. + validations: + required: true + - type: textarea + id: claim + attributes: + label: Claim and release rule + value: "Comment /claim before starting; keep one open claim per person. Link the results PR, or comment /release if you stop. A maintainer updates the assignment and task state." + validations: + required: true + - type: checkboxes + id: boundary + attributes: + label: Contribution boundary + options: + - label: This task does not edit ACCEPT/AMEND rows, STATUS.md, PROOF_INDEX, LANDING_CLAIMS, claims, prizes, or lemma_closed. + required: true + - label: This task does not merge AMEND mathematics or copy sandbox work into Math-; its results require review. + required: true + - label: The task uses pinned public bytes and labels numerical output or illustrations without claiming theorem acceptance. + required: true diff --git a/.github/workflows/public-intake-controls.yml b/.github/workflows/public-intake-controls.yml new file mode 100644 index 000000000..368755e5a --- /dev/null +++ b/.github/workflows/public-intake-controls.yml @@ -0,0 +1,25 @@ +# Kept separate so pull_request events cannot emit a skipped/successful +# public-intake check with the same name as the trusted guard. +name: Public intake checker controls +on: + pull_request: + branches: [main] + paths: ['tools/public_intake_check.py', 'tests/test_public_intake.py', '.github/workflows/public-intake.yml', '.github/workflows/public-intake-controls.yml'] + push: + branches: [main] + paths: ['tools/public_intake_check.py', 'tests/test_public_intake.py', '.github/workflows/public-intake.yml', '.github/workflows/public-intake-controls.yml'] +permissions: + contents: read +jobs: + intake-controls: + name: intake-controls + runs-on: ubuntu-latest + timeout-minutes: 5 + steps: + - uses: actions/checkout@11d5960a326750d5838078e36cf38b85af677262 + with: + persist-credentials: false + - name: Run positive and refusal controls without network + run: | + python3 -B -S -m unittest discover -s tests -p test_public_intake.py -v + python3 -B -O -S -m unittest discover -s tests -p test_public_intake.py -v diff --git a/.github/workflows/public-intake.yml b/.github/workflows/public-intake.yml new file mode 100644 index 000000000..048994b2d --- /dev/null +++ b/.github/workflows/public-intake.yml @@ -0,0 +1,28 @@ +name: Public results intake +on: + # Read trusted default-branch workflow and checker only. Never checkout a + # submitted branch or execute submitted code in this workflow. + pull_request_target: + branches: [main] + types: [opened, reopened, synchronize, edited, labeled, unlabeled, ready_for_review] +permissions: + contents: read + pull-requests: read +jobs: + public-intake: + name: public-intake + runs-on: ubuntu-latest + timeout-minutes: 5 + steps: + - name: Read trusted default-branch checker + uses: actions/checkout@11d5960a326750d5838078e36cf38b85af677262 + with: + # github.sha is the trusted default-branch commit for this event. + ref: ${{ github.sha }} + persist-credentials: false + sparse-checkout: tools/public_intake_check.py + sparse-checkout-cone-mode: false + - name: Verify intake from API bytes without checking out the PR + env: + GH_TOKEN: ${{ github.token }} + run: python3 -B -I tools/public_intake_check.py diff --git a/.github/workflows/public-shop.yml b/.github/workflows/public-shop.yml new file mode 100644 index 000000000..3f2680a2f --- /dev/null +++ b/.github/workflows/public-shop.yml @@ -0,0 +1,24 @@ +name: public-shop +on: + pull_request: + branches: [main] + push: + branches: [main] + workflow_dispatch: +permissions: + contents: read +jobs: + public-shop: + runs-on: ubuntu-latest + timeout-minutes: 5 + steps: + - uses: actions/checkout@11d5960a326750d5838078e36cf38b85af677262 + with: + persist-credentials: false + fetch-depth: 0 + - name: Status-export negative controls + run: python3 -B -m unittest discover -s tests -p test_public_shop_data.py + - name: Browser data-validation controls + run: node --test tests/test_public_shop_frontend.mjs + - name: Pinned public source readback and interaction harness + run: python3 -B tools/public_shop_check.py diff --git a/CONTRIBUTING.md b/CONTRIBUTING.md index d6c0d99bf..7f7b34229 100644 --- a/CONTRIBUTING.md +++ b/CONTRIBUTING.md @@ -18,6 +18,107 @@ participants and may be improved by them. 4. Check the current branch and exact head. A merge is not a semantic reconciliation, and a stale base silently changes what your diff means. +## Pick a public task + +Use [public tasks](https://github.com/d6g8k5htny-coder/main/issues?q=is%3Aissue+is%3Aopen+label%3Aeng-only) +or [propose a bounded task](https://github.com/d6g8k5htny-coder/main/issues/new?template=task.yml). +The starter types are `replay`, `chart`, `review-comment`, `catalog-stub`, and +`docs`. Cite the existing key, public path, full commit and digest from +[the single public inventory](docs/PUBLIC_MATHEMATICS.md). An import is a byte +copy for review, not an accepted result. + +Comment `/claim` before beginning. Keep one open claim per person; a maintainer +records the claimant and assigns the issue when GitHub permits. Link your PR when +ready, or comment `/release` if you stop. These are manual coordination conventions, +not an installed claim bot. The task states are `open` → `claimed` → `results-pr` +→ `review` → `parked` or `landed-eng`. `landed-eng` means published engineering +or review material, not mathematical acceptance. + +Good tasks regenerate a chart from pinned JSON, document one existing import ID, +or submit a precisely located review comment. Closing the D1 parent or accepting +SARD-G is not a public starter task. Do not edit ACCEPT/AMEND rows, `STATUS.md`, +`PROOF_INDEX`, `LANDING_CLAIMS`, `claims/`, prizes or `lemma_closed`, or merge AMEND +mathematics. Math- remains the proof vault; sandbox and trial are not upload lanes. + +## Submit public results for review + +1. Fork this repository and create a branch from its current `main`. +2. Add a **new** `incoming//` directory. Use a short lowercase ID containing + letters, digits or hyphens, for example `incoming/side24-replay-yourname/`. + Change only files in that one new directory. For a correction after landing, + use a new ID and link the previous result; earlier submissions remain readable. +3. Include `RESULT.md`, your `output.json` and/or plots, and `IDENTITY.json`. + In `RESULT.md`, link the task and describe the exact source commit, command or + method, runtime, result, limitations and any source exposure. State that the + result is for review and has scientific effect `NONE`. A numerical result or + plot is not a theorem. Never upload credentials, personal data or private sources. +4. In `IDENTITY.json`, list every artifact except the identity file itself with + its byte count and SHA-256. List one to eight public source files by repository, + path, full 40-character commit and SHA-256. The checker reads those exact public + bytes. Use the real values, not the placeholders in this schema: + + ```json + { + "schema": 1, + "scientific_effect": "NONE", + "review_status": "REVIEW_REQUIRED", + "sources": [ + { + "repository": "d6g8k5htny-coder/Math-", + "path": "path/to/public/source.json", + "commit": "REPLACE_WITH_40_LOWERCASE_HEX_CHARACTERS", + "sha256": "REPLACE_WITH_64_LOWERCASE_HEX_CHARACTERS" + } + ], + "artifacts": [ + {"path": "RESULT.md", "bytes": 123, "sha256": "REPLACE_WITH_REAL_SHA256"}, + {"path": "output.json", "bytes": 456, "sha256": "REPLACE_WITH_REAL_SHA256"} + ] + } + ``` + + Generate byte counts with `len(Path(name).read_bytes())` and digests with + `hashlib.sha256(Path(name).read_bytes()).hexdigest()` in Python, or use + `wc -c` and `sha256sum`. Artifact paths are relative to the new package. + The identity file is excluded to avoid a circular self-hash; its Git blob and + PR head are checked separately. +5. Open a draft PR **against this repository's `main`**, link the claimed task, + and request the `results-for-review` label. A maintainer applies it if you cannot. + Mark the PR ready when the result is ready to review. Removing the label cannot + bypass the guard: a fork, an `incoming/` path, or that label independently selects + the restricted lane. +6. A human or designated agent reviews the content and exact bytes. If accepted + for publication, the PR lands only in `incoming/`. This is not automatic merge, + a theorem verdict, or transfer into Math-. A later audit needs its own reviewed + engineering PR; no upload changes the scientific registers. + +The first intake version accepts UTF-8 `.md`, `.txt`, `.json`, `.csv`, and `.png` +files, with at most 50 files, 256 KiB per file and 2 MiB per package. Source files +must be public in `main`, `Math-`, `query-` or `Universal-Law-Workspace` and regular +files of at most 2 MiB, bound to their exact commit-tree path and blob. Scripts, notebooks, +HTML, SVG, archives, executable files, symlinks and submodules are refused here. +For code or a notebook proposal, describe it in an issue; a maintainer can sponsor +a separate engineering PR. Do not encode a refused file inside an allowed format. + +`public-intake` runs trusted default-branch code with a read-only token. It reads +PR metadata and blobs through the GitHub API, checks complete path lists and source +identities, and fails on missing information or a changing PR. It never checks +out or executes submitted code. The credential scan catches a small documented +set of recognizable private-key/token patterns; **it is not a complete secret +scanner**, and a green check cannot establish that content is safe or correct. +Reviewers must inspect the content before merging. Source readback proves identity +and public availability, not the source's acceptance or the output's correctness. + +Maintainer branches in this repository can still submit ordinary engineering PRs. +Adding an `incoming/` change or `results-for-review` label also restricts those PRs. +Require PR review and the `public-intake` check in repository rules before treating +this workflow as an enforced merge boundary. The workflow file alone does not +install branch protection or prevent an administrator bypass. Before merging, +the designated reviewer must verify that the actual `Public results intake` run +used the trusted `pull_request_target` workflow and reports the PR's current exact +head. A check name alone does not bind its workflow or event identity; a similarly +named check from a submitted workflow is not the trusted intake guard. + ## Evidence standards These are not style preferences. A change that breaks one of them will be sent diff --git a/README.md b/README.md index 7333949ff..8ee1a276c 100644 --- a/README.md +++ b/README.md @@ -8,21 +8,27 @@ This is the **single public front door** for the Universal Law research program. The project studies persistence lifetimes and critical-point geometry of Gaussian random fields, together with exact/reproducible computational methods and a fail-closed review workflow. Proofs, code, reviews, and source identities live in several focused repositories, but readers should start here. +## Public research shop + +[Open the shop guide](docs/site/README.md) for the status board, pinned SIDE24 coefficient viewer, searchable full-text catalog, and contribution route. The [SIDE24 notebook](docs/notebooks/README.md) is also readable on GitHub and runnable in Colab. [Grab a public task](https://github.com/d6g8k5htny-coder/main/issues?q=is%3Aissue+is%3Aopen+label%3Agood-first-task) or [submit an incoming result PR](CONTRIBUTING.md). + +The static app is committed under `docs/site`; Pages activation is a separate [setup step](docs/PUBLIC_SHOP_SETUP.md). All views preserve scoped ACCEPT, AMEND/open, and engineering-only distinctions. They cannot change scientific status. + ## Public source path For a stranger who wants the landed mathematics rather than the live agent queue, use this order: -1. **Proof index:** [Math- `PROOF_INDEX.md` at `10e1f191c7d9f2755ca971ddbba87874d2475619`](https://github.com/d6g8k5htny-coder/Math-/blob/10e1f191c7d9f2755ca971ddbba87874d2475619/PROOF_INDEX.md) +1. **Proof index:** [Math- `PROOF_INDEX.md` at `58f7936d1138b24dd6cc988081d74d07683611d6`](https://github.com/d6g8k5htny-coder/Math-/blob/58f7936d1138b24dd6cc988081d74d07683611d6/PROOF_INDEX.md) 2. **Human status map:** [`STATUS.md`](STATUS.md) 3. **Pinned Math checkout:** ```sh git clone https://github.com/d6g8k5htny-coder/Math-.git Math- - git -C Math- checkout --detach 10e1f191c7d9f2755ca971ddbba87874d2475619 + git -C Math- checkout --detach 58f7936d1138b24dd6cc988081d74d07683611d6 ``` 4. **Pinned query checkout:** ```sh git clone https://github.com/d6g8k5htny-coder/query-.git query- - git -C query- checkout --detach 76e1ca09a4838f84f20e28daa51eb024c0781dc1 + git -C query- checkout --detach 89456c5033173c69a304c5fffa781888185675cc python -B -S -m unittest discover -s query-/tests -p 'test_*.py' -v ``` diff --git a/STATUS.md b/STATUS.md index 8edcec739..526881022 100644 --- a/STATUS.md +++ b/STATUS.md @@ -33,7 +33,7 @@ These are useful infrastructure, but they carry **no theorem-acceptance meaning* ## Where to read — public source custody -The two human maps are this file and the [Math- proof index at the pinned public Math commit](https://github.com/d6g8k5htny-coder/Math-/blob/10e1f191c7d9f2755ca971ddbba87874d2475619/PROOF_INDEX.md). Neither file replaces the underlying proof or review. +The two human maps are this file and the [Math- proof index at the pinned public Math commit](https://github.com/d6g8k5htny-coder/Math-/blob/58f7936d1138b24dd6cc988081d74d07683611d6/PROOF_INDEX.md). Neither file replaces the underlying proof or review. For exact source identity, use [`docs/public-math/sources.json`](docs/public-math/sources.json). It indexes **2,138 intended public text artifacts** and points to 14 JSON shards. Each artifact row carries: @@ -45,9 +45,9 @@ The machine catalog at [`meta-framework/registry.json`](https://github.com/d6g8k ### Default-branch boundary -- Pinned Math reading checkout: `10e1f191c7d9f2755ca971ddbba87874d2475619`. -- Pinned query checkout: `76e1ca09a4838f84f20e28daa51eb024c0781dc1`. -- [Math- PR #70](https://github.com/d6g8k5htny-coder/Math-/pull/70) proposes default-branch custody copies of nine proof files already public on `main`. Until that PR lands, those copies are **not** default-branch Math; their immutable public source paths remain discoverable in the frozen public-source inventory. +- Pinned Math reading checkout: `58f7936d1138b24dd6cc988081d74d07683611d6`. +- Pinned query checkout: `89456c5033173c69a304c5fffa781888185675cc`. +- [Math- PR #70](https://github.com/d6g8k5htny-coder/Math-/pull/70) landed nine byte-custody copies at `9d7b6802424fb4715b31999066aafca8ee2f3cca`; [PR #75](https://github.com/d6g8k5htny-coder/Math-/pull/75) added their proof-index pointer. These are public default-branch imports, **not newly accepted mathematics**. Source self-labels were not adopted. - The `main#59` issue-body file in PR #70 is explicitly a transcription, not original source bytes, so it is not counted as byte custody. - Open draft AMEND/review PRs remain visible but are not represented here as landed mathematics. diff --git a/docs/.nojekyll b/docs/.nojekyll new file mode 100644 index 000000000..e69de29bb diff --git a/docs/NAVIGATION.json b/docs/NAVIGATION.json index 0aff1747a..86b5de7be 100644 --- a/docs/NAVIGATION.json +++ b/docs/NAVIGATION.json @@ -19,7 +19,10 @@ "docs/public-math/sources-11.md", "docs/public-math/sources-12.md", "docs/public-math/sources-13.md", - "docs/public-math/sources-14.md" + "docs/public-math/sources-14.md", + "docs/site/README.md", + "docs/notebooks/README.md", + "docs/PUBLIC_SHOP_SETUP.md" ], "public_targets": [ { diff --git a/docs/PUBLIC_SHOP_SETUP.md b/docs/PUBLIC_SHOP_SETUP.md new file mode 100644 index 000000000..c1917db41 --- /dev/null +++ b/docs/PUBLIC_SHOP_SETUP.md @@ -0,0 +1,31 @@ +# Public shop deployment and contribution board + +Scientific effect: **NONE**. This page records the remaining GitHub configuration and the exact reviewable repository implementation. It does not claim settings are already installed. + +## Pages + +In [main Pages settings](https://github.com/d6g8k5htny-coder/main/settings/pages), choose **Deploy from a branch**, branch **main**, folder **/docs**, then Save. The entry file and `.nojekyll` are committed. Verify the deployment before advertising the public Pages URL as live. Do not enable Pages on Math-, trial, or sandbox for this shop. + +## Profile pins + +On the [owner profile](https://github.com/d6g8k5htny-coder), use Customize your pins. Select **main**, **Math-**, **query-**, and **Universal-Law-Workspace**. Leave trial and sandbox unpinned. + +## Issues and Project + +Issues are already in use on main. Keep tasks in [main Issues](https://github.com/d6g8k5htny-coder/main/issues), using the public task form. Create these labels if absent: + +`good-first-task`, `needs-replay`, `needs-chart`, `eng-only`, `math-review`, `do-not-merge`, `results-for-review`. + +Create one [main Project](https://github.com/d6g8k5htny-coder/main/projects), **Public contributions**, with Status options: + +`open → claimed → results-pr → review → parked / landed-eng`. + +Add the public contribution tasks to that project. `/claim` is a request: a maintainer assigns it after checking one active claim per person. This is a human/agent coordination convention, not an installed assignment bot. Keep deep open theorems off this introductory board. + +## Branch protection and review + +In [main branch settings](https://github.com/d6g8k5htny-coder/main/settings/branches) and [Math- branch settings](https://github.com/d6g8k5htny-coder/Math-/settings/branches), protect the default `main` branch: require a pull request, a designated review, and the applicable passing checks. For main, the external results guard is **public-intake**; its tests are a different check. For Math-, retain the existing replay/scientific gates and require review rather than treating a green replay as acceptance. Do not grant outsiders direct write access. + +A check name alone does not authenticate the workflow. Before merging an intake PR, inspect the **trusted public-intake workflow**, its `pull_request_target` event, the precise reviewed PR head, and the pass result. Administrative override must not be treated as a scientific review. + +Do not merge Math #60/#64/#69 or main #122/#128 to populate this shop. Landed custody copies, results intake, and notebook figures never adopt source status labels or promote a theorem. diff --git a/docs/index.html b/docs/index.html new file mode 100644 index 000000000..41e62dbb4 --- /dev/null +++ b/docs/index.html @@ -0,0 +1 @@ +Universal Law public researchOpen the Universal Law public research shop diff --git a/docs/notebooks/README.md b/docs/notebooks/README.md new file mode 100644 index 000000000..2ca161a5c --- /dev/null +++ b/docs/notebooks/README.md @@ -0,0 +1,11 @@ +# Public research notebooks + +[![Open in Colab](https://colab.research.google.com/assets/colab-badge.svg)](https://colab.research.google.com/github/d6g8k5htny-coder/main/blob/main/docs/notebooks/SIDE24_PUBLIC_COEFFICIENTS.ipynb) + +Open [SIDE24_PUBLIC_COEFFICIENTS.ipynb](SIDE24_PUBLIC_COEFFICIENTS.ipynb) on GitHub or in Colab, then run the cells in order. It fetches one public JSON file at a fixed 40-character Math- commit and verifies its size and SHA256 before parsing. + +The notebook preserves the published decimal endpoint strings and original `scientific_acceptance: false`. Its optional two-bar chart uses approximate midpoints and is **NON-CERTIFYING**. No random field or lifetime solver runs, and the notebook cannot change repository status. The exact table needs only Python's standard library; the chart uses Matplotlib if available. + +Input: [`Math-@9d7b6802424fb4715b31999066aafca8ee2f3cca:coefficients/side24_v1/ENCLOSURE.json`](https://github.com/d6g8k5htny-coder/Math-/blob/9d7b6802424fb4715b31999066aafca8ee2f3cca/coefficients/side24_v1/ENCLOSURE.json), 1090 bytes, SHA256 `72b6cd92d31394cdaf5da8919a5d548e902228af1f095cc184158a71d8287811`. + +See the [scoped coefficient review](https://github.com/d6g8k5htny-coder/main/issues/65#issuecomment-5841269490) and [current program status](https://github.com/d6g8k5htny-coder/main/blob/main/STATUS.md) separately. Viewing or replaying these numbers does not accept a parent theorem. The public inventory remains [`../public-math/`](../public-math/sources.json); these files create no separate catalog. diff --git a/docs/notebooks/SIDE24_PUBLIC_COEFFICIENTS.ipynb b/docs/notebooks/SIDE24_PUBLIC_COEFFICIENTS.ipynb new file mode 100644 index 000000000..c7fcde546 --- /dev/null +++ b/docs/notebooks/SIDE24_PUBLIC_COEFFICIENTS.ipynb @@ -0,0 +1,214 @@ +{ + "cells": [ + { + "cell_type": "markdown", + "id": "scope", + "metadata": {}, + "source": [ + "# SIDE24 public coefficient viewer\n", + "\n", + "**NON-CERTIFYING visualization of already published numbers.** This notebook displays the published coefficient intervals for dimensions 2 and 3. It does not prove a theorem, perform a new enclosure, simulate a random field, or evaluate a lifetime law.\n", + "\n", + "The exact input is [`coefficients/side24_v1/ENCLOSURE.json`](https://github.com/d6g8k5htny-coder/Math-/blob/9d7b6802424fb4715b31999066aafca8ee2f3cca/coefficients/side24_v1/ENCLOSURE.json) from public `Math-` commit `9d7b6802424fb4715b31999066aafca8ee2f3cca`: **1090 bytes**, SHA256 `72b6cd92d31394cdaf5da8919a5d548e902228af1f095cc184158a71d8287811`.\n", + "\n", + "Read the [pinned coefficient proof and scope](https://github.com/d6g8k5htny-coder/Math-/blob/9d7b6802424fb4715b31999066aafca8ee2f3cca/coefficients/side24_v1/PROOF.md). The retained source says `scientific_acceptance: false` and describes its parent theorem as unreviewed; this notebook preserves those original fields. Later [scoped coefficient review](https://github.com/d6g8k5htny-coder/main/issues/65#issuecomment-5841269490) and [current program status](https://github.com/d6g8k5htny-coder/main/blob/main/STATUS.md) are separate records. Their links do not promote the parent theorem or change this source.\n", + "\n", + "Run the cells in order. Fetching and identity checks use only Python's standard library. Matplotlib, if already installed (as in Colab), draws the optional chart; no package installation is required for the exact table.\n", + "\n", + "The committed preview was executed locally from the exact verified bytes in the public Git checkout, supplied at the fetch boundary. Re-running the fetch cell retrieves and verifies the pinned public URL directly.\n" + ] + }, + { + "cell_type": "code", + "id": "fetch-verified-bytes", + "metadata": {}, + "execution_count": 1, + "outputs": [ + { + "output_type": "stream", + "name": "stdout", + "text": [ + "Verified: 9d7b6802424fb4715b31999066aafca8ee2f3cca coefficients/side24_v1/ENCLOSURE.json\n", + "Bytes: 1090 SHA256: 72b6cd92d31394cdaf5da8919a5d548e902228af1f095cc184158a71d8287811\n", + "Original scientific_acceptance: False\n", + "Original scope: coefficient of issue63 Eq15.2; parent theorem unreviewed\n" + ] + } + ], + "source": [ + "import hashlib\n", + "import json\n", + "import urllib.request\n", + "from decimal import Decimal, localcontext\n", + "\n", + "SOURCE_COMMIT = \"9d7b6802424fb4715b31999066aafca8ee2f3cca\"\n", + "SOURCE_PATH = \"coefficients/side24_v1/ENCLOSURE.json\"\n", + "SOURCE_URL = (\n", + " \"https://raw.githubusercontent.com/d6g8k5htny-coder/Math-/\"\n", + " + SOURCE_COMMIT + \"/\" + SOURCE_PATH\n", + ")\n", + "EXPECTED_BYTES = 1090\n", + "EXPECTED_SHA256 = \"72b6cd92d31394cdaf5da8919a5d548e902228af1f095cc184158a71d8287811\"\n", + "\n", + "\n", + "def decode_verified_source(raw):\n", + " # Check raw bytes before JSON decoding or plotting. Never fall back to a mutable ref.\n", + " if len(raw) != EXPECTED_BYTES:\n", + " raise ValueError(\"Source byte count mismatch; refusing to display this input\")\n", + " if hashlib.sha256(raw).hexdigest() != EXPECTED_SHA256:\n", + " raise ValueError(\"Source SHA256 mismatch; refusing to display this input\")\n", + " source = json.loads(raw.decode(\"utf-8\"))\n", + " if source.get(\"scientific_acceptance\") is not False:\n", + " raise ValueError(\"Unexpected source acceptance field\")\n", + " return source\n", + "\n", + "\n", + "with urllib.request.urlopen(SOURCE_URL, timeout=30) as response:\n", + " raw_source = response.read(EXPECTED_BYTES + 1)\n", + "source = decode_verified_source(raw_source)\n", + "print(\"Verified:\", SOURCE_COMMIT, SOURCE_PATH)\n", + "print(\"Bytes:\", len(raw_source), \"SHA256:\", hashlib.sha256(raw_source).hexdigest())\n", + "print(\"Original scientific_acceptance:\", source[\"scientific_acceptance\"])\n", + "print(\"Original scope:\", source[\"scope\"])\n" + ] + }, + { + "cell_type": "code", + "id": "exact-decimal-table", + "metadata": {}, + "execution_count": 2, + "outputs": [ + { + "output_type": "stream", + "name": "stdout", + "text": [ + "Exact published endpoints (open intervals):\n", + "d=2: 0.07340691930603427103 < c < 0.07340691930603427104\n", + "d=3: 0.04177593184059834334 < c < 0.04177593184059834335\n", + "Published relative_periodization_bound: 1e-106\n", + "NON-CERTIFYING display; original scientific_acceptance remains False\n" + ] + } + ], + "source": [ + "# Keep the published endpoint strings intact; Decimal arithmetic is used only\n", + "# to choose a midpoint for display. No float is used to validate an interval.\n", + "if set(source[\"dimensions\"]) != {\"2\", \"3\"}:\n", + " raise ValueError(\"Unexpected dimension set\")\n", + "rows = []\n", + "with localcontext() as context:\n", + " context.prec = 50\n", + " for dimension in (\"2\", \"3\"):\n", + " record = source[\"dimensions\"][dimension]\n", + " lower_text, upper_text = record[\"lower\"], record[\"upper\"]\n", + " if not isinstance(lower_text, str) or not isinstance(upper_text, str):\n", + " raise ValueError(\"Published decimal endpoints must remain strings\")\n", + " lower, upper = Decimal(lower_text), Decimal(upper_text)\n", + " if not lower.is_finite() or not upper.is_finite() or not Decimal(0) < lower < upper:\n", + " raise ValueError(\"Invalid published interval\")\n", + " rows.append({\n", + " \"dimension\": dimension,\n", + " \"lower\": lower_text,\n", + " \"upper\": upper_text,\n", + " \"display_midpoint\": (lower + upper) / Decimal(2),\n", + " })\n", + "\n", + "print(\"Exact published endpoints (open intervals):\")\n", + "for row in rows:\n", + " print(\"d=\" + row[\"dimension\"] + \": \" + row[\"lower\"] + \" < c < \" + row[\"upper\"])\n", + "print(\"Published relative_periodization_bound:\", source[\"relative_periodization_bound\"])\n", + "print(\"NON-CERTIFYING display; original scientific_acceptance remains\", source[\"scientific_acceptance\"])\n" + ] + }, + { + "cell_type": "markdown", + "id": "chart-boundary", + "metadata": {}, + "source": [ + "## Optional approximate chart\n", + "\n", + "Bar heights are floating-point conversions of the decimal midpoints. The published interval widths are about `1e-20`, far below this chart's resolution, so the bars do **not** show enclosure precision or an error probability. Use the exact endpoint strings above for the original intervals. The chart creates no new coefficient, constant, theorem, or scientific verdict.\n" + ] + }, + { + "cell_type": "code", + "id": "approximate-chart", + "metadata": {}, + "execution_count": 3, + "outputs": [ + { + "output_type": "display_data", + "metadata": {}, + "data": { + "image/png": "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", + "text/plain": [ + "NON-CERTIFYING SIDE24 coefficient display; pinned public input." + ] + } + } + ], + "source": [ + "try:\n", + " import matplotlib.pyplot as plt\n", + "except ImportError:\n", + " print(\"Matplotlib is unavailable. The verified exact table above is complete.\")\n", + "else:\n", + " dimensions = [\"d = \" + row[\"dimension\"] for row in rows]\n", + " approximate_midpoints = [float(row[\"display_midpoint\"]) for row in rows]\n", + " fig, ax = plt.subplots(figsize=(7, 4.5))\n", + " bars = ax.bar(dimensions, approximate_midpoints, color=[\"#2563eb\", \"#0f766e\"], width=0.55)\n", + " ax.set_ylim(0, max(approximate_midpoints) * 1.25)\n", + " ax.set_ylabel(\"Published coefficient (approximate midpoint)\")\n", + " ax.set_title(\"SIDE24 coefficients: NON-CERTIFYING display\")\n", + " ax.spines[[\"top\", \"right\"]].set_visible(False)\n", + " ax.grid(axis=\"y\", alpha=0.2)\n", + " ax.set_axisbelow(True)\n", + " for bar, value in zip(bars, approximate_midpoints):\n", + " ax.text(bar.get_x() + bar.get_width() / 2, value + 0.0015,\n", + " format(value, \".8f\"), ha=\"center\")\n", + " fig.text(0.5, 0.025, \"Pinned Math- input: \" + SOURCE_COMMIT[:12] + \" | original acceptance: false\",\n", + " ha=\"center\", fontsize=9)\n", + " fig.tight_layout(rect=(0, 0.06, 1, 1))\n", + " plt.show()\n" + ] + }, + { + "cell_type": "markdown", + "id": "reproduction", + "metadata": {}, + "source": [ + "## Reproduction and contribution boundary\n", + "\n", + "The fetch cell refuses missing, changed, oversized, or differently hashed input. It never substitutes current `main`, another JSON file, or generated samples. Retain the pinned URL and expected digest when sharing the notebook.\n", + "\n", + "Submit new results through the [public contribution process](https://github.com/d6g8k5htny-coder/main/blob/main/CONTRIBUTING.md). A chart or successful run is review material, not permission to edit `STATUS.md`, `PROOF_INDEX.md`, `claims/`, or `lemma_closed`.\n" + ] + } + ], + "metadata": { + "kernelspec": { + "display_name": "Python 3", + "language": "python", + "name": "python3" + }, + "language_info": { + "name": "python", + "version": "3.12.14" + }, + "colab": { + "provenance": [] + }, + "source_replay": { + "mode": "local public Git bytes injected into the fetch boundary", + "repository": "d6g8k5htny-coder/Math-", + "commit": "9d7b6802424fb4715b31999066aafca8ee2f3cca", + "path": "coefficients/side24_v1/ENCLOSURE.json", + "sha256": "72b6cd92d31394cdaf5da8919a5d548e902228af1f095cc184158a71d8287811", + "scientific_effect": "NONE", + "python_version": "3.12.14", + "matplotlib_version": "3.10.8" + } + }, + "nbformat": 4, + "nbformat_minor": 5 +} diff --git a/docs/site/README.md b/docs/site/README.md new file mode 100644 index 000000000..4e98480ff --- /dev/null +++ b/docs/site/README.md @@ -0,0 +1,40 @@ +# Public research shop + +This static viewer makes the existing public work easier to read. It does not own scientific status. + +- **Board:** a mechanically exported, byte-bound `STATUS.md` snapshot. Counts refer to the selected rows, with full scope and limits. API observations are dated separately. +- **SIDE24 explorer:** exact decimal endpoints from pinned public JSON; approximate bar lengths are NON-CERTIFYING. No lifetime curve, random field simulation, or new bound is generated. +- **Inventory browser:** reads the existing `docs/public-math/sources.json` and its fourteen hash-verified shards. No second inventory is created. +- **Contributions:** GitHub issues and incoming-only result PRs. The viewer has no upload endpoint, credentials, write token, or backend. + +The original enclosure's `scientific_acceptance: false` is preserved. Later scoped review is quoted separately from the status snapshot; neither is silently substituted for the other. AMEND mathematics remains AMEND. + +## Run locally + +From the repository root: + +```sh +python3 -m http.server 8000 --directory docs +``` + +Open `http://localhost:8000/site/`. Internet access is required to read the immutable public GitHub inputs. If a hash or fetch fails, the affected view reports unavailable and infers no result. + +```sh +python3 -B -m unittest discover -s tests -p test_public_shop_data.py +node --test tests/test_public_shop_frontend.mjs +python3 -B tools/public_shop_check.py +``` + +The interaction harness tests loading, searching, exact decimal selection and commit currency; it is not a visual browser test. Browser preview from the editing environment was unavailable because its browser could not reach the local server. + +Reproduce the exports with `python3 -B tools/public_shop_data.py --check`. The exporter uses fixed source identities, refuses changed bytes or unfamiliar tables, and preserves verbatim cells. Updating the snapshot requires an explicit source-bound engineering PR; this viewer never decides a review disposition. + +## Notebook + +The [SIDE24 notebook](../notebooks/SIDE24_PUBLIC_COEFFICIENTS.ipynb) exposes the same immutable input and exact values, with an optional approximate chart. See [notebook instructions](../notebooks/README.md). + +## Publish on main only + +Use GitHub Pages **Deploy from a branch → main → /docs**. The entry `docs/index.html` points to `site/`; `docs/.nojekyll` serves static files. GitHub's branch publishing supports `/` or `/docs`, so `docs/site` is the app directory, not a selectable publishing root. + +See [settings and task-board setup](../PUBLIC_SHOP_SETUP.md). Repository files do not by themselves enable Pages, pin profile repositories, install branch protection, or create a Project. Their activation must be verified in GitHub settings. diff --git a/docs/site/app.js b/docs/site/app.js new file mode 100644 index 000000000..ef8e3704c --- /dev/null +++ b/docs/site/app.js @@ -0,0 +1,91 @@ +import {verifiedJSON, verifiedBytes, validateStatus, validateCoefficient, safeSourceURL, hex40, hex64} from './core.mjs'; +const el=id=>document.getElementById(id); +const node=(tag,text,cls)=>{const n=document.createElement(tag);if(text!==undefined)n.textContent=text;if(cls)n.className=cls;return n;}; +const error=(id,e)=>{el(id).textContent=`Unavailable: ${e.message}. No result inferred.`;el(id).className='error';}; +const link=(text,url)=>{const a=node('a',text);a.href=url;return a;}; +// Small safe renderer: links to this public GitHub owner; no HTML execution. +function cell(target,text,base) { + const re=/\[([^\]]+)\]\(([^)]+)\)/g;let start=0; + for(const match of text.matchAll(re)) { + target.append(document.createTextNode(text.slice(start,match.index).replace(/\*\*|`/g,''))); + let url;try{url=new URL(match[2],base);}catch{url=null;} + if(url?.origin==='https://github.com' && url.pathname.startsWith('/d6g8k5htny-coder/'))target.append(link(match[1],url.href)); + else target.append(document.createTextNode(match[1])); + start=match.index+match[0].length; + } + target.append(document.createTextNode(text.slice(start).replace(/\*\*|`/g,''))); +} +function identity(target,pin) { + for(const [label,value] of [['Commit',pin.commit],['Path',pin.path],['SHA-256',pin.sha256],['Bytes',pin.bytes]]) { + const p=node('p');p.append(node('strong',label+': '),node('code',String(value)));target.append(p); + } + const url=pin.url||pin.raw_url;if(url)target.append(link('Read the pinned public bytes ↗',url)); +} +async function board(config) { + const s=validateStatus(await verifiedJSON(config.status_json)); + await verifiedBytes(s.source); + const base=`https://github.com/d6g8k5htny-coder/main/blob/${s.source.commit}/`; + el('status-note').textContent=`Snapshot ${s.snapshot_date}. Counts cover the selected rows below, not every theorem or artifact. ${s.meaning}`; + const labels={accept:'ACCEPT — scoped',amend:'AMEND / open',engineering:'Engineering only'}; + for(const section of s.sections) { + const card=node('article',undefined,section.key);card.append(node('span',String(section.count),'count'),node('h3',labels[section.key]),node('p','Selected source rows; read the scope below.'));el('counts').append(card); + const details=node('details',undefined,'status-group');details.append(node('summary',`${labels[section.key]} · ${section.count}`)); + for(const row of section.rows) { + const article=node('article',undefined,'status-object');const title=node('h4');cell(title,row[0],base);article.append(title); + row.slice(1).forEach((c,i)=>{const p=node('p');p.append(node('strong',section.headers[i+1]+': '));cell(p,c,base);article.append(p);});details.append(article); + }el('status-rows').append(details); + } + const details=node('details');details.append(node('summary','Status source identity'));identity(details,s.source);el('status-rows').append(details); +} +function svgElement(tag,attributes,text) {const n=document.createElementNS('http://www.w3.org/2000/svg',tag);Object.entries(attributes).forEach(([k,v])=>n.setAttribute(k,String(v)));if(text)n.textContent=text;return n;} +function drawCoefficient(data,dimension) { + const selected=data.dimensions[dimension];el('lower').textContent=selected.lower;el('upper').textContent=selected.upper;el('moment').textContent=data.cone_moments[dimension]; + const svg=el('coefficient-chart');svg.replaceChildren(); + svg.append(svgElement('line',{x1:80,y1:175,x2:475,y2:175,stroke:'#829793'})); + ['2','3'].forEach((d,i)=>{const value=Number(data.dimensions[d].lower),y=40+i*65; + svg.append(svgElement('text',{x:8,y:y+23,fill:'#304e55','font-size':15},`d = ${d}`)); + svg.append(svgElement('rect',{x:80,y,width:380*value/0.08,height:32,rx:3,fill:d===dimension?'#2b7565':'#adc6ba'})); + svg.append(svgElement('text',{x:80,y:y+49,fill:'#526b70','font-size':12},`≈ ${value.toFixed(6)} (display)`)); + }); + for(const [x,text] of [[80,'0'],[270,'0.04'],[460,'0.08']])svg.append(svgElement('text',{x,y:201,fill:'#526b70','font-size':12},text)); +} +async function coefficients(config) { + const data=validateCoefficient(await verifiedJSON(config.coefficient)); + el('coefficient-state').textContent='SHA-256 and byte count verified. Exact endpoints shown verbatim.'; + el('proof-link').href=`https://github.com/d6g8k5htny-coder/Math-/blob/${config.proof.commit}/${config.proof.path}`; + identity(el('coefficient-identity'),config.coefficient);el('coefficient-identity').append(node('p',data.method),node('p',`Original source scope: ${data.scope}`)); + drawCoefficient(data,el('dimension').value);el('dimension').addEventListener('change',()=>drawCoefficient(data,el('dimension').value)); +} +async function inventory(config) { + const index=await verifiedJSON(config.inventory); + if(index.source_count!==2138||index.pages.length!==config.inventory.pages.length)throw new Error('Catalog index mismatch'); + const chunks=await Promise.all(config.inventory.pages.map(async (pin,i)=>{ + if(index.pages[i].path!==pin.path.split('/').at(-1)||index.pages[i].count!==pin.count)throw new Error('Shard selector mismatch'); + const data=await verifiedJSON(pin); + if(!Array.isArray(data.sources)||data.sources.length!==pin.count)throw new Error('Shard count mismatch'); + data.sources.forEach(row=>{safeSourceURL(row);if(!Number.isSafeInteger(row.bytes)||row.bytes<0||!hex40.test(row.blob))throw new Error('Catalog row identity missing');});return data.sources; + })); + const rows=chunks.flat();if(rows.length!==index.source_count)throw new Error('Catalog total mismatch'); + let limit=50; + const render=()=>{const query=el('search').value.trim().toLowerCase();const matches=rows.filter(row=>[row.repository,row.path,row.commit,row.sha256].some(s=>s.toLowerCase().includes(query)));el('catalog').replaceChildren(); + matches.slice(0,limit).forEach(row=>{const tr=node('tr'),name=node('td'),commit=node('td'),hash=node('td');name.append(node('small',row.repository),link(row.path,safeSourceURL(row)));commit.append(node('code',row.commit));hash.append(node('code',row.sha256));tr.append(name,commit,hash);el('catalog').append(tr);}); + el('inventory-state').textContent=`${matches.length.toLocaleString()} matches · ${Math.min(limit,matches.length)} shown · all 2,138 source records loaded from the original hash-verified shards.`;el('more').hidden=matches.length<=limit;}; + el('search').disabled=false;el('search').addEventListener('input',()=>{limit=50;render();});el('more').addEventListener('click',()=>{limit+=50;render();});render(); +} +async function custody(config) { + const manifest=await verifiedJSON(config.imports); + if(manifest.scientific_effect!=='NONE'||manifest.byte_copies.length!==config.imports.count||manifest.byte_copies.some(row=>row.kind!=='BYTE_COPY'||row.source_label_adopted!==false))throw new Error('Import custody mismatch'); + const observed=config.observations; + el('custody-note').textContent=`${config.imports.count} byte-copy imports landed at Math ${config.imports.commit}; source labels were not adopted. ${observed.open_math_prs} Math PRs were open when observed ${observed.observed_at}. An open PR is not landed math.`; + el('custody-note').append(' ',link('Import identities ↗',config.imports.manifest_url)); + const q=config.query;const bundle=await verifiedJSON(q);if(bundle.math_tip!==q.math_pin||bundle.scientific_status_authority!==false)throw new Error('Query source mismatch');el('query-note').textContent=`Query checkout ${q.commit}; recorded Math commit ${q.math_pin}. --check-math-tip checks seven file identities, not commit equality. The button below checks commit currency only.`; + if(!hex40.test(q.math_pin)||!hex40.test(q.commit))throw new Error('Query pin unavailable'); + el('check-tip').disabled=false;el('check-tip').addEventListener('click',async()=>{el('check-tip').disabled=true;el('tip-result').textContent='Reading current public Math ref…'; + try{const r=await fetch('https://api.github.com/repos/d6g8k5htny-coder/Math-/git/ref/heads/main',{credentials:'omit',redirect:'error'});if(!r.ok)throw new Error(`GitHub API ${r.status}`);const ref=await r.json(),tip=ref.object?.sha;if(!hex40.test(tip)||ref.ref!=='refs/heads/main')throw new Error('Unexpected ref response');const same=tip===q.math_pin;el('tip-result').className=same?'good':'error';el('tip-result').textContent=`${same?'Commit pin current':'Commit pin differs'} at ${new Date().toISOString()}: Math ${tip}. Gate-byte equality was not tested by this browser check.`; + }catch(e){error('tip-result',e);}finally{el('check-tip').disabled=false;}}); +} +try { + const response=await fetch('config.json',{credentials:'omit'});if(!response.ok)throw new Error('Shop config unavailable');const config=await response.json(); + const jobs=[['status-note',()=>board(config)],['coefficient-state',()=>coefficients(config)],['inventory-state',()=>inventory(config)],['custody-note',()=>custody(config)]]; + await Promise.all(jobs.map(async([id,job])=>{try{await job();}catch(e){error(id,e);}})); +} catch(e) {['status-note','coefficient-state','inventory-state','custody-note'].forEach(id=>error(id,e));} diff --git a/docs/site/config.json b/docs/site/config.json new file mode 100644 index 000000000..17d5f5abd --- /dev/null +++ b/docs/site/config.json @@ -0,0 +1,230 @@ +{ + "coefficient": { + "blob": "57af39a05e14ed0ba8ebc00a9b4aca4dffb067c7", + "bytes": 1090, + "commit": "9d7b6802424fb4715b31999066aafca8ee2f3cca", + "path": "coefficients/side24_v1/ENCLOSURE.json", + "repository": "d6g8k5htny-coder/Math-", + "sha256": "72b6cd92d31394cdaf5da8919a5d548e902228af1f095cc184158a71d8287811", + "url": "https://raw.githubusercontent.com/d6g8k5htny-coder/Math-/9d7b6802424fb4715b31999066aafca8ee2f3cca/coefficients/side24_v1/ENCLOSURE.json" + }, + "imports": { + "blob": "4cc679d65d8af2162fa9915ad7edf35fda16a576", + "byte_copy_ids": [ + "EC-014", + "EC-015", + "EC-021", + "P02-LM-001", + "P02-LM-002", + "P02-LM-005", + "P02-LM-007", + "P02-LM-008", + "P15-B" + ], + "bytes": 18262, + "commit": "9d7b6802424fb4715b31999066aafca8ee2f3cca", + "count": 9, + "manifest_url": "https://raw.githubusercontent.com/d6g8k5htny-coder/Math-/9d7b6802424fb4715b31999066aafca8ee2f3cca/imports/hardening_ebedb780/MANIFEST.json", + "meaning": "Nine byte-custody imports, separately one transcription; not accepted-theorem counts.", + "path": "imports/hardening_ebedb780/MANIFEST.json", + "repository": "d6g8k5htny-coder/Math-", + "scientific_effect": "NONE", + "sha256": "fa7f33839924d340cc1123fe05276f681e6aa12193c68b2d1aa6ab489150d8e3", + "transcription_count": 1, + "url": "https://raw.githubusercontent.com/d6g8k5htny-coder/Math-/9d7b6802424fb4715b31999066aafca8ee2f3cca/imports/hardening_ebedb780/MANIFEST.json" + }, + "inventory": { + "blob": "edf9a7088a574134fa982946c9e779476b617e3d", + "bytes": 1863, + "commit": "a26f744be7597e3f0c0543c34ead23049bbac657", + "meaning": "Existing public-text inventory; loaded in place, never copied into a second catalog.", + "pages": [ + { + "blob": "550519fe77b73927169e2a1efdc0276bb0f6141f", + "bytes": 58276, + "commit": "a26f744be7597e3f0c0543c34ead23049bbac657", + "count": 160, + "path": "docs/public-math/sources-01.json", + "repository": "d6g8k5htny-coder/main", + "sha256": "f675167fe655fb07015b0178e818cc0f92e23f683bdf490a45b2401c4ff45557", + "url": "https://raw.githubusercontent.com/d6g8k5htny-coder/main/a26f744be7597e3f0c0543c34ead23049bbac657/docs/public-math/sources-01.json" + }, + { + "blob": "0037f84f28f3e9dada4d921c903ee0271723d544", + "bytes": 86078, + "commit": "a26f744be7597e3f0c0543c34ead23049bbac657", + "count": 160, + "path": "docs/public-math/sources-02.json", + "repository": "d6g8k5htny-coder/main", + "sha256": "6f50efb1ffae3e39c39335ee889e4e9e184e82e54a5b5d690750b23425c60960", + "url": "https://raw.githubusercontent.com/d6g8k5htny-coder/main/a26f744be7597e3f0c0543c34ead23049bbac657/docs/public-math/sources-02.json" + }, + { + "blob": "9b1eb04eb09fc3227d394110e1913e85306392ce", + "bytes": 96034, + "commit": "a26f744be7597e3f0c0543c34ead23049bbac657", + "count": 160, + "path": "docs/public-math/sources-03.json", + "repository": "d6g8k5htny-coder/main", + "sha256": "38a261921ce336b47ed1660997bcea084e2fc98e32166f9a179c8e0e428970fe", + "url": "https://raw.githubusercontent.com/d6g8k5htny-coder/main/a26f744be7597e3f0c0543c34ead23049bbac657/docs/public-math/sources-03.json" + }, + { + "blob": "b4c66773898213e7b58483b018fd15063911af93", + "bytes": 87348, + "commit": "a26f744be7597e3f0c0543c34ead23049bbac657", + "count": 160, + "path": "docs/public-math/sources-04.json", + "repository": "d6g8k5htny-coder/main", + "sha256": "1da5d266246196626bfd98a82d135c0e67dd916318b165f11d466a84e6157c7a", + "url": "https://raw.githubusercontent.com/d6g8k5htny-coder/main/a26f744be7597e3f0c0543c34ead23049bbac657/docs/public-math/sources-04.json" + }, + { + "blob": "5247d6927cee10e49d9b9d8f378797ebae29c926", + "bytes": 68164, + "commit": "a26f744be7597e3f0c0543c34ead23049bbac657", + "count": 160, + "path": "docs/public-math/sources-05.json", + "repository": "d6g8k5htny-coder/main", + "sha256": "66dd57a32c41d995ada8ee8e9f6eee8d9b3e3fba9907899ef71b53f8377dd345", + "url": "https://raw.githubusercontent.com/d6g8k5htny-coder/main/a26f744be7597e3f0c0543c34ead23049bbac657/docs/public-math/sources-05.json" + }, + { + "blob": "eda5411fe6e3035e9e981a3f614aac46882828b9", + "bytes": 81840, + "commit": "a26f744be7597e3f0c0543c34ead23049bbac657", + "count": 160, + "path": "docs/public-math/sources-06.json", + "repository": "d6g8k5htny-coder/main", + "sha256": "63c0c063f7e559d5f27cc3896f0c6f8f041dd44746bc35ce382be01bba4b4712", + "url": "https://raw.githubusercontent.com/d6g8k5htny-coder/main/a26f744be7597e3f0c0543c34ead23049bbac657/docs/public-math/sources-06.json" + }, + { + "blob": "0cd78768bb71eef7a84ea9fe35867a5b6d103ea3", + "bytes": 95161, + "commit": "a26f744be7597e3f0c0543c34ead23049bbac657", + "count": 160, + "path": "docs/public-math/sources-07.json", + "repository": "d6g8k5htny-coder/main", + "sha256": "8e957b2732181731d72bece75b82a2d0fbed6f4a205a4faa37486350732f090a", + "url": "https://raw.githubusercontent.com/d6g8k5htny-coder/main/a26f744be7597e3f0c0543c34ead23049bbac657/docs/public-math/sources-07.json" + }, + { + "blob": "882219d447d249c3221a526ea0f59dd2d69a108f", + "bytes": 87801, + "commit": "a26f744be7597e3f0c0543c34ead23049bbac657", + "count": 160, + "path": "docs/public-math/sources-08.json", + "repository": "d6g8k5htny-coder/main", + "sha256": "96c801dc214d054f9aa2a5a63a553e5d26a2ebccda99d9eca666c5db98a0e63b", + "url": "https://raw.githubusercontent.com/d6g8k5htny-coder/main/a26f744be7597e3f0c0543c34ead23049bbac657/docs/public-math/sources-08.json" + }, + { + "blob": "a59e56e0351a77b624058be9efad3f30d495d1e1", + "bytes": 76228, + "commit": "a26f744be7597e3f0c0543c34ead23049bbac657", + "count": 160, + "path": "docs/public-math/sources-09.json", + "repository": "d6g8k5htny-coder/main", + "sha256": "35598ba1479bb0a7ca858a5c3a38b217a78ab725e9d89613765ee7f0b6b3220f", + "url": "https://raw.githubusercontent.com/d6g8k5htny-coder/main/a26f744be7597e3f0c0543c34ead23049bbac657/docs/public-math/sources-09.json" + }, + { + "blob": "addd0228282e1ec31228dca1476f2d770f206181", + "bytes": 76144, + "commit": "a26f744be7597e3f0c0543c34ead23049bbac657", + "count": 160, + "path": "docs/public-math/sources-10.json", + "repository": "d6g8k5htny-coder/main", + "sha256": "ff67d89bef01008348903bd8cd8e2c2fb97cbd2a4a83bb99b5d6585a20e60313", + "url": "https://raw.githubusercontent.com/d6g8k5htny-coder/main/a26f744be7597e3f0c0543c34ead23049bbac657/docs/public-math/sources-10.json" + }, + { + "blob": "b50b28a293503b35fa0851be9f8854f5fe4aed55", + "bytes": 86339, + "commit": "a26f744be7597e3f0c0543c34ead23049bbac657", + "count": 160, + "path": "docs/public-math/sources-11.json", + "repository": "d6g8k5htny-coder/main", + "sha256": "83a3d41737f1695413c78f82b186549617564e7368ea86d5dc3941bd84d04fea", + "url": "https://raw.githubusercontent.com/d6g8k5htny-coder/main/a26f744be7597e3f0c0543c34ead23049bbac657/docs/public-math/sources-11.json" + }, + { + "blob": "950783d361a676c61e96f9299a845d9e2b9a2c66", + "bytes": 63991, + "commit": "a26f744be7597e3f0c0543c34ead23049bbac657", + "count": 160, + "path": "docs/public-math/sources-12.json", + "repository": "d6g8k5htny-coder/main", + "sha256": "3185e198547e8e1a56759442784f63b2587fd5001cc8bc773435b6750cf22419", + "url": "https://raw.githubusercontent.com/d6g8k5htny-coder/main/a26f744be7597e3f0c0543c34ead23049bbac657/docs/public-math/sources-12.json" + }, + { + "blob": "9d4ab75e0423e456294ee90399a3c22648153fa5", + "bytes": 69414, + "commit": "a26f744be7597e3f0c0543c34ead23049bbac657", + "count": 160, + "path": "docs/public-math/sources-13.json", + "repository": "d6g8k5htny-coder/main", + "sha256": "f2e7dd2c6187bd83e0039a44ee919184638a839632412d103b32ddb19ab105cc", + "url": "https://raw.githubusercontent.com/d6g8k5htny-coder/main/a26f744be7597e3f0c0543c34ead23049bbac657/docs/public-math/sources-13.json" + }, + { + "blob": "f9df9ee169376c01f7f3a7b1f794e79ded81915b", + "bytes": 20295, + "commit": "a26f744be7597e3f0c0543c34ead23049bbac657", + "count": 58, + "path": "docs/public-math/sources-14.json", + "repository": "d6g8k5htny-coder/main", + "sha256": "f1df0d99ab802659cc5fb99dea665d8516aaca8da1cb9b3842890a8b14d9b3ce", + "url": "https://raw.githubusercontent.com/d6g8k5htny-coder/main/a26f744be7597e3f0c0543c34ead23049bbac657/docs/public-math/sources-14.json" + } + ], + "path": "docs/public-math/sources.json", + "relative_url": "../public-math/sources.json", + "repository": "d6g8k5htny-coder/main", + "sha256": "78ac59ed59579a1ee7cd0912f52ad702249b6978e836e5bccd90577a02591a52", + "source_count": 2138, + "url": "https://raw.githubusercontent.com/d6g8k5htny-coder/main/a26f744be7597e3f0c0543c34ead23049bbac657/docs/public-math/sources.json" + }, + "observations": { + "math_tip": "58f7936d1138b24dd6cc988081d74d07683611d6", + "observed_at": "2026-09-26T16:17:49Z", + "open_math_prs": 19, + "path": "observations.json" + }, + "proof": { + "blob": "44b66f04f89fcd87383b3603fa69f1feb64cdddd", + "bytes": 10272, + "commit": "9d7b6802424fb4715b31999066aafca8ee2f3cca", + "path": "coefficients/side24_v1/PROOF.md", + "repository": "d6g8k5htny-coder/Math-", + "sha256": "c06daccc4ba4b9168522b9888b76a7d599934fc3b91bd753ee5d492262917769", + "url": "https://raw.githubusercontent.com/d6g8k5htny-coder/Math-/9d7b6802424fb4715b31999066aafca8ee2f3cca/coefficients/side24_v1/PROOF.md" + }, + "query": { + "bytes": 4623, + "commit": "89456c5033173c69a304c5fffa781888185675cc", + "math_pin": "58f7936d1138b24dd6cc988081d74d07683611d6", + "path": "portable/CANDIDATE_DOWNSTREAM_GATE_STUBS.json", + "repository": "d6g8k5htny-coder/query-", + "sha256": "94d850209edc190242750cad6da7da815712acf835029991754937c6bd3d4646", + "url": "https://raw.githubusercontent.com/d6g8k5htny-coder/query-/89456c5033173c69a304c5fffa781888185675cc/portable/CANDIDATE_DOWNSTREAM_GATE_STUBS.json" + }, + "schema_version": 1, + "scientific_status_authority": false, + "status": { + "blob": "52688102260e916dec1a38143186198b089a0261", + "bytes": 6881, + "commit": "a26f744be7597e3f0c0543c34ead23049bbac657", + "path": "STATUS.md", + "repository": "d6g8k5htny-coder/main", + "sha256": "9c3e21144423591a3dbff926858048c0363b9a32d6fe258a1de5088d38096141", + "url": "https://raw.githubusercontent.com/d6g8k5htny-coder/main/a26f744be7597e3f0c0543c34ead23049bbac657/STATUS.md" + }, + "status_json": { + "bytes": 7056, + "sha256": "570de5a0ffcd14269dedd6018fa05d37f4354e8177fa0eec78ea9b1da6125cc6", + "url": "status.json" + } +} diff --git a/docs/site/core.mjs b/docs/site/core.mjs new file mode 100644 index 000000000..79ea0d33d --- /dev/null +++ b/docs/site/core.mjs @@ -0,0 +1,51 @@ +// Read-only public source validation. No acceptance decisions or write APIs. +export const hex40 = /^[0-9a-f]{40}$/; +export const hex64 = /^[0-9a-f]{64}$/; +export function safeSourceURL(row) { + if (!['Math-', 'main'].includes(row.repository) || !hex40.test(row.commit) || + !hex64.test(row.sha256) || typeof row.path !== 'string' || + row.path.split('/').some(p => !p || p === '.' || p === '..') || + /[\\\x00-\x1f]/.test(row.path)) throw new Error('Invalid public source identity'); + return `https://github.com/d6g8k5htny-coder/${row.repository}/blob/${row.commit}/${row.path.split('/').map(encodeURIComponent).join('/')}`; +} +export async function verifiedBytes(pin, fetcher = fetch) { + if (!pin || !hex64.test(pin.sha256) || !Number.isSafeInteger(pin.bytes) || pin.bytes < 0) + throw new Error('Missing source digest or byte count'); + const target = pin.url || pin.raw_url; + if (typeof target !== 'string' || (!/^https:\/\/raw\.githubusercontent\.com\/d6g8k5htny-coder\/(main|Math-|query-)\/[0-9a-f]{40}\//.test(target) && !/^(?:\.\.\/public-math\/sources(?:-\d{2})?\.json|status\.json|observations\.json)$/.test(target))) + throw new Error('Source must be a pinned public URL or a declared local data file'); + if (target.startsWith('https:')) { + if (!/^d6g8k5htny-coder\/(main|Math-|query-)$/.test(pin.repository) || !hex40.test(pin.commit) || typeof pin.path !== 'string' || pin.path.split('/').some(p=>!p||p==='.'||p==='..')) throw new Error('Invalid displayed source identity'); + const expected = `https://raw.githubusercontent.com/${pin.repository}/${pin.commit}/${pin.path.split('/').map(encodeURIComponent).join('/')}`; + if (target !== expected) throw new Error('Displayed identity does not match source URL'); + } + const response = await fetcher(target, {credentials:'omit', redirect:'error'}); + if (!response.ok) throw new Error(`Source unavailable (${response.status})`); + const data = new Uint8Array(await response.arrayBuffer()); + if (data.byteLength !== pin.bytes) throw new Error('Source byte count mismatch'); + const digest = Array.from(new Uint8Array(await crypto.subtle.digest('SHA-256',data)), x=>x.toString(16).padStart(2,'0')).join(''); + if (digest !== pin.sha256) throw new Error('Source SHA-256 mismatch'); + return data; +} +export async function verifiedJSON(pin, fetcher = fetch) { + return JSON.parse(new TextDecoder('utf-8', {fatal:true}).decode(await verifiedBytes(pin, fetcher))); +} +export function validateStatus(status) { + if (status.scientific_status_authority !== false || !Array.isArray(status.sections)) throw new Error('Invalid status export'); + const keys = new Set(); + for (const section of status.sections) { + if (!['accept','amend','engineering'].includes(section.key) || keys.has(section.key) || !Array.isArray(section.rows) || !Array.isArray(section.headers)) throw new Error('Unrecognized status section'); + keys.add(section.key); + if (section.rows.length !== section.count || status.counts[section.key] !== section.count || section.rows.some(row=>!Array.isArray(row)||row.length!==section.headers.length||row.some(c=>typeof c!=='string'))) throw new Error('Status count/schema mismatch'); + } + if (keys.size !== 3) throw new Error('Incomplete status export'); + return status; +} +export function validateCoefficient(data) { + if(data.scientific_acceptance!==false || data.object!=='SIDE24-COEFFICIENT-D23-20260924-v1') throw new Error('Unexpected coefficient scope'); + for(const d of ['2','3']) { + const {lower,upper}=data.dimensions[d]; + if(!/^0\.\d{20}$/.test(lower)||!/^0\.\d{20}$/.test(upper)||BigInt(lower.replace('.',''))>=BigInt(upper.replace('.',''))) throw new Error('Invalid exact decimal interval'); + } + return data; +} diff --git a/docs/site/index.html b/docs/site/index.html new file mode 100644 index 000000000..c522fe43f --- /dev/null +++ b/docs/site/index.html @@ -0,0 +1,25 @@ + + + + + +Universal Law · Public research shop + + + +
UNIVERSAL LAW PUBLIC RESEARCH
+
+

READ · REPLAY · REVIEW

Research you can open.
Evidence you can trace.

Explore the mathematics, inspect its limits, and contribute a reproducible result. Every view points back to public source bytes.

A plot is not a theorem. Publication, a merge, and green checks do not change mathematical acceptance.

+

01 / THE BOARD

Read the scope with the status.

Current status source ↗
+

Loading the committed status snapshot…

+
+

02 / SCOPED EXPLORER

SIDE24 coefficients

Read the full proof ↗
+

Dimensions 2 and 3, SIDE24, normalized variance-one covariance. This view displays a committed arithmetic enclosure. It supplies no finite-radius error band or lifetime cutoff.

+

Verifying pinned source bytes…

Exact lower endpoint
—
Exact upper endpoint
—
Reference cone moment
—
Approximate display only. Bar lengths use binary floating point; the exact endpoints remain visible at left. The enclosure width is too small to show at this scale.
+

The enclosure retains its original scientific_acceptance: false flag. The board separately quotes the later scoped review. Neither overrides the parent theorem’s open dependencies.

Source identity and method
+

03 / THE EXISTING CATALOG

Find the full argument.

Reading guide ↗
+

The existing 2,138-file inventory includes proofs, partial arguments, reviews, and historical reading copies. It counts files, not accepted theorems. New imports and proposals have separate public links.

+

Verifying the original inventory and its shards…

Repository / full textCommitSHA-256
+

04 / JOIN THE WORK

Bring a result. Keep its evidence.

1. Claim a bounded task

Replay a pinned calculation, chart public data, document an import, or leave a source-bound review comment. Comment /claim; wait for assignment and keep one active claim.

Browse public tasks ↗

2. Submit a result PR

Fork main. Add an incoming/<id>/ package with your result, outputs, and source/file identities. Do not edit scientific status rows.

Contribution instructions ↗

3. Review before integration

A designated reviewer checks the sources, scope, and limitations. Intake checks validate packaging; accepted intake is not an accepted theorem.

Public review queue ↗
+
+ diff --git a/docs/site/observations.json b/docs/site/observations.json new file mode 100644 index 000000000..0dcf213d1 --- /dev/null +++ b/docs/site/observations.json @@ -0,0 +1,166 @@ +{ + "schema_version": 1, + "scientific_status_authority": false, + "observed_at": "2026-09-26T16:17:49Z", + "math_tip": "58f7936d1138b24dd6cc988081d74d07683611d6", + "open_math_prs": 19, + "pull_requests": [ + { + "number": 74, + "head": "eb8bf7a58ec89d63868d8e281e709844b0ded47b", + "base": "main", + "title": "Nonauthor review of the PR69 pin-microdisk candidate", + "url": "https://github.com/d6g8k5htny-coder/Math-/pull/74", + "draft": true + }, + { + "number": 73, + "head": "5913b004f173cbf23a434828baf7e836a81413fd", + "base": "main", + "title": "Nonauthor review of PR36 contact-kernel tail additions", + "url": "https://github.com/d6g8k5htny-coder/Math-/pull/73", + "draft": true + }, + { + "number": 72, + "head": "cdb6bdd40b215b9974050b449e0161e31a54bafd", + "base": "main", + "title": "Nonauthor AMEND review of main PR125 shrinking-witness bound", + "url": "https://github.com/d6g8k5htny-coder/Math-/pull/72", + "draft": true + }, + { + "number": 71, + "head": "21e39741a1e604f57dc8997d286545f79bdbb602", + "base": "main", + "title": "Nonauthor re-review of main PR124 C1/C2 repair", + "url": "https://github.com/d6g8k5htny-coder/Math-/pull/71", + "draft": true + }, + { + "number": 69, + "head": "ae45d35192c2b601c7962e0b16b282ad9e98a400", + "base": "main", + "title": "D5 pin microdisk: divided-difference frame after the inner-disk gap", + "url": "https://github.com/d6g8k5htny-coder/Math-/pull/69", + "draft": true + }, + { + "number": 67, + "head": "e14d41101ddd7fc8e8ef2ed296a288d1cdd70191", + "base": "main", + "title": "Cross-repository proof custody audit", + "url": "https://github.com/d6g8k5htny-coder/Math-/pull/67", + "draft": true + }, + { + "number": 65, + "head": "3c5fc88a20736be3b93c96912e14676a4f929837", + "base": "main", + "title": "D0 audit: proof availability, absent carriers, and regional supersession", + "url": "https://github.com/d6g8k5htny-coder/Math-/pull/65", + "draft": true + }, + { + "number": 64, + "head": "d573b99d8792f3d5146c952737a4ba446a549e6f", + "base": "main", + "title": "Erratum: endpoint Hessian congruence in lifetime parent", + "url": "https://github.com/d6g8k5htny-coder/Math-/pull/64", + "draft": true + }, + { + "number": 60, + "head": "ad27c6b8802167ae8798221a9fb8ba3365162b63", + "base": "main", + "title": "Pin microdisk: anisotropic gradient covariance and density envelope", + "url": "https://github.com/d6g8k5htny-coder/Math-/pull/60", + "draft": true + }, + { + "number": 59, + "head": "718029c453d4514f59690315918e18333ba36050", + "base": "main", + "title": "Disposition missing TRANSVERSE_CONTACT_ASYMPTOTIC source as unavailable", + "url": "https://github.com/d6g8k5htny-coder/Math-/pull/59", + "draft": true + }, + { + "number": 55, + "head": "4e188e25b1e1ef560f3eeb75c0d354d2ccf0ea22", + "base": "main", + "title": "Nonauthor review of the PR53 pin-neighborhood chart", + "url": "https://github.com/d6g8k5htny-coder/Math-/pull/55", + "draft": true + }, + { + "number": 53, + "head": "9a6f8a660d4508ec273b67d67e6b3871ddf2aa19", + "base": "main", + "title": "Pin-neighborhood reconnaissance: desingularized endpoint chart", + "url": "https://github.com/d6g8k5htny-coder/Math-/pull/53", + "draft": true + }, + { + "number": 52, + "head": "f5e859495b24761cd65c4fe63d9b3a8264debd4e", + "base": "main", + "title": "Nonauthor ACCEPT of the PR25 D2 cumulative correction", + "url": "https://github.com/d6g8k5htny-coder/Math-/pull/52", + "draft": true + }, + { + "number": 49, + "head": "596e8098bec751e16d0caa56ca15ca20052b38f3", + "base": "main", + "title": "Integrate reviewed collision/simplex/contact-transfer package from exact PR25 blobs", + "url": "https://github.com/d6g8k5htny-coder/Math-/pull/49", + "draft": true + }, + { + "number": 46, + "head": "79a791a1f810dad5e695113fb0fa4d537d4d71ee", + "base": "main", + "title": "Add closed/open lemma and theorem reading maps", + "url": "https://github.com/d6g8k5htny-coder/Math-/pull/46", + "draft": false + }, + { + "number": 45, + "head": "7785bc82eb0ada3f25ea2be5513a147378f22e8a", + "base": "main", + "title": "Fail-closed claim audit of active landing corpus", + "url": "https://github.com/d6g8k5htny-coder/Math-/pull/45", + "draft": true + }, + { + "number": 35, + "head": "513bd15fb7b6f091bc50a4e11fa3fe9233cab6e0", + "base": "main", + "title": "Typed contact angular tails: directional exponential scales and full-covariance coefficient reduction", + "url": "https://github.com/d6g8k5htny-coder/Math-/pull/35", + "draft": true + }, + { + "number": 18, + "head": "0ae7e8fdf5d359f80cf6a3dcd614120f7aa9a19c", + "base": "main", + "title": "P15: source-bound exact-real SMT pilot, seven obligations and six false variants", + "url": "https://github.com/d6g8k5htny-coder/Math-/pull/18", + "draft": true + }, + { + "number": 7, + "head": "0f5ce608c1b1d9d4ee1e6731e59e828842c24017", + "base": "main", + "title": "RN mesoscopic annulus: desingularize the first shrinking spatial scale", + "url": "https://github.com/d6g8k5htny-coder/Math-/pull/7", + "draft": true + } + ], + "sources": { + "pull_requests": "https://api.github.com/repos/d6g8k5htny-coder/Math-/pulls?state=open&per_page=100", + "math_tip": "https://api.github.com/repos/d6g8k5htny-coder/Math-/git/ref/heads/main" + }, + "meaning": "Time-stamped public GitHub observations, not live counts or scientific acceptance; all listed pull requests were open. Math tip read immediately after the pull-request snapshot." +} diff --git a/docs/site/status.json b/docs/site/status.json new file mode 100644 index 000000000..830b61100 --- /dev/null +++ b/docs/site/status.json @@ -0,0 +1,113 @@ +{ + "counts": { + "accept": 4, + "amend": 3, + "engineering": 3 + }, + "meaning": "Counts of selected rows in the pinned STATUS snapshot, not totals of all theorems or an independent acceptance register.", + "schema_version": 1, + "scientific_status_authority": false, + "sections": [ + { + "count": 4, + "headers": [ + "Object", + "Accepted scope", + "Source and review", + "Explicit limits" + ], + "key": "accept", + "rows": [ + [ + "**D2 — unrestricted lifetime remainder**", + "Theorem R at its stated existential `O(1)` remainder scope: candidate and elder densities have leading `c ell^(-1/3)` term with bounded remainder for sufficiently small lifetime", + "[Proof](https://github.com/d6g8k5htny-coder/Math-/blob/main/frontiers/three_fronts_20260924/LIFETIME_REMAINDER.md) · [review reconciliation](https://github.com/d6g8k5htny-coder/main/issues/67#issuecomment-5841782206)", + "No numerical remainder constant or numerical lifetime cutoff; no RN/JETMOD closure" + ], + [ + "**D3 — SIDE24 coefficient calculation**", + "The coefficient expression for SIDE24 in dimensions 2 and 3, including cone moments, all-direction periodization comparison, covariance/Schur transfer, and outward special-function arithmetic", + "[Proof/package](https://github.com/d6g8k5htny-coder/Math-/tree/main/coefficients/side24_v1) · [review](https://github.com/d6g8k5htny-coder/main/issues/65#issuecomment-5841269490) · [reconciliation](https://github.com/d6g8k5htny-coder/main/issues/65#issuecomment-5841779222)", + "Coefficient arithmetic acceptance is separate from any imported parent theorem and from a finite-radius error band" + ], + [ + "**D4 — fixed-remote RN count theorem**", + "Fixed positive spatial separation `rho`, fixed witness separation `eta`, between-pin height window; conditioned covariance, three determinant factors, endpoint normalizer, contact kernel, and fixed-separation factorial moments", + "[Proof](https://github.com/d6g8k5htny-coder/Math-/blob/main/frontiers/remote_window_20260924/PROOF.md) · [review](https://github.com/d6g8k5htny-coder/main/issues/76#issuecomment-5841783172) · [reconciliation](https://github.com/d6g8k5htny-coder/main/issues/76#issuecomment-5841861362)", + "Does not cover shrinking `rho` or `eta`, pin neighborhoods, intermediate scales, all remote heights, or global RN/24-jet closure" + ], + [ + "**D6 — P15 full-price theorem**", + "Realized disjoint capacity/clutter family with `d_i >= 2`, all independent probabilities, `c_v <= phi(p_v)`, same palette `K >= K_H(d)`, sharp `rho*=1/(3-log(3e-2))`", + "[Proof](https://github.com/d6g8k5htny-coder/Math-/blob/main/frontiers/full_price_20260924/PROOF.md) · [review reconciliation](https://github.com/d6g8k5htny-coder/main/issues/74#issuecomment-5842112010)", + "Demand one remains an obstruction; no arbitrary-downset or unrestricted prize-problem extension" + ] + ], + "title": "ACCEPT — scoped" + }, + { + "count": 3, + "headers": [ + "Object", + "Current reason", + "Source" + ], + "key": "amend", + "rows": [ + [ + "**D1 — parent quantitative Theorem-A selection chain**", + "Later review accepted the load-bearing §8–§15 interfaces, but the quantitative §§2–§7 selection chain was reopened for independent review. A displayed congruence defect in §5 has an additive erratum and the remaining A1–A7 chain is not reconciled.", + "[Review issue #63](https://github.com/d6g8k5htny-coder/main/issues/63) · [fail-closed reopening](https://github.com/d6g8k5htny-coder/main/issues/63#issuecomment-5841830743) · [source-first erratum](https://github.com/d6g8k5htny-coder/main/issues/63#issuecomment-5841947606)" + ], + [ + "**D5 — pin neighborhoods / microdisk**", + "The public reconnaissance has an AMEND review; the inner microdisk bound and collar to the reviewed annulus are not complete, and the claimed summed pin-neighborhood bound remains AMEND.", + "[Math proof index](https://github.com/d6g8k5htny-coder/Math-/blob/main/PROOF_INDEX.md) · [Math issue #58](https://github.com/d6g8k5htny-coder/Math-/issues/58)" + ], + [ + "**SARD-G A1/A6**", + "A1 remains AMEND as written; A6's slicing argument is conditionally valid but its source application remains AMEND until the required open-chart premise is repaired.", + "[Successor review](reviews/sard_g_successor_a1_a6_20260926/REVIEW.md) · [current PR](https://github.com/d6g8k5htny-coder/main/pull/122)" + ] + ], + "title": "AMEND / open" + }, + { + "count": 3, + "headers": [ + "Surface", + "What it provides" + ], + "key": "engineering", + "rows": [ + [ + "**[query-](https://github.com/d6g8k5htny-coder/query-)**", + "Public read-only package and exact-source lookup; default commit `76e1ca09` includes the package and the canonical no-dependency unittest command in CI" + ], + [ + "**[Universal-Law-Workspace](https://github.com/d6g8k5htny-coder/Universal-Law-Workspace)**", + "Supporting federation/navigation map with `scientific_status_authority: false`" + ], + [ + "**main CI/navigation**", + "Link, structure, and engineering checks; green runs are not mathematical review" + ] + ], + "title": "Engineering only" + } + ], + "snapshot_context": { + "default_branch_boundary": "- Pinned Math reading checkout: `58f7936d1138b24dd6cc988081d74d07683611d6`.\n- Pinned query checkout: `89456c5033173c69a304c5fffa781888185675cc`.\n- [Math- PR #70](https://github.com/d6g8k5htny-coder/Math-/pull/70) landed nine byte-custody copies at `9d7b6802424fb4715b31999066aafca8ee2f3cca`; [PR #75](https://github.com/d6g8k5htny-coder/Math-/pull/75) added their proof-index pointer. These are public default-branch imports, **not newly accepted mathematics**. Source self-labels were not adopted.\n- The `main#59` issue-body file in PR #70 is explicitly a transcription, not original source bytes, so it is not counted as byte custody.\n- Open draft AMEND/review PRs remain visible but are not represented here as landed mathematics.", + "notice": "This historical snapshot's custody/query boundary may be stale. Current observations are separate; scientific rows are not inferred from merges." + }, + "snapshot_date": "2026-09-26", + "source": { + "blob": "52688102260e916dec1a38143186198b089a0261", + "bytes": 6881, + "commit": "a26f744be7597e3f0c0543c34ead23049bbac657", + "path": "STATUS.md", + "repository": "d6g8k5htny-coder/main", + "sha256": "9c3e21144423591a3dbff926858048c0363b9a32d6fe258a1de5088d38096141", + "url": "https://raw.githubusercontent.com/d6g8k5htny-coder/main/a26f744be7597e3f0c0543c34ead23049bbac657/STATUS.md" + } +} diff --git a/docs/site/style.css b/docs/site/style.css new file mode 100644 index 000000000..4768912f1 --- /dev/null +++ b/docs/site/style.css @@ -0,0 +1 @@ +*{box-sizing:border-box}html{scroll-behavior:smooth}body{margin:0;background:#f6f5f0;color:#162f36;font:16px/1.65 system-ui,sans-serif}a{color:#07596c;text-underline-offset:4px}header{display:flex;justify-content:space-between;align-items:center;padding:24px 5vw;border-bottom:1px solid #ced5d2;gap:24px}header a{text-decoration:none}.brand{font-weight:850;letter-spacing:.1em;color:#162f36}.brand span{display:block;font-size:10px;color:#536b70;letter-spacing:.2em}nav{display:flex;gap:24px;font-size:14px;font-weight:650}main{max-width:1180px;margin:auto;padding:0 32px}section{padding:64px 0;border-bottom:1px solid #ced5d2;scroll-margin-top:20px}.hero{padding-top:76px}.eyebrow{font-size:12px;letter-spacing:.16em;font-weight:750;color:#53706c;margin:0 0 18px}h1{font-family:Georgia,serif;font-size:clamp(36px,5.4vw,66px);line-height:1.12;letter-spacing:-.04em;font-weight:500;margin:12px 0 26px}h2{font-family:Georgia,serif;font-size:clamp(27px,3.3vw,39px);line-height:1.2;font-weight:500;letter-spacing:-.025em;margin:0 0 12px}h3{line-height:1.35}.intro{font-size:19px;max-width:640px;color:#41575c}.actions{display:flex;gap:12px;margin:28px 0}.button,button{display:inline-block;border:1px solid #204c52;background:#204c52;color:white;padding:10px 18px;font:650 14px/1.5 system-ui;cursor:pointer;text-decoration:none;border-radius:4px}.button.secondary{color:#204c52;background:transparent}button:disabled{cursor:wait;opacity:.55}.boundary{font-size:14px;border-left:3px solid #bc893b;padding:9px 16px;background:#eeebe1;max-width:900px}.section-heading{display:flex;justify-content:space-between;align-items:end;gap:24px;margin-bottom:24px}.section-heading>a{font-size:14px;white-space:nowrap}.cards{display:grid;grid-template-columns:repeat(3,1fr);gap:18px;margin:28px 0}.cards article{padding:24px;background:#fff;border:1px solid #dbe0dc;border-top:3px solid #538b77;border-radius:5px}.cards article.amend{border-top-color:#b48235}.cards article.engineering{border-top-color:#6d859d}.count{font:500 44px/1 Georgia,serif;display:block}.cards h3{font-size:16px;margin:15px 0 8px}.cards p{font-size:14px;color:#526568;margin:0}.status-group{margin:24px 0}.status-group summary{cursor:pointer;font-weight:700;padding:15px 0;border-bottom:1px solid #ccd6d0}.status-object{padding:16px 0;border-bottom:1px solid #dfe4df}.status-object h4{margin:0 0 8px}.status-object p{margin:7px 0;font-size:14px}.custody{padding:20px 24px;background:#e9eeea;margin-top:24px;border-radius:5px}.custody h3{margin-top:0}.custody p{font-size:14px}code,dd,.hash{font-family:ui-monospace,monospace;font-size:12px;overflow-wrap:anywhere}.explorer{display:grid;grid-template-columns:1fr 1.1fr;gap:40px;margin:32px 0;padding:28px;background:#fff;border:1px solid #dbe0dc;border-radius:6px}label{display:block;font-size:14px;font-weight:700;margin-bottom:7px}select,input{font:inherit;padding:10px 12px;border:1px solid #a4b7b1;border-radius:4px;background:white;color:#162f36}input{width:100%;margin-top:5px}dt{font-size:13px;color:#546c6b;margin-top:16px}dd{font-size:16px;margin:2px 0}figure{margin:0;align-self:center}svg{width:100%;height:auto}figcaption{font-size:12px;color:#576b70}details>summary{cursor:pointer}details p{font-size:14px}table{border-collapse:collapse;width:100%;font-size:13px}th{text-align:left;font-size:11px;letter-spacing:.09em;text-transform:uppercase;background:#e8ede8;padding:12px}td{vertical-align:top;padding:14px 12px;border-bottom:1px solid #d9e1db}td:first-child{max-width:460px;overflow-wrap:anywhere}td:nth-child(2){max-width:150px}td:nth-child(3){max-width:280px}.table-wrap{overflow:auto;margin:20px 0}td small{display:block;color:#54696d}.contribute a{display:block;margin-top:20px;font-size:14px}.error{color:#993921}.good{color:#22654d}.muted{color:#596e72}footer{max-width:1180px;margin:auto;padding:30px 32px 60px;font-size:13px;color:#576b70}a:focus-visible,button:focus-visible,input:focus-visible,select:focus-visible,summary:focus-visible{outline:3px solid #bd8531;outline-offset:4px}@media(max-width:720px){header{align-items:start;padding:20px;flex-direction:column;gap:14px}nav{gap:22px}main{padding:0 20px}section{padding:44px 0}.hero{padding-top:42px}.section-heading{display:block}.cards{grid-template-columns:1fr}.cards article{padding:20px}.count{font-size:34px}.explorer{grid-template-columns:1fr;padding:20px;gap:24px}.boundary{font-size:13px}.contribute{gap:12px}footer{padding:26px 20px}} diff --git a/tests/test_public_intake.py b/tests/test_public_intake.py new file mode 100644 index 000000000..62270eb32 --- /dev/null +++ b/tests/test_public_intake.py @@ -0,0 +1,369 @@ +"""Negative controls for the trusted public contribution boundary; no network.""" +import base64 +import copy +import hashlib +import importlib.util +import json +import contextlib +import io +import os +import tempfile +from unittest import mock +from pathlib import Path +import unittest + +spec = importlib.util.spec_from_file_location('intake', Path(__file__).resolve().parents[1] / 'tools/public_intake_check.py') +intake = importlib.util.module_from_spec(spec) +spec.loader.exec_module(intake) + +REPO = 'd6g8k5htny-coder/main' +HEAD = 'a' * 40 +BASE = 'b' * 40 +SOURCE = 'c' * 40 + + +def sha(raw): + return hashlib.sha256(raw).hexdigest() + + +def blob(raw): + return hashlib.sha1(b'blob ' + str(len(raw)).encode() + b'\0' + raw).hexdigest() + + +class FakeAPI: + def __init__(self): + self.routes = {} + self.calls = [] + + def get(self, route): + self.calls.append(route) + if route not in self.routes: + raise AssertionError('Unexpected API request: ' + route) + result = self.routes[route] + if isinstance(result, Exception): + raise result + return copy.deepcopy(result) + + +class IntakeTests(unittest.TestCase): + def setUp(self): + self.api = FakeAPI() + self.pr = {'number': 7, 'state': 'open', 'changed_files': 3, + 'head': {'sha': HEAD, 'repo': {'full_name': 'visitor/main'}}, + 'base': {'sha': BASE, 'ref': 'main', 'repo': {'full_name': REPO}}, + 'labels': []} + self.event = {'number': 7, 'repository': {'full_name': REPO}, + 'pull_request': copy.deepcopy(self.pr)} + self.package = 'incoming/example/' + self.raw = {'RESULT.md': b'# Result\nIllustration only; scientific effect NONE.\n', + 'output.json': b'{"illustration":true}\n'} + self.source = b'public source numbers\n' + self.manifest = {'schema': 1, 'scientific_effect': 'NONE', 'review_status': 'REVIEW_REQUIRED', + 'sources': [{'repository': 'd6g8k5htny-coder/Math-', 'path': 'coefficients/example.json', + 'commit': SOURCE, 'sha256': sha(self.source)}], + 'artifacts': []} + self.save() + + def save(self): + self.manifest['artifacts'] = [{'path': name, 'bytes': len(raw), 'sha256': sha(raw)} for name, raw in self.raw.items()] + self.files = dict(self.raw, **{'IDENTITY.json': json.dumps(self.manifest).encode()}) + self.install() + + def install(self): + entries = [] + changes = [] + for name, raw in self.files.items(): + path = self.package + name + entries.append({'path': path, 'type': 'blob', 'mode': '100644', 'sha': blob(raw), 'size': len(raw)}) + changes.append({'filename': path, 'status': 'added', 'sha': blob(raw)}) + self.api.routes[f'/repos/{REPO}/git/blobs/{blob(raw)}'] = {'encoding': 'base64', 'content': base64.b64encode(raw).decode(), 'size': len(raw), 'sha': blob(raw)} + self.pr['changed_files'] = len(changes) + self.api.routes[f'/repos/{REPO}/pulls/7'] = self.pr + self.api.routes[f'/repos/{REPO}/pulls/7/files?per_page=100&page=1'] = changes + self.api.routes[f'/repos/{REPO}/git/trees/{HEAD}?recursive=1'] = {'truncated': False, 'tree': entries} + self.api.routes[f'/repos/{REPO}/git/trees/{BASE}?recursive=1'] = {'truncated': False, 'tree': []} + sr = self.manifest['sources'][0] + source_repo = sr['repository'] + self.api.routes[f'/repos/{source_repo}'] = {'private': False, 'full_name': source_repo} + self.api.routes[f'/repos/{source_repo}/git/commits/{sr["commit"]}'] = {'sha': sr['commit']} + self.api.routes[f'/repos/{source_repo}/git/trees/{sr["commit"]}?recursive=1'] = {'truncated': False, 'tree': [ + {'path': sr['path'], 'mode': '100644', 'type': 'blob', 'size': len(self.source), 'sha': blob(self.source)}]} + self.api.routes[f'/repos/{source_repo}/git/blobs/{blob(self.source)}'] = { + 'encoding': 'base64', 'size': len(self.source), 'content': base64.b64encode(self.source).decode(), 'sha': blob(self.source)} + self.api.routes[f'/repos/{source_repo}/contents/{sr["path"]}?ref={sr["commit"]}'] = { + 'type': 'file', 'encoding': 'base64', 'size': len(self.source), 'content': base64.b64encode(self.source).decode(), 'sha': blob(self.source)} + + def run_check(self): + return intake.check(self.event, self.api, REPO) + + def reject(self, message): + with self.assertRaisesRegex((ValueError, OSError), message): + self.run_check() + + def test_valid_fork_without_label_is_restricted_and_verified(self): + result = self.run_check() + self.assertEqual(result['lane'], 'incoming') + self.assertEqual(result['scientific_effect'], 'NONE') + self.assertEqual(result['verified_sources'], 1) + self.assertEqual(result['head'], HEAD) + + def test_ordinary_same_repo_engineering_is_allowed(self): + self.pr['head']['repo']['full_name'] = REPO + self.api.routes[f'/repos/{REPO}/pulls/7/files?per_page=100&page=1'] = [ + {'filename': name, 'status': 'modified', 'sha': 'd' * 40} + for name in ['.github/workflows/check.yml', 'tools/check.py', 'docs/theorem α.md']] + self.assertEqual(self.run_check()['lane'], 'maintainer-engineering') + self.assertEqual(len(self.api.calls), 3) + + def test_label_removal_does_not_bypass_same_repo_incoming(self): + self.pr['head']['repo']['full_name'] = REPO + self.raw['STATUS.md'] = b'ACCEPT\n' + self.save() + self.reject('protected') + + def test_label_alone_restricts_engineering_edits(self): + self.pr['head']['repo']['full_name'] = REPO + self.pr['labels'] = [{'name': 'results-for-review'}] + self.api.routes[f'/repos/{REPO}/pulls/7/files?per_page=100&page=1'][0]['filename'] = 'README.md' + self.reject('incoming-only') + + def test_fork_cannot_modify_guard_without_label(self): + self.api.routes[f'/repos/{REPO}/pulls/7/files?per_page=100&page=1'][0]['filename'] = 'tools/public_intake_check.py' + self.reject('incoming-only') + + def test_protected_status_and_claim_paths_refused(self): + for name in ['STATUS.md', 'PROOF_INDEX.md', 'LANDING_CLAIMS.json', 'claims/graph.json']: + with self.subTest(name=name): + old = self.raw.copy() + self.raw[name] = b'changed' + self.save() + self.reject('protected') + self.raw = old + + def test_rename_from_status_cannot_hide_as_incoming(self): + change = self.api.routes[f'/repos/{REPO}/pulls/7/files?per_page=100&page=1'][0] + change.update(status='renamed', previous_filename='STATUS.md') + self.reject('add-only') + + def test_existing_package_is_immutable(self): + self.api.routes[f'/repos/{REPO}/git/trees/{BASE}?recursive=1']['tree'] = [ + {'path': self.package + 'old.txt', 'mode': '100644', 'type': 'blob', 'sha': 'd'*40}] + self.reject('new package') + + def test_symlink_and_executable_and_submodule_refused(self): + entry = self.api.routes[f'/repos/{REPO}/git/trees/{HEAD}?recursive=1']['tree'][0] + for mode, kind in [('120000', 'blob'), ('100755', 'blob'), ('160000', 'commit')]: + with self.subTest(mode=mode): + entry.update(mode=mode, type=kind) + self.reject('regular non-executable') + + def test_truncated_tree_and_file_listing_refused(self): + self.api.routes[f'/repos/{REPO}/git/trees/{HEAD}?recursive=1']['truncated'] = True + self.reject('truncated') + self.api.routes[f'/repos/{REPO}/git/trees/{HEAD}?recursive=1']['truncated'] = False + self.pr['changed_files'] += 1 + self.reject('incomplete') + + def test_missing_or_false_digest_refused(self): + for digest in ['0'*64, None]: + with self.subTest(digest=digest): + self.manifest['artifacts'][0]['sha256'] = digest + self.files['IDENTITY.json'] = json.dumps(self.manifest).encode() + self.install() + self.reject('artifact') + + def test_unlisted_artifact_and_duplicate_manifest_key_refused(self): + self.files['hidden.txt'] = b'not listed' + self.install() + self.reject('exactly cover') + self.files.pop('hidden.txt') + self.files['IDENTITY.json'] = b'{"schema":1,"schema":1}' + self.install() + self.reject('duplicate') + + def test_source_pin_and_public_bytes_verified(self): + self.source = b'changed source' + self.install() + self.reject('source digest') + + def test_private_and_foreign_sources_refused(self): + self.api.routes['/repos/d6g8k5htny-coder/Math-']['private'] = True + self.reject('public') + self.manifest['sources'][0]['repository'] = 'stranger/repo' + self.save() + self.reject('source repository') + + def test_missing_head_and_stale_head_fail_closed(self): + self.pr['head']['repo'] = None + self.reject('head repository') + self.pr['head']['repo'] = {'full_name': 'visitor/main'} + self.pr['head']['sha'] = 'd' * 40 + self.reject('head changed') + + def test_bool_is_not_size_or_schema(self): + self.manifest['artifacts'][0]['bytes'] = True + self.files['IDENTITY.json'] = json.dumps(self.manifest).encode() + self.install() + self.reject('artifact') + + def test_path_escape_and_active_content_refused(self): + for name in ['../evil.txt', 'nested/../../evil.txt', 'plot.svg', 'run.py', 'notebook.ipynb', '.env', 'page.html']: + with self.subTest(name=name): + old = self.raw.copy() + self.raw[name] = b'payload' + self.save() + self.reject('path|extension') + self.raw = old + + def test_known_secret_refused_without_printing_value(self): + self.raw['output.json'] = ('{"token":"' + 'ghp_' + 'X'*36 + '"}').encode() + self.save() + self.reject('possible credential') + + def test_false_scientific_status_refused(self): + self.manifest['scientific_effect'] = 'ACCEPT' + self.save() + self.reject('review-only') + + def test_api_failure_cannot_be_passed(self): + self.api.routes[f'/repos/{REPO}/pulls/7/files?per_page=100&page=1'] = OSError('unavailable') + self.reject('unavailable') + + + def test_source_commit_must_resolve_to_exact_commit(self): + self.api.routes[f'/repos/d6g8k5htny-coder/Math-/git/commits/{SOURCE}'] = {'sha': 'd'*40} + self.reject('exact commit') + + def test_blob_sha_tampering_refused(self): + path = f'/repos/{REPO}/git/blobs/{blob(self.files["RESULT.md"])}' + self.api.routes[path]['content'] = base64.b64encode(b'X' * len(self.files['RESULT.md'])).decode() + self.reject('Git blob identity') + + def test_digest_must_be_sha256_and_commit_must_be_40_hex(self): + self.manifest['sources'][0]['commit'] = 'main' + self.save() + self.reject('full SHA') + + def test_size_limits_apply_before_blob_fetch(self): + self.api.routes[f'/repos/{REPO}/git/trees/{HEAD}?recursive=1']['tree'][0]['size'] = 262145 + self.reject('size limit') + self.assertFalse(any('/git/blobs/' in path for path in self.api.calls)) + + def test_second_package_refused(self): + self.api.routes[f'/repos/{REPO}/pulls/7/files?per_page=100&page=1'][0]['filename'] = 'incoming/other/RESULT.md' + self.reject('one package') + + def test_nonfinite_and_invalid_utf8_json_refused(self): + for data in [b'{"x": NaN}', b'\xff']: + with self.subTest(data=data): + self.raw['output.json'] = data + self.save() + self.reject('nonfinite|decode') + + def test_invalid_png_refused_without_decoding_image(self): + self.raw['plot.png'] = b'not a png' + self.save() + self.reject('PNG signature') + + def test_renamed_out_of_incoming_still_routes_to_intake(self): + self.pr['head']['repo']['full_name'] = REPO + rows = self.api.routes[f'/repos/{REPO}/pulls/7/files?per_page=100&page=1'] + rows[0].update(filename='docs/result.md', previous_filename='incoming/old/RESULT.md', status='renamed') + self.reject('incoming-only') + + def test_deleted_or_modified_intake_refused(self): + row = self.api.routes[f'/repos/{REPO}/pulls/7/files?per_page=100&page=1'][0] + for status in ['removed', 'modified', 'copied']: + with self.subTest(status=status): + row['status'] = status + self.reject('add-only') + + def test_complete_pagination_before_maintainer_bypass(self): + self.pr['head']['repo']['full_name'] = REPO + self.pr['changed_files'] = 101 + rows = [{'filename': f'docs/item{i}.md', 'status': 'added'} for i in range(101)] + self.api.routes[f'/repos/{REPO}/pulls/7/files?per_page=100&page=1'] = rows[:100] + self.api.routes[f'/repos/{REPO}/pulls/7/files?per_page=100&page=2'] = rows[100:] + self.assertEqual(self.run_check()['lane'], 'maintainer-engineering') + self.assertTrue(any('page=2' in route for route in self.api.calls)) + self.api.routes[f'/repos/{REPO}/pulls/7/files?per_page=100&page=2'] = [{'filename': 'incoming/hidden/result.md', 'status': 'added'}] + self.reject('too many package files') + + def test_pr_race_fails_at_final_readback(self): + original_get = self.api.get + reads = 0 + def changing_get(route): + nonlocal reads + result = original_get(route) + if route == f'/repos/{REPO}/pulls/7': + reads += 1 + if reads == 2: + result['head']['sha'] = 'e' * 40 + return result + self.api.get = changing_get + self.reject('changed during verification') + + def test_non_open_pr_and_wrong_base_are_refused(self): + self.pr['state'] = 'closed' + self.reject('not open') + self.pr['state'] = 'open' + self.pr['base']['ref'] = 'other' + self.reject('targets main') + + def test_cli_pass_and_failure_are_distinct_without_network(self): + with tempfile.TemporaryDirectory() as folder: + event_file = Path(folder) / 'event.json' + event_file.write_text(json.dumps(self.event)) + env = {'GITHUB_EVENT_NAME': 'pull_request_target', 'GITHUB_REPOSITORY': REPO, 'GH_TOKEN': 'test-only'} + with mock.patch.dict(os.environ, env), mock.patch.object(intake, 'API', return_value=self.api), contextlib.redirect_stdout(io.StringIO()) as output: + self.assertEqual(intake.main(['--event', str(event_file)]), 0) + self.assertEqual(json.loads(output.getvalue())['lane'], 'incoming') + self.raw['output.json'] = ('{"token":"' + 'ghp_' + 'X'*36 + '"}').encode() + self.save() + output.truncate(0) + output.seek(0) + self.assertEqual(intake.main(['--event', str(event_file)]), 1) + self.assertEqual(json.loads(output.getvalue())['result'], 'REJECTED') + self.assertNotIn('X'*36, output.getvalue()) + + def test_cli_untrusted_event_refused_before_network(self): + with mock.patch.dict(os.environ, {'GITHUB_EVENT_NAME': 'pull_request'}), mock.patch.object(intake, 'API') as api, contextlib.redirect_stdout(io.StringIO()): + self.assertEqual(intake.main([]), 1) + api.assert_not_called() + + def test_transport_does_not_follow_redirects(self): + with self.assertRaisesRegex(ValueError, 'redirects refused'): + intake.NoRedirect().redirect_request(None, None, 302, '', {}, 'https://example.invalid/token') + + def test_source_symlink_refused_despite_file_like_contents_response(self): + # GitHub's contents endpoint follows this link and reports the target as + # type=file. The immutable tree still names a mode120000 symlink blob. + route = f'/repos/d6g8k5htny-coder/Math-/git/trees/{SOURCE}?recursive=1' + entry = self.api.routes[route]['tree'][0] + entry.update(mode='120000', sha=blob(b'target.json'), size=11) + self.reject('regular non-executable public file') + self.assertFalse(any('/contents/' in path for path in self.api.calls)) + + def test_source_tree_and_blob_sha_must_match(self): + route = f'/repos/d6g8k5htny-coder/Math-/git/trees/{SOURCE}?recursive=1' + self.api.routes[route]['tree'][0]['sha'] = 'd'*40 + self.api.routes['/repos/d6g8k5htny-coder/Math-/git/blobs/' + 'd'*40] = { + 'encoding': 'base64', 'size': len(self.source), 'content': base64.b64encode(self.source).decode(), 'sha': blob(self.source)} + self.reject('Git blob identity mismatch') + + def test_known_credential_in_package_path_is_refused_without_logging(self): + token = 'sk-' + 'a' * 40 + self.package = 'incoming/' + token + '/' + self.save() + with tempfile.TemporaryDirectory() as folder: + event_file = Path(folder) / 'event.json' + event_file.write_text(json.dumps(self.event)) + env = {'GITHUB_EVENT_NAME': 'pull_request_target', 'GITHUB_REPOSITORY': REPO, 'GH_TOKEN': 'test-only'} + with mock.patch.dict(os.environ, env), mock.patch.object(intake, 'API', return_value=self.api), contextlib.redirect_stdout(io.StringIO()) as output: + self.assertEqual(intake.main(['--event', str(event_file)]), 1) + self.assertIn('possible credential in path', output.getvalue()) + self.assertNotIn(token, output.getvalue()) + + +if __name__ == '__main__': + unittest.main() diff --git a/tests/test_public_shop_app.mjs b/tests/test_public_shop_app.mjs new file mode 100644 index 000000000..96ca1a7fb --- /dev/null +++ b/tests/test_public_shop_app.mjs @@ -0,0 +1,48 @@ +import assert from 'node:assert/strict'; +import fs from 'node:fs'; +import path from 'node:path'; +// Minimal DOM observation harness: exercises loading/search/selection/currency. +// This is not a browser layout or accessibility test. +class Element { + constructor(tag){this.tag=tag;this.children=[];this.attributes={};this.listeners={};this.value='';this.hidden=false;this.disabled=false;this._text='';} + set textContent(t){this._text=String(t);this.children=[];} get textContent(){return this._text+this.children.map(x=>typeof x==='string'?x:x.textContent).join('');} + append(...children){this.children.push(...children);}replaceChildren(...c){this.children=c;this._text='';} + setAttribute(k,v){this.attributes[k]=v;}addEventListener(k,f){this.listeners[k]=f;} +} +const nodes=new Map(); +globalThis.document={getElementById:id=>{if(!nodes.has(id))nodes.set(id,new Element(id));return nodes.get(id);},createElement:tag=>new Element(tag),createElementNS:(_,tag)=>new Element(tag),createTextNode:t=>({textContent:t})}; +document.getElementById('dimension').value='2'; +const root=path.resolve(import.meta.dirname,'..'); +const fixture=process.env.SHOP_MATH_FIXTURE; +assert.ok(fixture,'Set SHOP_MATH_FIXTURE to exact public Math fixture directory'); +const qfixture=process.env.SHOP_QUERY_FIXTURE; +assert.ok(qfixture,'Set SHOP_QUERY_FIXTURE to exact query fixture directory'); +const config=JSON.parse(fs.readFileSync(path.join(root,'docs/site/config.json'))); +const mapping=new Map([ + ['config.json',path.join(root,'docs/site/config.json')],['status.json',path.join(root,'docs/site/status.json')], + [config.status.url,path.join(root,'STATUS.md')], + [config.coefficient.url,path.join(fixture,config.coefficient.path)], + [config.imports.url,path.join(fixture,config.imports.path)], + [config.query.url,path.join(qfixture,config.query.path)], + [config.inventory.url,path.join(root,'docs/public-math/sources.json')], + ...config.inventory.pages.map(p=>[p.url,path.join(root,p.path)]) +]); +let requested=[]; +globalThis.fetch=async(url,options={})=>{requested.push(String(url));assert.equal(options.credentials,'omit'); + if(String(url).startsWith('https://api.github.com/'))return Response.json({ref:'refs/heads/main',object:{sha:config.query.math_pin}}); + assert.ok(mapping.has(String(url)),`Unexpected request ${url}`);return new Response(fs.readFileSync(mapping.get(String(url))));}; +await import('../docs/site/app.js'); +assert.equal(document.getElementById('counts').children.length,3); +assert.match(document.getElementById('inventory-state').textContent,/2,138 matches/); +assert.equal(document.getElementById('catalog').children.length,50); +assert.equal(document.getElementById('lower').textContent,'0.07340691930603427103'); +document.getElementById('dimension').value='3';document.getElementById('dimension').listeners.change(); +assert.equal(document.getElementById('lower').textContent,'0.04177593184059834334'); +document.getElementById('search').value='EC-014';document.getElementById('search').listeners.input(); +assert.ok(document.getElementById('catalog').children.length>0); +assert.ok(document.getElementById('catalog').children.every(row=>row.textContent.toLowerCase().includes('ec-014'))); +await document.getElementById('check-tip').listeners.click(); +assert.match(document.getElementById('tip-result').textContent,/Commit pin current/); +assert.match(document.getElementById('tip-result').textContent,/Gate-byte equality was not tested/); +assert.ok(!requested.some(url=>/sandbox|Drive|google-drive/i.test(url))); +console.log('Public shop interaction harness passed: 2138 rows, exact decimals, search, selection, read-only pin currency.'); diff --git a/tests/test_public_shop_data.py b/tests/test_public_shop_data.py new file mode 100644 index 000000000..291b7e462 --- /dev/null +++ b/tests/test_public_shop_data.py @@ -0,0 +1,90 @@ +import importlib.util +import json +from pathlib import Path +import unittest + +ROOT = Path(__file__).resolve().parents[1] +SPEC = importlib.util.spec_from_file_location('public_shop_data', ROOT / 'tools/public_shop_data.py') +shop = importlib.util.module_from_spec(SPEC) +SPEC.loader.exec_module(shop) + + +class PublicShopDataTests(unittest.TestCase): + def setUp(self): + self.status = (ROOT / 'STATUS.md').read_bytes() + + def test_pinned_status_counts_and_verbatim_scope(self): + result = shop.parse_status(self.status) + self.assertEqual(result['counts'], {'accept': 4, 'amend': 3, 'engineering': 3}) + self.assertIn('No numerical remainder constant or numerical lifetime cutoff', result['sections'][0]['rows'][0][3]) + self.assertEqual(result['source']['sha256'], shop.STATUS['sha256']) + self.assertFalse(result['scientific_status_authority']) + + def test_changed_source_bytes_refused_before_parsing(self): + with self.assertRaisesRegex(ValueError, 'identity mismatch'): + shop.parse_status(self.status.replace(b'AMEND', b'ACCEPT', 1)) + + def test_unknown_heading_refused_even_with_matching_identity(self): + changed = self.status + b'\n## APPROVED\n\n| Name |\n|---|\n| X |\n' + with self.assertRaisesRegex(ValueError, 'unknown heading'): + shop.parse_status(changed, shop.identity_for(changed, shop.STATUS)) + + def test_changed_table_schema_refused(self): + changed = self.status.replace(b'| Explicit limits |', b'| New verdict |') + with self.assertRaisesRegex(ValueError, 'table header'): + shop.parse_status(changed, shop.identity_for(changed, shop.STATUS)) + + def test_missing_status_section_refused(self): + changed = self.status.replace(b'## AMEND / open', b'## AMEND moved') + with self.assertRaisesRegex(ValueError, 'unknown heading'): + shop.parse_status(changed, shop.identity_for(changed, shop.STATUS)) + + def test_extra_table_cell_refused(self): + changed = self.status.replace(b'| **D2 ', b'| extra | **D2 ', 1) + with self.assertRaisesRegex(ValueError, 'table row width'): + shop.parse_status(changed, shop.identity_for(changed, shop.STATUS)) + + def test_coefficient_endpoints_stay_exact_strings(self): + raw = json.dumps(shop.COEFFICIENT_EXPECTED).encode() + data = shop.parse_coefficient(raw, shop.identity_for(raw, shop.COEFFICIENT)) + self.assertEqual(data['dimensions']['2']['lower'], '0.07340691930603427103') + self.assertEqual(data['dimensions']['2']['upper'], '0.07340691930603427104') + self.assertFalse(data['scientific_acceptance']) + + def test_coefficient_float_or_added_dimension_refused(self): + for mutation in ('float', 'dimension', 'acceptance'): + data = json.loads(json.dumps(shop.COEFFICIENT_EXPECTED)) + if mutation == 'float': + data['dimensions']['2']['lower'] = 0.07340691930603427 + elif mutation == 'dimension': + data['dimensions']['4'] = data['dimensions']['3'] + else: + data['scientific_acceptance'] = True + raw = json.dumps(data).encode() + with self.subTest(mutation=mutation), self.assertRaisesRegex(ValueError, 'coefficient schema'): + shop.parse_coefficient(raw, shop.identity_for(raw, shop.COEFFICIENT)) + + def test_changed_inventory_manifest_refused(self): + raw = (ROOT / 'docs/public-math/sources.json').read_bytes() + b' ' + with self.assertRaisesRegex(ValueError, 'identity mismatch'): + shop.verify_bytes(raw, shop.INVENTORY) + + def test_inventory_uses_original_shards_and_detects_tampering(self): + index, pages = shop.inventory_config(lambda path: (ROOT / path).read_bytes()) + self.assertEqual(sum(p['count'] for p in pages), 2138) + self.assertEqual(len(pages), 14) + self.assertEqual(index['path'], 'docs/public-math/sources.json') + def damaged(path): + raw = (ROOT / path).read_bytes() + return raw + b' ' if path.endswith('sources-01.json') else raw + with self.assertRaisesRegex(ValueError, 'shard identity mismatch'): + shop.inventory_config(damaged) + + def test_raw_urls_are_commit_pinned(self): + for source in (shop.STATUS, shop.COEFFICIENT, shop.PROOF, shop.INVENTORY, shop.IMPORTS): + self.assertIn('/' + source['commit'] + '/', shop.with_url(source)['url']) + self.assertEqual(len(source['commit']), 40) + + +if __name__ == '__main__': + unittest.main() diff --git a/tests/test_public_shop_frontend.mjs b/tests/test_public_shop_frontend.mjs new file mode 100644 index 000000000..67dbf5149 --- /dev/null +++ b/tests/test_public_shop_frontend.mjs @@ -0,0 +1,34 @@ +import test from 'node:test'; +import assert from 'node:assert/strict'; +import fs from 'node:fs'; +import {createHash} from 'node:crypto'; +import {verifiedBytes,verifiedJSON,validateStatus,validateCoefficient,safeSourceURL} from '../docs/site/core.mjs'; +const bytes=new TextEncoder().encode('{"value":"0.04177593184059834334"}'); +const pin={url:'status.json',bytes:bytes.length,sha256:createHash('sha256').update(bytes).digest('hex')}; +const fetcher=async()=>new Response(bytes); +test('valid source preserves exact strings',async()=>assert.equal((await verifiedJSON(pin,fetcher)).value,'0.04177593184059834334')); +test('digest mismatch refuses data',async()=>assert.rejects(()=>verifiedBytes({...pin,sha256:'0'.repeat(64)},fetcher),/SHA-256/)); +test('byte count mismatch refuses data',async()=>assert.rejects(()=>verifiedBytes({...pin,bytes:pin.bytes+1},fetcher),/byte count/)); +test('mutable branch URL refused before request',async()=>assert.rejects(()=>verifiedBytes({...pin,url:'https://raw.githubusercontent.com/d6g8k5htny-coder/main/main/STATUS.md'},()=>{throw Error('must not fetch');}),/pinned public/)); +test('HTTP failure gives no data',async()=>assert.rejects(()=>verifiedBytes(pin,async()=>new Response('',{status:404})),/unavailable/)); +const status=JSON.parse(fs.readFileSync(new URL('../docs/site/status.json',import.meta.url))); +test('status snapshot counts are selected rows',()=>assert.deepEqual(validateStatus(status).counts,{accept:4,amend:3,engineering:3})); +test('unknown category refused',()=>{const s=structuredClone(status);s.sections[0].key='proved';assert.throws(()=>validateStatus(s),/Unrecognized/);}); +test('changed count refused',()=>{const s=structuredClone(status);s.counts.accept=5;assert.throws(()=>validateStatus(s),/count/);}); +test('promotion authority refused',()=>assert.throws(()=>validateStatus({...status,scientific_status_authority:true}),/Invalid/)); +const coefficient={object:'SIDE24-COEFFICIENT-D23-20260924-v1',scientific_acceptance:false,dimensions:{'2':{lower:'0.07340691930603427103',upper:'0.07340691930603427104'},'3':{lower:'0.04177593184059834334',upper:'0.04177593184059834335'}}}; +test('coefficient endpoints remain distinct exactly',()=>{const d=validateCoefficient(coefficient).dimensions['2'];assert.notEqual(d.lower,d.upper);assert.equal(Number(d.lower),Number(d.upper));}); +test('float endpoints refused',()=>{const d=structuredClone(coefficient);d.dimensions['2'].lower=Number(d.dimensions['2'].lower);assert.throws(()=>validateCoefficient(d));}); +test('coefficient acceptance flag cannot be flipped',()=>assert.throws(()=>validateCoefficient({...coefficient,scientific_acceptance:true}))); +const row={repository:'Math-',commit:'a'.repeat(40),path:'proofs/a proof.md',sha256:'b'.repeat(64)}; +test('catalog points at immutable public paths',()=>assert.ok(safeSourceURL(row).endsWith('/proofs/a%20proof.md'))); +test('catalog rejects private repo and traversal',()=>{assert.throws(()=>safeSourceURL({...row,repository:'sandbox'}));assert.throws(()=>safeSourceURL({...row,path:'../STATUS.md'}));}); + +test('correct bytes cannot be attributed to a different commit',async()=>{ + const full={...pin,repository:'d6g8k5htny-coder/main',commit:'a'.repeat(40),path:'STATUS.md',url:'https://raw.githubusercontent.com/d6g8k5htny-coder/main/'+ 'b'.repeat(40)+'/STATUS.md'}; + await assert.rejects(()=>verifiedBytes(full,fetcher),/Displayed identity/); +}); +test('correct bytes cannot be attributed to a different path',async()=>{ + const full={...pin,repository:'d6g8k5htny-coder/main',commit:'a'.repeat(40),path:'STATUS.md',url:'https://raw.githubusercontent.com/d6g8k5htny-coder/main/'+ 'a'.repeat(40)+'/README.md'}; + await assert.rejects(()=>verifiedBytes(full,fetcher),/Displayed identity/); +}); diff --git a/tools/public_intake_check.py b/tools/public_intake_check.py new file mode 100644 index 000000000..100efb345 --- /dev/null +++ b/tools/public_intake_check.py @@ -0,0 +1,296 @@ +"""Read-only PR intake boundary. Run only this trusted default-branch code in CI. + +No submitted file is checked out, imported, rendered, or executed. The limited +credential-pattern scan is not a guarantee that a submission contains no secret. +A pass means packaging checks passed; scientific effect remains NONE. +""" +from __future__ import annotations + +import argparse +import base64 +import hashlib +import json +import os +from pathlib import Path, PurePosixPath +import re +import urllib.request + +MAX_FILES = 500 # Below the API's 3000-file ceiling; pagination is mandatory. +MAX_PACKAGE_FILES = 50 +MAX_FILE_BYTES = 262144 +MAX_PACKAGE_BYTES = 2097152 +MAX_RESPONSE_BYTES = 8388608 +SOURCE_REPOS = {'main', 'Math-', 'query-', 'Universal-Law-Workspace'} +TEXT_SUFFIXES = {'.md', '.txt', '.json', '.csv'} +HEX40 = re.compile(r'[0-9a-f]{40}\Z') +HEX64 = re.compile(r'[0-9a-f]{64}\Z') +REPOSITORY = re.compile(r'[A-Za-z0-9_.-]+/[A-Za-z0-9_.-]+\Z') +SAFE_PATH = re.compile(r'[A-Za-z0-9_][A-Za-z0-9_. /-]*\Z') +CREDENTIALS = [ + re.compile(rb'-----BEGIN (?:RSA |EC |OPENSSH |DSA )?PRIVATE KEY-----'), + re.compile(rb'\bgh[pousr]_[A-Za-z0-9]{36,}\b'), + re.compile(rb'\bgithub_pat_[A-Za-z0-9_]{60,}\b'), + re.compile(rb'\b(?:AKIA|ASIA)[A-Z0-9]{16}\b'), + re.compile(rb'\bxox[baprs]-[A-Za-z0-9-]{10,}\b'), + re.compile(rb'\bsk-(?:proj-)?[A-Za-z0-9_-]{32,}\b'), +] + + +def require(condition, message): + if not condition: + raise ValueError(message) + + +def unique(pairs): + result = {} + for key, value in pairs: + require(key not in result, 'duplicate JSON key') + result[key] = value + return result + + +def strict_json(raw): + def bad_constant(_): + raise ValueError('nonfinite JSON value') + return json.loads(raw, object_pairs_hook=unique, parse_constant=bad_constant) + + +def safe_path(path): + require(isinstance(path, str) and SAFE_PATH.fullmatch(path), 'unsafe path') + parts = path.split('/') + require(all(p not in ('', '.', '..') and not p.startswith('.') for p in parts), 'unsafe path') + require(str(PurePosixPath(path)) == path, 'noncanonical path') + return parts + + +def integer(value, low, high, message): + require(type(value) is int and low <= value <= high, message) + return value + + +def sha40(value, message): + require(isinstance(value, str) and HEX40.fullmatch(value) and value != '0'*40, message) + return value + + +def sha256(value, message): + require(isinstance(value, str) and HEX64.fullmatch(value), message) + return value + + +class NoRedirect(urllib.request.HTTPRedirectHandler): + def redirect_request(self, req, fp, code, msg, headers, newurl): + raise ValueError('API redirects refused') + + +class API: + def __init__(self, token): + require(bool(token), 'read-only GitHub token missing') + self.token = token + self.opener = urllib.request.build_opener(NoRedirect()) + + def get(self, route): + require(route.startswith('/repos/') and '\n' not in route and '\r' not in route, 'invalid API route') + request = urllib.request.Request('https://api.github.com' + route, headers={ + 'Authorization': 'Bearer ' + self.token, 'Accept': 'application/vnd.github+json', + 'X-GitHub-Api-Version': '2022-11-28', 'User-Agent': 'public-intake-read-only'}) + with self.opener.open(request, timeout=30) as response: + raw = response.read(MAX_RESPONSE_BYTES + 1) + require(len(raw) <= MAX_RESPONSE_BYTES, 'API response exceeds safe limit') + return strict_json(raw) + + +def unpack_blob(data, max_size, expected_sha=None): + require(isinstance(data, dict) and data.get('encoding') == 'base64', 'blob encoding unavailable') + size = integer(data.get('size'), 0, max_size, 'blob exceeds size limit') + require(isinstance(data.get('content'), str), 'blob content missing') + raw = base64.b64decode(''.join(data['content'].split()), validate=True) + require(len(raw) == size, 'blob size mismatch') + identity = hashlib.sha1(b'blob ' + str(size).encode('ascii') + b'\0' + raw).hexdigest() + require(data.get('sha') == identity and (expected_sha is None or identity == expected_sha), 'Git blob identity mismatch') + return raw + + +def tree(api, repo, ref): + data = api.get(f'/repos/{repo}/git/trees/{ref}?recursive=1') + require(isinstance(data, dict) and data.get('truncated') is False and isinstance(data.get('tree'), list), + 'tree unavailable or truncated') + rows = {} + for row in data['tree']: + require(isinstance(row, dict) and isinstance(row.get('path'), str) and row['path'] not in rows, 'invalid tree entries') + rows[row['path']] = row + return rows + + +def snapshot(pr, repo): + require(isinstance(pr, dict) and pr.get('state') == 'open', 'PR is not open') + base, head = pr.get('base'), pr.get('head') + require(isinstance(base, dict) and isinstance(base.get('repo'), dict) and base['repo'].get('full_name') == repo, + 'base repository mismatch') + require(base.get('ref') == 'main', 'this intake lane targets main only') + require(isinstance(head, dict) and isinstance(head.get('repo'), dict), 'head repository missing') + head_repo = head['repo'].get('full_name') + require(isinstance(head_repo, str) and REPOSITORY.fullmatch(head_repo), 'invalid head repository') + labels = pr.get('labels') + require(isinstance(labels, list) and all(isinstance(x, dict) and isinstance(x.get('name'), str) for x in labels), 'labels unavailable') + return (sha40(head.get('sha'), 'invalid head SHA'), sha40(base.get('sha'), 'invalid base SHA'), + head_repo, tuple(sorted(x['name'] for x in labels)), integer(pr.get('changed_files'), 1, MAX_FILES, 'unsupported changed file count')) + + +def changes(api, repo, number, count): + rows = [] + for page in range(1, (count + 99)//100 + 1): + batch = api.get(f'/repos/{repo}/pulls/{number}/files?per_page=100&page={page}') + require(isinstance(batch, list), 'file listing unavailable') + rows.extend(batch) + require(len(rows) == count, 'incomplete file listing') + seen = set() + for row in rows: + require(isinstance(row, dict), 'invalid changed file') + path = row.get('filename') + require(isinstance(path, str) and bool(path) and not any(ord(c) < 32 for c in path) + and '\\' not in path and all(p not in ('', '.', '..') for p in path.split('/')), + 'invalid changed path') + require(path not in seen, 'duplicate changed path') + seen.add(path) + if 'previous_filename' in row: + previous = row['previous_filename'] + require(isinstance(previous, str) and bool(previous), 'invalid previous path') + return rows + + +def verify_package(api, repo, head, base, rows): + require(len(rows) <= MAX_PACKAGE_FILES, 'too many package files') + roots = set() + for row in rows: + # Package IDs are reported in the result. Inspect paths as well as blob + # bytes, and never include the rejected value in the error message. + for candidate_path in (row['filename'], row.get('previous_filename', '')): + require(not any(pattern.search(candidate_path.encode('utf-8')) for pattern in CREDENTIALS), + 'possible credential in path; values are not logged') + parts = safe_path(row['filename']) + require(len(parts) >= 3 and parts[0] == 'incoming', 'incoming-only edits required') + require(re.fullmatch(r'[a-z0-9][a-z0-9-]{0,63}', parts[1]), 'invalid package id') + require(row.get('status') == 'added' and 'previous_filename' not in row, 'add-only intake; use a new package id for a successor') + require(not any(p.lower() == 'claims' or p.upper().split('.')[0] in {'STATUS', 'PROOF_INDEX', 'LANDING_CLAIMS'} for p in parts[2:]), 'protected scientific status path') + roots.add('/'.join(parts[:2]) + '/') + require(len(roots) == 1, 'one package per PR') + prefix = roots.pop() + old_tree = tree(api, repo, base) + require(not any(p == prefix[:-1] or p.startswith(prefix) for p in old_tree), 'use a new package id; landed intake is immutable') + new_tree = tree(api, repo, head) + package_entries = {p: row for p, row in new_tree.items() if p.startswith(prefix) and row.get('type') != 'tree'} + require(set(package_entries) == {row['filename'] for row in rows}, 'package tree does not match changed files') + payload = {} + total = 0 + for row in rows: + name = row['filename'] + entry = package_entries[name] + require(entry.get('type') == 'blob' and entry.get('mode') == '100644', 'regular non-executable files only') + identity = sha40(entry.get('sha'), 'invalid blob SHA') + require(identity == row.get('sha'), 'changed file/tree identity mismatch') + integer(entry.get('size'), 0, MAX_FILE_BYTES, 'file exceeds size limit') + suffix = PurePosixPath(name).suffix.lower() + require(suffix in TEXT_SUFFIXES | {'.png'}, 'unsupported file extension') + raw = unpack_blob(api.get(f'/repos/{repo}/git/blobs/{identity}'), MAX_FILE_BYTES, identity) + total += len(raw) + require(total <= MAX_PACKAGE_BYTES, 'package exceeds total size limit') + require(not any(pattern.search(raw) for pattern in CREDENTIALS), 'possible credential detected; values are not logged') + if suffix in TEXT_SUFFIXES: + text = raw.decode('utf-8') + require('\0' not in text, 'NUL byte in text') + if suffix == '.json': + strict_json(text) + else: + require(raw.startswith(b'\x89PNG\r\n\x1a\n'), 'invalid PNG signature') + payload[name[len(prefix):]] = raw + require('RESULT.md' in payload and payload['RESULT.md'].strip() and 'IDENTITY.json' in payload, 'RESULT.md and IDENTITY.json required') + identity = strict_json(payload['IDENTITY.json']) + require(isinstance(identity, dict) and set(identity) == {'schema', 'scientific_effect', 'review_status', 'sources', 'artifacts'}, 'invalid identity schema') + require(type(identity['schema']) is int and identity['schema'] == 1, 'invalid schema version') + require(identity['scientific_effect'] == 'NONE' and identity['review_status'] == 'REVIEW_REQUIRED', 'intake is review-only; no status promotion') + artifacts = identity['artifacts'] + require(isinstance(artifacts, list), 'artifact list required') + seen = set() + for row in artifacts: + require(isinstance(row, dict) and set(row) == {'path', 'bytes', 'sha256'}, 'invalid artifact record') + name = row['path'] + safe_path(name) + require(name not in seen and name != 'IDENTITY.json' and name in payload, 'duplicate or unknown artifact') + seen.add(name) + size = integer(row['bytes'], 0, MAX_FILE_BYTES, 'invalid artifact size') + digest = sha256(row['sha256'], 'invalid artifact digest') + require(size == len(payload[name]) and digest == hashlib.sha256(payload[name]).hexdigest(), 'artifact identity mismatch') + require(seen == set(payload) - {'IDENTITY.json'}, 'manifest must exactly cover every artifact except itself') + sources = identity['sources'] + require(isinstance(sources, list) and 1 <= len(sources) <= 8, 'one to eight pinned sources required') + seen_sources = set() + for row in sources: + require(isinstance(row, dict) and set(row) == {'repository', 'path', 'commit', 'sha256'}, 'invalid source record') + source_repo = row['repository'] + require(isinstance(source_repo, str) and source_repo in {'d6g8k5htny-coder/' + r for r in SOURCE_REPOS}, 'source repository outside public pillars') + path = row['path'] + safe_path(path) + commit = sha40(row['commit'], 'source commit must be a full SHA') + digest = sha256(row['sha256'], 'invalid source digest') + key = (source_repo, commit, path) + require(key not in seen_sources, 'duplicate source') + seen_sources.add(key) + metadata = api.get(f'/repos/{source_repo}') + require(isinstance(metadata, dict) and metadata.get('private') is False and metadata.get('full_name') == source_repo, 'source is not verified public') + commit_record = api.get(f'/repos/{source_repo}/git/commits/{commit}') + require(isinstance(commit_record, dict) and commit_record.get('sha') == commit, 'source is not an exact commit') + # The contents endpoint follows in-repository symlinks. Resolve the + # exact path from the commit tree instead, then read that exact blob. + source_tree = tree(api, source_repo, commit) + source_entry = source_tree.get(path) + require(isinstance(source_entry, dict) and source_entry.get('type') == 'blob' + and source_entry.get('mode') == '100644', 'source must be a regular non-executable public file') + source_sha = sha40(source_entry.get('sha'), 'invalid source blob SHA') + integer(source_entry.get('size'), 0, MAX_PACKAGE_BYTES, 'source exceeds size limit') + raw = unpack_blob(api.get(f'/repos/{source_repo}/git/blobs/{source_sha}'), MAX_PACKAGE_BYTES, source_sha) + require(hashlib.sha256(raw).hexdigest() == digest, 'source digest mismatch') + return {'package': prefix[:-1], 'artifact_files': len(payload)-1, 'verified_sources': len(sources), 'bytes': total} + + +def check(event, api, repository): + require(repository == 'd6g8k5htny-coder/main', 'wrong repository') + require(isinstance(event, dict) and isinstance(event.get('repository'), dict) and event['repository'].get('full_name') == repository, + 'event repository mismatch') + number = integer(event.get('number'), 1, 10000000, 'invalid PR number') + pr = api.get(f'/repos/{repository}/pulls/{number}') + require(pr.get('number') == number, 'PR number mismatch') + original = snapshot(pr, repository) + head, base, head_repo, labels, count = original + event_pr = event.get('pull_request') + require(isinstance(event_pr, dict) and isinstance(event_pr.get('head'), dict) and event_pr['head'].get('sha') == head, + 'head changed since event; rerun latest event') + rows = changes(api, repository, number, count) + intake = head_repo != repository or 'results-for-review' in labels or any( + row['filename'].split('/')[0] == 'incoming' or row.get('previous_filename', '').split('/')[0] == 'incoming' for row in rows) + result = {'head': head, 'base': base, 'scientific_effect': 'NONE', 'lane': 'incoming' if intake else 'maintainer-engineering'} + if intake: + result.update(verify_package(api, repository, head, base, rows)) + require(snapshot(api.get(f'/repos/{repository}/pulls/{number}'), repository) == original, + 'PR changed during verification; rerun latest event') + return result + + +def main(argv=None): + parser = argparse.ArgumentParser(description=__doc__) + parser.add_argument('--event', type=Path, default=Path(os.environ.get('GITHUB_EVENT_PATH', '/nonexistent-event'))) + args = parser.parse_args(argv) + try: + require(os.environ.get('GITHUB_EVENT_NAME') == 'pull_request_target', 'CI requires trusted pull_request_target context') + event = strict_json(args.event.read_bytes()) + result = check(event, API(os.environ.get('GH_TOKEN', '')), os.environ.get('GITHUB_REPOSITORY', '')) + print(json.dumps(result, sort_keys=True)) + return 0 + except (ValueError, OSError, TypeError, KeyError, UnicodeError, RecursionError) as error: + # Never print response bodies, submitted file contents, or credentials. + print(json.dumps({'result': 'REJECTED', 'reason': str(error), 'scientific_effect': 'NONE'})) + return 1 + + +if __name__ == '__main__': + raise SystemExit(main()) diff --git a/tools/public_shop_check.py b/tools/public_shop_check.py new file mode 100644 index 000000000..8a74cc142 --- /dev/null +++ b/tools/public_shop_check.py @@ -0,0 +1,40 @@ +"""Check the static shop against bounded, immutable public input bytes.""" +import hashlib +import json +import os +from pathlib import Path +import subprocess +import tempfile +from urllib.request import urlopen + +ROOT = Path(__file__).resolve().parents[1] + +def main(): + config = json.loads((ROOT / 'docs/site/config.json').read_bytes()) + with tempfile.TemporaryDirectory(prefix='public-shop-') as directory: + fixtures = Path(directory) + for field in ('coefficient', 'proof', 'imports', 'query'): + pin = config[field] + if pin['repository'] not in ('d6g8k5htny-coder/Math-', 'd6g8k5htny-coder/query-'): + raise ValueError('Unexpected public repository') + from urllib.parse import quote + expected = 'https://raw.githubusercontent.com/' + pin['repository'] + '/' + pin['commit'] + '/' + quote(pin['path'], safe='/') + if pin['url'] != expected or len(pin['commit']) != 40: + raise ValueError('Pin URL/identity mismatch') + with urlopen(expected, timeout=30) as response: + raw = response.read(pin['bytes'] + 1) + if len(raw) != pin['bytes'] or hashlib.sha256(raw).hexdigest() != pin['sha256']: + raise ValueError('Public source identity mismatch: ' + field) + destination = fixtures / ('query' if field == 'query' else 'math') / pin['path'] + destination.parent.mkdir(parents=True, exist_ok=True) + destination.write_bytes(raw) + subprocess.run(['python3', '-B', 'tools/public_shop_data.py', '--math-root', str(fixtures/'math'), '--check'], cwd=ROOT, check=True) + env = dict(os.environ, SHOP_MATH_FIXTURE=str(fixtures/'math'), SHOP_QUERY_FIXTURE=str(fixtures/'query')) + subprocess.run(['node', 'tests/test_public_shop_app.mjs'], cwd=ROOT, env=env, check=True) + notebook = json.loads((ROOT/'docs/notebooks/SIDE24_PUBLIC_COEFFICIENTS.ipynb').read_bytes()) + if notebook['nbformat'] != 4 or not notebook['cells']: + raise ValueError('Invalid notebook format') + print('Pinned public sources, static interactions and notebook structure checked. Scientific effect NONE.') + +if __name__ == '__main__': + main() diff --git a/tools/public_shop_data.py b/tools/public_shop_data.py new file mode 100644 index 000000000..c33aa3472 --- /dev/null +++ b/tools/public_shop_data.py @@ -0,0 +1,373 @@ +"""Reproduce read-only public-shop exports from exact public source bytes. + +Run with --main-root for the pinned main checkout and optionally --math-root +for an offline Math checkout. Otherwise only the three pinned Math resources +are fetched. --check compares exports without writing. No scientific register +is changed; snapshot table cells remain verbatim Markdown. +""" +from __future__ import annotations + +import argparse +from decimal import Decimal +import hashlib +import json +from pathlib import Path +import re +import subprocess +from urllib.parse import quote +from urllib.request import urlopen + +MAIN_COMMIT = "a26f744be7597e3f0c0543c34ead23049bbac657" +MATH_COMMIT = "9d7b6802424fb4715b31999066aafca8ee2f3cca" +OWNER = "d6g8k5htny-coder" + + +def source(repo, commit, path, size, blob, digest): + return dict(repository=OWNER + "/" + repo, commit=commit, path=path, + bytes=size, blob=blob, sha256=digest) + + +STATUS = source("main", MAIN_COMMIT, "STATUS.md", 6881, + "52688102260e916dec1a38143186198b089a0261", + "9c3e21144423591a3dbff926858048c0363b9a32d6fe258a1de5088d38096141") +COEFFICIENT = source("Math-", MATH_COMMIT, "coefficients/side24_v1/ENCLOSURE.json", 1090, + "57af39a05e14ed0ba8ebc00a9b4aca4dffb067c7", + "72b6cd92d31394cdaf5da8919a5d548e902228af1f095cc184158a71d8287811") +PROOF = source("Math-", MATH_COMMIT, "coefficients/side24_v1/PROOF.md", 10272, + "44b66f04f89fcd87383b3603fa69f1feb64cdddd", + "c06daccc4ba4b9168522b9888b76a7d599934fc3b91bd753ee5d492262917769") +INVENTORY = source("main", MAIN_COMMIT, "docs/public-math/sources.json", 1863, + "edf9a7088a574134fa982946c9e779476b617e3d", + "78ac59ed59579a1ee7cd0912f52ad702249b6978e836e5bccd90577a02591a52") +IMPORTS = source("Math-", MATH_COMMIT, "imports/hardening_ebedb780/MANIFEST.json", 18262, + "4cc679d65d8af2162fa9915ad7edf35fda16a576", + "fa7f33839924d340cc1123fe05276f681e6aa12193c68b2d1aa6ab489150d8e3") +SHARDS = [ + [ + "docs/public-math/sources-01.json", + "550519fe77b73927169e2a1efdc0276bb0f6141f", + 58276 + ], + [ + "docs/public-math/sources-02.json", + "0037f84f28f3e9dada4d921c903ee0271723d544", + 86078 + ], + [ + "docs/public-math/sources-03.json", + "9b1eb04eb09fc3227d394110e1913e85306392ce", + 96034 + ], + [ + "docs/public-math/sources-04.json", + "b4c66773898213e7b58483b018fd15063911af93", + 87348 + ], + [ + "docs/public-math/sources-05.json", + "5247d6927cee10e49d9b9d8f378797ebae29c926", + 68164 + ], + [ + "docs/public-math/sources-06.json", + "eda5411fe6e3035e9e981a3f614aac46882828b9", + 81840 + ], + [ + "docs/public-math/sources-07.json", + "0cd78768bb71eef7a84ea9fe35867a5b6d103ea3", + 95161 + ], + [ + "docs/public-math/sources-08.json", + "882219d447d249c3221a526ea0f59dd2d69a108f", + 87801 + ], + [ + "docs/public-math/sources-09.json", + "a59e56e0351a77b624058be9efad3f30d495d1e1", + 76228 + ], + [ + "docs/public-math/sources-10.json", + "addd0228282e1ec31228dca1476f2d770f206181", + 76144 + ], + [ + "docs/public-math/sources-11.json", + "b50b28a293503b35fa0851be9f8854f5fe4aed55", + 86339 + ], + [ + "docs/public-math/sources-12.json", + "950783d361a676c61e96f9299a845d9e2b9a2c66", + 63991 + ], + [ + "docs/public-math/sources-13.json", + "9d4ab75e0423e456294ee90399a3c22648153fa5", + 69414 + ], + [ + "docs/public-math/sources-14.json", + "f9df9ee169376c01f7f3a7b1f794e79ded81915b", + 20295 + ] +] +COEFFICIENT_EXPECTED = json.loads(r'''{ + "cone_moments": { + "2": "4/3", + "3": "29/6-sqrt(6)" + }, + "dimensions": { + "2": { + "lower": "0.07340691930603427103", + "upper": "0.07340691930603427104" + }, + "3": { + "lower": "0.04177593184059834334", + "upper": "0.04177593184059834335" + } + }, + "image_ledger": { + "covariance_relative_bound": "31763607879717/2500000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000", + "density_comparison_below_reported": true, + "derivative_bound": "10587869293239/50000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000", + "exp_lower_gt_10": true, + "image_constant": 21175738586478, + "relative_below_eps": true + }, + "method": "outward rational arithmetic; analytic image and Stirling remainder bounds", + "object": "SIDE24-COEFFICIENT-D23-20260924-v1", + "relative_periodization_bound": "1e-106", + "scientific_acceptance": false, + "scope": "coefficient of issue63 Eq15.2; parent theorem unreviewed" +} +''') +TABLES = { + "ACCEPT — scoped": ("accept", ["Object", "Accepted scope", "Source and review", "Explicit limits"]), + "AMEND / open": ("amend", ["Object", "Current reason", "Source"]), + "Engineering only": ("engineering", ["Surface", "What it provides"]), +} +OTHER_HEADINGS = {"Where to read — public source custody", "Reading rule"} +EXPECTED_COUNTS = {"accept": 4, "amend": 3, "engineering": 3} +IMPORT_IDS = ["EC-014", "EC-015", "EC-021", "P02-LM-001", "P02-LM-002", + "P02-LM-005", "P02-LM-007", "P02-LM-008", "P15-B"] + + +def blob_sha(raw): + return hashlib.sha1(b"blob " + str(len(raw)).encode("ascii") + b"\0" + raw).hexdigest() + + +def identity_for(raw, template): + return dict(template, bytes=len(raw), sha256=hashlib.sha256(raw).hexdigest(), + blob=blob_sha(raw)) + + +def verify_bytes(raw, expected): + if any(identity_for(raw, expected)[key] != expected[key] + for key in ("bytes", "sha256", "blob")): + raise ValueError("source identity mismatch: " + expected["path"]) + return raw + + +def with_url(identity): + result = dict(identity) + result["url"] = ("https://raw.githubusercontent.com/" + identity["repository"] + + "/" + identity["commit"] + "/" + quote(identity["path"], safe="/")) + return result + + +def parse_status(raw, identity=STATUS): + verify_bytes(raw, identity) + text = raw.decode("utf-8") + date = re.search(r"^\*\*Snapshot date:\*\* (\d{4}-\d{2}-\d{2})\s*$", text, re.M) + if not date: + raise ValueError("missing snapshot date") + sections = [] + current = None + stage = None + seen = set() + for line in text.splitlines(): + if line.startswith("## "): + title = line[3:] + if title in seen: + raise ValueError("duplicate heading: " + title) + seen.add(title) + if title not in TABLES and title not in OTHER_HEADINGS: + raise ValueError("unknown heading: " + title) + if title in TABLES: + key, headers = TABLES[title] + current = dict(key=key, title=title, headers=headers, rows=[]) + sections.append(current) + stage = "header" + else: + current, stage = None, None + elif line.startswith("### ") and line != "### Default-branch boundary": + raise ValueError("unknown heading: " + line[4:]) + elif line.startswith("|"): + if current is None: + raise ValueError("table outside classified section") + if not line.endswith("|"): + raise ValueError("malformed table row") + cells = [cell.strip() for cell in line[1:-1].split("|")] + if stage == "header": + if cells != current["headers"]: + raise ValueError("table header schema changed") + stage = "separator" + elif stage == "separator": + if len(cells) != len(current["headers"]) or not all( + re.fullmatch(r":?-{3,}:?", cell) for cell in cells): + raise ValueError("table separator schema changed") + stage = "rows" + else: + if len(cells) != len(current["headers"]) or not all(cells): + raise ValueError("table row width/content changed") + current["rows"].append(cells) + if seen != set(TABLES) | OTHER_HEADINGS: + raise ValueError("missing required heading") + counts = {section["key"]: len(section["rows"]) for section in sections} + if counts != EXPECTED_COUNTS: + raise ValueError("snapshot row counts changed; explicit source review required") + for section in sections: + section["count"] = counts[section["key"]] + boundary = text.split("### Default-branch boundary\n", 1)[1].split("\n## Reading rule", 1)[0].strip() + return dict(schema_version=1, scientific_status_authority=False, + source=with_url(identity), snapshot_date=date.group(1), + meaning="Counts of selected rows in the pinned STATUS snapshot, not totals of all theorems or an independent acceptance register.", + sections=sections, counts=counts, + snapshot_context=dict(default_branch_boundary=boundary, + notice="This historical snapshot's custody/query boundary may be stale. Current observations are separate; scientific rows are not inferred from merges.")) + + +def parse_coefficient(raw, identity=COEFFICIENT): + verify_bytes(raw, identity) + data = json.loads(raw) + if data != COEFFICIENT_EXPECTED or data.get("scientific_acceptance") is not False: + raise ValueError("coefficient schema or values changed") + for bounds in data["dimensions"].values(): + if any(type(value) is not str for value in bounds.values()) or not ( + Decimal(bounds["lower"]) < Decimal(bounds["upper"])): + raise ValueError("coefficient schema requires exact decimal strings") + return data + + +def inventory_config(read_main): + raw = read_main(INVENTORY["path"]) + verify_bytes(raw, INVENTORY) + data = json.loads(raw) + if data["source_count"] != 2138 or len(data["pages"]) != len(SHARDS): + raise ValueError("inventory schema/count changed") + pages = [] + for (path, blob, size), expected in zip(SHARDS, data["pages"]): + if "docs/public-math/" + expected["path"] != path: + raise ValueError("inventory shard order/path changed") + raw_page = read_main(path) + if len(raw_page) != size or blob_sha(raw_page) != blob: + raise ValueError("shard identity mismatch: " + path) + page = json.loads(raw_page) + if set(page) != {"sources"} or len(page["sources"]) != expected["count"]: + raise ValueError("inventory shard schema/count changed") + for row in page["sources"]: + if set(row) != {"repository", "path", "commit", "blob", "bytes", "sha256"}: + raise ValueError("inventory row schema changed") + if row["repository"] not in {"main", "Math-"} or not all( + re.fullmatch("[0-9a-f]{" + str(n) + "}", row[key]) + for key, n in (("commit", 40), ("blob", 40), ("sha256", 64))): + raise ValueError("inventory row identity changed") + identity = identity_for(raw_page, dict(INVENTORY, path=path)) + pages.append(dict(with_url(identity), count=expected["count"])) + if sum(page["count"] for page in pages) != data["source_count"]: + raise ValueError("inventory total mismatch") + return with_url(INVENTORY), pages + + +def build(read_main, read_math, observations=None): + status = parse_status(read_main(STATUS["path"])) + parse_coefficient(read_math(COEFFICIENT["path"])) + verify_bytes(read_math(PROOF["path"]), PROOF) + manifest = json.loads(verify_bytes(read_math(IMPORTS["path"]), IMPORTS)) + copies = manifest["byte_copies"] + if (manifest["scientific_effect"] != "NONE" + or [row["id"] for row in copies] != IMPORT_IDS + or any(row["kind"] != "BYTE_COPY" or row["source_label_adopted"] is not False for row in copies)): + raise ValueError("import custody schema changed") + inventory, pages = inventory_config(read_main) + inventory.update(source_count=2138, pages=pages, + relative_url="../public-math/sources.json", + meaning="Existing public-text inventory; loaded in place, never copied into a second catalog.") + imports = dict(with_url(IMPORTS), count=len(copies), byte_copy_ids=IMPORT_IDS, + manifest_url=with_url(IMPORTS)["url"], scientific_effect="NONE", + transcription_count=len(manifest["transcriptions"]), + meaning="Nine byte-custody imports, separately one transcription; not accepted-theorem counts.") + config = dict(schema_version=1, scientific_status_authority=False, + coefficient=with_url(COEFFICIENT), proof=with_url(PROOF), + status=with_url(STATUS), inventory=inventory, imports=imports) + status_bytes = dump(status) + config["status_json"] = dict(url="status.json", bytes=len(status_bytes), + sha256=hashlib.sha256(status_bytes).hexdigest()) + if observations: + if (observations.get("scientific_status_authority") is not False + or observations["open_math_prs"] != len(observations["pull_requests"]) + or not re.fullmatch("[0-9a-f]{40}", observations["math_tip"])): + raise ValueError("observation schema/count changed") + config["observations"] = {key: observations[key] + for key in ("observed_at", "math_tip", "open_math_prs")} + config["observations"]["path"] = "observations.json" + return status, config + + +def dump(data): + return (json.dumps(data, indent=2, ensure_ascii=False, sort_keys=True) + "\n").encode("utf-8") + + +def main(argv=None): + parser = argparse.ArgumentParser(description=__doc__) + parser.add_argument("--main-root", type=Path, default=Path(__file__).resolve().parents[1]) + parser.add_argument("--math-root", type=Path) + parser.add_argument("--output", type=Path) + parser.add_argument("--check", action="store_true") + args = parser.parse_args(argv) + output = args.output or args.main_root / "docs/site" + math_sources = {item["path"]: item for item in (COEFFICIENT, PROOF, IMPORTS)} + def read_main(path): + # Use the pinned Git object when present, so a later unrelated branch + # movement cannot silently substitute different public source bytes. + result = subprocess.run(["git", "show", MAIN_COMMIT + ":" + path], + cwd=args.main_root, capture_output=True) + if result.returncode == 0: + return result.stdout + return (args.main_root / path).read_bytes() + def read_math(path): + if args.math_root: + return (args.math_root / path).read_bytes() + identity = math_sources[path] + with urlopen(with_url(identity)["url"], timeout=30) as response: + return response.read(identity["bytes"] + 1) + observation_path = output / "observations.json" + observations = json.loads(observation_path.read_bytes()) if observation_path.exists() else None + status, config = build(read_main, read_math, observations) + # Query pin refresh is maintained independently. Preserve only an explicit + # well-formed optional identity block supplied by that reviewed integration. + existing_config = output / "config.json" + if existing_config.exists(): + query = json.loads(existing_config.read_bytes()).get("query") + if query is not None: + if not all(re.fullmatch("[0-9a-f]{40}", query.get(k, "")) for k in ("commit", "math_pin")): + raise ValueError("invalid query identity block") + config["query"] = query + for name, data in (("status.json", status), ("config.json", config)): + destination = output / name + raw = dump(data) + if args.check: + if not destination.exists() or destination.read_bytes() != raw: + raise ValueError("generated export differs: " + str(destination)) + else: + output.mkdir(parents=True, exist_ok=True) + destination.write_bytes(raw) + print("Public shop exports verified; scientific effect NONE.") + return 0 + + +if __name__ == "__main__": + raise SystemExit(main())