What’s actually slowing this PC down?
Pick the symptom - the matching free tool is one click away.
Most EmDash pages that appear stale, show a missing editor toolbar, or contain duplicate SEO tags are suffering from a response-variant or ownership conflict—not an SEO parser failure. Separate EmDash object caching from full-page/CDN caching, make shared HTML anonymous-only, keep editor and preview responses private, assign every metadata field to one emitter, and purge each affected layer in order.
Start by identifying what is actually stale
EmDash can be involved in several independent delivery paths. An object cache may return an old content or configuration query result while the generated HTML is new. Conversely, EmDash may generate current HTML that a reverse proxy or CDN continues to serve from an older full-response entry. A browser can also retain an old response, and an image or other media object can be stale even when the page source is current.
As an Amazon Associate I earn from qualifying purchases.
| Layer | What it stores | Typical variance inputs | Correct purge or fix |
|---|---|---|---|
| EmDash object cache | Content and configuration query results used while rendering | Query arguments, tenant or site context, locale, request-specific configuration | Clear the EmDash object cache or let the relevant entry expire; then render the page again |
| Full HTML or CDN cache | A complete HTTP response for a URL | URL and query string, cookies, authentication, headers, device or locale branches, method | Purge the page or cache zone and correct the cache key and bypass rules |
| Browser cache | A response held by an individual browser | HTTP caching headers, browser history and local cache state | Reload with cache disabled or clear the browser entry after server-side fixes |
| Media delivery | Images, files and other objects served from R2 or S3-compatible storage and their public URLs | Object key, hostname, protocol, path and query-string policy | Check the media URL and object cache independently; do not purge HTML as a substitute |
A quick comparison usually reveals the layer. Request the same URL anonymously and then with the editor’s cookies. Record the query string, authentication state, Cache-Control, ETag, Age, Via and any CDN cache-status header. If the responses differ in an unexpected way, you have a cache-variance problem before you have an SEO problem.
Use a controlled diagnostic request
Begin with one affected URL and write down exactly what is wrong: an old title, an old body, a missing toolbar, a stale image, or duplicate tags. Do not test several pages at once; different templates and keys can hide the cause.
#1 Best Overall
- Capture an anonymous response. Use a private browser window or a request with no application cookies. Save the response headers and the raw HTML source.
- Capture an editor response. Repeat with the authenticated editor session. Note cookies, status code, headers and whether the toolbar or preview controls appear.
- Compare the variants. A shared cache should not serve an editor-specific response to an anonymous visitor, nor an anonymous response with stale or missing editor controls to an editor. Differences in
Age,ETagor CDN status often show which request was served from storage. - Check the origin directly when possible. Bypass the CDN through the documented origin hostname or an internal route. If origin HTML is current but the public response is old, concentrate on the full-page cache. If origin HTML is already wrong, inspect EmDash rendering, object caching and plugin execution.
- Inspect source, not only the visual page. Search the final response for the title, canonical URL, robots directive, Open Graph properties, Twitter card tags and JSON-LD. Browser developer tools can show a DOM modified by scripts; the response source tells you what the server and cache actually delivered.
Do not treat a cache hit as proof that the data is correct. A hit only means that a stored representation matched the key. The key may be too broad, or the stored representation may have been created for a different user state.
Understand EmDash object caching before changing CDN rules
EmDash’s objectCache stores content and configuration query results used during rendering. It is separate from full-response caching: enabling one does not automatically enable the other. If objectCache is omitted, object caching is disabled. Documented adapters include Cloudflare KV through kvCache and an in-memory Node/development cache.
Object caching can make a newly edited page render with old data at the origin. In that case, purging a CDN alone simply causes the CDN to fetch the same stale origin output again. Check the object-cache status and clear it first after a content or configuration change. When the origin becomes correct but visitors still see old HTML, continue to the outer cache.
PC Slower Than It Used to Be?
A free scan shows the junk files, broken settings and background clutter dragging Windows down - then fixes them in one click.Free scan · Windows 10 & 11Crashes, No Sound, or Screen Glitches?
Random freezes, missing sound and display glitches usually trace back to one bad driver. Find and replace yours safely.Free scan · under a minuteObject-cache checks
- Confirm whether
objectCacheis configured at all and which adapter is active. - Check whether the key includes every context that changes the query result, such as site, locale, tenant or route parameters.
- Compare a fresh origin render after clearing the object cache with the prior response.
- Do not assume an in-memory development cache behaves like a shared production adapter; test the production path separately.
Make the outer HTML cache safe for anonymous visitors
Full-response caching belongs in outer middleware or infrastructure around EmDash. The safe baseline is deliberately narrow: cache only successful anonymous GET requests that return HTML and are not marked private or no-store.
Required bypass rules
- Skip every non-
GETmethod. Never cache form submissions, mutations or administrative actions. - Bypass requests carrying cookies. Cookies can represent authentication, editing, previews, experiments, carts or other state that changes the response.
- Bypass authenticated, preview and edit routes, including requests carrying authorization credentials.
- Do not store a response with
Cache-Control: privateorCache-Control: no-store. - Store only successful HTML responses. Do not cache redirects, errors, API payloads or an HTML response whose content type is not the public page representation.
- Include every output-changing request property in the cache key. At minimum, account for the complete URL and query string; add any header, host, locale, device, tenant or feature flag that changes rendering.
The key and bypass policy must be designed together. Adding a property to the key without bypassing private requests can still expose a user-specific representation; bypassing cookies while ignoring a locale query parameter can still mix language variants. The EmDash configuration guidance states that cache keys and bypass rules must include every request property that changes the rendered response.
Node and edge implementations
On Node, Redis or an equivalent shared cache can implement the same policy. At the edge, a Workers or reverse-proxy cache can store anonymous HTML. The technology is less important than the invariants: anonymous-only input, complete variance, successful HTML output and respect for privacy headers. Log the key, hit or miss decision, bypass reason and response headers while diagnosing; remove verbose logging after the issue is resolved.
Prevent editor and preview leakage behind a shared CDN
A shared cache can deliver an anonymous HTML variant to an editor when the editor request is not bypassed, or deliver a response containing server-injected editor controls to ordinary visitors when the cache key is too broad. EmDash recommends toolbar: "client" when public HTML is served through a shared cache such as Cloudflare Cache Everything, Workers Cache, Fastly or Varnish.
Do these 3 things before closing this tab:
1Repair Windows errors before they cause bigger problems2Fix the driver behind crashes, sound loss and screen glitches3Clear out junk files and repair common Windows errorsClient toolbar mode keeps shareable public HTML identical for visitors. Editing uses a fresh _edit response instead of relying on editor-specific markup embedded in a cacheable page. Preview and edit responses are server-rendered with Cache-Control: private, no-store; your middleware must honor those directives and never place them in a shared cache.
Editor-leakage checklist
- Set the EmDash toolbar mode to
clientfor a site behind a shared cache. - Verify that editor and preview URLs, including
_editrequests, bypass the shared cache. - Confirm that preview and edit responses return private, no-store headers.
- Remove session-dependent branches from your own templates where possible. A template that changes for a logged-in user fragments the cache even if EmDash itself is configured correctly.
- Test an anonymous request after an editor request and an editor request after an anonymous request. Neither should inherit the other’s representation.
Do not confuse stale media with stale HTML
Images and downloads can be delivered from R2 or S3-compatible storage through a configured publicUrl. Verify the public hostname, protocol, path and query-string policy. A changed image object behind an unchanged URL can remain stale in a media cache while the page HTML is current; an HTML purge will not necessarily replace that object.
Conversely, a page can contain an old media URL because object-cached configuration or template output is stale. Compare the URL in the final HTML with the expected object key, then request that media URL directly. Check response headers and cache status for the object itself before changing page-cache settings.
Give SEO metadata one owner
Duplicate titles, canonicals, robots directives or social tags usually mean that two emitters believe they own the same field. Treat metadata as a single-owner contract. EmDash’s sandboxable page:metadata surface supports descriptions, robots, Twitter cards, Open Graph and property tags, canonical and alternate links, and JSON-LD.
| Field | Choose one authoritative emitter | What to verify in final HTML |
|---|---|---|
| Document title | EmDash metadata or the existing SEO plugin, not both | One intended <title> element with the current value |
| Meta description | One metadata hook or one SEO plugin | No competing descriptions with different text |
| Robots | One policy source | One effective robots directive, including index and follow behavior |
| Canonical and alternate links | One URL-generation system | One canonical and the intended alternate-language or format links |
| Open Graph and Twitter cards | One social-metadata emitter | One value for each property or name that matters |
| JSON-LD | One structured-data owner per schema type | No duplicate entities or conflicting scripts for the same page |
Disable the overlapping emitter or narrow its scope. For example, an SEO plugin can retain sitemap or analysis features while EmDash owns canonical and social tags, provided the plugin is configured not to print those fields. The correct choice depends on which system has the authoritative data; the requirement is that only one system emits each field.
Use page:metadata for structured data and SEO metadata while remaining sandboxed. Raw scripts, styles or arbitrary HTML require a native plugin. After changing ownership, inspect the final response source and not merely an administrative preview. A preview can show intended values while a second plugin still writes another set into the delivered document.
Check native versus sandboxed plugin execution
EmDash has two plugin registration paths. Native plugins belong in plugins. Sandbox-compatible plugins belong in sandboxed and require a usable sandboxRunner. If a sandboxed plugin has no runner, the documentation says it is skipped without a runner; the result can look like a cache failure because the expected metadata or toolbar code never appears.
Execution-mode diagnostic
- Locate the package registration and confirm whether it is under
pluginsorsandboxed. - If it is sandboxed, verify that a compatible
sandboxRunneris configured and starts successfully. - Check startup and request logs for a skipped plugin, initialization exception or permission failure.
- Compare the final HTML with the plugin enabled and with the expected hook output.
- As a short diagnostic comparison only, set
sandbox: falseand retest. If behavior changes, the execution boundary or runner is implicated. - Restore sandboxing after the comparison. Running unsandboxed permanently expands the plugin’s access and is not a production fix for a missing runner or incorrect registration.
Keep the metadata hook in a sandboxed plugin when it is sufficient. Move to a native plugin only when the requirement genuinely needs raw scripts, styles or arbitrary HTML.
Purge every affected layer in the right order
A configuration or content change can leave several representations alive at once. Purging in the wrong order often recreates stale output. Use this sequence:
- Clear EmDash object cache. This removes stale query results that could make the origin render old content or metadata.
- Purge full-page and CDN cache. Remove the affected URL and any related variants, including query-string variants if the CDN stores them separately. If Workers Cache is used, run its documented cache-clear operation.
- Refresh or clear the browser cache. Do this only after server-side layers are correct; otherwise you may mask a persistent origin or CDN problem.
- Re-test both identities. Request the page anonymously and with editor cookies, then inspect headers and source for each.
The official troubleshooting package exposes object-cache and Workers Cache clear actions when the required EmDash cache capability is available. If a purge control is missing, confirm that the cache capability and adapter are enabled rather than assuming the purge succeeded.
Use a controlled plugin-conflict test for mixed stacks
When EmDash is integrated with a WordPress-originated or otherwise mixed plugin stack, isolate variables instead of deactivating random components. Back up first, then follow this order:
- Clear the caching plugin’s cache and record the original configuration.
- Deactivate every nonessential plugin, leaving only the platform, theme and the components required to reproduce the page.
- Refresh the affected URL and inspect the final source and headers.
- If the problem disappears, reactivate one plugin at a time and retest after each activation.
- When the conflict returns, compare the reactivated plugin’s emitted metadata, cache hooks and execution mode with EmDash’s output.
- If the issue remains with all nonessential plugins disabled, stop treating it as a plugin conflict. Investigate the theme, server, CDN configuration or platform instead.
This test is destructive to neither content nor settings when performed carefully, but it can change active functionality temporarily. Schedule it for a maintenance window when the site has editors or transactional features.
Quick wins for a faster PC:
Repair Windows errors before they cause bigger problemsFix Now →Scan for outdated or missing drivers - takes under a minuteDriver Scan →Clear out junk files and repair common Windows errorsFree Scan →Symptom-to-cause troubleshooting branches
The page is stale for everyone
- Request the origin after clearing EmDash object cache.
- If origin is stale, inspect object-cache keys, adapter state and template data.
- If origin is current but the public response is old, purge the full-page/CDN cache and check its key and TTL.
Only editors see old content or a missing toolbar
- Compare the cookie-bearing response with an anonymous response.
- Ensure cookie requests bypass the shared cache.
- Use
toolbar: "client"and verify that_editresponses are private and no-store. - Check that a stale anonymous object was not reused for an authenticated request.
Visitors see editor controls
- Purge the cached HTML immediately.
- Check whether an editor response was stored under an anonymous key.
- Confirm cookie and authentication bypass rules and switch to client toolbar mode.
The title or canonical appears twice
- Search the final response source for every duplicate element.
- Identify the emitting plugin or hook for each copy.
- Choose one owner, disable the duplicate emitter or narrow its scope, purge object and CDN caches, then retest.
The admin preview is correct but crawlers receive old tags
- Inspect the public response source rather than the preview interface.
- Clear object cache and the CDN cache.
- Check whether a second plugin emits cached metadata after EmDash’s hook.
- Verify that the crawler-facing URL and query string map to the intended cache key.
The page is current but an image is old
- Check the image URL, hostname, protocol, path and query string.
- Request the media object directly and inspect its cache headers.
- Purge or version the media object according to the storage and delivery configuration; do not rely on an HTML purge.
Design a conflict-resistant EmDash deployment
Preventive configuration is easier than repeated emergency purges. Document the following before enabling a shared cache:
- The exact anonymous cache key and every input that varies rendering.
- Cookie, authorization, preview and edit bypass rules.
- The distinction between object-cache purge, full-page purge, Workers Cache purge and browser refresh.
- The owner of title, description, robots, canonical, alternate, Open Graph, Twitter and JSON-LD output.
- Each plugin’s registration path, required sandbox runner and permitted execution mode.
- The public media hostname and its path and query-string policy.
- A repeatable test URL and the expected anonymous and editor headers and source.
After deployments, test one unchanged page and one edited page. Confirm that anonymous HTML remains shareable, editor and preview responses remain private, metadata appears once, and media URLs resolve to the intended objects. Keep a short change record of cache purges and metadata-owner changes so a later incident can be tied to a specific configuration change.
What a successful fix looks like
A resolved installation has a current origin render after the object cache is cleared; anonymous GET HTML is the only shared representation; cookie-bearing, authenticated, preview and edit requests bypass storage; private and no-store responses are never cached; editor controls are delivered through client toolbar mode; each SEO field has one emitter; sandboxed plugins have a working runner; and the final public source contains the intended metadata exactly once. Validate those conditions with separate anonymous and editor requests instead of relying on a single browser refresh.
Quick Recap
Product prices and availability are accurate as of the date/time indicated and are subject to change. Any price and availability information displayed on Amazon at the time of purchase will apply.
Free tools Windows power users keep installed
One-click scans. No signup required.
