spike(modules): carry /public/atlas/* behind the proposed module surface

THROWAWAY BRANCH — evidence for the Phase 1 contract, never merged. See
modules/uo/SPIKE.md and docs/website/MODULE_API.md Part 7.

The six public spawn-atlas routes now live in modules/uo/, reached only through
the ctx/register surface, with the client half loading as a prebuilt ESM chunk.
All three exit criteria met:

  • zero internal-file imports from the module into core; the built chunk has
    zero bare import specifiers and bundles no React
  • routes.manifest.json AND routes.guards.json are byte-identical
  • /uo/atlas renders from /modules/uo/entry.js under script-src 'self' with
    zero CSP violation reports

729 core tests and 81 module tests pass. Verified end to end against the real
database: the schema fragment replays after core's, onBoot runs the atlas
refresh, and the six API URLs answer unchanged.

Two things the spike changed in the contract:

  • ctx.express / ctx.validator. A module lives outside server/, so Node never
    reaches server/node_modules and require('express') fails outright — the
    server-side twin of the one-React rule, which §2.6 had only for the client.
  • window.__rg.jsxRuntime, so a module can build with the automatic JSX
    runtime its tooling already assumes rather than being forced to classic.

And it confirmed §6.1 empirically: regenerating the OpenAPI spec silently
deleted all 361 lines of the atlas paths with "Swagger-autogen: Success", while
the route manifest kept all six in the same run. That is exactly the
static-analysis-vs-runtime split the fragment merge exists to prevent.

Co-Authored-By: Claude <noreply@anthropic.com>

modules/uo/server/core.js

@@ -0,0 +1,88 @@
+// ── The module's single point of contact with core ─────────────────────────
+//
+// Every other file in this module imports THIS file instead of reaching into
+// the website's tree. That is the whole mechanical trick behind the
+// zero-internal-imports rule (docs/website/MODULE_API.md §5.1): the moved files
+// changed by one `require` line each, and a CI grep for a relative path
+// escaping the module root can then be an exact test rather than a heuristic.
+//
+// It exists because `ctx` arrives as an ARGUMENT to register(), while the files
+// that need it are plain CommonJS modules that were written against top-level
+// requires. Rather than thread ctx through nine constructors, register() parks
+// it here once and everything else reads it lazily.
+//
+// Lazily is load-bearing: this file is required at module-require time, which is
+// during app.js's own require, and reading `ctx.db` eagerly would rebuild the
+// startup-time database dependency the loader is careful not to have.
+
+let ctx = null
+
+/** Called exactly once, by server/index.js, at the top of register(). */
+function init(next) {
+  if (ctx) throw new Error('module-uo: core.init() called twice')
+  ctx = next
+}
+
+function require_() {
+  if (!ctx) throw new Error('module-uo: core used before register() ran')
+  return ctx
+}
+
+// Forwarders rather than re-exports: `const { query } = require('./core')`
+// destructures at require time, which is before init(), so a plain re-export
+// would capture undefined. Each of these resolves ctx at CALL time.
+const query = (sql, params) => require_().db.query(sql, params)
+
+const logger = (namespace) => require_().log(namespace)
+
+const settings = {
+  get: (key) => require_().settings.get(key),
+  // `updatedBy` is the third parameter core's settings.model.set carries — the
+  // atlas path setter passes it (shardAtlas.model.js:60), so dropping it here
+  // would silently lose the audit attribution rather than fail.
+  set: (key, value, updatedBy) => require_().settings.set(key, value, updatedBy),
+  getInstanceName: () => require_().settings.getInstanceName(),
+}
+
+const auth = {
+  getUserFromRequest: (req) => require_().auth.getUserFromRequest(req),
+}
+
+const middleware = {
+  siteMode: (req, res, next) => require_().middleware.siteMode(req, res, next),
+  validate: (req, res, next) => require_().middleware.validate(req, res, next),
+  requireAuth: (req, res, next) => require_().middleware.requireAuth(req, res, next),
+  noindex: (req, res, next) => require_().middleware.noindex(req, res, next),
+  requireRole: (...roles) => {
+    // requireRole is a FACTORY, so it must be resolved at call time and the
+    // resulting middleware kept — resolving it per request would build a new
+    // closure on every hit.
+    let built = null
+    return (req, res, next) => {
+      built = built || require_().middleware.requireRole(...roles)
+      return built(req, res, next)
+    }
+  },
+}
+
+module.exports = {
+  init,
+  // Shared server dependencies, taken from core rather than required directly.
+  // A module lives outside server/, so `require('express')` from here does not
+  // resolve at all — and even where it did, a second express in the process
+  // would be a second Router prototype. Same rule as React on the client.
+  get express() { return require_().express },
+  get validator() { return require_().validator },
+  query,
+  logger,
+  settings,
+  auth,
+  middleware,
+  get pool() { return require_().db.pool },
+  get secretBox() { return require_().secretBox },
+  get push() { return require_().push },
+  get uploads() { return require_().uploads },
+  get posts() { return require_().posts },
+  get paths() { return require_().paths },
+  get moduleId() { return require_().moduleId },
+}