// ── module-uo's client entry point ─────────────────────────────────────────
//
// This file is the whole of the chunk's top-level behaviour: core injects
// `dist/entry.js` as a `<script type="module" src>` before `</body>`, the module
// registers what it has, and core renders it. The normative contract is
// MODULE_API.md §3.3.
//
// **Registration is synchronous and happens at evaluation time.** Module scripts
// are deferred, so this runs after core's bundle — which is where `window.__rg`
// is published — and before DOMContentLoaded, which is what core waits for
// before its first render. There is no subscription and no late registration: a
// module that registered asynchronously would register after the routes had been
// read, and the symptom is a page that redirects home with nothing logged. That
// bug cost the Phase 2 client PR an afternoon and no unit test in either repo
// can see it, which is why §7.7's browser smoke exists.
//
// Slice 0 of the Phase 3 extraction (MODULE_SYSTEM.md §2.7.1) registers NOTHING,
// on purpose. What it proves is the delivery path itself, and the imports below
// are how it proves the hardest part of it.

// These four specifiers are the whole shared-dependency contract, written the
// ordinary way — which is the point. `vite.config.js` aliases each to a shim
// that re-exports from `window.__rg`, so what ends up in the chunk is core's
// React, core's renderer and core's router, and no second copy of any of them.
// A module author writes these imports exactly as they would in any app.
//
// They are here in slice 0 rather than arriving with the first page because an
// unexercised alias is an unproven one: with nothing importing `react`, the
// build emits a 0.2 kB chunk, `checkExternals` passes vacuously, and the seam
// this whole slice exists to prove has not been touched.
import { createElement, isValidElement } from 'react'
import { createRoot } from 'react-dom/client'
import { Link } from 'react-router-dom'

const rg = window.__rg

// A module that cannot see the global is a module core did not load — which
// means the injection or the ordering broke, not the module. Say so, once,
// rather than throwing a TypeError about a property of undefined three frames
// deep in a component.
if (!rg) {
  console.error('[module-uo] window.__rg is missing — core did not publish its shared dependencies before this chunk evaluated.')
} else {
  // JSX, so the `react/jsx-runtime` alias is exercised too. That one is the
  // easiest of the four to get wrong and the hardest to notice: Vite's
  // object-form alias prefix-matches, so a `react` key silently captures
  // `react/jsx-runtime` as well, and the failure surfaces as `jsx is not a
  // function` in whichever component happens to render first.
  const probe = <span>module-uo</span>

  // The self-check: are the bindings this chunk imported the SAME objects core
  // published? Identity is the only question worth asking. A bundled second
  // React satisfies every type check, renders its first element happily, and
  // then throws about an invalid hook call somewhere unrelated.
  const shared = [
    ['react', createElement === rg.react.createElement],
    ['react/jsx-runtime', isValidElement(probe)],
    ['react-dom/client', createRoot === rg.reactDom.createRoot],
    ['react-router-dom', Link === rg.router.Link],
  ]
  const bundled = shared.filter(([, ok]) => !ok).map(([name]) => name)

  if (bundled.length) {
    console.error(
      `[module-uo] ${bundled.join(', ')} did not come from window.__rg — the chunk has bundled its own copy. ` +
      'Check the aliases in vite.config.js (MODULE_API.md §3.6).',
    )
  } else {
    // Registrations land here, slice by slice:
    //
    //   rg.registry.registerRoutes('uo', { public: [...], admin: [...], player: [...] })
    //   rg.registry.registerNav('uo', { area: 'public', items: [...] })
    //   rg.registry.registerFeatureProvider('uo', 'uo', useShardFeatures)
    //
    // `MODULE_API_VERSION` is checked by core against `module.json`'s `coreApi`
    // before this file is ever served, so there is nothing to re-check here. It
    // is logged because a mismatch between the core that validated the manifest
    // and the core that published this global would otherwise be invisible from
    // the browser, which is where the client half actually fails.
    console.info(`[module-uo] loaded against core API ${rg.version}; shared dependencies OK`)
  }
}