Per-module backend (cg stage), non-main module: wrap this module's accumulated top-level global destructors in a nullary exported proc and return its C name ("" when there are none).

graph.globalDestructors is filled while a module's own cg process injects destructors into its top level, but the teardown code is emitted by the MAIN module's cg — a different process, whose graph only ever sees its own entries. So each module emits its own teardown here and records the name in its .c.nif meta head; the main module's cg reads the heads (like it already does for init/datInit) and calls them.

Whether the cg of the module at modPos emits the generic instance s ITSELF, so that every other demander only prototypes it. That module is the instance's HOME: the module that created it and serializes it, and whose (offer) makes every importer reuse this very symbol instead of minting its own. Emitting it once there restores the original one-definition semantics; emit-everywhere + merge remains the fallback for what does not qualify.

The predicate reads only the symbol as its home serialized it, so the home's cg (which seeds it) and every demander's cg (which then skips the body) agree without talking to each other. It excludes:

• BACKEND-MINTED syms (rttiDestroy/rttiTrace wrappers, lifted hooks): no module's index lists them, so no home would seed them;
• generated type-bound ops (sfGeneratedOp): same reason — they are produced per process, not serialized by a home;
• instances the home does not OFFER: the ones minted inside a compiles() probe. Such an instance can survive with a body that never resolved ($ of a CountTable[PIdent] with a raw nkDotExpr callee); nothing demands it, and codegen of it crashes. The home always loads its own header, so it sees its offers; a demander that did not load the home's header just emits the body as before, which merge dedups;
• everything isSeedableRoutine rejects (metatypes, unused, forward, ...).

cg transforms a seeded instance in its own process, exactly as a demander did before, so the lower stage still never sees one.

• nested/closure procs (owner is a proc, not a module): emitted via their enclosing routine's lambda-lifting, never standalone;
• generic instances (sfFromGeneric): seeded by their home module instead, see homeEmitsInstance;
• importc/compileTime/error/forward sentinels and meta signatures: not real codegen targets.
• method DISPATCHERS (sfDispatcher): their bodies are (re)synthesized into the main TU by emitMethodDispatchers/generateIfMethodDispatchers, never per module. A dispatcher is a copySym clone of the method that shares the method's body sub-tree (incl. its closure iterator); transforming it here would lambda-lift that SHARED iterator a SECOND time under a different owner identity, baking a conflicting up field → "up references do not agree" (the divergence is impossible in non-IC, where the dispatcher body is empty at lift time). So a dispatcher is never an owned runtime routine.

A {.closure.} iterator IS a standalone runtime routine (unlike an inline iterator, which is expanded at each call site) and must be emitted by its owner — else a cross-module for over it links to nothing.

Generic INSTANCES (sfFromGeneric) are NEVER an owned runtime routine, so the lower stage never transforms one; cg seeds them separately through homeEmitsInstance and transforms them itself. The lower stage must not transform an instance: a not-fully-concrete instance (a closure factory over a static param, or a $/= op instance whose body resolves only at its further-specialised use sites) still carries unresolved overload choices and crashes transformBody (empty-namePos lambda, nil-typed const-fold).