[
  {
    "slug": "home",
    "title": "Runtime.MiRust.com",
    "nav": "Home",
    "description": "Project website for TinyRustLM, the custom Rust/WASM browser-local SLM runtime behind Runtime.MiRust.com.",
    "keywords": "TinyRustLM, Runtime.MiRust.com, Rust WASM, browser local SLM, zero dependency AI runtime",
    "body_html": "<h1>Runtime.MiRust.com</h1>\n<blockquote><p>Runtime.MiRust.com is the project website for TinyRustLM: a custom Rust/WASM browser-local small language model runtime, static browser UI, local model format, adapter route, and proof pipeline.</p></blockquote>\n<p>Runtime.MiRust.com should not read like a placeholder CMS blog. It should explain the actual project: a zero-dependency Rust and browser runtime that loads local <code>.slm</code> model files, validates them, runs inference in WebAssembly, displays model provenance, and records the evidence chain around generated model artifacts.</p>\n<h2>Current implementation in one view</h2>\n<div class=\"table-scroll\"><table><thead><tr><th scope=\"col\">Area</th><th scope=\"col\">Current source-backed status</th></tr></thead><tbody><tr><td>Browser shell</td><td>Static HTML, custom CSS, handwritten JavaScript.</td></tr><tr><td>Runtime</td><td>No-crate Rust compiled to WASM with explicit exported functions.</td></tr><tr><td>Model format</td><td>Custom <code>.slm</code> format with checksum, tensor directory, tokenizer metadata, and quantization metadata.</td></tr><tr><td>Quantization</td><td>f32, q8_0, and q4_0 fixture and TinyLM-16M smoke paths.</td></tr><tr><td>Adapters</td><td>ADP1 raw adapters, ASP1 sparse adapters, and ALR1 low-rank adapters.</td></tr><tr><td>Provenance</td><td><code>.slm.manifest</code>, assembly receipts, adapter-family receipts, selector registries, and module-plan receipts.</td></tr><tr><td>Testing</td><td>Rust tests, browser harness checks, Node DevTools browser smokes, WASM ABI smoke, route-soak checks.</td></tr><tr><td>Product boundary</td><td>Runtime and evidence are real. Trained assistant quality and full GGUF import are not claimed yet.</td></tr></tbody></table></div>\n<h2>What the name means</h2>\n<p>Runtime.MiRust.com is the public lane for the Rust/WASM local-model runtime work. GGUF remains an important roadmap-facing format boundary, but the source-backed implementation currently centers on TinyRustLM and the custom <code>.slm</code> route because that path is small enough to audit, validate, and prove in the browser before wider format support is added.</p>\n<h2>Why this exists</h2>\n<p>Most local AI demonstrations hide important boundaries behind frameworks, package managers, opaque model loaders, or remote inference calls. TinyRustLM takes the opposite route:</p>\n<ul><li>keep the browser app static;</li><li>keep JavaScript as a host boundary, not a tensor engine;</li><li>keep Rust in charge of model parsing, validation, inference, adapters, diagnostics, and state;</li><li>keep model artifacts local and checksum-bound;</li><li>keep every expansion behind receipts, manifests, and browser smoke evidence.</li></ul>\n<h2>Main project lanes</h2>\n<ol><li><strong>Browser-local runtime</strong>: local <code>.slm</code> files and WASM runtime, no external inference API.</li><li><strong>Proof-first model format</strong>: checksum-bearing local model files with explicit quality boundaries.</li><li><strong>Adapter ecology</strong>: raw, sparse, and low-rank delta packages validated by Rust before use.</li><li><strong>Model breeding pipeline</strong>: offline compatibility, lineage, operators, candidates, promotions, population review, parent-pool recipes, selector admission, and browser-routable bundles.</li><li><strong>Agent-readable site</strong>: semantic PHP-rendered pages, Markdown alternates, <code>llms.txt</code>, <code>llms-full.txt</code>, and no dependency-heavy front-end framework.</li></ol>\n\n<h2>Audit-driven site improvements</h2>\n<p>The latest improvement round adds the missing layer that a technical project site needs before deeper UI work: deployment trust, namespace clarity, research routing, and explicit launch checks.</p>\n<div class=\"route-cluster\" aria-label=\"Audit-driven improvement links\"><a class=\"route-tile\" href=\"/site-audit-response/\"><strong>Audit Response</strong><span>What changed from the attached review.</span></a><a class=\"route-tile\" href=\"/site-infrastructure/\"><strong>Infrastructure &amp; Trust</strong><span>DNS, TLS, headers, docs routes, and trust checks.</span></a><a class=\"route-tile\" href=\"/name-scope/\"><strong>Name &amp; Scope</strong><span>Make TinyRustLM and the .slm boundary unambiguous.</span></a><a class=\"route-tile\" href=\"/deployment-checklist/\"><strong>Deploy Check</strong><span>Post-deploy commands for humans and agents.</span></a></div>\n<h2>Start here</h2>\n<ul><li>Read <strong>Architecture</strong> for the system map.</li><li>Read <strong>Browser Runtime</strong> for what runs in the user’s browser.</li><li>Read <strong>Model Format</strong> for the <code>.slm</code> boundary.</li><li>Read <strong>Adapters &amp; Assembly</strong> for ADP1, ASP1, ALR1, module plans, selector registries, and assembly receipts.</li><li>Read <strong>Proof &amp; Testing</strong> before trusting any support claim.</li><li>Read <strong>Contact Mike Kappel</strong> when you need maintainer contact, project follow-up, or external profile links.</li></ul>\n\n<h2>Live operations added in v1.0.6</h2>\n<p>The latest continuation round adds explicit health endpoints, origin-fix guidance, stale WordPress route interception, and deploy verification scripts so the site can stay out of the cPanel default-page failure mode.</p>\n<div class=\"route-cluster\" aria-label=\"Operational links\"><a class=\"route-tile\" href=\"/site-origin-fix/\"><strong>Origin Fix</strong><span>Why cPanel default pages appear and how to correct root mapping.</span></a><a class=\"route-tile\" href=\"/runtime-health/\"><strong>Runtime Health</strong><span>Health, version, docs, memory, and Markdown checks.</span></a><a class=\"route-tile\" href=\"/source-facts/\"><strong>Fact Sheet</strong><span>Short source-backed claim boundary for humans and agents.</span></a><a class=\"route-tile\" href=\"/launch-operations/\"><strong>Launch Ops</strong><span>Backup, extraction, verification, cache purge, and rollback rules.</span></a></div>\n",
    "markdown": "# Runtime.MiRust.com\n\n> Runtime.MiRust.com is the project website for TinyRustLM: a custom Rust/WASM browser-local small language model runtime, static browser UI, local model format, adapter route, and proof pipeline.\n\nRuntime.MiRust.com should not read like a placeholder CMS blog. It should explain the actual project: a zero-dependency Rust and browser runtime that loads local `.slm` model files, validates them, runs inference in WebAssembly, displays model provenance, and records the evidence chain around generated model artifacts.\n\n## Current implementation in one view\n\n| Area | Current source-backed status |\n| --- | --- |\n| Browser shell | Static HTML, custom CSS, handwritten JavaScript. |\n| Runtime | No-crate Rust compiled to WASM with explicit exported functions. |\n| Model format | Custom `.slm` format with checksum, tensor directory, tokenizer metadata, and quantization metadata. |\n| Quantization | f32, q8_0, and q4_0 fixture and TinyLM-16M smoke paths. |\n| Adapters | ADP1 raw adapters, ASP1 sparse adapters, and ALR1 low-rank adapters. |\n| Provenance | `.slm.manifest`, assembly receipts, adapter-family receipts, selector registries, and module-plan receipts. |\n| Testing | Rust tests, browser harness checks, Node DevTools browser smokes, WASM ABI smoke, route-soak checks. |\n| Product boundary | Runtime and evidence are real. Trained assistant quality and full GGUF import are not claimed yet. |\n\n## What the name means\n\nRuntime.MiRust.com is the public lane for the Rust/WASM local-model runtime work. GGUF remains an important roadmap-facing format boundary, but the source-backed implementation currently centers on TinyRustLM and the custom `.slm` route because that path is small enough to audit, validate, and prove in the browser before wider format support is added.\n\n## Why this exists\n\nMost local AI demonstrations hide important boundaries behind frameworks, package managers, opaque model loaders, or remote inference calls. TinyRustLM takes the opposite route:\n\n- keep the browser app static;\n- keep JavaScript as a host boundary, not a tensor engine;\n- keep Rust in charge of model parsing, validation, inference, adapters, diagnostics, and state;\n- keep model artifacts local and checksum-bound;\n- keep every expansion behind receipts, manifests, and browser smoke evidence.\n\n## Main project lanes\n\n1. **Browser-local runtime**: local `.slm` files and WASM runtime, no external inference API.\n2. **Proof-first model format**: checksum-bearing local model files with explicit quality boundaries.\n3. **Adapter ecology**: raw, sparse, and low-rank delta packages validated by Rust before use.\n4. **Model breeding pipeline**: offline compatibility, lineage, operators, candidates, promotions, population review, parent-pool recipes, selector admission, and browser-routable bundles.\n5. **Agent-readable site**: semantic PHP-rendered pages, Markdown alternates, `llms.txt`, `llms-full.txt`, and no dependency-heavy front-end framework.\n\n\n## Audit-driven site improvements\n\nThe latest improvement round adds the missing layer that a technical project site needs before deeper UI work: deployment trust, namespace clarity, research routing, and explicit launch checks.\n\n- [Audit Response](/site-audit-response/): What changed from the attached review.\n- [Infrastructure & Trust](/site-infrastructure/): DNS, TLS, headers, docs routes, and trust checks.\n- [Name & Scope](/name-scope/): Make TinyRustLM and the `.slm` boundary unambiguous.\n- [Deploy Check](/deployment-checklist/): Post-deploy commands for humans and agents.\n\n## Start here\n\n- Read **Architecture** for the system map.\n- Read **Browser Runtime** for what runs in the user’s browser.\n- Read **Model Format** for the `.slm` boundary.\n- Read **Adapters & Assembly** for ADP1, ASP1, ALR1, module plans, selector registries, and assembly receipts.\n- Read **Proof & Testing** before trusting any support claim.\n- Read **Contact Mike Kappel** when you need maintainer contact, project follow-up, or external profile links.\n\n## Live operations added in v1.0.6\n\nThe latest continuation round adds explicit health endpoints, origin-fix guidance, stale WordPress route interception, and deploy verification scripts so the site can stay out of the cPanel default-page failure mode.\n\n- [Origin Fix](/site-origin-fix/): why cPanel default pages appear and how to correct root mapping.\n- [Runtime Health](/runtime-health/): health, version, docs, memory, and Markdown checks.\n- [Fact Sheet](/source-facts/): short source-backed claim boundary for humans and agents.\n- [Launch Ops](/launch-operations/): backup, extraction, verification, cache purge, and rollback rules.\n"
  },
  {
    "slug": "project",
    "title": "Project Explanation",
    "nav": "Project",
    "description": "Plain-language explanation of what Runtime.MiRust.com and TinyRustLM are, what is implemented, and what is still future work.",
    "keywords": "Runtime.MiRust.com project, TinyRustLM explanation, local AI runtime",
    "body_html": "<h1>Project Explanation</h1>\n<p>Runtime.MiRust.com is a project website for a custom local AI runtime stack. The active implementation target is <strong>TinyRustLM</strong>, a browser-local small language model application built from static HTML, custom CSS, handwritten JavaScript, and no-crate Rust compiled to WebAssembly.</p>\n<h2>The simplest accurate description</h2>\n<p>TinyRustLM is a small, auditable runtime that proves a local model can be loaded, validated, tokenized, run, adapted, diagnosed, and tested inside the browser without depending on a third-party front-end framework, an external inference API, or a large machine-learning runtime.</p>\n<h2>What the project is not</h2>\n<p>The current source should not be marketed as a general assistant product. It should not claim trained assistant quality, full GGUF import, Mini Browser orchestration, hosted model execution, remote inference, analytics, telemetry, or plugin-driven automation.</p>\n<p>The site should instead describe the real thing that exists:</p>\n<ul><li>a custom model file route;</li><li>local deterministic smoke models;</li><li>quantized runtime paths;</li><li>adapter package validation;</li><li>receipts and manifests;</li><li>browser route proofs;</li><li>a model-breeding research pipeline;</li><li>strict boundaries around what has and has not been proven.</li></ul>\n<h2>The project’s engineering posture</h2>\n<p>The project is intentionally small at the trusted boundary. It favors direct Rust modules, explicit file formats, deterministic test artifacts, and visible browser diagnostics over framework-level magic.</p>\n<p>That is why the website uses the same public posture:</p>\n<ul><li>no Bootstrap;</li><li>no jQuery;</li><li>no external CSS framework;</li><li>no page builder dependency;</li><li>no client-side rendering requirement for core content;</li><li>no hidden bot-only copy;</li><li>no “magic AI” language where evidence should be shown.</li></ul>\n<h2>How to read the site</h2>\n<p>The site is organized as a proof map:</p>\n<ol><li><strong>Architecture</strong> explains the parts.</li><li><strong>Browser Runtime</strong> explains the runtime/app boundary.</li><li><strong>Model Format</strong> explains <code>.slm</code>.</li><li><strong>Adapters &amp; Assembly</strong> explains ADP1, ASP1, ALR1, selector registries, module plans, and assembly receipts.</li><li><strong>Model Breeding</strong> explains the offline candidate lineage and promotion pipeline.</li><li><strong>Proof &amp; Testing</strong> records what support claims should be backed by tests or smoke evidence.</li><li><strong>Roadmap &amp; Boundaries</strong> keeps future ambition separate from current support.</li></ol>\n<h2>Public positioning</h2>\n<p>Use the phrase “browser-local Rust/WASM SLM runtime” before broader phrases like “AI system.” This keeps the project precise, searchable, and agent-readable.</p>\n<p>Runtime.MiRust.com is a constructive local-model craft site. It should make the engineering understandable without diluting the boundaries.</p>",
    "markdown": "# Project Explanation\n\nRuntime.MiRust.com is a project website for a custom local AI runtime stack. The active implementation target is **TinyRustLM**, a browser-local small language model application built from static HTML, custom CSS, handwritten JavaScript, and no-crate Rust compiled to WebAssembly.\n\n## The simplest accurate description\n\nTinyRustLM is a small, auditable runtime that proves a local model can be loaded, validated, tokenized, run, adapted, diagnosed, and tested inside the browser without depending on a third-party front-end framework, an external inference API, or a large machine-learning runtime.\n\n## What the project is not\n\nThe current source should not be marketed as a general assistant product. It should not claim trained assistant quality, full GGUF import, Mini Browser orchestration, hosted model execution, remote inference, analytics, telemetry, or plugin-driven automation.\n\nThe site should instead describe the real thing that exists:\n\n- a custom model file route;\n- local deterministic smoke models;\n- quantized runtime paths;\n- adapter package validation;\n- receipts and manifests;\n- browser route proofs;\n- a model-breeding research pipeline;\n- strict boundaries around what has and has not been proven.\n\n## The project’s engineering posture\n\nThe project is intentionally small at the trusted boundary. It favors direct Rust modules, explicit file formats, deterministic test artifacts, and visible browser diagnostics over framework-level magic.\n\nThat is why the website uses the same public posture:\n\n- no Bootstrap;\n- no jQuery;\n- no external CSS framework;\n- no page builder dependency;\n- no client-side rendering requirement for core content;\n- no hidden bot-only copy;\n- no “magic AI” language where evidence should be shown.\n\n## How to read the site\n\nThe site is organized as a proof map:\n\n1. **Architecture** explains the parts.\n2. **Browser Runtime** explains the runtime/app boundary.\n3. **Model Format** explains `.slm`.\n4. **Adapters & Assembly** explains ADP1, ASP1, ALR1, selector registries, module plans, and assembly receipts.\n5. **Model Breeding** explains the offline candidate lineage and promotion pipeline.\n6. **Proof & Testing** records what support claims should be backed by tests or smoke evidence.\n7. **Roadmap & Boundaries** keeps future ambition separate from current support.\n\n## Public positioning\n\nUse the phrase “browser-local Rust/WASM SLM runtime” before broader phrases like “AI system.” This keeps the project precise, searchable, and agent-readable.\n\nRuntime.MiRust.com is a constructive local-model craft site. It should make the engineering understandable without diluting the boundaries."
  },
  {
    "slug": "source-facts",
    "title": "Source-Backed Facts",
    "nav": "Fact Sheet",
    "description": "Concise source-backed facts and claim boundaries for Runtime.MiRust.com and TinyRustLM.",
    "keywords": "Runtime.MiRust.com facts, TinyRustLM facts, current claim boundary, no broad GGUF import claim",
    "body_html": "<h1>Source-Backed Facts</h1>\n<blockquote><p>This page is the short answer for humans, search engines, and AI agents: what exists, what is being proven, and what is not claimed yet.</p></blockquote>\n<div class=\"metric-strip\" aria-label=\"Runtime facts\"><span><strong>Runtime</strong> Rust/WASM</span><span><strong>Current format</strong> .slm</span><span><strong>Host</strong> plain PHP</span><span><strong>Dependencies</strong> zero front-end libraries</span></div>\n<h2>Current facts</h2>\n<ul><li><strong>Runtime.MiRust.com</strong> is the project site for TinyRustLM.</li><li><strong>TinyRustLM</strong> is a browser-local Rust/WASM small language model runtime and static app.</li><li>The current source-backed model route is the custom <code>.slm</code> format, with manifest and checksum discipline.</li><li>The current browser app treats JavaScript as the host boundary and Rust as the owner of model parsing, generation, adapters, diagnostics, and runtime state.</li><li>The site is now plain PHP, no WordPress, no database, no Composer, and no external front-end library.</li></ul>\n<h2>Current support boundary</h2>\n<div class=\"table-scroll\"><table><thead><tr><th scope=\"col\">Claim</th><th scope=\"col\">Status</th></tr></thead><tbody><tr><td>Browser-local Rust/WASM SLM runtime</td><td>Current source-backed lane.</td></tr><tr><td>Custom <code>.slm</code> model loading</td><td>Current source-backed lane.</td></tr><tr><td>ADP1, ASP1, ALR1 adapter routes</td><td>Current evidence lane for compatible local packages.</td></tr><tr><td>Broad GGUF import</td><td>Roadmap only until converter/import proof exists.</td></tr><tr><td>Trained assistant quality</td><td>Not claimed until eval sidecars and source-backed model evidence support it.</td></tr><tr><td>Remote inference service</td><td>Not the current product.</td></tr></tbody></table></div>\n<h2>Use this page when citing the project</h2>\n<p>Use <code>Runtime.MiRust.com</code> for the site and <code>TinyRustLM</code> for the runtime. Use <code>.slm</code> when describing the current implemented model route. Use <code>GGUF</code> only as roadmap or compatibility context unless a future package proves broad import support.</p>\n",
    "markdown": "# Source-Backed Facts\n\n> This page is the short answer for humans, search engines, and AI agents: what exists, what is being proven, and what is not claimed yet.\n\n## Current facts\n\n- **Runtime.MiRust.com** is the project site for TinyRustLM.\n- **TinyRustLM** is a browser-local Rust/WASM small language model runtime and static app.\n- The current source-backed model route is the custom `.slm` format.\n- JavaScript is the host boundary; Rust owns model parsing, generation, adapters, diagnostics, and runtime state.\n- The public site is plain PHP, no WordPress, no database, no Composer, and no external front-end library.\n\n## Current support boundary\n\n| Claim | Status |\n| --- | --- |\n| Browser-local Rust/WASM SLM runtime | Current source-backed lane. |\n| Custom `.slm` model loading | Current source-backed lane. |\n| ADP1, ASP1, ALR1 adapter routes | Current evidence lane. |\n| Broad GGUF import | Roadmap only. |\n| Trained assistant quality | Not claimed until eval evidence supports it. |\n| Remote inference service | Not the current product. |\n"
  },
  {
    "slug": "architecture",
    "title": "Architecture",
    "nav": "Architecture",
    "description": "System architecture for TinyRustLM: static browser app, Rust/WASM runtime, .slm model format, packer, local server, browser harness, and proof memory.",
    "keywords": "TinyRustLM architecture, Rust WASM runtime architecture, browser local SLM",
    "body_html": "<h1>Architecture</h1>\n<p>TinyRustLM is split into small, explicit boundaries. The website should explain those boundaries because they are the product.</p>\n<h2>Source-backed workspace</h2>\n<div class=\"table-scroll\"><table><thead><tr><th scope=\"col\">Component</th><th scope=\"col\">Role</th></tr></thead><tbody><tr><td><code>tinyrustlm/app/</code></td><td>Static browser UI with handwritten HTML, CSS, and JavaScript.</td></tr><tr><td><code>tinyrustlm/runtime/</code></td><td>No-crate Rust runtime compiled to WASM.</td></tr><tr><td><code>tinyrustlm/tools/slm_pack/</code></td><td>No-crate Rust utility for model files, manifests, receipts, operators, and browser bundles.</td></tr><tr><td><code>tinyrustlm/tools/local_server/</code></td><td>No-crate local static server for loopback app hosting.</td></tr><tr><td><code>tinyrustlm/tools/browser_harness/</code></td><td>No-crate Rust contract checker for app and route assumptions.</td></tr><tr><td><code>tinyrustlm/docs/</code></td><td>Durable architecture, browser runtime, testing, performance, tokenizer, quantization, and format notes.</td></tr><tr><td><code>.uai/</code></td><td>Hot project handoff and routing memory.</td></tr><tr><td><code>wiki/runtime-mirust/</code></td><td>LLM Wiki source namespace for durable memory publication.</td></tr></tbody></table></div>\n<h2>Runtime boundary</h2>\n<p>The runtime owns the parts that must be trustworthy:</p>\n<ul><li><code>.slm</code> parsing and validation;</li><li>checksum checks before tensor decoding;</li><li>tokenizer behavior;</li><li>f32, q8_0, and q4_0 storage and dispatch;</li><li>tensor routing and tied-output fallback;</li><li>KV cache and scratch buffers;</li><li>sampler and output limits;</li><li>diagnostics;</li><li>context reset;</li><li>model free;</li><li>ADP1, ASP1, and ALR1 adapter validation and apply.</li></ul>\n<p>JavaScript does not parse <code>.slm</code>, own tensor math, or make quality claims. JavaScript hosts the browser state, fetches local files, copies bytes into WASM memory, calls Rust exports, and renders diagnostics.</p>\n<h2>Browser app boundary</h2>\n<p>The browser app is intentionally static. It presents model selection, prompt controls, output, transcript state, Step Token, Adapter Sidecar, Model Provenance, Module Plan, Assembly Evidence, and developer diagnostics. It fetches only local or same-origin project artifacts.</p>\n<p>The browser-side rules are strict:</p>\n<ul><li>selected model bytes must match declared byte counts;</li><li>manifests must fit text-sidecar budgets;</li><li>generated module plans must be verified before model bytes;</li><li>adapter manifests and adapter bytes must be verified before WASM transfer;</li><li>generated adapter stacks must validate in Rust before apply;</li><li>transcript Clear is different from runtime Reset.</li></ul>\n<h2>Packer boundary</h2>\n<p><code>tinyrustlm-slm-pack</code> is the offline tool lane. It produces or validates model artifacts, adapter artifacts, receipts, manifests, candidates, promotions, population records, parent-pool recipes, selector registries, and browser-routable bundles.</p>\n<p>This design keeps model-breeding work out of the live runtime until it has normal <code>.slm</code> validation, manifests, evidence sidecars, admission records, and browser route proof.</p>\n<h2>Proof memory</h2>\n<p>The <code>.uai</code> and <code>wiki/runtime-mirust/</code> files are not decorative. They are part of the project handoff system. They route future agents to source boundaries, testing rules, report synthesis, long-term pointers, and next prompts without dumping every report body into hot memory.</p>",
    "markdown": "# Architecture\n\nTinyRustLM is split into small, explicit boundaries. The website should explain those boundaries because they are the product.\n\n## Source-backed workspace\n\n| Component | Role |\n| --- | --- |\n| `tinyrustlm/app/` | Static browser UI with handwritten HTML, CSS, and JavaScript. |\n| `tinyrustlm/runtime/` | No-crate Rust runtime compiled to WASM. |\n| `tinyrustlm/tools/slm_pack/` | No-crate Rust utility for model files, manifests, receipts, operators, and browser bundles. |\n| `tinyrustlm/tools/local_server/` | No-crate local static server for loopback app hosting. |\n| `tinyrustlm/tools/browser_harness/` | No-crate Rust contract checker for app and route assumptions. |\n| `tinyrustlm/docs/` | Durable architecture, browser runtime, testing, performance, tokenizer, quantization, and format notes. |\n| `.uai/` | Hot project handoff and routing memory. |\n| `wiki/runtime-mirust/` | LLM Wiki source namespace for durable memory publication. |\n\n## Runtime boundary\n\nThe runtime owns the parts that must be trustworthy:\n\n- `.slm` parsing and validation;\n- checksum checks before tensor decoding;\n- tokenizer behavior;\n- f32, q8_0, and q4_0 storage and dispatch;\n- tensor routing and tied-output fallback;\n- KV cache and scratch buffers;\n- sampler and output limits;\n- diagnostics;\n- context reset;\n- model free;\n- ADP1, ASP1, and ALR1 adapter validation and apply.\n\nJavaScript does not parse `.slm`, own tensor math, or make quality claims. JavaScript hosts the browser state, fetches local files, copies bytes into WASM memory, calls Rust exports, and renders diagnostics.\n\n## Browser app boundary\n\nThe browser app is intentionally static. It presents model selection, prompt controls, output, transcript state, Step Token, Adapter Sidecar, Model Provenance, Module Plan, Assembly Evidence, and developer diagnostics. It fetches only local or same-origin project artifacts.\n\nThe browser-side rules are strict:\n\n- selected model bytes must match declared byte counts;\n- manifests must fit text-sidecar budgets;\n- generated module plans must be verified before model bytes;\n- adapter manifests and adapter bytes must be verified before WASM transfer;\n- generated adapter stacks must validate in Rust before apply;\n- transcript Clear is different from runtime Reset.\n\n## Packer boundary\n\n`tinyrustlm-slm-pack` is the offline tool lane. It produces or validates model artifacts, adapter artifacts, receipts, manifests, candidates, promotions, population records, parent-pool recipes, selector registries, and browser-routable bundles.\n\nThis design keeps model-breeding work out of the live runtime until it has normal `.slm` validation, manifests, evidence sidecars, admission records, and browser route proof.\n\n## Proof memory\n\nThe `.uai` and `wiki/runtime-mirust/` files are not decorative. They are part of the project handoff system. They route future agents to source boundaries, testing rules, report synthesis, long-term pointers, and next prompts without dumping every report body into hot memory."
  },
  {
    "slug": "browser-runtime",
    "title": "Browser Runtime",
    "nav": "Runtime",
    "description": "Browser runtime explanation for TinyRustLM, including local WASM, local model files, Step Token, Adapter Sidecar, diagnostics, and privacy boundaries.",
    "keywords": "TinyRustLM browser runtime, Rust WASM local AI, local model browser app",
    "body_html": "<h1>Browser Runtime</h1>\n<p>The browser runtime is the human-facing proof surface for TinyRustLM. It is not a remote chat service. It is a local static app that loads local project artifacts and calls the Rust/WASM runtime.</p>\n<h2>What loads in the browser</h2>\n<p>The browser shell includes:</p>\n<ul><li>static <code>index.html</code>;</li><li>custom <code>app.css</code>;</li><li>handwritten <code>app.js</code>;</li><li><code>runtime/tinyrustlm.wasm</code>;</li><li><code>runtime/tinyrustlm.wasm.manifest</code>;</li><li>local <code>.slm</code> model files and <code>.slm.manifest</code> sidecars;</li><li>optional <code>models/selector.registry</code>;</li><li>generated <code>.module-plan.receipt</code>, <code>.assembly.receipt</code>, <code>.adapter-family.receipt</code>, and adapter manifests when a generated bundle is being tested.</li></ul>\n<h2>Runtime controls</h2>\n<p>The browser app can expose:</p>\n<ul><li>model selection;</li><li>prompt entry;</li><li>deterministic and stochastic decoding controls;</li><li>Generate;</li><li>Step Token;</li><li>Reset runtime context;</li><li>Clear transcript;</li><li>Adapter Sidecar apply;</li><li>Model Provenance;</li><li>Module Plan;</li><li>Assembly Evidence;</li><li>diagnostics and developer console.</li></ul>\n<h2>Local-only privacy boundary</h2>\n<p>The app is designed around local files and same-origin fetches. It should not silently call remote inference APIs. It should not download hidden model files from external hosts. It should not add telemetry, analytics, or remote logging unless the project explicitly changes that boundary.</p>\n<h2>Browser-owned state versus Rust-owned state</h2>\n<p>The browser owns UI state and transcript rendering. Rust owns runtime state, model state, adapter apply state, diagnostics, and generation boundaries.</p>\n<p>This matters because Clear should only clear browser transcript history, while Reset should clear runtime context/output state. Mixing those two actions would make diagnostics less trustworthy.</p>\n<h2>Failure states are product behavior</h2>\n<p>The browser app should visibly handle:</p>\n<ul><li>missing model files;</li><li>malformed model files;</li><li>checksum mismatches;</li><li>model byte-budget rejection;</li><li>text-sidecar budget rejection;</li><li>oversized prompt bytes;</li><li>context overflow;</li><li>adapter identity mismatch;</li><li>adapter checksum mismatch;</li><li>generated receipt drift;</li><li>failed WASM ABI calls.</li></ul>\n<p>These are not polish issues. They are the evidence that the runtime boundary is real.</p>",
    "markdown": "# Browser Runtime\n\nThe browser runtime is the human-facing proof surface for TinyRustLM. It is not a remote chat service. It is a local static app that loads local project artifacts and calls the Rust/WASM runtime.\n\n## What loads in the browser\n\nThe browser shell includes:\n\n- static `index.html`;\n- custom `app.css`;\n- handwritten `app.js`;\n- `runtime/tinyrustlm.wasm`;\n- `runtime/tinyrustlm.wasm.manifest`;\n- local `.slm` model files and `.slm.manifest` sidecars;\n- optional `models/selector.registry`;\n- generated `.module-plan.receipt`, `.assembly.receipt`, `.adapter-family.receipt`, and adapter manifests when a generated bundle is being tested.\n\n## Runtime controls\n\nThe browser app can expose:\n\n- model selection;\n- prompt entry;\n- deterministic and stochastic decoding controls;\n- Generate;\n- Step Token;\n- Reset runtime context;\n- Clear transcript;\n- Adapter Sidecar apply;\n- Model Provenance;\n- Module Plan;\n- Assembly Evidence;\n- diagnostics and developer console.\n\n## Local-only privacy boundary\n\nThe app is designed around local files and same-origin fetches. It should not silently call remote inference APIs. It should not download hidden model files from external hosts. It should not add telemetry, analytics, or remote logging unless the project explicitly changes that boundary.\n\n## Browser-owned state versus Rust-owned state\n\nThe browser owns UI state and transcript rendering. Rust owns runtime state, model state, adapter apply state, diagnostics, and generation boundaries.\n\nThis matters because Clear should only clear browser transcript history, while Reset should clear runtime context/output state. Mixing those two actions would make diagnostics less trustworthy.\n\n## Failure states are product behavior\n\nThe browser app should visibly handle:\n\n- missing model files;\n- malformed model files;\n- checksum mismatches;\n- model byte-budget rejection;\n- text-sidecar budget rejection;\n- oversized prompt bytes;\n- context overflow;\n- adapter identity mismatch;\n- adapter checksum mismatch;\n- generated receipt drift;\n- failed WASM ABI calls.\n\nThese are not polish issues. They are the evidence that the runtime boundary is real."
  },
  {
    "slug": "model-format",
    "title": "Model Format",
    "nav": "Model Format",
    "description": "Explanation of the custom .slm model file format, manifest sidecars, checksums, tokenizer metadata, tensor directory, and current quality boundaries.",
    "keywords": ".slm model format, TinyRustLM model format, local model manifest, q8_0 q4_0",
    "body_html": "<h1>Model Format</h1>\n<p>TinyRustLM currently uses a custom local <code>.slm</code> model format. This is the format the runtime can validate and load in the browser today.</p>\n<h2>Why <code>.slm</code> exists</h2>\n<p>The <code>.slm</code> path is a constrained proof lane. It avoids the complexity of broad external model formats while the runtime stabilizes:</p>\n<ul><li>header validation;</li><li>checksum validation;</li><li>tokenizer metadata;</li><li>tensor directory validation;</li><li>f32, q8_0, and q4_0 storage;</li><li>context/token limits;</li><li>adapter compatibility;</li><li>browser byte budgets;</li><li>manifest sidecars.</li></ul>\n<p>The domain name is GGUF-facing, but the current source does not claim full GGUF import. GGUF support belongs on the roadmap until it has the same style of validation and proof.</p>\n<h2>Core <code>.slm</code> concepts</h2>\n<div class=\"table-scroll\"><table><thead><tr><th scope=\"col\">Concept</th><th scope=\"col\">Meaning</th></tr></thead><tbody><tr><td>Header</td><td>Versioned binary record that defines shape, quantization, tokenizer, tensor count, and checksums.</td></tr><tr><td>Tensor directory</td><td>Explicit map of tensor names, offsets, sizes, types, and layout.</td></tr><tr><td>Tokenizer section</td><td>Byte tokenizer or custom BPE fixture metadata.</td></tr><tr><td>Quantization metadata</td><td>f32, q8_0, or q4_0 route metadata.</td></tr><tr><td>Manifest sidecar</td><td>Human- and agent-readable route that records checksum, shape, source kind, admission status, and quality boundary.</td></tr><tr><td>Admission status</td><td>Whether the artifact is accepted for runtime smoke, pending evaluation, or rejected.</td></tr></tbody></table></div>\n<h2>Current model artifacts</h2>\n<p>The source bundle references deterministic smoke models and TinyLM-16M f32/q8_0/q4_0 artifacts. Those artifacts exist to prove runtime execution, not to claim finished assistant quality.</p>\n<h2>Quality boundary</h2>\n<p>A manifest can say <code>runtime-execution-smoke-only</code> or <code>trained_quality_claim=not-claimed</code>. The public site must preserve that distinction. A model that can load and generate one deterministic smoke output is not automatically a trained, useful assistant.</p>\n<h2>Future route</h2>\n<p>Future trained or converted models should enter through validated source manifests, provenance sidecars, runtime-smoke evidence, eval sidecars, promotion gates, selector admission, and browser route proof.</p>",
    "markdown": "# Model Format\n\nTinyRustLM currently uses a custom local `.slm` model format. This is the format the runtime can validate and load in the browser today.\n\n## Why `.slm` exists\n\nThe `.slm` path is a constrained proof lane. It avoids the complexity of broad external model formats while the runtime stabilizes:\n\n- header validation;\n- checksum validation;\n- tokenizer metadata;\n- tensor directory validation;\n- f32, q8_0, and q4_0 storage;\n- context/token limits;\n- adapter compatibility;\n- browser byte budgets;\n- manifest sidecars.\n\nThe domain name is GGUF-facing, but the current source does not claim full GGUF import. GGUF support belongs on the roadmap until it has the same style of validation and proof.\n\n## Core `.slm` concepts\n\n| Concept | Meaning |\n| --- | --- |\n| Header | Versioned binary record that defines shape, quantization, tokenizer, tensor count, and checksums. |\n| Tensor directory | Explicit map of tensor names, offsets, sizes, types, and layout. |\n| Tokenizer section | Byte tokenizer or custom BPE fixture metadata. |\n| Quantization metadata | f32, q8_0, or q4_0 route metadata. |\n| Manifest sidecar | Human- and agent-readable route that records checksum, shape, source kind, admission status, and quality boundary. |\n| Admission status | Whether the artifact is accepted for runtime smoke, pending evaluation, or rejected. |\n\n## Current model artifacts\n\nThe source bundle references deterministic smoke models and TinyLM-16M f32/q8_0/q4_0 artifacts. Those artifacts exist to prove runtime execution, not to claim finished assistant quality.\n\n## Quality boundary\n\nA manifest can say `runtime-execution-smoke-only` or `trained_quality_claim=not-claimed`. The public site must preserve that distinction. A model that can load and generate one deterministic smoke output is not automatically a trained, useful assistant.\n\n## Future route\n\nFuture trained or converted models should enter through validated source manifests, provenance sidecars, runtime-smoke evidence, eval sidecars, promotion gates, selector admission, and browser route proof."
  },
  {
    "slug": "adapters-assembly",
    "title": "Adapters & Assembly",
    "nav": "Adapters",
    "description": "ADP1, ASP1, ALR1 adapters, module plans, adapter-family receipts, assembly receipts, selector registries, and Rust validation-before-apply rules.",
    "keywords": "ADP1, ASP1, ALR1, TinyRustLM adapters, module plan, selector registry, assembly receipt",
    "body_html": "<h1>Adapters &amp; Assembly</h1>\n<p>Adapters are how TinyRustLM explores small, modular model changes without pretending every change is a finished model.</p>\n<h2>Adapter package types</h2>\n<div class=\"table-scroll\"><table><thead><tr><th scope=\"col\">Package</th><th scope=\"col\">Meaning</th><th scope=\"col\">Runtime role</th></tr></thead><tbody><tr><td>ADP1</td><td>Raw f32 task-delta adapter package.</td><td>Can be validated and applied to compatible f32/q8_0/q4_0 loaded models.</td></tr><tr><td>ASP1</td><td>Sparse f32 task-delta adapter package.</td><td>Compact sparse route with retention and mask metadata.</td></tr><tr><td>ALR1</td><td>Low-rank adapter package.</td><td>Factor-based low-rank route with source-backed metadata.</td></tr></tbody></table></div>\n<p>Rust is the package authority. JavaScript may select and transfer adapter bytes, but Rust validates identity, checksums, tensor directory, tokenizer, layout, finite payload values, sparse indexes or low-rank shapes, and fused values before mutation.</p>\n<h2>Generated assembly chain</h2>\n<p>Generated browser bundles can carry:</p>\n<ol><li>selector registry;</li><li>module-plan receipt;</li><li>model bytes;</li><li>model manifest;</li><li>assembly receipt;</li><li>evidence files;</li><li>adapter-family receipt;</li><li>adapter manifests;</li><li>ADP1, ASP1, and ALR1 stack artifacts;</li><li>Rust validation calls;</li><li>Rust apply calls;</li><li>diagnostics proving the assembly state.</li></ol>\n<h2>Module plan</h2>\n<p>A module plan is a browser-constrained assembly receipt. It states what must be fetched, in what class, under what byte budgets, with what checksums, roles, phases, dependencies, and slots.</p>\n<p>The browser must verify the plan before fetching generated model bytes. This prevents a selector registry from silently routing an unplanned artifact.</p>\n<h2>Selector registry</h2>\n<p>The selector registry is the browser route gate. It carries entries for admitted model candidates and optional adapter families. It must include budget fields such as model byte budgets and text-sidecar budgets before generated entries are accepted.</p>\n<h2>Assembly receipt</h2>\n<p>The assembly receipt binds the model manifest, ledger, review, recipe, operator, candidate, promotion, runtime, eval, admission, eval-case digest, and adapter-family evidence by checksum.</p>\n<p>The browser should fetch evidence files referenced by the receipt and verify their checksums before showing Assembly Evidence as loaded.</p>\n<h2>Why this matters</h2>\n<p>This project is about controlled local evolution, not arbitrary runtime mutation. Every generated route should be a chain of ordinary files that can be inspected, replayed, and rejected when drift is detected.</p>",
    "markdown": "# Adapters & Assembly\n\nAdapters are how TinyRustLM explores small, modular model changes without pretending every change is a finished model.\n\n## Adapter package types\n\n| Package | Meaning | Runtime role |\n| --- | --- | --- |\n| ADP1 | Raw f32 task-delta adapter package. | Can be validated and applied to compatible f32/q8_0/q4_0 loaded models. |\n| ASP1 | Sparse f32 task-delta adapter package. | Compact sparse route with retention and mask metadata. |\n| ALR1 | Low-rank adapter package. | Factor-based low-rank route with source-backed metadata. |\n\nRust is the package authority. JavaScript may select and transfer adapter bytes, but Rust validates identity, checksums, tensor directory, tokenizer, layout, finite payload values, sparse indexes or low-rank shapes, and fused values before mutation.\n\n## Generated assembly chain\n\nGenerated browser bundles can carry:\n\n1. selector registry;\n2. module-plan receipt;\n3. model bytes;\n4. model manifest;\n5. assembly receipt;\n6. evidence files;\n7. adapter-family receipt;\n8. adapter manifests;\n9. ADP1, ASP1, and ALR1 stack artifacts;\n10. Rust validation calls;\n11. Rust apply calls;\n12. diagnostics proving the assembly state.\n\n## Module plan\n\nA module plan is a browser-constrained assembly receipt. It states what must be fetched, in what class, under what byte budgets, with what checksums, roles, phases, dependencies, and slots.\n\nThe browser must verify the plan before fetching generated model bytes. This prevents a selector registry from silently routing an unplanned artifact.\n\n## Selector registry\n\nThe selector registry is the browser route gate. It carries entries for admitted model candidates and optional adapter families. It must include budget fields such as model byte budgets and text-sidecar budgets before generated entries are accepted.\n\n## Assembly receipt\n\nThe assembly receipt binds the model manifest, ledger, review, recipe, operator, candidate, promotion, runtime, eval, admission, eval-case digest, and adapter-family evidence by checksum.\n\nThe browser should fetch evidence files referenced by the receipt and verify their checksums before showing Assembly Evidence as loaded.\n\n## Why this matters\n\nThis project is about controlled local evolution, not arbitrary runtime mutation. Every generated route should be a chain of ordinary files that can be inspected, replayed, and rejected when drift is detected."
  },
  {
    "slug": "model-breeding",
    "title": "Model Breeding Pipeline",
    "nav": "Breeding",
    "description": "Offline model breeding pipeline: compatibility, lineage, operators, receipts, candidates, promotion, population review, parent pools, and selector admission.",
    "keywords": "model breeding, TinyRustLM model evolution, parent pool, sign merge, soup, DARE, sparse delta",
    "body_html": "<h1>Model Breeding Pipeline</h1>\n<p>Model breeding in Runtime.MiRust.com is an offline evidence pipeline. It is not a live browser swarm and it is not unbounded self-modification.</p>\n<h2>The pipeline shape</h2>\n<ol><li><strong>Source artifact</strong>: a <code>.slm</code> file, trained-source manifest, or adapter-source manifest.</li><li><strong>Compatibility report</strong>: confirms direct-parameter compatibility before merge-style operators are allowed.</li><li><strong>Lineage template</strong>: binds parents, operator identity, budget, and expected output.</li><li><strong>Operator receipt</strong>: records what the operator did and how to recompute it.</li><li><strong>Candidate manifest</strong>: binds the produced candidate artifact.</li><li><strong>Runtime smoke</strong>: proves the candidate can run.</li><li><strong>Evaluation sidecar</strong>: required before assistant-quality claims.</li><li><strong>Promotion template</strong>: records readiness and pending gates.</li><li><strong>Admission record</strong>: admits evidence-passed candidates.</li><li><strong>Promotion ledger</strong>: hash-chains accepted history.</li><li><strong>Population review</strong>: ranks candidates by objective vectors.</li><li><strong>Parent-pool recipe</strong>: selects parents for later cycles.</li><li><strong>Selector registry</strong>: routes admitted candidates to browser-visible local artifacts.</li></ol>\n<h2>Implemented operator families</h2>\n<p>The source bundle references implemented or routed operator lanes including:</p>\n<ul><li>blend;</li><li>task delta;</li><li>sparse task delta;</li><li>deterministic crossover;</li><li>bounded mutation;</li><li>deterministic magnitude pruning;</li><li>DARE dropout/rescaled task delta;</li><li>federated/local update;</li><li>sign-aware parent-pool merge;</li><li>seed-weighted parent-pool soup.</li></ul>\n<p>Each operator should remain offline until its output passes normal artifact gates.</p>\n<h2>The biology vocabulary translated</h2>\n<div class=\"table-scroll\"><table><thead><tr><th scope=\"col\">Concept</th><th scope=\"col\">Project meaning</th></tr></thead><tbody><tr><td>Heritable artifact</td><td><code>.slm</code>, manifest, receipt, eval sidecar, or adapter package.</td></tr><tr><td>Mate selection</td><td>Compatibility, population review, and parent-pool recipe.</td></tr><tr><td>Phenotype evidence</td><td>Runtime smoke, eval evidence, provenance, and browser smoke.</td></tr><tr><td>Fitness</td><td>Objective-vector review and eval-bound checksums.</td></tr><tr><td>Species fit</td><td>Quantization, tokenizer, layout, adapter, and resource envelope compatibility.</td></tr><tr><td>Novelty</td><td>Behavior-relevant descriptor and evidence checksum.</td></tr></tbody></table></div>\n<h2>Public boundary</h2>\n<p>Do not describe this as autonomous replication. Describe it as controlled candidate assembly with evidence, manifests, receipts, and explicit promotion gates.</p>",
    "markdown": "# Model Breeding Pipeline\n\nModel breeding in Runtime.MiRust.com is an offline evidence pipeline. It is not a live browser swarm and it is not unbounded self-modification.\n\n## The pipeline shape\n\n1. **Source artifact**: a `.slm` file, trained-source manifest, or adapter-source manifest.\n2. **Compatibility report**: confirms direct-parameter compatibility before merge-style operators are allowed.\n3. **Lineage template**: binds parents, operator identity, budget, and expected output.\n4. **Operator receipt**: records what the operator did and how to recompute it.\n5. **Candidate manifest**: binds the produced candidate artifact.\n6. **Runtime smoke**: proves the candidate can run.\n7. **Evaluation sidecar**: required before assistant-quality claims.\n8. **Promotion template**: records readiness and pending gates.\n9. **Admission record**: admits evidence-passed candidates.\n10. **Promotion ledger**: hash-chains accepted history.\n11. **Population review**: ranks candidates by objective vectors.\n12. **Parent-pool recipe**: selects parents for later cycles.\n13. **Selector registry**: routes admitted candidates to browser-visible local artifacts.\n\n## Implemented operator families\n\nThe source bundle references implemented or routed operator lanes including:\n\n- blend;\n- task delta;\n- sparse task delta;\n- deterministic crossover;\n- bounded mutation;\n- deterministic magnitude pruning;\n- DARE dropout/rescaled task delta;\n- federated/local update;\n- sign-aware parent-pool merge;\n- seed-weighted parent-pool soup.\n\nEach operator should remain offline until its output passes normal artifact gates.\n\n## The biology vocabulary translated\n\n| Concept | Project meaning |\n| --- | --- |\n| Heritable artifact | `.slm`, manifest, receipt, eval sidecar, or adapter package. |\n| Mate selection | Compatibility, population review, and parent-pool recipe. |\n| Phenotype evidence | Runtime smoke, eval evidence, provenance, and browser smoke. |\n| Fitness | Objective-vector review and eval-bound checksums. |\n| Species fit | Quantization, tokenizer, layout, adapter, and resource envelope compatibility. |\n| Novelty | Behavior-relevant descriptor and evidence checksum. |\n\n## Public boundary\n\nDo not describe this as autonomous replication. Describe it as controlled candidate assembly with evidence, manifests, receipts, and explicit promotion gates."
  },
  {
    "slug": "proof-testing",
    "title": "Proof & Testing",
    "nav": "Proof",
    "description": "Testing and evidence strategy for TinyRustLM, including Rust unit tests, browser smokes, WASM ABI checks, route drift tests, and quality gates.",
    "keywords": "TinyRustLM tests, browser smoke, Rust tests, WASM ABI smoke, model quality gate",
    "body_html": "<h1>Proof &amp; Testing</h1>\n<p>Support claims on Runtime.MiRust.com should map to evidence. The source code already treats tests as part of the architecture.</p>\n<h2>Test categories</h2>\n<div class=\"table-scroll\"><table><thead><tr><th scope=\"col\">Test lane</th><th scope=\"col\">What it protects</th></tr></thead><tbody><tr><td>Rust unit tests</td><td>Math ops, parser rules, tokenizer, quantization, adapters, packer operators, receipts, manifests.</td></tr><tr><td>WASM ABI smoke</td><td>Export boundary, allocation, model load, generation, next token, adapter validation/apply, reset, free.</td></tr><tr><td>Browser harness</td><td>Static app IDs, local-only markers, route declarations, manifest presence, content types.</td></tr><tr><td>Browser smoke</td><td>Headless browser behavior, model load, generation, Step Token, Adapter Sidecar, selector registries, module-plan drift rejection, assembly evidence checks.</td></tr><tr><td>Route soaks</td><td>Repeated q4_0/q8_0/f32 generated assembly routes, reload behavior, no-store fetches, model release before reassembly.</td></tr><tr><td>Visual Studio scripts</td><td>Build, test, copy WASM, check model artifacts, run browser harness, reuse local server.</td></tr></tbody></table></div>\n<h2>Drift tests</h2>\n<p>Generated routes should reject checksum-consistent but semantically wrong metadata. The source references drift gates for:</p>\n<ul><li>runtime manifest drift;</li><li>selector byte-budget drift;</li><li>text-sidecar budget drift;</li><li>module-plan profile drift;</li><li>execution profile drift;</li><li>fetch policy drift;</li><li>origin policy drift;</li><li>fetch-count drift;</li><li>resource drift;</li><li>graph drift;</li><li>stack drift;</li><li>role drift;</li><li>slot drift;</li><li>phase drift;</li><li>dependency drift;</li><li>byte-count drift;</li><li>checksum drift;</li><li>assembly eval-case drift;</li><li>assembly evidence-file drift;</li><li>adapter manifest drift;</li><li>adapter artifact drift;</li><li>adapter Rust validation drift.</li></ul>\n<h2>Quality gates</h2>\n<p>A runtime smoke model proves runtime behavior. It does not prove assistant usefulness.</p>\n<p>Assistant-quality claims need converted-trained provenance and a matching passed evaluation sidecar with declared cases, prompts, expected text, actual text, totals, and checksums.</p>\n<h2>Public evidence wording</h2>\n<p>Use phrases such as:</p>\n<ul><li>“source-backed at bundle time”;</li><li>“runtime-smoke evidence”;</li><li>“deterministic fixture”;</li><li>“quality not claimed yet”;</li><li>“accepted for runtime smoke”;</li><li>“requires trained/evaluated model before product-quality claim.”</li></ul>\n<p>Avoid implying that deterministic smoke models are production assistants.</p>",
    "markdown": "# Proof & Testing\n\nSupport claims on Runtime.MiRust.com should map to evidence. The source code already treats tests as part of the architecture.\n\n## Test categories\n\n| Test lane | What it protects |\n| --- | --- |\n| Rust unit tests | Math ops, parser rules, tokenizer, quantization, adapters, packer operators, receipts, manifests. |\n| WASM ABI smoke | Export boundary, allocation, model load, generation, next token, adapter validation/apply, reset, free. |\n| Browser harness | Static app IDs, local-only markers, route declarations, manifest presence, content types. |\n| Browser smoke | Headless browser behavior, model load, generation, Step Token, Adapter Sidecar, selector registries, module-plan drift rejection, assembly evidence checks. |\n| Route soaks | Repeated q4_0/q8_0/f32 generated assembly routes, reload behavior, no-store fetches, model release before reassembly. |\n| Visual Studio scripts | Build, test, copy WASM, check model artifacts, run browser harness, reuse local server. |\n\n## Drift tests\n\nGenerated routes should reject checksum-consistent but semantically wrong metadata. The source references drift gates for:\n\n- runtime manifest drift;\n- selector byte-budget drift;\n- text-sidecar budget drift;\n- module-plan profile drift;\n- execution profile drift;\n- fetch policy drift;\n- origin policy drift;\n- fetch-count drift;\n- resource drift;\n- graph drift;\n- stack drift;\n- role drift;\n- slot drift;\n- phase drift;\n- dependency drift;\n- byte-count drift;\n- checksum drift;\n- assembly eval-case drift;\n- assembly evidence-file drift;\n- adapter manifest drift;\n- adapter artifact drift;\n- adapter Rust validation drift.\n\n## Quality gates\n\nA runtime smoke model proves runtime behavior. It does not prove assistant usefulness.\n\nAssistant-quality claims need converted-trained provenance and a matching passed evaluation sidecar with declared cases, prompts, expected text, actual text, totals, and checksums.\n\n## Public evidence wording\n\nUse phrases such as:\n\n- “source-backed at bundle time”;\n- “runtime-smoke evidence”;\n- “deterministic fixture”;\n- “quality not claimed yet”;\n- “accepted for runtime smoke”;\n- “requires trained/evaluated model before product-quality claim.”\n\nAvoid implying that deterministic smoke models are production assistants."
  },
  {
    "slug": "developer-docs",
    "title": "Developer Docs",
    "nav": "Docs",
    "description": "Developer documentation map for Runtime.MiRust.com, TinyRustLM, local build commands, source structure, model artifacts, and proof files.",
    "keywords": "TinyRustLM developer docs, Runtime.MiRust.com README, Rust WASM build, local server",
    "body_html": "<h1>Developer Docs</h1>\n<p>This page is the public map from website readers to the implementation structure.</p>\n<h2>Important source files</h2>\n<div class=\"table-scroll\"><table><thead><tr><th scope=\"col\">File or directory</th><th scope=\"col\">Purpose</th></tr></thead><tbody><tr><td><code>README.md</code></td><td>Workspace overview and command entry.</td></tr><tr><td><code>tinyrustlm/README.md</code></td><td>TinyRustLM app and runtime overview.</td></tr><tr><td><code>tinyrustlm/docs/architecture.md</code></td><td>Architecture detail.</td></tr><tr><td><code>tinyrustlm/docs/browser-runtime.md</code></td><td>Browser-local runtime detail.</td></tr><tr><td><code>tinyrustlm/docs/slm-format.md</code></td><td><code>.slm</code> model format detail.</td></tr><tr><td><code>tinyrustlm/docs/tokenizer.md</code></td><td>Byte tokenizer and BPE fixture rules.</td></tr><tr><td><code>tinyrustlm/docs/quantization.md</code></td><td>f32/q8_0/q4_0 support boundaries.</td></tr><tr><td><code>tinyrustlm/docs/testing.md</code></td><td>Test matrix and proof expectations.</td></tr><tr><td><code>tinyrustlm/docs/performance.md</code></td><td>Scratch, logits, sampling, output cap, and benchmark guidance.</td></tr><tr><td><code>wiki/runtime-mirust/</code></td><td>Local LLM Wiki source namespace.</td></tr><tr><td><code>.uai/</code></td><td>Project handoff memory and source routing.</td></tr></tbody></table></div>\n<h2>Useful local commands</h2>\n<p>The exact command set evolves with the source tree, but the public site can safely describe the command families:</p>\n<pre><code class=\"language-bash\">cargo fmt --all\ncargo test --workspace\ncargo run -p tinyrustlm-browser-harness -- tinyrustlm\nnode tinyrustlm/tools/wasm-abi-smoke.js\nnode tinyrustlm/tools/browser-smoke.js</code></pre>\n<p>Visual Studio wrapper scripts live under <code>tools/vs/</code> for build, run, and test flows.</p>\n<h2>Website content rule</h2>\n<p>Developer docs on this site should summarize source-backed boundaries. They should not replace the repository docs, and they should not claim support that the tests do not support.</p>\n<h2>Agent-readable docs</h2>\n<p>This site exposes <code>llms.txt</code>, <code>llms-full.txt</code>, Markdown alternates, and semantic page structure so AI systems can cite the project accurately without scraping a generic plain PHP shell.</p>\n<h2>Root /docs corpus</h2>\n<p>The full root package also publishes <a href=\"/docs/index.md\"><code>/docs/index.md</code></a>, <a href=\"/docs/reports/index.md\"><code>/docs/reports/index.md</code></a>, and <a href=\"/docs/long-term-memory.uai\"><code>/docs/long-term-memory.uai</code></a>. The hot .uai deep-link map is <a href=\"/.uai/docs-routing.uai\"><code>/.uai/docs-routing.uai</code></a>.</p>",
    "markdown": "# Developer Docs\n\nThis page is the public map from website readers to the implementation structure.\n\n## Important source files\n\n| File or directory | Purpose |\n| --- | --- |\n| `README.md` | Workspace overview and command entry. |\n| `tinyrustlm/README.md` | TinyRustLM app and runtime overview. |\n| `tinyrustlm/docs/architecture.md` | Architecture detail. |\n| `tinyrustlm/docs/browser-runtime.md` | Browser-local runtime detail. |\n| `tinyrustlm/docs/slm-format.md` | `.slm` model format detail. |\n| `tinyrustlm/docs/tokenizer.md` | Byte tokenizer and BPE fixture rules. |\n| `tinyrustlm/docs/quantization.md` | f32/q8_0/q4_0 support boundaries. |\n| `tinyrustlm/docs/testing.md` | Test matrix and proof expectations. |\n| `tinyrustlm/docs/performance.md` | Scratch, logits, sampling, output cap, and benchmark guidance. |\n| `wiki/runtime-mirust/` | Local LLM Wiki source namespace. |\n| `.uai/` | Project handoff memory and source routing. |\n\n## Useful local commands\n\nThe exact command set evolves with the source tree, but the public site can safely describe the command families:\n\n```bash\ncargo fmt --all\ncargo test --workspace\ncargo run -p tinyrustlm-browser-harness -- tinyrustlm\nnode tinyrustlm/tools/wasm-abi-smoke.js\nnode tinyrustlm/tools/browser-smoke.js\n```\n\nVisual Studio wrapper scripts live under `tools/vs/` for build, run, and test flows.\n\n## Website content rule\n\nDeveloper docs on this site should summarize source-backed boundaries. They should not replace the repository docs, and they should not claim support that the tests do not support.\n\n## Agent-readable docs\n\nThis site exposes `llms.txt`, `llms-full.txt`, Markdown alternates, and semantic page structure so AI systems can cite the project accurately without scraping a generic plain PHP shell.\n\n## Root /docs corpus\n\nThe full root package also publishes [`/docs/index.md`](/docs/index.md), [`/docs/reports/index.md`](/docs/reports/index.md), and [`/docs/long-term-memory.uai`](/docs/long-term-memory.uai). The hot .uai deep-link map is [`/.uai/docs-routing.uai`](./.uai/docs-routing.uai)."
  },
  {
    "slug": "memory-reports",
    "title": "Memory & Reports",
    "nav": "Memory",
    "description": "Public map of the Runtime.MiRust.com .uai memory suite, /docs reports, long-term memory ledger, and UAIX file-handoff routing.",
    "keywords": "Runtime.MiRust.com UAI memory, .uai, long-term memory, docs reports, file handoff, LLM Wiki",
    "body_html": "<h1>Memory &amp; Reports</h1>\n<p>This page explains the public memory layer packaged with the site. The project now ships a root <code>/.uai/</code> folder for hot project memory and a root <code>/docs/</code> folder for durable report bodies, implementation docs, and the published long-term memory ledger.</p>\n<h2>Primary memory routes</h2>\n<div class=\"table-scroll\"><table><thead><tr><th scope=\"col\">Route</th><th scope=\"col\">Purpose</th></tr></thead><tbody><tr><td><a href=\"/docs/index.md\"><code>/docs/index.md</code></a></td><td>Durable documentation index for reports, research, implementation docs, source-memory pages, and dogfood notes.</td></tr><tr><td><a href=\"/docs/reports/index.md\"><code>/docs/reports/index.md</code></a></td><td>Index of source-backed report memory extracted from the review bundle.</td></tr><tr><td><a href=\"/docs/long-term-memory.uai\"><code>/docs/long-term-memory.uai</code></a></td><td>Published copy of the long-term pointer ledger with public-docs overlay.</td></tr><tr><td><a href=\"/.uai/docs-routing.uai\"><code>/.uai/docs-routing.uai</code></a></td><td>Hot deep-link map from .uai memory to every durable report and memory file.</td></tr><tr><td><a href=\"/.uai/long-term-memory.uai\"><code>/.uai/long-term-memory.uai</code></a></td><td>Active long-term pointer ledger.</td></tr><tr><td><a href=\"/.uai/file-handoff.uai\"><code>/.uai/file-handoff.uai</code></a></td><td>Agent File Handoff configuration and active intake rules.</td></tr></tbody></table></div>\n<h2>Why reports live in /docs instead of hot .uai files</h2>\n<p>The site follows the file-handoff pattern: <code>.uai</code> files carry current routing, synthesis, pointer records, checksums, and startup guidance. Full report bodies live in durable Markdown under <code>/docs/</code>, where humans and agents can deep-link exact sources without overloading the startup memory layer.</p>\n<h2>Included durable memory</h2>\n<ul><li>source report bodies under <code>/docs/reports/</code>;</li><li>model-breeding and zero-dependency research under <code>/docs/research/</code>;</li><li>uploaded website architecture research under <code>/docs/web-research/</code>;</li><li>source-memory maps under <code>/docs/source-memory/</code>;</li><li>TinyRustLM implementation docs under <code>/docs/implementation/</code>;</li><li>UAIX dogfood notes under <code>/docs/dogfood/</code>;</li><li>the published long-term memory ledger at <code>/docs/long-term-memory.uai</code>.</li></ul>\n<h2>Agent startup rule</h2>\n<p>For memory-aware work, start with <code>/.uai/index.uai</code>, then <code>/.uai/docs-routing.uai</code>, then <code>/.uai/long-term-memory.uai</code>. Open the durable report or research body only when the current task needs that evidence.</p>",
    "markdown": "# Memory & Reports\n\nThis page explains the public memory layer packaged with the site. The project now ships a root `/.uai/` folder for hot project memory and a root `/docs/` folder for durable report bodies, implementation docs, and the published long-term memory ledger.\n\n## Primary memory routes\n\n| Route | Purpose |\n| --- | --- |\n| [`/docs/index.md`](/docs/index.md) | Durable documentation index for reports, research, implementation docs, source-memory pages, and dogfood notes. |\n| [`/docs/reports/index.md`](/docs/reports/index.md) | Index of source-backed report memory extracted from the review bundle. |\n| [`/docs/long-term-memory.uai`](/docs/long-term-memory.uai) | Published copy of the long-term pointer ledger with public-docs overlay. |\n| [`/.uai/docs-routing.uai`](./.uai/docs-routing.uai) | Hot deep-link map from .uai memory to every durable report and memory file. |\n| [`/.uai/long-term-memory.uai`](./.uai/long-term-memory.uai) | Active long-term pointer ledger. |\n| [`/.uai/file-handoff.uai`](./.uai/file-handoff.uai) | Agent File Handoff configuration and active intake rules. |\n\n## Why reports live in /docs instead of hot .uai files\n\nThe site follows the file-handoff pattern: `.uai` files carry current routing, synthesis, pointer records, checksums, and startup guidance. Full report bodies live in durable Markdown under `/docs/`, where humans and agents can deep-link exact sources without overloading the startup memory layer.\n\n## Included durable memory\n\n- source report bodies under `/docs/reports/`;\n- model-breeding and zero-dependency research under `/docs/research/`;\n- uploaded website architecture research under `/docs/web-research/`;\n- source-memory maps under `/docs/source-memory/`;\n- TinyRustLM implementation docs under `/docs/implementation/`;\n- UAIX dogfood notes under `/docs/dogfood/`;\n- the published long-term memory ledger at `/docs/long-term-memory.uai`.\n\n## Agent startup rule\n\nFor memory-aware work, start with `/.uai/index.uai`, then `/.uai/docs-routing.uai`, then `/.uai/long-term-memory.uai`. Open the durable report or research body only when the current task needs that evidence."
  },
  {
    "slug": "agent-readiness",
    "title": "Agent-Readable Site",
    "nav": "Agent Site",
    "description": "How this plain PHP package makes Runtime.MiRust.com readable to AI agents with semantic HTML, Markdown alternates, llms.txt, and no dependency-heavy front-end runtime.",
    "keywords": "llms.txt, AI readable website, Markdown content negotiation, plain PHP agent ready, semantic HTML",
    "body_html": "<h1>Agent-Readable Site</h1>\n<p>This plain PHP package implements the same philosophy as the runtime: keep the trusted surface small and make the structure explicit.</p>\n<h2>Human and machine surfaces</h2>\n<div class=\"table-scroll\"><table><thead><tr><th scope=\"col\">Surface</th><th scope=\"col\">Purpose</th></tr></thead><tbody><tr><td>HTML pages</td><td>Human-facing project site with semantic structure.</td></tr><tr><td>Markdown alternates</td><td>Token-efficient versions for LLMs and coding agents.</td></tr><tr><td><code>llms.txt</code></td><td>Curated site map for agents.</td></tr><tr><td><code>llms-full.txt</code></td><td>Single-file corpus for project summary ingestion.</td></tr><tr><td><code>robots.txt</code></td><td>Explicit crawl map and sitemap reference.</td></tr><tr><td>JSON-LD</td><td>Search and answer-engine entity clarity.</td></tr><tr><td>Sitemap XML</td><td>Conventional crawler route map.</td></tr></tbody></table></div>\n<h2>No front-end dependency stack</h2>\n<p>The site does not use Bootstrap, Tailwind, jQuery, Popper, React, Vue, Angular, or page builders. It uses plain PHP, semantic HTML, custom CSS, and small handwritten JavaScript.</p>\n<h2>Native web techniques used</h2>\n<ul><li>semantic landmarks;</li><li>strict heading hierarchy;</li><li>CSS custom properties;</li><li>container queries;</li><li>native details/summary;</li><li>native dialog for the site map;</li><li>View Transition opt-in where supported;</li><li>reduced-motion guardrails;</li><li>Markdown content negotiation by <code>Accept: text/markdown</code>;</li><li><code>Vary: Accept</code> headers for negotiated Markdown responses.</li></ul>\n<h2>Why it matters</h2>\n<p>AI systems often misread generic PHP-rendered pages because the page says almost nothing about the project. This package makes the project understandable at the URL level, page-title level, heading level, and machine-readable text level.</p>",
    "markdown": "# Agent-Readable Site\n\nThis plain PHP package implements the same philosophy as the runtime: keep the trusted surface small and make the structure explicit.\n\n## Human and machine surfaces\n\n| Surface | Purpose |\n| --- | --- |\n| HTML pages | Human-facing project site with semantic structure. |\n| Markdown alternates | Token-efficient versions for LLMs and coding agents. |\n| `llms.txt` | Curated site map for agents. |\n| `llms-full.txt` | Single-file corpus for project summary ingestion. |\n| `robots.txt` | Explicit crawl map and sitemap reference. |\n| JSON-LD | Search and answer-engine entity clarity. |\n| Sitemap XML | Conventional crawler route map. |\n\n## No front-end dependency stack\n\nThe site does not use Bootstrap, Tailwind, jQuery, Popper, React, Vue, Angular, or page builders. It uses plain PHP, semantic HTML, custom CSS, and small handwritten JavaScript.\n\n## Native web techniques used\n\n- semantic landmarks;\n- strict heading hierarchy;\n- CSS custom properties;\n- container queries;\n- native details/summary;\n- native dialog for the site map;\n- View Transition opt-in where supported;\n- reduced-motion guardrails;\n- Markdown content negotiation by `Accept: text/markdown`;\n- `Vary: Accept` headers for negotiated Markdown responses.\n\n## Why it matters\n\nAI systems often misread generic PHP-rendered pages because the page says almost nothing about the project. This package makes the project understandable at the URL level, page-title level, heading level, and machine-readable text level."
  },
  {
    "slug": "roadmap-boundaries",
    "title": "Roadmap & Boundaries",
    "nav": "Roadmap",
    "description": "Current support boundaries and future roadmap for TinyRustLM, including GGUF import, trained-quality models, LoRA, WebGPU, OPFS, workers, and persistence.",
    "keywords": "TinyRustLM roadmap, GGUF import roadmap, trained model quality boundary, local AI runtime roadmap",
    "body_html": "<h1>Roadmap &amp; Boundaries</h1>\n<p>The project has broad ambition, but the public site must preserve the current evidence boundary.</p>\n<h2>Current support boundary</h2>\n<p>The current source-backed implementation supports the TinyRustLM lane:</p>\n<ul><li>static browser shell;</li><li>no-crate Rust/WASM runtime;</li><li>custom <code>.slm</code> format;</li><li>deterministic smoke artifacts;</li><li>f32/q8_0/q4_0 routes;</li><li>model manifests and provenance display;</li><li>ADP1/ASP1/ALR1 adapter validation and apply;</li><li>selector registry route gates;</li><li>module-plan receipt gates;</li><li>assembly and adapter-family receipt gates;</li><li>browser smoke and route drift evidence.</li></ul>\n<h2>Not claimed yet</h2>\n<p>The site should not claim:</p>\n<ul><li>general trained assistant quality;</li><li>production assistant accuracy;</li><li>broad GGUF model import;</li><li>remote model hosting;</li><li>hidden model download;</li><li>telemetry-driven production monitoring;</li><li>live autonomous model replication;</li><li>Mini Browser orchestration as a completed feature.</li></ul>\n<h2>Future lanes</h2>\n<div class=\"table-scroll\"><table><thead><tr><th scope=\"col\">Lane</th><th scope=\"col\">Future direction</th></tr></thead><tbody><tr><td>GGUF import</td><td>Add only after parser, tensor routing, tokenizer, quantization, manifests, and browser smoke proof exist.</td></tr><tr><td>Trained models</td><td>Add with raw source manifests, provenance, runtime smoke, eval sidecars, and quality gates.</td></tr><tr><td>LoRA-style adapters</td><td>Extend ADP1/ASP1/ALR1 with trained factor evidence and runtime validation.</td></tr><tr><td>Multi-model routing</td><td>Introduce after one local runtime path remains stable under tests.</td></tr><tr><td>WebGPU</td><td>Compare after CPU/WASM correctness and evidence routes are mature.</td></tr><tr><td>OPFS and persistence</td><td>Add after privacy, storage, checksum, and recovery boundaries are explicit.</td></tr><tr><td>Workers</td><td>Add after current single-threaded WASM proof remains stable.</td></tr><tr><td>Agent integration</td><td>Keep the site agent-readable before exposing richer browser tools.</td></tr></tbody></table></div>\n<h2>Public language rule</h2>\n<p>Use “planned,” “future,” “not claimed yet,” and “requires proof” where appropriate. That keeps the project credible and prevents ModelBreeder-style ideas from being mistaken for completed runtime behavior.</p>",
    "markdown": "# Roadmap & Boundaries\n\nThe project has broad ambition, but the public site must preserve the current evidence boundary.\n\n## Current support boundary\n\nThe current source-backed implementation supports the TinyRustLM lane:\n\n- static browser shell;\n- no-crate Rust/WASM runtime;\n- custom `.slm` format;\n- deterministic smoke artifacts;\n- f32/q8_0/q4_0 routes;\n- model manifests and provenance display;\n- ADP1/ASP1/ALR1 adapter validation and apply;\n- selector registry route gates;\n- module-plan receipt gates;\n- assembly and adapter-family receipt gates;\n- browser smoke and route drift evidence.\n\n## Not claimed yet\n\nThe site should not claim:\n\n- general trained assistant quality;\n- production assistant accuracy;\n- broad GGUF model import;\n- remote model hosting;\n- hidden model download;\n- telemetry-driven production monitoring;\n- live autonomous model replication;\n- Mini Browser orchestration as a completed feature.\n\n## Future lanes\n\n| Lane | Future direction |\n| --- | --- |\n| GGUF import | Add only after parser, tensor routing, tokenizer, quantization, manifests, and browser smoke proof exist. |\n| Trained models | Add with raw source manifests, provenance, runtime smoke, eval sidecars, and quality gates. |\n| LoRA-style adapters | Extend ADP1/ASP1/ALR1 with trained factor evidence and runtime validation. |\n| Multi-model routing | Introduce after one local runtime path remains stable under tests. |\n| WebGPU | Compare after CPU/WASM correctness and evidence routes are mature. |\n| OPFS and persistence | Add after privacy, storage, checksum, and recovery boundaries are explicit. |\n| Workers | Add after current single-threaded WASM proof remains stable. |\n| Agent integration | Keep the site agent-readable before exposing richer browser tools. |\n\n## Public language rule\n\nUse “planned,” “future,” “not claimed yet,” and “requires proof” where appropriate. That keeps the project credible and prevents ModelBreeder-style ideas from being mistaken for completed runtime behavior."
  },
  {
    "slug": "contact-mike-kappel",
    "title": "Contact Mike Kappel",
    "nav": "Contact",
    "description": "Contact page for Michael Kappel, with public email, phone, Signal, professional links, personal domains, and source notes for Runtime.MiRust.com questions.",
    "keywords": "Contact Mike Kappel, Michael Kappel contact, Runtime.MiRust.com contact, TinyRustLM contact",
    "body_html": "<h1>Contact Mike Kappel</h1>\n<blockquote><p>Use this page for questions about Runtime.MiRust.com, TinyRustLM, local Rust/WASM model work, plain PHP implementation, source-backed project documentation, or related engineering review.</p></blockquote>\n<p>Michael Kappel is a senior software engineer and software architect focused on enterprise modernization, .NET, SQL Server, TypeScript/Angular, and human-reviewed AI-assisted engineering. The project site links here so visitors do not have to leave the source-backed documentation path just to find the maintainer.</p>\n<h2>Direct contact</h2>\n<div class=\"contact-grid\">\n  <article class=\"contact-card contact-card--primary\">\n    <p class=\"eyebrow\">Primary email</p>\n    <h3><a href=\"mailto:mike@ns12.com\">mike@ns12.com</a></h3>\n    <p>Best first option for project questions, implementation review, consulting, or technical follow-up.</p>\n    <p class=\"contact-actions\"><a class=\"button button--primary\" href=\"mailto:mike@ns12.com\">Email Mike</a> <button class=\"button button--ghost\" type=\"button\" data-copy=\"mike@ns12.com\">Copy</button></p>\n  </article>\n  <article class=\"contact-card\">\n    <p class=\"eyebrow\">Primary phone</p>\n    <h3><a href=\"tel:+16303627576\">(630) 362-7576</a></h3>\n    <p>Primary public phone number listed on MikeKappel.com and MJK.tel.</p>\n    <p class=\"contact-actions\"><a class=\"button\" href=\"tel:+16303627576\">Call</a> <button class=\"button button--ghost\" type=\"button\" data-copy=\"(630) 362-7576\">Copy</button></p>\n  </article>\n  <article class=\"contact-card\">\n    <p class=\"eyebrow\">Signal</p>\n    <h3>Mike.7576</h3>\n    <p>Signal username listed on the public contact hub.</p>\n    <p class=\"contact-actions\"><button class=\"button\" type=\"button\" data-copy=\"Mike.7576\">Copy Signal</button></p>\n  </article>\n</div>\n<h2>Professional and project links</h2>\n<div class=\"table-scroll\"><table><thead><tr><th scope=\"col\">Link</th><th scope=\"col\">Use</th></tr></thead><tbody><tr><td><a href=\"https://MikeKappel.com/\" rel=\"me noopener\">MikeKappel.com</a></td><td>Resume, project evidence, selected projects, case studies, and contact route.</td></tr><tr><td><a href=\"https://MJK.tel/\" rel=\"me noopener\">MJK.tel</a></td><td>Central public contact hub with vCard, phone, Signal, domains, and profiles.</td></tr><tr><td><a href=\"https://www.linkedin.com/in/michaelkappel\" rel=\"me noopener\">LinkedIn</a></td><td>Professional profile.</td></tr><tr><td><a href=\"https://github.com/MichaelKappel\" rel=\"me noopener\">GitHub</a></td><td>Public development profile and repositories.</td></tr><tr><td><a href=\"https://MichaelJosephKappel.com/\" rel=\"me noopener\">MichaelJosephKappel.com</a></td><td>Full-name personal domain and creative/photography route.</td></tr></tbody></table></div>\n<h2>Contact context</h2>\n<p>For Runtime.MiRust.com, include the page or artifact you are reviewing, the exact claim or UI behavior in question, and whether the question concerns the plain PHP site package, the Rust/WASM runtime, the <code>.slm</code> model path, adapter/assembly evidence, or future GGUF import work.</p>\n<h2>Public source note</h2>\n<p>The contact details on this page are taken from the public MikeKappel.com and MJK.tel contact surfaces. If those sources change, treat them as the authority and refresh this page in the next package revision.</p>",
    "markdown": "# Contact Mike Kappel\n\n> Use this page for questions about Runtime.MiRust.com, TinyRustLM, local Rust/WASM model work, plain PHP implementation, source-backed project documentation, or related engineering review.\n\nMichael Kappel is a senior software engineer and software architect focused on enterprise modernization, .NET, SQL Server, TypeScript/Angular, and human-reviewed AI-assisted engineering. The project site links here so visitors do not have to leave the source-backed documentation path just to find the maintainer.\n\n## Direct contact\n\n| Channel | Detail | Use |\n| --- | --- | --- |\n| Primary email | mike@ns12.com | Best first option for project questions, implementation review, consulting, or technical follow-up. |\n| Primary phone | (630) 362-7576 | Primary public phone number listed on MikeKappel.com and MJK.tel. |\n| Signal | Mike.7576 | Public Signal username listed on MJK.tel. |\n\n## Professional and project links\n\n| Link | Use |\n| --- | --- |\n| [MikeKappel.com](https://MikeKappel.com/) | Resume, project evidence, selected projects, case studies, and contact route. |\n| [MJK.tel](https://MJK.tel/) | Central public contact hub with vCard, phone, Signal, domains, and profiles. |\n| [LinkedIn](https://www.linkedin.com/in/michaelkappel) | Professional profile. |\n| [GitHub](https://github.com/MichaelKappel) | Public development profile and repositories. |\n| [MichaelJosephKappel.com](https://MichaelJosephKappel.com/) | Full-name personal domain and creative/photography route. |\n\n## Contact context\n\nFor Runtime.MiRust.com, include the page or artifact you are reviewing, the exact claim or UI behavior in question, and whether the question concerns the plain PHP site package, the Rust/WASM runtime, the `.slm` model path, adapter/assembly evidence, or future GGUF import work.\n\n## Public source note\n\nThe contact details on this page are taken from the public MikeKappel.com and MJK.tel contact surfaces. If those sources change, treat them as the authority and refresh this page in the next package revision."
  },
  {
    "slug": "site-audit-response",
    "title": "Site Audit Response",
    "nav": "Audit Response",
    "description": "How the attached infrastructure and semantic namespace review was converted into concrete Runtime.MiRust.com site improvements.",
    "keywords": "Runtime.MiRust.com site audit, website improvement plan, infrastructure trust, namespace clarity, agent readable plain PHP",
    "body_html": "<h1>Site Audit Response</h1>\n<blockquote><p>The attached review is a site-infrastructure and namespace-risk report. It is not TinyRustLM source evidence. The applicable lesson is direct: a technical project site must first be reachable, secure, disambiguated, crawlable, and evidence-backed.</p></blockquote>\n<h2>How the report changes this site</h2>\n<p>The report treats foundational availability as the first-order failure mode: if DNS, transport, and routing fail, every content or interface improvement becomes irrelevant. This package turns that into an explicit Runtime.MiRust.com launch gate instead of leaving it as an operations afterthought.</p>\n<div class=\"table-scroll\"><table><thead><tr><th scope=\"col\">Report pressure</th><th scope=\"col\">Site change</th><th scope=\"col\">New route</th></tr></thead><tbody><tr><td>Network blackout risk</td><td>Added a deployment checklist that tests DNS, TLS, root pages, static docs, and machine-readable endpoints before the site is considered live.</td><td><a href=\"/deployment-checklist/\">Deployment Checklist</a></td></tr><tr><td>DNS and cryptographic records</td><td>Added a host-neutral infrastructure page covering A/AAAA, CAA, DNSSEC, SPF, DKIM, DMARC, TLS, HSTS, cache, and route stability.</td><td><a href=\"/site-infrastructure/\">Infrastructure &amp; Trust</a></td></tr><tr><td>Namespace collision</td><td>Added a scope page that distinguishes Runtime.MiRust.com, TinyRustLM, <code>.slm</code>, current proof, and future GGUF work.</td><td><a href=\"/name-scope/\">Name &amp; Scope</a></td></tr><tr><td>Research credibility</td><td>Added an R&amp;D page that explains how reports become docs, pointer memory, and public claims.</td><td><a href=\"/research-development/\">Research &amp; Development</a></td></tr><tr><td>Machine-readable structure</td><td>Expanded top navigation, <code>llms.txt</code>, <code>llms-full.txt</code>, sitemap routing, and <code>.uai</code> deep links.</td><td><a href=\"/agent-readiness/\">Agent-Readable Site</a></td></tr></tbody></table></div>\n<h2>What changed in v1.0.4</h2>\n<ul><li>New trust-oriented top menu group.</li><li>New seeded pages for site audit response, infrastructure, naming, R&amp;D, and deployment verification.</li><li>New static <code>/.well-known/security.txt</code> route in the root package.</li><li>Front-end security headers emitted by the site where appropriate.</li><li>Attached report preserved under <code>/docs/web-research/website-review-and-improvement-plan.md</code>.</li><li><code>.uai</code> memory deep-linked to the new report and follow-up pages.</li><li>Home page expanded with an audit-driven improvement map.</li></ul>\n<h2>Adapted, not copied</h2>\n<p>The report contains broad examples from adjacent namespaces and recommends some stacks that are intentionally outside this project’s constraints. Runtime.MiRust.com remains a plain PHP site with semantic PHP-rendered content, custom CSS, and small handwritten JavaScript. It does not adopt React, Tailwind, Vite, Bootstrap, jQuery, or page builders.</p>\n<h2>Current public rule</h2>\n<p>Every major public claim should point to one of three things: a source-backed implementation page, a durable <code>/docs/</code> report, or a hot <code>.uai</code> pointer that routes to durable evidence. Claims that cannot point to evidence belong on the roadmap, not in the hero.</p>",
    "markdown": "# Site Audit Response\n\n> The attached review is a site-infrastructure and namespace-risk report. It is not TinyRustLM source evidence. The applicable lesson is direct: a technical project site must first be reachable, secure, disambiguated, crawlable, and evidence-backed.\n\n## How the report changes this site\n\nThe report treats foundational availability as the first-order failure mode: if DNS, transport, and routing fail, every content or interface improvement becomes irrelevant. This package turns that into an explicit Runtime.MiRust.com launch gate instead of leaving it as an operations afterthought.\n\n| Report pressure | Site change | New route |\n| --- | --- | --- |\n| Network blackout risk | Added a deployment checklist that tests DNS, TLS, root pages, static docs, and machine-readable endpoints before the site is considered live. | [Deployment Checklist](/deployment-checklist/) |\n| DNS and cryptographic records | Added a host-neutral infrastructure page covering A/AAAA, CAA, DNSSEC, SPF, DKIM, DMARC, TLS, HSTS, cache, and route stability. | [Infrastructure & Trust](/site-infrastructure/) |\n| Namespace collision | Added a scope page that distinguishes Runtime.MiRust.com, TinyRustLM, `.slm`, current proof, and future GGUF work. | [Name & Scope](/name-scope/) |\n| Research credibility | Added an R&D page that explains how reports become docs, pointer memory, and public claims. | [Research & Development](/research-development/) |\n| Machine-readable structure | Expanded top navigation, `llms.txt`, `llms-full.txt`, sitemap routing, and `.uai` deep links. | [Agent-Readable Site](/agent-readiness/) |\n\n## What changed in v1.0.4\n\n- New trust-oriented top menu group.\n- New seeded pages for site audit response, infrastructure, naming, R&D, and deployment verification.\n- New static `/.well-known/security.txt` route in the root package.\n- Front-end security headers emitted by the site where appropriate.\n- Attached report preserved under `/docs/web-research/website-review-and-improvement-plan.md`.\n- `.uai` memory deep-linked to the new report and follow-up pages.\n- Home page expanded with an audit-driven improvement map.\n\n## Adapted, not copied\n\nThe report contains broad examples from adjacent namespaces and recommends some stacks that are intentionally outside this project’s constraints. Runtime.MiRust.com remains a plain PHP site with semantic PHP-rendered content, custom CSS, and small handwritten JavaScript. It does not adopt React, Tailwind, Vite, Bootstrap, jQuery, or page builders.\n\n## Current public rule\n\nEvery major public claim should point to one of three things: a source-backed implementation page, a durable `/docs/` report, or a hot `.uai` pointer that routes to durable evidence. Claims that cannot point to evidence belong on the roadmap, not in the hero."
  },
  {
    "slug": "site-origin-fix",
    "title": "Origin Fix: cPanel Default Page",
    "nav": "Origin Fix",
    "description": "Plain PHP deployment fix notes for cPanel default webpage redirects, stale WordPress files, document roots, DNS, and root extraction.",
    "keywords": "Runtime.MiRust.com cPanel default webpage, cgi-sys defaultwebpage, document root fix, plain PHP deployment",
    "body_html": "<h1>Origin Fix: cPanel Default Page</h1>\n<blockquote><p>If <code>/cgi-sys/defaultwebpage.cgi</code> appears, the request is not reaching the intended Runtime.MiRust.com plain PHP root. Fix the host mapping before doing design work.</p></blockquote>\n<h2>What it means</h2>\n<p>The default cPanel page is usually an origin-routing problem: the subdomain is pointed at a server account, IP, or document root that is not the folder containing this package's <code>index.php</code>. The plain PHP package can only answer requests that arrive at the configured document root.</p>\n<div class=\"status-grid\" aria-label=\"Origin failure map\"><section><h3>DNS</h3><p><code>A</code>/<code>AAAA</code> records must point to the hosting account that owns this subdomain.</p></section><section><h3>Virtual host</h3><p>cPanel must map <code>runtime.mirust.com</code> to the same document root where this package was extracted.</p></section><section><h3>Document root</h3><p>The root folder must contain <code>index.php</code>, <code>.htaccess</code>, <code>assets/</code>, <code>docs/</code>, and <code>.uai/</code> directly.</p></section><section><h3>Stale app files</h3><p>Old WordPress files should not remain as the active route owner for this subdomain.</p></section></div>\n<h2>Immediate checks</h2>\n<pre><code>curl -IL https://runtime.mirust.com/\ncurl -IL https://runtime.mirust.com/index.php\ncurl -IL https://runtime.mirust.com/healthz\ncurl -IL https://runtime.mirust.com/version.json\ncurl -IL https://runtime.mirust.com/cgi-sys/defaultwebpage.cgi</code></pre>\n<p>Expected result: root, <code>index.php</code>, <code>healthz</code>, and <code>version.json</code> return the Runtime.MiRust.com package, and the old <code>cgi-sys</code> path is redirected to this explanation page if it reaches Apache.</p>\n<h2>Root extraction test</h2>\n<p>After extraction, the public root should look like this. If the files are nested in a subfolder, move the files up one level.</p>\n<pre><code>index.php\n.htaccess\nassets/\ninc/\ndata/\ndocs/\n.uai/\nllms.txt\nllms-full.txt\nsitemap.xml\nrobots.txt</code></pre>\n<h2>Stale WordPress cleanup</h2>\n<p>This package now intercepts common WordPress routes through <code>.htaccess</code>, but old files should still be archived or removed after the plain PHP site is confirmed live.</p>\n",
    "markdown": "# Origin Fix: cPanel Default Page\n\n> If `/cgi-sys/defaultwebpage.cgi` appears, the request is not reaching the intended Runtime.MiRust.com plain PHP root. Fix the host mapping before doing design work.\n\n## What it means\n\nThe default cPanel page is usually an origin-routing problem: the subdomain is pointed at a server account, IP, or document root that is not the folder containing this package's `index.php`.\n\n## Immediate checks\n\n```bash\ncurl -IL https://runtime.mirust.com/\ncurl -IL https://runtime.mirust.com/index.php\ncurl -IL https://runtime.mirust.com/healthz\ncurl -IL https://runtime.mirust.com/version.json\ncurl -IL https://runtime.mirust.com/cgi-sys/defaultwebpage.cgi\n```\n\n## Expected root layout\n\n```text\nindex.php\n.htaccess\nassets/\ninc/\ndata/\ndocs/\n.uai/\nllms.txt\nllms-full.txt\nsitemap.xml\nrobots.txt\n```\n\n## WordPress cleanup\n\nArchive or remove old `wp-admin/`, `wp-includes/`, `wp-content/`, and `wp-login.php` after the plain PHP root is confirmed live.\n"
  },
  {
    "slug": "site-infrastructure",
    "title": "Infrastructure & Trust",
    "nav": "Infrastructure",
    "description": "Deployment, DNS, TLS, security headers, crawler files, and evidence routes required for Runtime.MiRust.com to be a reliable technical project site.",
    "keywords": "Runtime.MiRust.com DNS, TLS, DNSSEC, CAA, SPF DKIM DMARC, security headers, plain PHP infrastructure",
    "body_html": "<h1>Infrastructure &amp; Trust</h1>\n<p>A project site about proof-bound local AI has to be proof-bound itself. The infrastructure layer is not cosmetic: if the domain does not resolve, redirects are broken, certificates fail, or machine-readable files are missing, the site cannot carry technical authority.</p>\n<h2>Launch-gate infrastructure matrix</h2>\n<div class=\"table-scroll\"><table><thead><tr><th scope=\"col\">Layer</th><th scope=\"col\">Required state</th><th scope=\"col\">Why it matters</th></tr></thead><tbody><tr><td>A / AAAA</td><td>Root and <code>www</code> resolve to active IPv4 and, where available, IPv6 routes.</td><td>Basic reachability and crawler access.</td></tr><tr><td>HTTPS</td><td>Valid TLS certificate, forced HTTPS, no mixed-content assets.</td><td>Trust, browser security, and agent fetch reliability.</td></tr><tr><td>HSTS</td><td>Enable after HTTPS is stable; use a cautious ramp before preload.</td><td>Prevents protocol downgrade once configured correctly.</td></tr><tr><td>CAA</td><td>Restrict certificate issuance to the intended certificate authority.</td><td>Limits unauthorized certificate issuance.</td></tr><tr><td>DNSSEC</td><td>Publish DS/DNSKEY where registrar and DNS host support it.</td><td>Improves DNS integrity for a technical brand.</td></tr><tr><td>SPF / DKIM / DMARC</td><td>Publish strict mail authentication for any sending domain.</td><td>Reduces spoofing risk for the maintainer and project.</td></tr><tr><td>robots.txt</td><td>Allow public crawl, publish sitemap, do not block project docs.</td><td>Prevents accidental invisibility.</td></tr><tr><td>llms.txt</td><td>Root file exists and links to core project pages and docs.</td><td>Gives agents a curated map instead of forcing blind scraping.</td></tr><tr><td>/docs and /.uai</td><td>Static public routes are reachable from the root package.</td><td>Preserves durable memory and source report access.</td></tr><tr><td>Markdown negotiation</td><td><code>Accept: text/markdown</code> can return Markdown for project pages.</td><td>Reduces token waste while preserving the same semantic content.</td></tr></tbody></table></div>\n<h2>Headers emitted by the site</h2>\n<p>The site now sends conservative front-end headers when plain PHP serves public pages:</p>\n<ul><li><code>X-Content-Type-Options: nosniff</code></li><li><code>Referrer-Policy: strict-origin-when-cross-origin</code></li><li><code>Permissions-Policy</code> restricting camera, microphone, geolocation, payment, USB, and serial access by default</li><li><code>Strict-Transport-Security</code> only when the request is already HTTPS</li></ul>\n<p>These do not replace server configuration. They provide a baseline while the deployment host should still own TLS, redirects, HTTP/2 or HTTP/3, compression, caching, and WAF behavior.</p>\n<h2>Host-neutral verification commands</h2>\n<pre><code>dig Runtime.MiRust.com A +short\ndig Runtime.MiRust.com AAAA +short\ndig Runtime.MiRust.com CAA +short\ndig Runtime.MiRust.com TXT +short\ncurl -I https://Runtime.MiRust.com/\ncurl -I https://Runtime.MiRust.com/llms.txt\ncurl -H \"Accept: text/markdown\" https://Runtime.MiRust.com/architecture/\ncurl https://Runtime.MiRust.com/.uai/index.uai\ncurl https://Runtime.MiRust.com/docs/index.md\ncurl https://Runtime.MiRust.com/.well-known/security.txt</code></pre>\n<h2>What the plain PHP package controls</h2>\n<ul><li>Theme-rendered pages and semantic HTML.</li><li>Dynamic <code>llms.txt</code>, <code>llms-full.txt</code>, sitemap XML, Markdown alternates, and robots output.</li><li>Root package static <code>/docs</code>, <code>/.uai</code>, and <code>/.well-known/security.txt</code> files.</li><li>Public contact path for maintainer follow-up.</li><li>No external front-end dependencies or CDN assets.</li></ul>\n<h2>What deployment controls</h2>\n<ul><li>Registrar status and domain lock.</li><li>Authoritative DNS provider and DNSSEC.</li><li>TLS certificate lifecycle.</li><li>HTTP to HTTPS redirect.</li><li>Server compression and object/page cache.</li><li>WAF and bot policy.</li><li>Email authentication records.</li></ul>",
    "markdown": "# Infrastructure & Trust\n\nA project site about proof-bound local AI has to be proof-bound itself. The infrastructure layer is not cosmetic: if the domain does not resolve, redirects are broken, certificates fail, or machine-readable files are missing, the site cannot carry technical authority.\n\n## Launch-gate infrastructure matrix\n\n| Layer | Required state | Why it matters |\n| --- | --- | --- |\n| A / AAAA | Root and `www` resolve to active IPv4 and, where available, IPv6 routes. | Basic reachability and crawler access. |\n| HTTPS | Valid TLS certificate, forced HTTPS, no mixed-content assets. | Trust, browser security, and agent fetch reliability. |\n| HSTS | Enable after HTTPS is stable; use a cautious ramp before preload. | Prevents protocol downgrade once configured correctly. |\n| CAA | Restrict certificate issuance to the intended certificate authority. | Limits unauthorized certificate issuance. |\n| DNSSEC | Publish DS/DNSKEY where registrar and DNS host support it. | Improves DNS integrity for a technical brand. |\n| SPF / DKIM / DMARC | Publish strict mail authentication for any sending domain. | Reduces spoofing risk for the maintainer and project. |\n| robots.txt | Allow public crawl, publish sitemap, do not block project docs. | Prevents accidental invisibility. |\n| llms.txt | Root file exists and links to core project pages and docs. | Gives agents a curated map instead of forcing blind scraping. |\n| /docs and /.uai | Static public routes are reachable from the root package. | Preserves durable memory and source report access. |\n| Markdown negotiation | `Accept: text/markdown` can return Markdown for project pages. | Reduces token waste while preserving the same semantic content. |\n\n## Headers emitted by the site\n\nThe site now sends conservative front-end headers when plain PHP serves public pages:\n\n- `X-Content-Type-Options: nosniff`\n- `Referrer-Policy: strict-origin-when-cross-origin`\n- `Permissions-Policy` restricting camera, microphone, geolocation, payment, USB, and serial access by default\n- `Strict-Transport-Security` only when the request is already HTTPS\n\nThese do not replace server configuration. They provide a baseline while the deployment host should still own TLS, redirects, HTTP/2 or HTTP/3, compression, caching, and WAF behavior.\n\n## Host-neutral verification commands\n\n```bash\ndig Runtime.MiRust.com A +short\ndig Runtime.MiRust.com AAAA +short\ndig Runtime.MiRust.com CAA +short\ndig Runtime.MiRust.com TXT +short\ncurl -I https://Runtime.MiRust.com/\ncurl -I https://Runtime.MiRust.com/llms.txt\ncurl -H \"Accept: text/markdown\" https://Runtime.MiRust.com/architecture/\ncurl https://Runtime.MiRust.com/.uai/index.uai\ncurl https://Runtime.MiRust.com/docs/index.md\ncurl https://Runtime.MiRust.com/.well-known/security.txt\n```\n\n## What the plain PHP package controls\n\n- Theme-rendered pages and semantic HTML.\n- Dynamic `llms.txt`, `llms-full.txt`, sitemap XML, Markdown alternates, and robots output.\n- Root package static `/docs`, `/.uai`, and `/.well-known/security.txt` files.\n- Public contact path for maintainer follow-up.\n- No external front-end dependencies or CDN assets.\n\n## What deployment controls\n\n- Registrar status and domain lock.\n- Authoritative DNS provider and DNSSEC.\n- TLS certificate lifecycle.\n- HTTP to HTTPS redirect.\n- Server compression and object/page cache.\n- WAF and bot policy.\n- Email authentication records."
  },
  {
    "slug": "name-scope",
    "title": "Name & Scope",
    "nav": "Name & Scope",
    "description": "Brand and entity clarity for Runtime.MiRust.com, TinyRustLM, the current .slm route, and future GGUF support boundaries.",
    "keywords": "Runtime.MiRust.com brand, TinyRustLM scope, .slm current boundary, GGUF roadmap, namespace clarity",
    "body_html": "<h1>Name &amp; Scope</h1>\n<p>The attached review spends significant space on namespace collision. That pressure matters here because the domain contains several loaded technical terms: <strong>GGUF</strong>, <strong>MiRust</strong>, and the implementation name <strong>TinyRustLM</strong>.</p>\n<h2>Entity map</h2>\n<div class=\"table-scroll\"><table><thead><tr><th scope=\"col\">Name</th><th scope=\"col\">Meaning on this site</th><th scope=\"col\">Boundary</th></tr></thead><tbody><tr><td>Runtime.MiRust.com</td><td>The public project site and documentation surface.</td><td>Site identity, not proof that broad GGUF import is complete.</td></tr><tr><td>MiRust</td><td>The Rust-oriented Machine Intelligence naming lane.</td><td>Brand family context.</td></tr><tr><td>TinyRustLM</td><td>The active source-backed runtime implementation.</td><td>Current product reality.</td></tr><tr><td><code>.slm</code></td><td>The current custom small-language-model file route.</td><td>Implemented and documented path.</td></tr><tr><td>GGUF import</td><td>A future compatibility lane.</td><td>Roadmap until parser, tensor routing, tokenizer, quantization, and browser proof exist.</td></tr><tr><td>Model breeding</td><td>Offline evidence pipeline around compatible artifacts, receipts, population review, parent pools, and selector admission.</td><td>Proof-oriented artifact process, not autonomous live replication.</td></tr><tr><td>Mike Kappel</td><td>Maintainer/contact identity for the project site.</td><td>Use <a href=\"/contact-mike-kappel/\">Contact Mike Kappel</a> for follow-up.</td></tr></tbody></table></div>\n<h2>First-viewport clarity rule</h2>\n<p>The homepage and metadata should identify the site as a <strong>Rust/WASM browser-local SLM runtime project</strong> before broader AI language. That phrase gives humans and agents a concrete anchor.</p>\n<h2>Avoid these confusing claims</h2>\n<ul><li>Do not call the current implementation a full GGUF runtime.</li><li>Do not call deterministic smoke output trained assistant quality.</li><li>Do not describe future model-breeding theory as live production behavior.</li><li>Do not let Mememtech, memory-hardware, apparel, industrial automation, or generic “AI memory” namespaces bleed into this project’s public identity.</li><li>Do not use “local AI” alone when a more precise phrase is available.</li></ul>\n<h2>Use these precise claims</h2>\n<ul><li>“TinyRustLM is the current source-backed implementation target.”</li><li>“The runtime is a no-crate Rust/WASM local SLM lane.”</li><li>“The current model file route is custom <code>.slm</code>.”</li><li>“ADP1, ASP1, and ALR1 adapter packages are validated by Rust before apply.”</li><li>“Broad GGUF import is future work until comparable proof exists.”</li></ul>\n<h2>Search and answer-engine target</h2>\n<p>Every answer engine should be able to summarize the project without guessing: Runtime.MiRust.com documents TinyRustLM, a custom Rust/WASM browser-local SLM runtime and proof pipeline. The site exists to explain the current implementation, evidence routes, and roadmap boundaries.</p>",
    "markdown": "# Name & Scope\n\nThe attached review spends significant space on namespace collision. That pressure matters here because the domain contains several loaded technical terms: **GGUF**, **MiRust**, and the implementation name **TinyRustLM**.\n\n## Entity map\n\n| Name | Meaning on this site | Boundary |\n| --- | --- | --- |\n| Runtime.MiRust.com | The public project site and documentation surface. | Site identity, not proof that broad GGUF import is complete. |\n| MiRust | The Rust-oriented Machine Intelligence naming lane. | Brand family context. |\n| TinyRustLM | The active source-backed runtime implementation. | Current product reality. |\n| `.slm` | The current custom small-language-model file route. | Implemented and documented path. |\n| GGUF import | A future compatibility lane. | Roadmap until parser, tensor routing, tokenizer, quantization, and browser proof exist. |\n| Model breeding | Offline evidence pipeline around compatible artifacts, receipts, population review, parent pools, and selector admission. | Proof-oriented artifact process, not autonomous live replication. |\n| Mike Kappel | Maintainer/contact identity for the project site. | Use [Contact Mike Kappel](/contact-mike-kappel/) for follow-up. |\n\n## First-viewport clarity rule\n\nThe homepage and metadata should identify the site as a **Rust/WASM browser-local SLM runtime project** before broader AI language. That phrase gives humans and agents a concrete anchor.\n\n## Avoid these confusing claims\n\n- Do not call the current implementation a full GGUF runtime.\n- Do not call deterministic smoke output trained assistant quality.\n- Do not describe future model-breeding theory as live production behavior.\n- Do not let Mememtech, memory-hardware, apparel, industrial automation, or generic “AI memory” namespaces bleed into this project’s public identity.\n- Do not use “local AI” alone when a more precise phrase is available.\n\n## Use these precise claims\n\n- “TinyRustLM is the current source-backed implementation target.”\n- “The runtime is a no-crate Rust/WASM local SLM lane.”\n- “The current model file route is custom `.slm`.”\n- “ADP1, ASP1, and ALR1 adapter packages are validated by Rust before apply.”\n- “Broad GGUF import is future work until comparable proof exists.”\n\n## Search and answer-engine target\n\nEvery answer engine should be able to summarize the project without guessing: Runtime.MiRust.com documents TinyRustLM, a custom Rust/WASM browser-local SLM runtime and proof pipeline. The site exists to explain the current implementation, evidence routes, and roadmap boundaries."
  },
  {
    "slug": "research-development",
    "title": "Research & Development",
    "nav": "R&D",
    "description": "How Runtime.MiRust.com turns source reviews, reports, research, tests, and .uai memory into a durable R&D surface.",
    "keywords": "TinyRustLM R&D, Runtime.MiRust.com research, local AI runtime reports, .uai memory, source-backed documentation",
    "body_html": "<h1>Research &amp; Development</h1>\n<p>The report argues that a serious technology site needs visible research and development depth. Runtime.MiRust.com should show that depth without turning speculative ideas into completed-runtime claims.</p>\n<h2>R&amp;D pipeline</h2>\n<ol><li><strong>Intake</strong>: source review bundles, implementation reports, web architecture reports, and improvement reports arrive as source material.</li><li><strong>Durable body</strong>: useful bodies are preserved under <code>/docs/</code>.</li><li><strong>Pointer memory</strong>: <code>.uai</code> files record route summaries, checksums, and truth boundaries.</li><li><strong>Public synthesis</strong>: PHP-rendered pages explain the parts in human-readable form.</li><li><strong>Claim gate</strong>: claims stay bounded to source-backed implementation, manifests, receipts, tests, and browser smokes.</li></ol>\n<h2>Active research lanes</h2>\n<div class=\"table-scroll\"><table><thead><tr><th scope=\"col\">Lane</th><th scope=\"col\">Current site treatment</th><th scope=\"col\">Evidence route</th></tr></thead><tbody><tr><td>Rust/WASM runtime</td><td>Presented as the current implementation boundary.</td><td><a href=\"/architecture/\">Architecture</a> and <code>/docs/implementation/</code></td></tr><tr><td><code>.slm</code> model format</td><td>Explained as the current file route before broader GGUF import.</td><td><a href=\"/model-format/\">Model Format</a></td></tr><tr><td>Adapters</td><td>ADP1, ASP1, and ALR1 explained as package lanes that Rust validates.</td><td><a href=\"/adapters-assembly/\">Adapters &amp; Assembly</a></td></tr><tr><td>Model breeding</td><td>Offline compatibility, lineage, operators, receipts, and selector admission.</td><td><a href=\"/model-breeding/\">Model Breeding</a></td></tr><tr><td>Browser proof</td><td>Manifest, module-plan, assembly, adapter-family, and drift-test evidence.</td><td><a href=\"/proof-testing/\">Proof &amp; Testing</a></td></tr><tr><td>Agent-readable site</td><td>Markdown alternates, <code>llms.txt</code>, <code>llms-full.txt</code>, docs, and <code>.uai</code>.</td><td><a href=\"/agent-readiness/\">Agent-Readable Site</a></td></tr><tr><td>Infrastructure trust</td><td>DNS/TLS/security/deploy checks made explicit.</td><td><a href=\"/site-infrastructure/\">Infrastructure &amp; Trust</a></td></tr></tbody></table></div>\n<h2>What should be expanded next</h2>\n<ul><li>A concise diagram showing browser, WASM, model file, manifest, module plan, adapter stack, and receipt flow.</li><li>A current-limit table for context tokens, prompt bytes, output bytes, model byte budgets, adapter budgets, and route-count limits.</li><li>A release-evidence page for each deployed package version.</li><li>A benchmark page that separates deterministic runtime proof from trained assistant quality.</li><li>A public issue/decision log distilled from <code>/docs/source-memory/log.md</code>.</li></ul>\n<h2>Research language rule</h2>\n<p>Use “research lane,” “design pressure,” “future work,” “receipt route,” and “proof gate” where appropriate. Avoid language that makes exploratory model-breeding concepts sound like uncontrolled live autonomy.</p>",
    "markdown": "# Research & Development\n\nThe report argues that a serious technology site needs visible research and development depth. Runtime.MiRust.com should show that depth without turning speculative ideas into completed-runtime claims.\n\n## R&D pipeline\n\n1. **Intake**: source review bundles, implementation reports, web architecture reports, and improvement reports arrive as source material.\n2. **Durable body**: useful bodies are preserved under `/docs/`.\n3. **Pointer memory**: `.uai` files record route summaries, checksums, and truth boundaries.\n4. **Public synthesis**: PHP-rendered pages explain the parts in human-readable form.\n5. **Claim gate**: claims stay bounded to source-backed implementation, manifests, receipts, tests, and browser smokes.\n\n## Active research lanes\n\n| Lane | Current site treatment | Evidence route |\n| --- | --- | --- |\n| Rust/WASM runtime | Presented as the current implementation boundary. | [Architecture](/architecture/) and `/docs/implementation/` |\n| `.slm` model format | Explained as the current file route before broader GGUF import. | [Model Format](/model-format/) |\n| Adapters | ADP1, ASP1, and ALR1 explained as package lanes that Rust validates. | [Adapters & Assembly](/adapters-assembly/) |\n| Model breeding | Offline compatibility, lineage, operators, receipts, and selector admission. | [Model Breeding](/model-breeding/) |\n| Browser proof | Manifest, module-plan, assembly, adapter-family, and drift-test evidence. | [Proof & Testing](/proof-testing/) |\n| Agent-readable site | Markdown alternates, `llms.txt`, `llms-full.txt`, docs, and `.uai`. | [Agent-Readable Site](/agent-readiness/) |\n| Infrastructure trust | DNS/TLS/security/deploy checks made explicit. | [Infrastructure & Trust](/site-infrastructure/) |\n\n## What should be expanded next\n\n- A concise diagram showing browser, WASM, model file, manifest, module plan, adapter stack, and receipt flow.\n- A current-limit table for context tokens, prompt bytes, output bytes, model byte budgets, adapter budgets, and route-count limits.\n- A release-evidence page for each deployed package version.\n- A benchmark page that separates deterministic runtime proof from trained assistant quality.\n- A public issue/decision log distilled from `/docs/source-memory/log.md`.\n\n## Research language rule\n\nUse “research lane,” “design pressure,” “future work,” “receipt route,” and “proof gate” where appropriate. Avoid language that makes exploratory model-breeding concepts sound like uncontrolled live autonomy."
  },
  {
    "slug": "deployment-checklist",
    "title": "Deployment Checklist",
    "nav": "Deploy Check",
    "description": "Post-deployment verification checklist for Runtime.MiRust.com covering DNS, HTTPS, security headers, static memory routes, Markdown negotiation, and dependency policy.",
    "keywords": "Runtime.MiRust.com deployment checklist, plain PHP launch verification, llms.txt test, .uai docs test, DNS TLS checklist",
    "body_html": "<h1>Deployment Checklist</h1>\n<p>This checklist converts the infrastructure-risk report into a concrete post-deploy gate. Do not treat the site as ready until these checks pass from an external network.</p>\n<h2>1. DNS and registration</h2>\n<ul><li>Registrar shows the domain as active and locked against unauthorized transfer.</li><li>Authoritative nameservers are correct.</li><li><code>A</code> and optional <code>AAAA</code> records resolve globally.</li><li><code>www</code> either redirects cleanly or resolves intentionally.</li><li><code>CAA</code> records match the certificate authority in use.</li><li>DNSSEC is either configured correctly or intentionally deferred.</li></ul>\n<h2>2. Transport and headers</h2>\n<ul><li><code>https://Runtime.MiRust.com/</code> returns HTTP 200 or the intended plain PHP front page.</li><li><code>https://Runtime.MiRust.com/</code> redirects to HTTPS.</li><li>The certificate chain is valid.</li><li>No mixed content is loaded.</li><li>Security headers are present on front-end responses.</li></ul>\n<h2>3. plain PHP content</h2>\n<ul><li>The homepage is no longer “Hello world!” or “Sample Page.”</li><li>The seeded pages exist and have clean permalinks.</li><li>Top navigation groups fit on desktop and wrap on smaller screens.</li><li>The footer contains <a href=\"/contact-mike-kappel/\">Contact Mike Kappel</a>.</li><li>The contact page works without requiring external profile lookup.</li></ul>\n<h2>4. Machine-readable routes</h2>\n<pre><code>curl https://Runtime.MiRust.com/llms.txt\ncurl https://Runtime.MiRust.com/llms-full.txt\ncurl https://Runtime.MiRust.com/sitemap.xml\ncurl https://Runtime.MiRust.com/robots.txt\ncurl https://Runtime.MiRust.com/.uai/index.uai\ncurl https://Runtime.MiRust.com/.uai/docs-routing.uai\ncurl https://Runtime.MiRust.com/docs/index.md\ncurl https://Runtime.MiRust.com/docs/web-research/website-review-and-improvement-plan.md\ncurl https://Runtime.MiRust.com/.well-known/security.txt</code></pre>\n<h2>5. Markdown negotiation</h2>\n<pre><code>curl -H \"Accept: text/markdown\" https://Runtime.MiRust.com/project/\ncurl -H \"Accept: text/markdown\" https://Runtime.MiRust.com/site-infrastructure/\ncurl https://Runtime.MiRust.com/name-scope.md</code></pre>\n<p>Expected result: Markdown output with <code>Content-Type: text/markdown; charset=utf-8</code> and <code>Vary: Accept</code>.</p>\n<h2>6. Dependency policy</h2>\n<ul><li>No Bootstrap, Tailwind, Popper, jQuery front-end dependency, CDN CSS, CDN JavaScript, page builder, or framework hydration path is present.</li><li>Core content renders server-side as HTML.</li><li>Theme JavaScript is only small behavior around native dialog, navigation details, filtering, and copy buttons.</li></ul>\n<h2>7. Claim boundary</h2>\n<ul><li>Homepage and metadata say TinyRustLM is current.</li><li>Broad GGUF import remains roadmap language.</li><li>Trained assistant quality remains unclaimed until eval evidence exists.</li><li>Every major technical claim links to a page, <code>/docs</code> file, or <code>.uai</code> route.</li></ul>\n<h2>8. Origin default-page regression</h2><pre><code>curl -IL https://runtime.mirust.com/cgi-sys/defaultwebpage.cgi\ncurl -fsS https://runtime.mirust.com/healthz\ncurl -fsS https://runtime.mirust.com/version.json</code></pre><p>Expected result: the old cPanel default path is not the active homepage, and the health/version routes prove the request reaches this package root.</p>\n",
    "markdown": "# Deployment Checklist\n\nThis checklist converts the infrastructure-risk report into a concrete post-deploy gate. Do not treat the site as ready until these checks pass from an external network.\n\n## 1. DNS and registration\n\n- Registrar shows the domain as active and locked against unauthorized transfer.\n- Authoritative nameservers are correct.\n- `A` and optional `AAAA` records resolve globally.\n- `www` either redirects cleanly or resolves intentionally.\n- `CAA` records match the certificate authority in use.\n- DNSSEC is either configured correctly or intentionally deferred.\n\n## 2. Transport and headers\n\n- `https://Runtime.MiRust.com/` returns HTTP 200 or the intended plain PHP front page.\n- `https://Runtime.MiRust.com/` redirects to HTTPS.\n- The certificate chain is valid.\n- No mixed content is loaded.\n- Security headers are present on front-end responses.\n\n## 3. plain PHP content\n\n- The homepage is no longer “Hello world!” or “Sample Page.”\n- The seeded pages exist and have clean permalinks.\n- Top navigation groups fit on desktop and wrap on smaller screens.\n- The footer contains [Contact Mike Kappel](/contact-mike-kappel/).\n- The contact page works without requiring external profile lookup.\n\n## 4. Machine-readable routes\n\n```bash\ncurl https://Runtime.MiRust.com/llms.txt\ncurl https://Runtime.MiRust.com/llms-full.txt\ncurl https://Runtime.MiRust.com/sitemap.xml\ncurl https://Runtime.MiRust.com/robots.txt\ncurl https://Runtime.MiRust.com/.uai/index.uai\ncurl https://Runtime.MiRust.com/.uai/docs-routing.uai\ncurl https://Runtime.MiRust.com/docs/index.md\ncurl https://Runtime.MiRust.com/docs/web-research/website-review-and-improvement-plan.md\ncurl https://Runtime.MiRust.com/.well-known/security.txt\n```\n\n## 5. Markdown negotiation\n\n```bash\ncurl -H \"Accept: text/markdown\" https://Runtime.MiRust.com/project/\ncurl -H \"Accept: text/markdown\" https://Runtime.MiRust.com/site-infrastructure/\ncurl https://Runtime.MiRust.com/name-scope.md\n```\n\nExpected result: Markdown output with `Content-Type: text/markdown; charset=utf-8` and `Vary: Accept`.\n\n## 6. Dependency policy\n\n- No Bootstrap, Tailwind, Popper, jQuery front-end dependency, CDN CSS, CDN JavaScript, page builder, or framework hydration path is present.\n- Core content renders server-side as HTML.\n- Theme JavaScript is only small behavior around native dialog, navigation details, filtering, and copy buttons.\n\n## 7. Claim boundary\n\n- Homepage and metadata say TinyRustLM is current.\n- Broad GGUF import remains roadmap language.\n- Trained assistant quality remains unclaimed until eval evidence exists.\n- Every major technical claim links to a page, `/docs` file, or `.uai` route.\n## 8. Origin default-page regression\n\n```bash\ncurl -IL https://runtime.mirust.com/cgi-sys/defaultwebpage.cgi\ncurl -fsS https://runtime.mirust.com/healthz\ncurl -fsS https://runtime.mirust.com/version.json\n```\n\nExpected result: the old cPanel default path is not the active homepage, and the health/version routes prove the request reaches this package root.\n"
  },
  {
    "slug": "runtime-health",
    "title": "Runtime Health",
    "nav": "Health",
    "description": "Runtime.MiRust.com health endpoints, version endpoint, machine-readable route checks, and post-deployment verification commands.",
    "keywords": "Runtime.MiRust.com healthz, version.json, deployment verification, plain PHP health endpoint",
    "body_html": "<h1>Runtime Health</h1>\n<blockquote><p>This page turns the previous redirect problem into durable operational checks. It gives humans and agents quick endpoints for confirming the deployed root is the plain PHP package.</p></blockquote>\n<h2>Health endpoints</h2>\n<div class=\"route-cluster\" aria-label=\"Health endpoints\"><a class=\"route-tile\" href=\"/healthz\"><strong>/healthz</strong><span>Plain text package health marker.</span></a><a class=\"route-tile\" href=\"/version.json\"><strong>/version.json</strong><span>Machine-readable package version and claim boundary.</span></a><a class=\"route-tile\" href=\"/llms.txt\"><strong>/llms.txt</strong><span>Agent route map.</span></a><a class=\"route-tile\" href=\"/.uai/index.uai\"><strong>/.uai/index.uai</strong><span>Hot memory index.</span></a></div>\n<h2>External verification commands</h2>\n<pre><code>curl -fsS https://runtime.mirust.com/healthz\ncurl -fsS https://runtime.mirust.com/version.json\ncurl -fsS https://runtime.mirust.com/llms.txt\ncurl -fsS https://runtime.mirust.com/docs/index.md\ncurl -fsS https://runtime.mirust.com/.uai/index.uai\ncurl -H \"Accept: text/markdown\" -fsS https://runtime.mirust.com/source-facts/</code></pre>\n<h2>What each check proves</h2>\n<div class=\"table-scroll\"><table><thead><tr><th scope=\"col\">Check</th><th scope=\"col\">Evidence</th></tr></thead><tbody><tr><td><code>/healthz</code></td><td>The origin is serving this package root, not a host placeholder.</td></tr><tr><td><code>/version.json</code></td><td>The deployed version and claim boundary are machine-readable.</td></tr><tr><td><code>/llms.txt</code></td><td>Agents can find canonical project pages without crawling blind.</td></tr><tr><td><code>/docs/index.md</code></td><td>Durable report and long-term memory routes are public.</td></tr><tr><td><code>Accept: text/markdown</code></td><td>The same page can serve token-efficient Markdown without user-agent cloaking.</td></tr></tbody></table></div>\n",
    "markdown": "# Runtime Health\n\n> This page turns the previous redirect problem into durable operational checks.\n\n## Health endpoints\n\n- [/healthz](/healthz): Plain text package health marker.\n- [/version.json](/version.json): Machine-readable package version and claim boundary.\n- [/llms.txt](/llms.txt): Agent route map.\n- [/.uai/index.uai](/.uai/index.uai): Hot memory index.\n\n## External verification commands\n\n```bash\ncurl -fsS https://runtime.mirust.com/healthz\ncurl -fsS https://runtime.mirust.com/version.json\ncurl -fsS https://runtime.mirust.com/llms.txt\ncurl -fsS https://runtime.mirust.com/docs/index.md\ncurl -fsS https://runtime.mirust.com/.uai/index.uai\ncurl -H \"Accept: text/markdown\" -fsS https://runtime.mirust.com/source-facts/\n```\n"
  },
  {
    "slug": "launch-operations",
    "title": "Launch Operations",
    "nav": "Launch Ops",
    "description": "Operational launch plan for Runtime.MiRust.com: backups, rollback, cache purge, route verification, stale WordPress cleanup, and no-dependency checks.",
    "keywords": "Runtime.MiRust.com launch operations, rollback, backup, cache purge, no WordPress cleanup, plain PHP deploy",
    "body_html": "<h1>Launch Operations</h1>\n<blockquote><p>The site now works as plain PHP. This page keeps that state repeatable: extract, verify, purge, monitor, and roll back if necessary.</p></blockquote>\n<h2>Before extraction</h2>\n<ul><li>Download a full backup of the current document root.</li><li>Export or archive any remaining WordPress database before deleting WordPress files.</li><li>Confirm the cPanel document root for <code>runtime.mirust.com</code>.</li><li>Confirm the new ZIP is the root package and not a WordPress theme package.</li></ul>\n<h2>After extraction</h2>\n<ol><li>Run <code>curl -IL https://runtime.mirust.com/</code>.</li><li>Run <code>curl -fsS https://runtime.mirust.com/healthz</code>.</li><li>Run <code>curl -fsS https://runtime.mirust.com/version.json</code>.</li><li>Run <code>curl -H \"Accept: text/markdown\" -fsS https://runtime.mirust.com/project/</code>.</li><li>Open <code>/docs/index.md</code> and <code>/.uai/index.uai</code>.</li><li>Purge CDN/browser cache if stale redirects persist.</li></ol>\n<h2>Rollback rule</h2>\n<p>Rollback should restore the previous root backup only if the root package does not serve <code>/healthz</code>, <code>/version.json</code>, and the homepage from the same document root. Do not roll back because an old cached browser tab still points to <code>/cgi-sys/defaultwebpage.cgi</code>.</p>\n<h2>Package-level tools</h2>\n<p>The root ZIP now includes <code>/tools/verify-runtime-mirust.sh</code> and <code>/tools/verify-runtime-mirust.ps1</code>. These scripts test the root page, health endpoint, version endpoint, agent files, docs, and Markdown negotiation.</p>\n",
    "markdown": "# Launch Operations\n\n> The site now works as plain PHP. This page keeps that state repeatable: extract, verify, purge, monitor, and roll back if necessary.\n\n## Before extraction\n\n- Download a full backup of the current document root.\n- Export or archive any remaining WordPress database before deleting WordPress files.\n- Confirm the cPanel document root for `runtime.mirust.com`.\n- Confirm the new ZIP is the root package and not a WordPress theme package.\n\n## After extraction\n\n1. `curl -IL https://runtime.mirust.com/`\n2. `curl -fsS https://runtime.mirust.com/healthz`\n3. `curl -fsS https://runtime.mirust.com/version.json`\n4. `curl -H \"Accept: text/markdown\" -fsS https://runtime.mirust.com/project/`\n5. Open `/docs/index.md` and `/.uai/index.uai`.\n6. Purge CDN/browser cache if stale redirects persist.\n\n## Package-level tools\n\nThe root ZIP includes `/tools/verify-runtime-mirust.sh` and `/tools/verify-runtime-mirust.ps1`.\n"
  },
  {
    "slug": "plain-php-rebuild",
    "title": "Plain PHP Rebuild",
    "nav": "Plain PHP",
    "description": "Plain PHP rebuild notes for Runtime.MiRust.com after removing the WordPress layer.",
    "keywords": "Runtime.MiRust.com plain PHP, no WordPress, root extract, zero dependency website",
    "body_html": "<h1>Plain PHP Rebuild</h1>\n<blockquote><p>Runtime.MiRust.com now ships as a plain PHP root site. The WordPress layer has been removed from the deployable package.</p></blockquote>\n<h2>What changed</h2>\n<ul><li>Removed the WordPress theme package, theme folder, template files, functions file, and activation seeding logic.</li><li>Added a plain PHP front controller at <code>/index.php</code>.</li><li>Added a JSON-backed content registry at <code>/data/pages.json</code>.</li><li>Added semantic PHP templates in <code>/inc/site.php</code>.</li><li>Kept the source-backed page content, top-menu structure, contact footer, docs, <code>.uai</code> memory, <code>llms.txt</code>, <code>llms-full.txt</code>, sitemap, robots, and security file.</li><li>Added Markdown content negotiation for page routes and direct <code>.md</code> page alternates.</li></ul>\n<h2>Extraction target</h2>\n<p>Extract the root package directly at the public web root for <code>Runtime.MiRust.com</code>. The ZIP intentionally has no wrapper folder.</p>\n<h2>Runtime requirements</h2>\n<ul><li>PHP 8.1 or newer recommended.</li><li>Apache with <code>mod_rewrite</code> for clean routes, or equivalent Nginx routing to <code>/index.php</code>.</li><li>No Composer install step.</li><li>No database.</li><li>No WordPress.</li><li>No Bootstrap, Tailwind, jQuery, Popper, React, Vue, Angular, or page builder.</li></ul>\n<h2>Current package boundary</h2>\n<p>This rebuild changes the public website delivery layer only. It does not rebuild the Rust/WASM runtime or regenerate model artifacts.</p>",
    "markdown": "# Plain PHP Rebuild\n\n> Runtime.MiRust.com now ships as a plain PHP root site. The WordPress layer has been removed from the deployable package.\n\n## What changed\n\n- Removed the WordPress theme package, theme folder, template files, functions file, and activation seeding logic.\n- Added a plain PHP front controller at `/index.php`.\n- Added a JSON-backed content registry at `/data/pages.json`.\n- Added semantic PHP templates in `/inc/site.php`.\n- Kept the source-backed page content, top-menu structure, contact footer, docs, `.uai` memory, `llms.txt`, `llms-full.txt`, sitemap, robots, and security file.\n- Added Markdown content negotiation for page routes and direct `.md` page alternates.\n\n## Extraction target\n\nExtract the root package directly at the public web root for `Runtime.MiRust.com`. The ZIP intentionally has no wrapper folder.\n\n## Runtime requirements\n\n- PHP 8.1 or newer recommended.\n- Apache with `mod_rewrite` for clean routes, or equivalent Nginx routing to `/index.php`.\n- No Composer install step.\n- No database.\n- No WordPress.\n- No Bootstrap, Tailwind, jQuery, Popper, React, Vue, Angular, or page builder.\n\n## Current package boundary\n\nThis rebuild changes the public website delivery layer only. It does not rebuild the Rust/WASM runtime or regenerate model artifacts.\n"
  },
  {
    "slug": "faq",
    "title": "FAQ",
    "nav": "FAQ",
    "description": "Frequently asked questions about Runtime.MiRust.com, TinyRustLM, .slm, GGUF, model breeding, local runtime boundaries, and proof claims.",
    "keywords": "TinyRustLM FAQ, Runtime.MiRust.com FAQ, .slm FAQ, Rust WASM local model FAQ",
    "body_html": "<h1>FAQ</h1>\n<h2>Is Runtime.MiRust.com currently a full GGUF runtime?</h2>\n<p>No. The source-backed runtime currently centers on TinyRustLM and the custom <code>.slm</code> route. GGUF import belongs on the roadmap until it has proof comparable to the current <code>.slm</code> lane.</p>\n<h2>Does TinyRustLM use third-party Rust crates?</h2>\n<p>The current runtime, packer, local server, and browser harness are designed as no-crate Rust components.</p>\n<h2>Does the browser app call a remote inference API?</h2>\n<p>No. The source-backed app target is local/same-origin file loading and Rust/WASM inference. Remote inference is not part of the current claim boundary.</p>\n<h2>Is this a trained assistant?</h2>\n<p>Not yet. Deterministic smoke models and TinyLM-16M smoke artifacts prove runtime behavior. Assistant-quality claims require trained/evaluated artifacts and passed eval sidecars.</p>\n<h2>What are ADP1, ASP1, and ALR1?</h2>\n<p>They are adapter package lanes. ADP1 is raw task delta, ASP1 is sparse task delta, and ALR1 is low-rank adapter packaging. Rust validates compatible packages before applying them to a loaded model.</p>\n<h2>What is a selector registry?</h2>\n<p>A selector registry is the browser route gate for admitted model candidates and optional adapter routes. It carries budgets, manifest paths, checksums, default selection metadata, module-plan metadata, and evidence pointers.</p>\n<h2>What is a module plan?</h2>\n<p>A module plan is a receipt that tells the browser which generated modules should exist, how large they are, what checksums they have, what phase they belong to, and what dependencies they have. The browser verifies it before generated model bytes are fetched.</p>\n<h2>Why is the site built as plain PHP instead of a JavaScript app?</h2>\n<p>The public project website needs crawlable, semantic, server-rendered content. plain PHP is used as the content shell, but the site avoids dependency-heavy front-end runtimes and exposes Markdown alternates for agents.</p>\n<h2>Why include llms.txt?</h2>\n<p><code>llms.txt</code> gives AI systems a concise, curated project map. It reduces the chance that a model reads the live site as a generic CMS shell or confuses future-roadmap ideas with current implementation.</p>\n<h2>How do I contact Mike Kappel about this project?</h2>\n<p>Use the <a href=\"/contact-mike-kappel/\">Contact Mike Kappel</a> page for email, phone, Signal, professional links, and source notes.</p>",
    "markdown": "# FAQ\n\n## Is Runtime.MiRust.com currently a full GGUF runtime?\n\nNo. The source-backed runtime currently centers on TinyRustLM and the custom `.slm` route. GGUF import belongs on the roadmap until it has proof comparable to the current `.slm` lane.\n\n## Does TinyRustLM use third-party Rust crates?\n\nThe current runtime, packer, local server, and browser harness are designed as no-crate Rust components.\n\n## Does the browser app call a remote inference API?\n\nNo. The source-backed app target is local/same-origin file loading and Rust/WASM inference. Remote inference is not part of the current claim boundary.\n\n## Is this a trained assistant?\n\nNot yet. Deterministic smoke models and TinyLM-16M smoke artifacts prove runtime behavior. Assistant-quality claims require trained/evaluated artifacts and passed eval sidecars.\n\n## What are ADP1, ASP1, and ALR1?\n\nThey are adapter package lanes. ADP1 is raw task delta, ASP1 is sparse task delta, and ALR1 is low-rank adapter packaging. Rust validates compatible packages before applying them to a loaded model.\n\n## What is a selector registry?\n\nA selector registry is the browser route gate for admitted model candidates and optional adapter routes. It carries budgets, manifest paths, checksums, default selection metadata, module-plan metadata, and evidence pointers.\n\n## What is a module plan?\n\nA module plan is a receipt that tells the browser which generated modules should exist, how large they are, what checksums they have, what phase they belong to, and what dependencies they have. The browser verifies it before generated model bytes are fetched.\n\n## Why is the site built as plain PHP instead of a JavaScript app?\n\nThe public project website needs crawlable, semantic, server-rendered content. plain PHP is used as the content shell, but the site avoids dependency-heavy front-end runtimes and exposes Markdown alternates for agents.\n\n## Why include llms.txt?\n\n`llms.txt` gives AI systems a concise, curated project map. It reduces the chance that a model reads the live site as a generic CMS shell or confuses future-roadmap ideas with current implementation.\n\n## How do I contact Mike Kappel about this project?\n\nUse the [Contact Mike Kappel](/contact-mike-kappel/) page for email, phone, Signal, professional links, and source notes."
  }
]