# Newer web standards: a small-site fix kit Prepared November 20, 2026. Use this independently of the [companion article](https://jwatte.com/blog/newer-web-standards-small-sites-miss-2026/). Owner: choose the promised behavior and approve publication. Web person: inventory pages, headers, DNS and listings. Developer: implement and test the changes. Keep a baseline before editing and record the same check against the baseline and candidate. A back test is that unchanged check failing on the old defect; a new test that also passes on the defective version has proved little. Every sample below is original and illustrative. Replace example.com with a site you own or are authorized to test. HTTP reads, discovery and listing requests are read-only; they do not authorize tool execution, booking, form submission, account creation, DNS changes or registry publication. Do not run these checks against someone else's MCP server. Prices in the structured-result example are invented test data. The short heading labels are the section IDs for Markdown readers. A plain-text download does not itself implement clickable fragments; search for the label if your reader does not create heading anchors. ## mcp-protocol **MCP revision and browser transport** Model Context Protocol (MCP) lets an assistant ask a server for named functions, called tools, such as a public opening-hours lookup. Its [2026-07-28 revision](https://modelcontextprotocol.io/specification/2026-07-28/changelog.md) supports stateless requests and discovery without the earlier initialization exchange. **Read-only check, developer:** use the following request against your own endpoint. This original shell sample asks what the server supports; it does not execute a tool. ```sh curl --silent --show-error https://example.com/mcp \ -H 'Content-Type: application/json' \ -H 'Accept: application/json, text/event-stream' \ -H 'MCP-Protocol-Version: 2026-07-28' \ -H 'Mcp-Method: server/discover' \ --data-binary @- <<'JSON' {"jsonrpc":"2.0","id":1,"method":"server/discover","params":{"_meta":{"io.modelcontextprotocol/protocolVersion":"2026-07-28","io.modelcontextprotocol/clientCapabilities":{}}}} JSON ``` Original JSON example: a discovery answer for a fictional server implementing only the declared revision. A real compatibility release should also list the older versions it actually serves. ```json { "jsonrpc": "2.0", "id": 1, "result": { "resultType": "complete", "supportedVersions": ["2026-07-28"], "capabilities": {"tools": {}}, "instructions": "Read public service information.", "ttlMs": 60000, "cacheScope": "public", "_meta": { "io.modelcontextprotocol/serverInfo": { "name": "com.example/public-info", "version": "1.0.0" } } } } ``` **Fix, developer:** 1. Read the current lifecycle and transport specification. Route the requested version deliberately; do not answer every revision with the same old version string. 2. Implement discovery and stateless tool listing before adding tool execution. Return the required result envelope and server identity metadata. 3. Retain the supported older initialization path. Preserve existing tool names, descriptions, input schemas, permissions and text responses. 4. Check cross-origin browser preflight. Allow the headers the request actually needs, including `Mcp-Method` and `Mcp-Name`; preserve the site's origin policy and use `Vary: Access-Control-Request-Headers` where responses depend on that request header. 5. Reject unsupported versions as the specification requires. Never execute a tool from a JSON-RPC notification, which is a message without an `id`. **Test and back test:** replay the same request matrix against old and new builds: discovery, old initialization, listing, read-only result fixtures, invalid arguments, unknown methods, malformed JSON, batches, excessive bodies and notifications. Name every allowed difference. Test an actual cross-origin browser request in Chromium, Firefox and WebKit; the preflight failure must be visible on the old version. Keep all writing tools on synthetic fixtures. **Done when:** the declared versions work, browser requests work, old clients still receive their expected answers, and unrelated behavior is unchanged. **Common mistakes:** trusting a command-line success to prove browser compatibility; assuming a refused session DELETE ended a session; changing a server to satisfy an incorrect checker warning. The older transport permits refusal of client session termination with 405. ## structured-output **A complete machine-readable answer** An `outputSchema` describes the shape of a tool's answer, and this kit uses `structuredContent` to hold that answer as named fields. A client may rely on those fields, so they must preserve the meaning and next step in the text, as well as its amounts and dates; see [MCP tools](https://modelcontextprotocol.io/specification/2026-07-28/server/tools.md). The core specification makes an output schema optional and permits structured content to be any JSON value. Complete objects and an exact-text field are the compatibility choices in this kit; when a schema is supplied, the output must conform to it. **Read-only check, developer:** inspect `tools/list` using an authorized client, then inspect saved responses from your own synthetic tool fixtures. Do not call a booking or cancellation tool just to inspect its output. Original JSON tool definition, using a fictional fixed-price quote solely for validation: ```json { "name": "service_quote", "description": "Read the public example service quote.", "inputSchema": {"type": "object", "properties": {}, "additionalProperties": false}, "annotations": {"readOnlyHint": true}, "outputSchema": { "type": "object", "properties": { "status": {"type": "string", "enum": ["available"]}, "currency": {"type": "string", "const": "USD"}, "totalCents": {"type": "integer", "minimum": 0}, "nextUrl": {"type": "string", "format": "uri"}, "text": {"type": "string"} }, "required": ["status", "currency", "totalCents", "nextUrl", "text"], "additionalProperties": false } } ``` Original JSON matching result body; wrap it in your normal JSON-RPC response: ```json { "resultType": "complete", "content": [{"type": "text", "text": "Available. Total: USD 12.50. Next: https://example.com/services/"}], "structuredContent": { "status": "available", "currency": "USD", "totalCents": 1250, "nextUrl": "https://example.com/services/", "text": "Available. Total: USD 12.50. Next: https://example.com/services/" }, "_meta": {"io.modelcontextprotocol/serverInfo": {"name": "com.example/public-info", "version": "1.0.0"}} } ``` **Fix, developer:** 1. Build text and structured fields from the same underlying result object. Keep the existing public text unchanged. 2. Enumerate every outcome, including unavailable, partial, invalid input and refusal. Add the identifiers needed for the next step only where the text already exposes them. 3. Define a compact object schema for each result. Use explicit status values; preserve currency, units and the basis of a total. Never turn a weekly amount into a nightly offer. 4. Include the exact existing text in a `text` field if your clients need the complete wording there. Do not add private customer details or authentication codes. 5. Measure the whole tool-list response size. Repeated large schemas add cost to every new client conversation. **Test and back test:** validate every successful fixture against its schema, compare all amounts to the cent, and check dates, counts, links, warnings and next-step identifiers. Give a test client only `structuredContent` and ask what is available, what it costs and what happens next. The old incomplete response must fail those questions. Error results need their own protocol-appropriate assertions. **Done when:** either representation gives the same usable answer for every outcome. **Common mistakes:** extracting a list of number and URL tokens from prose; omitting an unavailable status; assuming schema validation proves completeness; guessing structured values from an older upstream answer. For mixed-version relays, label a temporary legacy result explicitly and preserve its exact text rather than inventing facts. ## server-identity **Names people recognize** Server identity gives the machine name and release version plus optional human details such as title, description, website and icons. These fields help a person recognize a connector; missing optional details do not by themselves mean the connection is broken. **Read-only check, web person:** compare the identity in old initialization and modern result metadata with the public server documentation. Open the website and icon links separately. **Fix, developer:** 1. Reuse the existing public title, description, website and icon instead of inventing a second identity. 2. Put the same identity into each supported protocol path. Keep release versions tied to one maintained source. 3. Regenerate the public server card, documentation and catalog wherever they repeat that version. Original JSON identity fragment: ```json { "name": "com.example/public-info", "version": "1.0.0", "title": "Example public information", "description": "Public service information from Example.", "websiteUrl": "https://example.com/", "icons": [{"src": "https://example.com/icon.png", "mimeType": "image/png", "sizes": ["512x512"]}] } ``` **Test and back test:** assert exact equality of the intended identity across protocol paths and generated files. The baseline must fail the added-field assertions without failing unchanged identity facts. **Done when:** the visible identity and version agree everywhere. **Common mistakes:** changing tool descriptions during an identity cleanup; hand-editing generated output; treating an icon declaration as proof the image loads. See the [MCP schema](https://modelcontextprotocol.io/specification/2026-07-28/schema.md). ## mcp-apps **Optional interactive cards** MCP Apps is an extension for presenting a tool result through a user interface in a supporting host. A text result remains necessary for hosts that do not display that interface; the [Apps specification](https://github.com/modelcontextprotocol/ext-apps/blob/main/specification/2026-01-26/apps.mdx) defines the resource and metadata contract. **Read-only check, developer:** inspect a tool's `_meta.ui.resourceUri`, then read its declared resource with an authorized client. UI-only resources may be absent from `resources/list`; read the declared URI before judging it missing. **Fix, developer:** 1. Keep the full text and structured result as the source of truth. 2. Declare a `ui://` resource and serve its HTML using `text/html;profile=mcp-app`. 3. For a simple public-information card, render only fields in that result, make no network requests, and offer ordinary reviewed links rather than buttons that write, reserve or send anything. 4. Handle absent, invalid and older result shapes without presenting invented values. Test the plain-text fallback. 5. Test the actual target host before promising that customers will see the card. **Test and back test:** a missing declared resource must fail retrieval; a wrong media type must fail contract checks. In an owner-controlled card test, verify a complete result, empty result, escaping of hostile text, blocked unapproved URLs and zero network activity. Compare with the old client path to prove the original answer is preserved. **Done when:** the resource is readable, a compatible host displays the intended result, and unsupported hosts receive a complete answer. **Common mistakes:** claiming every assistant supports cards; equating resource retrieval with successful rendering; assuming absence from the resource list proves the declared card is broken. This kit supplies design rules, not a tested card implementation. ## registry-listing **A release and its listing are separate records** A registry is a machine-readable catalog; a directory is a place people browse for connectors. Updating a server does not automatically update those other records, and listing never guarantees approval, discovery or traffic. **Read-only check, owner or web person:** use this original shell request to search the official registry, then compare the exact remote URL and release version with the server. A search is bounded and does not prove that no differently named record exists. ```sh curl --silent --show-error 'https://registry.modelcontextprotocol.io/v0.1/servers?search=com.example' ``` **Fix, owner and developer:** 1. Record every intended registry and directory, the exact endpoint, the published version and the person responsible. 2. Prepare the updated record through the registry's documented publisher process. Ownership and submission remain separate actions the owner authorizes. 3. After publication, read the latest record again and compare `server.remotes[].url` and `server.version` with the live server. 4. Add listing review to every release checklist and schedule the next check in the tracker. **Test and back test:** a saved stale record must fail an exact endpoint-and-version comparison; the corrected latest record must pass. Do not join records on a similar business name alone. **Done when:** the record describes the intended live endpoint and release, and each human directory has its own recorded status. **Common mistakes:** calling a missing bounded search result definitive absence; treating a private submission receipt as a public listing; assuming a healthy handshake updates the catalog. Read the [official registry documentation](https://modelcontextprotocol.io/registry/about.md). ## csp-reporting **Hear a security policy fail without keeping a browsing history** A Content Security Policy (CSP) tells a browser which resources a page may use. Reporting connects a violation to a receiving endpoint, called a collector, so an owner can learn what the policy blocked; see [CSP](https://www.w3.org/TR/CSP3/) and the [Reporting API](https://www.w3.org/TR/reporting-1/). **Read-only check, web person:** inspect response headers from the home page and one page of every template. This original shell command asks for headers; also confirm them on the document response in browser developer tools because a server can handle HEAD differently from GET. ```sh curl --silent --show-error --head https://example.com/ ``` **Fix, developer:** 1. Preserve the existing enforced policy. Append its reporting directives instead of replacing its allowed sources with a sample policy. 2. Use an absolute HTTPS collector address in this example's `Reporting-Endpoints` header for clarity. The standard also resolves relative addresses; an absolute address is not a universal syntax requirement. Support both legacy and modern report envelopes. 3. Make the collector POST-only with bounded input, an empty 204 response for accepted reports, and a fixed field whitelist. Add provider-level rate controls using the provider's actual deployed configuration format. 4. Build allowed page and asset paths from the site's real inventory. Treat reports as untrusted input even when their document URL claims to be yours. 5. Explain the exact collection behavior in the privacy page. Inspect hosting logs and retention separately; application filtering does not prove what the hosting provider retains. Original header example for an intentionally tiny fictional site whose existing policy is `default-src 'self'`. Preserve your own complete policy instead. Add the third header only after the quiet-visit tests in the next section pass. ```text Reporting-Endpoints: csp="https://example.com/csp-report" Content-Security-Policy: default-src 'self'; report-uri https://example.com/csp-report; report-to csp Content-Security-Policy-Report-Only: require-trusted-types-for 'script'; report-uri https://example.com/csp-report; report-to csp ``` Original collector whitelist pseudocode, expressed as parseable JavaScript. The `bounded` object must already have passed the validation rules below; this is not a complete request handler. ```js function selectReportFields(bounded) { return { kind: bounded.kind, directive: bounded.directive, documentPath: bounded.documentPath, blocked: bounded.blocked, source: bounded.source, line: bounded.line, column: bounded.column, disposition: bounded.disposition, sink: bounded.sink, browser: bounded.browser }; } ``` Required validation for this example design: - Reject foreign document hosts and bodies above 32 KiB. Accept `application/csp-report` and `application/reports+json`, checking the actual envelope after parsing. - Keep `kind` only as `csp` or `trusted-types`; bound directives and disposition to known values. - Keep a document path only if it is in the build's real page inventory; otherwise use `other`. Strip queries and fragments before comparison. - Keep a source path only for a known same-origin asset. Otherwise reduce it to an allowed host or `other-host`. - A blocked item may be `inline`, `eval`, `data`, `blob`, an allowed host or `other-host`. A retained host must be syntactically valid, at most 80 characters, and present in the site's enforced policy or a short fixed list of known third parties. - Keep bounded nonnegative line and column numbers. Keep only a known sink name from before the first `|` in a Trusted Types sample; never keep the sample itself. - Reduce browser identity to `Chromium`, `Firefox`, `Safari` or `other`. Keep no IP address, complete browser identifier, cookie, referrer, query, full URL or arbitrary input text. - Cap application log output at 60 lines per instance per minute; answer excess accepted reports quietly. That cap is separate from the hosting platform's rate control. **Test and back test:** in an isolated copy, cause a violation the existing policy actually blocks and wait for delivery. An allowed inline script is not a valid negative test. Feed both report formats and hostile values into the collector's unit tests; assert the exact retained fields and absence of personal strings. The baseline must fail delivery because it lacks reporting. Ordinary visits in every supported browser must remain quiet. **Done when:** a deliberate violation reaches the sanitized log, a normal visit does not, and deployed rate settings match the intended settings. **Common mistakes:** accepting arbitrary paths because they begin with `/`; logging complete samples; checking only console events; silently loosening the enforced policy; assuming a provider's similarly named configuration key activates a limit. ## trusted-types **Try stricter handling of browser injection points** Trusted Types requires certain browser operations to receive values produced by an approved policy rather than arbitrary strings. Report-only mode inventories where a stricter rule would complain without applying its blocking behavior; see the [Trusted Types specification](https://www.w3.org/TR/trusted-types/). **Read-only check, developer:** inspect the report-only header and review security events on ordinary first visits, after acceptance, and after opening lazy content. Leave actual service-worker registration enabled during this inventory. **Fix, developer:** 1. Inventory every reported sink, meaning the browser operation receiving the value, with its source asset and line. 2. Prefer DOM methods and `textContent` for plain text. For a necessary fixed service-worker URL, a narrowly scoped policy can approve only that exact URL. 3. Preserve behavior when Trusted Types is unavailable. Update asset and service-worker versions according to the site's cache rules. 4. Require quiet normal visits before adding the report-only header. If cleanup exceeds the scope, omit that trial header and record the remaining work. If ordinary enforced CSP itself produces reports you cannot fix, omit reporting too until the cause is addressed. 5. Treat later enforcement as a separate release with a full feature inventory and rollback plan. Original JavaScript example, limited to a fixed same-origin service-worker path. Integrate it into the existing registration path rather than registering a second worker: ```js function approvedWorkerUrl(tt) { const path = '/sw.js'; if (!tt) return path; const policy = tt.createPolicy('example-worker', { createScriptURL(value) { if (value !== path) throw new TypeError('Unexpected worker path'); return value; } }); return policy.createScriptURL(path); } ``` Create that named policy once and pass the returned value to the site's existing registration call. If the existing policy restricts Trusted Types policy names, review that restriction explicitly. This sample does not sanitize arbitrary HTML and does not justify a permissive default policy. **Test and back test:** under the diagnostic trial header, an injected plain-string assignment must create the expected trial report while normal page behavior is unchanged. A shipped CSP-only fallback intentionally lacks this Trusted Types report and must be labeled accordingly. The baseline must lack that trial report. In every page template and consent state, the candidate must produce zero reports from its own normal code. Compare behavior with and without Trusted Types support, including returning visits with a warm service-worker cache. **Done when:** the inventory is understood and normal visits stay quiet. **Common mistakes:** disabling service workers in the test; replacing the real registration function with a stub; testing only the undecided consent state; enabling enforcement solely because a report-only header exists. ## privacy-signal **Make the promise and the page agree** Global Privacy Control (GPC) is a browser signal expressing a privacy preference, exposed through `Sec-GPC` and `navigator.globalPrivacyControl`. The [GPC specification](https://www.w3.org/TR/gpc/) does not by itself mean every site must stop every analytics request; the following example implements a specific, stronger site promise. **Read-only check, owner and developer:** compare the privacy page, cookie page, banner, preferences control and actual network requests. Test every template, including errors, translated pages and lazy embeds. Example promised behavior: | State | Analytics | Session recording | Banner | | --- | --- | --- | --- | | GPC on, with any saved choice | No loading or contact | No loading or contact | Hidden | | Do Not Track on, if promised | No loading or contact | No loading or contact | Hidden | | Declined | No loading or contact | No loading or contact | Hidden | | No choice, no signal | Consent mode, storage denied | Not loaded | Shown | | Accepted, no signal | Analytics storage granted | Loaded with approved consent | Hidden | **Fix, developer and owner:** 1. Resolve contradictory policy sentences with the owner. Do not quietly weaken a promise to match old code. 2. Put one gate before any loader, delayed timer or interaction callback. A signal overrides saved acceptance without overwriting that preference. 3. Set consent defaults before loading analytics. A denied-storage consent mode can still send cookieless requests; it is different from a promise of no contact. Consult [Google's consent-mode behavior](https://developers.google.com/tag-platform/security/concepts/consent-mode) and [Clarity's Consent API](https://learn.microsoft.com/en-us/clarity/setup-and-installation/clarity-consent-api-v2) rather than assuming the two providers behave alike. 4. Apply acceptance and withdrawal through the existing control on the same page. Clear relevant cookies and stop permitted collection using documented provider APIs. Independently verify whether already loaded code continues sending requests. 5. Publish the support resource only after the actual page-state tests pass. Keep its update date accurate. Original minimal JavaScript gate: a pure decision function for integration before loaders. It does not include vendor loaders, cookie deletion or withdrawal APIs. ```js function analyticsPlan({gpc, dnt, honorDnt, choice}) { const blocked = gpc === true || (honorDnt && dnt === '1') || choice === 'declined'; if (blocked) return {analytics: 'off', recording: 'off', banner: false}; if (choice === 'accepted') { return {analytics: 'granted', recording: 'on', banner: false}; } return {analytics: 'denied-storage', recording: 'off', banner: true}; } const plan = analyticsPlan({ gpc: navigator.globalPrivacyControl, dnt: navigator.doNotTrack, honorDnt: true, choice: null }); ``` Replace `choice: null` with the site's validated saved choice; treat missing or unreadable storage as undecided. Invoke the same decision logic when the preferences control changes. An integration must map `off` to no loader and no request, not merely to a denied-consent command. Do not add a per-page network request just to discover the incoming `Sec-GPC` header; a static page reads the browser property. Header-only behavior must be listed as uncovered unless the existing server path handles it. Original support-resource JSON for `https://example.com/.well-known/gpc.json`, served with `Content-Type: application/json`: ```json {"gpc": true, "lastUpdate": "2026-11-20"} ``` **Test and back test:** record every outgoing browser request, independently of route interception. Cover signal with no choice, signal with saved acceptance, declined, undecided and accepted; test after six seconds and after interaction, in Chromium, Firefox and WebKit. Pair the signal header with the browser property. Check relevant cookies, banner state, positive acceptance, later withdrawal, warm caches and lazy content. Old fixtures must reproduce the named defect: a forbidden request, an unwanted banner under a signal, or a retained analytics cookie. **Done when:** every tested state matches the approved table and support declaration. **Common mistakes:** a timer bypassing the gate; treating no cookies as no requests; a service worker hiding requests from the test interceptor; an all-off implementation passing rejection tests while acceptance is broken; claiming live provider behavior from tests that prevented provider code from running. ## preload-list **A header token is not enrollment** HTTP Strict Transport Security (HSTS) tells a browser to use HTTPS for a domain. A preload list distributes that decision with browsers, and a `preload` token alone does not prove the domain is on that list; see [HSTS preload](https://hstspreload.org/). **Read-only check, web person:** inspect the HTTPS response header, then read the domain's public status separately using this original shell sample. ```sh curl --silent --show-error 'https://hstspreload.org/api/v2/status?domain=example.com' ``` **Fix, owner and web person:** 1. Build a complete authoritative hostname inventory. Check every resolving hostname for working HTTPS and valid certificates, including less visible mail and administrative web names. 2. Review current preload requirements and the effect of `includeSubDomains`. The preload service currently recommends HSTS but advises against preloading as general advice. Decide whether your domain has a reason to make that longer commitment; leaving it unsubmitted can be the right decision. 3. If appropriate, prepare and test the required header and HTTPS redirects. Do not infer custom-domain behavior from a review environment's hostname. 4. Let the owner authorize and perform submission separately. Record pending and included states honestly. 5. Read the [removal process](https://hstspreload.org/removal/) before submitting; browser updates make undoing enrollment slow. **Test and back test:** the old header or eligibility check must fail the specific prerequisite you change; the candidate must pass it. Inspect the redirect response itself before following it. Enrollment remains an independent status check after release. **Done when:** the header and all prerequisites pass, and the tracker states the actual submission/list status. **Common mistakes:** saying `unknown` proves nobody ever submitted; checking only the apex and `www`; submitting without the owner's decision. ## ai-source-markup **Describe how a work was made** Schema.org's `digitalSourceType` property describes the source type of a creative work using an enumeration value. It supplements a visible disclosure; it does not certify accuracy or promise a search feature. **Read-only check, web person:** inspect the main article's JSON-LD, the machine-readable metadata usually embedded in the page, and compare it with the actual writing process. Inspect generated pages rather than searching only a template. **Fix, developer and editor:** 1. Classify the work: wholly model-written text, a composite containing generated material, or no generated work. 2. Add the property to the work it describes. Do not label cited people, third-party source articles or a headline-only collection as your generated text. 3. Use the released Schema.org member whose current IPTC definition matches that process. A familiar label can outlive a changed definition. 4. Put the mapping in one maintained helper and execute every real generator path in tests. Original JSON-LD example for a wholly model-written article: ```json { "@context": "https://schema.org", "@type": "Article", "url": "https://example.com/analysis/", "headline": "Example analysis", "digitalSourceType": "https://schema.org/TrainedAlgorithmicMediaDigitalSource" } ``` For a composite containing generated elements, review `https://schema.org/CompositeSyntheticDigitalSource` and its current definition before using it. Do not replace it with the older generative-editing member merely because the name sounds similar. **Test and back test:** render every applicable page type through its real generator. Assert the exact property on the correct node and its absence from headline-only and third-party-only cases. The old render must fail the missing-property assertion. Compare before and after in public validators and keep an uncompleted validator check explicitly open. **Done when:** generated output uses the right released value and unrelated visible content is unchanged. **Common mistakes:** testing only static fixtures; confusing mixed material with generative editing; treating validator recognition as evidence that consumers use the field. Schema.org reports fewer than 1,000 domains using the property in its displayed usage line. We know of no consumer that reads this field yet; that is a limit on our knowledge, not proof none exists. ## mail-records **Repair syntax, then choose policy from actual mail use** SPF names the systems authorized to send for a domain, while DMARC tells receivers how to evaluate aligned authentication and what policy the domain requests. A DNS TXT record is a text value published in the domain's DNS; correct spacing and the exact hostname matter. **Read-only check, web person:** these original shell commands read the domain's existing records. ```sh dig +short TXT example.com dig +short TXT _dmarc.example.com ``` **Fix, owner and mail administrator:** 1. Inventory every legitimate sender, including forms, billing and mailing-list systems. Determine whether the domain truly sends no mail. 2. Fix malformed SPF spacing and keep a single applicable SPF record. Include only the actual provider's published sending mechanism and account for the SPF DNS-lookup limit. 3. For a sending domain, start with a monitoring DMARC policy while checking legitimate sources and DKIM alignment. DKIM is a domain's cryptographic mail signature; SPF alone is insufficient before a move to reject under the current DMARC standard. 4. For a domain that truly sends no mail, publish explicit no-sender SPF and a rejecting DMARC policy after checking subdomains. Do not apply that policy to a domain whose forgotten service still sends. 5. Have the owner approve DNS changes. Set a review date for monitoring reports rather than leaving monitoring indefinitely. Original DNS examples. These are proposed configuration changes, not commands to execute. The provider include name is a placeholder and must be replaced with a real verified provider record; the report mailbox must exist and be approved before use. ```text Sending domain: example.com. TXT "v=spf1 include:_spf.example.com -all" _dmarc.example.com. TXT "v=DMARC1; p=none; rua=mailto:dmarc@example.com" Domain and subdomains that send no mail: example.com. TXT "v=spf1 -all" _dmarc.example.com. TXT "v=DMARC1; p=reject; sp=reject" ``` The space after `v=spf1` is significant. A missing space can prevent an SPF record from being recognized. Monitoring is an operational starting point for a sending domain, not a universal standard requirement to keep `p=none` forever. A receiver still applies its own local handling policy. **Test and back test:** parse the malformed baseline and corrected record; the old syntax must fail the intended assertion. After an authorized DNS update, query authoritative and public resolvers and inspect authentication from legitimate test mail arranged by the owner. This kit sends no test mail. For a non-sending domain, confirm both the no-sender SPF and rejecting DMARC records are present. **Done when:** published records parse, legitimate senders authenticate, and enforcement matches actual mail use. **Common mistakes:** copying a provider include without checking it; creating two SPF records; assuming a web domain never sends mail; moving to reject before inventorying mail sources. See [SPF, RFC 7208](https://www.rfc-editor.org/rfc/rfc7208.txt), [DMARC, RFC 9989](https://www.rfc-editor.org/rfc/rfc9989.txt), and the [DMARC guide](https://jwatte.com/blog/dmarcbis-the-new-dmarc-standard/). ## One-page tracker Use `unmeasured`, `failed`, `built`, `tested`, `live` or `waiting for external action`. Do not collapse those into a single checkmark. Record a UTC timestamp with each measurement and schedule the next check after protocol, template, provider or privacy-policy changes. | Gap | Checked on | Status | Who | Next date | | --- | --- | --- | --- | --- | | MCP revision and browser preflight | | | | | | Complete structured output | | | | | | Server identity | | | | | | Interactive card and fallback | | | | | | Registry and directory release | | | | | | CSP delivery and collector fields | | | | | | Trusted Types quiet visits | | | | | | Privacy states and support resource | | | | | | Preload eligibility and enrollment | | | | | | AI-source markup by work type | | | | | | SPF, DKIM and DMARC | | | | | ## Validation and sources The 16 fenced samples were checked with JSON parsing, JavaScript syntax checking and shell syntax checking as applicable. The example input and output schemas passed JSON Schema 2020-12 schema checks, and the matching structured result validated against its output schema. DNS records and header blocks were checked for their intended structure. Those checks do not establish server interoperability, browser reporting delivery, vendor withdrawal behavior, DNS propagation or legal compliance. No sample server, registry submission, DNS change, form submission or email send was run for this kit. Source read times below are UTC. The accompanying article distinguishes measured site behavior from standards requirements and from work that remains unpublished. All sources in this list were read directly on November 20, 2026. Times are UTC; grouped links have their individual times stated. - MCP [revision changelog](https://modelcontextprotocol.io/specification/2026-07-28/changelog.md), 02:39:04; [version negotiation](https://modelcontextprotocol.io/specification/2026-07-28/basic/versioning.md), 02:39:37 through the lifecycle-page redirect; [discovery](https://modelcontextprotocol.io/specification/2026-07-28/server/discover.md), 02:40:07; [HTTP transport](https://modelcontextprotocol.io/specification/2026-07-28/basic/transports/streamable-http.md), 02:40:31. - MCP [tools](https://modelcontextprotocol.io/specification/2026-07-28/server/tools.md), 02:40:44; [schema](https://modelcontextprotocol.io/specification/2026-07-28/schema.md), 02:41:14; [older session transport](https://modelcontextprotocol.io/specification/2025-11-25/basic/transports.md), 02:44:08. - MCP Apps [stable extension specification](https://github.com/modelcontextprotocol/ext-apps/blob/main/specification/2026-01-26/apps.mdx), source read at 02:44:06; [host support overview](https://modelcontextprotocol.io/extensions/apps/overview.md), 02:40:45. Documented support was read; host rendering was not tested for this kit. - Official registry [documentation](https://modelcontextprotocol.io/registry/about.md), 02:44:07; [API definition](https://registry.modelcontextprotocol.io/openapi.yaml), 02:41:14. - W3C [CSP](https://www.w3.org/TR/CSP3/), 02:39:04; [Reporting API](https://www.w3.org/TR/reporting-1/), 02:40:07; [Trusted Types](https://www.w3.org/TR/trusted-types/), 02:40:31. - MDN [Reporting-Endpoints](https://developer.mozilla.org/en-US/docs/Web/HTTP/Reference/Headers/Reporting-Endpoints), 02:39:37; [report-only CSP](https://developer.mozilla.org/en-US/docs/Web/HTTP/Reference/Headers/Content-Security-Policy-Report-Only), 02:40:07; [Trusted Types directive](https://developer.mozilla.org/en-US/docs/Web/HTTP/Reference/Headers/Content-Security-Policy/require-trusted-types-for), 02:40:31. - W3C [GPC specification](https://www.w3.org/TR/gpc/), 02:39:04; Google [consent mode](https://developers.google.com/tag-platform/security/concepts/consent-mode), 02:39:37; Microsoft [Clarity Consent API](https://learn.microsoft.com/en-us/clarity/setup-and-installation/clarity-consent-api-v2), 02:39:37. - HSTS preload [requirements and opt-in guidance](https://hstspreload.org/), 02:40:07; [removal](https://hstspreload.org/removal/), 02:39:04. Submission was not performed. - Schema.org [digitalSourceType and usage](https://schema.org/digitalSourceType), 02:39:04; [enumeration](https://schema.org/IPTCDigitalSourceEnumeration), 02:39:37; [trained-source member](https://schema.org/TrainedAlgorithmicMediaDigitalSource), 02:41:14; [composite-source member](https://schema.org/CompositeSyntheticDigitalSource), 02:44:06. - IPTC [trained-model definition](https://cv.iptc.org/newscodes/digitalsourcetype/trainedAlgorithmicMedia), 02:39:37; [composite definition](https://cv.iptc.org/newscodes/digitalsourcetype/compositeSynthetic), 02:44:06; [generative-editing definition](https://cv.iptc.org/newscodes/digitalsourcetype/compositeWithTrainedAlgorithmicMedia), 02:44:21. - Schema.org [latest released vocabulary](https://schema.org/version/latest/schemaorg-current-https.jsonld), 02:44:19, and [version 30.1 vocabulary](https://schema.org/version/30.1/schemaorg-current-https.jsonld), 02:44:20: released membership of the composite-source value, independently of a development-page notice. - IETF [SPF, RFC 7208](https://www.rfc-editor.org/rfc/rfc7208.txt), 02:39:04; [DMARC, RFC 9989](https://www.rfc-editor.org/rfc/rfc9989.txt), 02:39:37. This kit is informational, not legal advice. Mentions of third parties are nominative fair use. No affiliation or endorsement is implied.