[TheAlexLichter]

Right now you can't opt out from SSR per page when using Void.

This PR changes that, adding a per-page export const ssr = false support for pages routes.
When set, it renders the client-only shells with loader data, head output, assets, and if using React, dev preamble support

Context

[netlify]

✅ Deploy Preview for staging-void-cloud ready!

Name	Link
🔨 Latest commit	a71dc17
🔍 Latest deploy log	https://app.netlify.com/projects/staging-void-cloud/deploys/6a145b2aa3622e00083371cb
😎 Deploy Preview	https://deploy-preview-212--staging-void-cloud.netlify.app
📱 Preview on mobile	Toggle QR Code... Use your smartphone camera to open QR code link.
🤖 Make changes	Run an agent on this branch

---

To edit notification comments on pull requests, go to your Netlify project configuration.

[cpojer]

If you wanna do one more pass, I think this is worth sending to your agent:

I’d keep the public API simple, but normalize it into explicit internal states immediately.

  Public API:

  export const ssr = false;
  export const prerender = true;
  export const revalidate = 60;

  Internal model:

  type ExplicitBoolean = true | false | undefined;

  type PageRenderMode = 'server' | 'client' | 'island';
  type PagePrerenderMode = 'auto' | 'force' | 'disabled';

  type PageDefinition = {
    // source facts
    island?: boolean;
    ssr?: ExplicitBoolean;
    prerender?: ExplicitBoolean;

    // normalized decisions
    renderMode: PageRenderMode;
    prerenderMode: PagePrerenderMode;
    shouldPrerender: boolean;
  };

  Then make one resolver own the rules:

  function resolvePageRendering(page, options): ResolvedPageRendering {
    if (page.island && page.ssr === false) {
      throw new Error(`pages: ssr = false is not valid for island page
  '${page.componentPath}'.`);
    }

    const renderMode =
      page.island ? 'island' :
      page.ssr === false ? 'client' :
      'server';

    const prerenderMode =
      page.prerender === true ? 'force' :
      page.prerender === false ? 'disabled' :
      'auto';

    const shouldPrerender =
      prerenderMode === 'force' ||
      (prerenderMode === 'auto' && inferAutoPrerender(page, options));

    return { renderMode, prerenderMode, shouldPrerender };
  }

  I would not pass island?, ssr? as positional booleans into handlePageGet. I’d pass a single
  options object:

  handlePageGet(..., {
    renderMode: page.renderMode,
  });

  and inside protocol:

  if (options.renderMode === 'client') {
    return renderClientOnlyPage(...);
  }

  if (options.renderMode === 'island') {
    // existing island behavior
  }

  return renderWithAssetTags(...);

  The important part: preserve explicit false. Right now prerender = false is consumed during
  scan and then disappears. I’d keep it as data until normalization, because “unset”, “forced
  true”, and “forced false” are different states.

  I’d also document/define these combinations:

  ssr unset/true + prerender unset   -> normal SSR, auto prerender rules
  ssr false      + prerender unset   -> client shell rendered on request
  ssr false      + prerender true    -> prerendered client shell with embedded loader data
  ssr false      + prerender false   -> client shell only on request, never prerender
  island page    + ssr false         -> error

  For ssr = true, I’d parse it but treat it as explicit server rendering. That gives you a
  future escape hatch if a global default ever becomes client-only:

  ssr: 'auto' | 'server' | 'client'

  or normalized from booleans:

  undefined -> 'auto'
  true      -> 'server'
  false     -> 'client'

  So my preferred final internal shape would be:

  type SsrMode = 'auto' | 'server' | 'client';
  type PrerenderMode = 'auto' | 'force' | 'disabled';

  type ResolvedPageOptions = {
    renderMode: 'server' | 'client' | 'island';
    prerenderMode: PrerenderMode;
    shouldPrerender: boolean;
  };

  That keeps the user-facing API familiar, but stops the implementation from accumulating
  ambiguous optional booleans.

[TheAlexLichter]

Forwarding 😛