[BUGFIX] renderComponent: don't depend on globalThis.Element

[alexkahndev]

Fixes #21363.

renderComponent does into instanceof Element in two places to discriminate Cursor from Element / SimpleElement in the IntoTarget union. That works in a browser (where Element is a built-in) and inside FastBoot (which patches a simulated Element onto globalThis), but throws ReferenceError: Element is not defined on a plain Node or Bun host that calls renderComponent with a fresh @simple-dom/document node as into.

The function already has an intoTarget() helper a few lines up that classifies the same union without touching any global:

function intoTarget(into: IntoTarget): Cursor {
  if ('element' in into) {
    return into;
  } else {
    return { element: into as SimpleElement, nextSibling: null };
  }
}

This PR aligns the two into instanceof Element outliers with that helper.

Changes

• First-render innerHTML clearing becomes a structural check —
  !('element' in into) && 'innerHTML' in into — so it fires only on a real DOM Element and skips on SimpleElement (no innerHTML setter) and Cursor (has .element).
• Re-render parentElement extraction calls intoTarget(into) directly instead of duplicating the discriminator. Drive-by fix: the previous (into as Cursor).element cast on the else branch was incorrect for SimpleElement input — SimpleElement has no .element property — though that path is rare in practice.

Behavior

into shape	Before	After
Real DOM Element (browser)	clears innerHTML, uses self as parentElement	identical
SimpleElement (server, no FastBoot)	crashes on Element is not defined	skips innerHTML clearing, uses self as parentElement
Cursor	skips innerHTML clearing, uses .element	identical
Real DOM Element (browser, no globalThis.Element for some reason)	crashes on Element is not defined	works

No behavior change for in-browser callers. New behavior for non-browser hosts that pass SimpleElement directly.

Test

Adds a regression test in render-component-test.ts that:

1. Stashes globalThis.Element and sets it to undefined.
2. Calls renderComponent with a real DOM target (which would have crashed at into instanceof undefined).
3. Asserts the render completed and produced the expected HTML.
4. Restores globalThis.Element.

Notes

• No new exports.
• No public-API surface change.
• Aligns with the FastBoot-codepath-removal direction in Drop isInteractive and hasDOM; remove FastBoot codepaths #21349 — the renderer becomes one fewer thing tied to the FastBoot environment-setup story.
• This unblocks calling renderComponent from bare Node / Bun / edge / worker hosts that supply a simple-dom Document via env.document.

Happy to iterate on review feedback.

[NullVoxPopuli]

You're likely going to need to simulate a browser env anyway

Which reminds me! This RFC for Deprecation targeting v8 may affect you

emberjs/rfcs#1178

[alexkahndev]

Thanks for the RFC heads-up I really appreciate it. Our adapter is using all three of simple-dom + hasDOM: true + isInteractive: false, so this would have ambushed us hard in v8. Will plan the migration to a happy-dom-shaped pattern (matching vite-ember-ssr) before we do anything user-facing.

[NullVoxPopuli]

well, it's not an accepted RFC yet. the community may revolt agaist this idea. haha

in general tho, I think all SSR/SSG environments should be no different from browser tho, becaues otherwise you infect all library code like a virus, special casing the existence or non-existence of various things everywhere (window, etc (fastboot was really bad at this, for example))

[alexkahndev]

Strong agreement on the underlying stance and worth saying that we've watched four other frameworks land in the same place from different angles, which is some signal that the principle is sound.

Quick tour through what AbsoluteJS sees across our existing adapters:

React's SSR is string-based (renderToReadableStream). The "is this SSR?" question is bounded to a single boundary in the user's mental model: effects don't run on the server. Render code is identical on both sides. Users essentially never write if (typeof window !== 'undefined') for anything outside an effect and even there, the convention is to put it inside useEffect/useLayoutEffect which only fires client-side. The split is in when things run, not what code runs.

Vue lands almost the same way string-based via renderToWebStream, lifecycle hooks like onMounted are client-only by contract. Vue's small improvement on the React shape is onServerPrefetch, an additive primitive ("do this on the server") rather than a defensive check ("am I on the server?"). Better posture against the virus problem because it inverts the polarity. Svelte moves the boundary to compile time entirely. The Svelte compiler emits components twice, once as a string-concatenating function (SSR), once as DOM-mutating code (client). User-written .svelte files are identical for both; the compiler picks the
codegen. From a user's perspective, "am I in SSR or browser?" basically doesn't exist there's nothing to ask. The cost is the build pipeline knows about both modes; the user doesn't.

Svelte moves the boundary to compile time entirely. The Svelte compiler emits each component twice once as a string-concatenating function (SSR mode), once as DOM-mutating code (client mode). User-written .svelte files are identical for both; the
compiler picks the codegen. From a user's perspective, "am I in SSR or browser?" basically doesn't exist there's nothing to ask.

Angular is the one that maps closest to where this RFC takes Ember.
@angular/platform-server wraps Domino internally, so when user code does inject(DOCUMENT) or reads el.nativeElement it gets a real Document / Element instance regardless of side. There is no isFastBoot / isInteractive flag visible to component authors. Angular's user code is server-agnostic because the platform owns the simulated DOM, not the user.

The common thread every framework that successfully kept the "this is SSR" virus out of library code did it by eliminating the runtime question, not by exposing a flag for it. React/Vue split it on lifecycle phases. Svelte splits it at compile time. Angular pretends the DOM is always there. None of them ask user code or addon code "are you
running on the server?" at runtime, and none of them have the FastBoot-style ecosystem fragmentation.

Ember post-RFC ends up on Angular's branch of that tree happy-dom (or any DOM) installs Element/Node/Document, the renderer always assumes interactive mode, and user/addon code stops needing to ask. From outside Ember, that looks like the framework finally adopting the same architectural answer the rest of the ecosystem converged on years ago just by removing the affordance to ask the question, rather than by adding a new abstraction layer.

The empirical evidence across React, Vue, Svelte, and Angular is consistent: the runtime "am I in SSR?" question is the source of the virus. Removing the question by whichever mechanism a framework can is what stops the spread. That seems like a strong technical case for the direction even outside the specifics of isInteractive / hasDOM.

[NullVoxPopuli]

this is a fantastic summary, but can you post in on the RFC as a comment? <3

[NullVoxPopuli]

Thanks for a test!

[NullVoxPopuli]

Does this test fail without your fix?

[alexkahndev]

Yes. Without the structural-check fix, the original into instanceof Element line throws once the test sets globalThis.Element = undefined:

• (globalThis as any).Element = undefined → TypeError: Right hand side of instanceof is not an object (the test's setup)
• delete globalThis.Element (production-equivalent path on a bare Node host) → ReferenceError: Element is not defined

Either path crashes the renderer before the render loop runs. With the fix, both paths short-circuit through the structural !('element' in into) && 'innerHTML' in into check and the render completes successfully. Test runs green on the patched renderer; reverting just the renderer hunk (keeping the test) reproduces the failure.