Logo Xantham

Render Module

Nested modules

Modules Description

Concrete

Transient

Functions and values

Function or value Description

aliasBodyVerdict ctx anchorPath name inScope anchoredBody

Full Usage: aliasBodyVerdict ctx anchorPath name inScope anchoredBody

Parameters:
Returns: TypeRefRender option
 ABBREVIATION-LEGALITY VERDICT for an ANCHORED, PRE-LOCALISE alias body (shared by
 the Transient and Concrete alias arms — the check must see atoms, and localise
 widgetizes them). Two F#-illegal abbreviation shapes degrade, LEDGERED:
  (1) SELF-REFERENCE — a body atom carrying the alias's OWN path is the prerender
      cycle-break placeholder (`type X<'T> = option>`, conditional-alias
      chains whose branches resolve back through the alias node): cyclic garbage
      by construction (FS0953).
  (2) PHANTOM TYPARS — a declared typar absent from the (post-scrub) body makes
      the abbreviation illegal (FS0035), and the arity-CHANGING fix needs every
      ref-arity source coordinated (the pinned +196 regression).
 `Some localisedBody` = legal abbreviation; `None` = the caller must emit the
 erased-preamble shape instead (an EMPTY INTERFACE with the same name and arity —
 refs stay legal at every use site, the unexpressible body becomes an opaque token).
ctx : GeneratorContext
anchorPath : AnchorPath
name : Name<MeasureProduct<pascal, MeasureOne>>
inScope : Set<string>
anchoredBody : TypeRefRender
Returns: TypeRefRender option

anchorMetadata ctx anchorPath metadata

Full Usage: anchorMetadata ctx anchorPath metadata

Parameters:
Returns: RenderMetadata
ctx : GeneratorContext
anchorPath : AnchorPath
metadata : RenderMetadata
Returns: RenderMetadata

anchorMetadataPath _ctx anchorPath path

Full Usage: anchorMetadataPath _ctx anchorPath path

Parameters:
Returns: AnchorPath
_ctx : GeneratorContext
anchorPath : AnchorPath
path : Path
Returns: AnchorPath

anchorScrubLocalise ctx inScope anchorPath render

Full Usage: anchorScrubLocalise ctx inScope anchorPath render

Parameters:
Returns: TypeRefRender
ctx : GeneratorContext
inScope : Set<string>
anchorPath : AnchorPath
render : TypeRefRender
Returns: TypeRefRender

anchorScrubLocaliseSplit ctx inScope resolveAnchor scrubHost localiseAnchor render

Full Usage: anchorScrubLocaliseSplit ctx inScope resolveAnchor scrubHost localiseAnchor render

Parameters:
Returns: TypeRefRender
 `anchorScrubLocalise` with the ANCHOR and LOCALISE roles SPLIT (the module-global
 holder classes — the Variable-arm rpcStub fix extended to Function params/returns):
 transient atoms resolve against the export's TRUE anchor, the same anchor the def
 walk places hoisted literals with, so a param literal's ref and def agree by
 construction (nameless ↔ nameless, Case{n} ↔ Case{n}); localisation shortens
 against the holder's REAL emission scope (namespace root), keeping the full
 module qualification. One shared anchor breaks one side or the other (the
 PartyServer GetServerByName class).

 The SCRUB HOST is the caller's choice, per channel history:
  - PARAMS pass the LOCALISE anchor — its legacy empty module trace indexes as
    unit 1, degrading holder-function param refs to obj as they always have been.
    Correcting their host to the export's unit (measured) lets REAL refs through,
    most valid — but cross-owner cache-hit literals whose defs materialized at
    their FIRST owner's path then dangle (Workers: the ExportedHandler.Fetch
    cf-properties literal referenced from the fetch holder as bare
    CloudflareWorkersTypes.Fetch). Params' host correction lands TOGETHER with
    the cross-owner def/ref closure, not before.
  - VARIABLE typeRefs and FUNCTION returns pass the RESOLVE anchor (the correct
    host): these channels were NEVER scrubbed, so there is no legacy to preserve
    and scrubbing only ADDS degradations — it cannot surface new refs. Their
    unscrubbed state was the Mcp first-count channel gap (obj-with-args escaping
    the collapse; the Mcp->Agents stray back-edges escaping the forward-DAG scrub).
ctx : GeneratorContext
inScope : Set<string>
resolveAnchor : AnchorPath
scrubHost : AnchorPath
localiseAnchor : AnchorPath
render : TypeRefRender
Returns: TypeRefRender

scrubAnchored ctx anchorPath render

Full Usage: scrubAnchored ctx anchorPath render

Parameters:
Returns: TypeRefRender

The three ANCHORED-REF SCRUBS as one stage — forward-DAG degradation, home-child def/ref closure, opaque/erased prefix collapse — shared by the member path (`anchorScrubLocalise`) and the HERITAGE path (which interleaves its inheritability filters and must therefore compose the chain itself). Every degradation is ledgered by its own scrub.

ctx : GeneratorContext
anchorPath : AnchorPath
render : TypeRefRender
Returns: TypeRefRender

scrubDanglingSelfRefs ctx scope anchorPath render

Full Usage: scrubDanglingSelfRefs ctx scope anchorPath render

Parameters:
Returns: TypeRefRender

DANGLING SELF-NAMESPACE SCRUB (module-global holder channels): after anchoring, a path atom INSIDE this export's own anchor namespace that the export's store will NOT materialize is a cross-owner cached transient's per-site resolution — its def lives only under its first owner (the Agents createMcpHandler class: the cf-shape INTERSECTION rides the interned-molecule cache into a later export's refs, and the shared-literal homes gate on TypeLiteral so it has no canonical home). Degrade the atom to obj, ledgered. DEF-SIDE ADOPTION was measured three ways (walk-wide: Workers 0->37 — a non-generic `type Request` planted beside the real one; export-arm-gated: 0->34; declared-type-guarded: Agents 2->22 duplicate-member merges with SYNTHESIZED defs) — every variant collides with the def-placement universe, which is not enumerable at prerender time. The ref side is total and collision-free. Healthy same-export transients (RpcStub, GetServerByName, Case{n} children) are STORE-BACKED and kept; concrete cross-unit refs live outside the anchor namespace and are untouched.

ctx : GeneratorContext
scope : RenderScopeStore
anchorPath : AnchorPath
render : TypeRefRender
Returns: TypeRefRender

typarNameSet typars

Full Usage: typarNameSet typars

Parameters:
Returns: Set<string>
Type parameters: 'r, 'c
typars : TypeParameterRender<'r, Name<'c>> list
Returns: Set<string>

Type something to start searching.