@geastack/compiler 1.0.16 → 1.0.18

package/dist/targets/cpp/conversions.js

@@ -11,7 +11,7 @@ import { cppTypeOf } from './types.js';
 import { nativeSumWidenable } from '../../conversion/native-sum.js';
 import { nativeSelectionRecipeOf, nativeTotalSelectionRecipeOf } from '../../conversion/native-selection.js';
 import { nativeClassReferenceIdentityOf } from '../../conversion/native-class-reference.js';
-import { ownedRecordMaterializationPlan, recordViewUsesOnlyDirectFields } from '../../conversion/record-view.js';
+import { isRecordViewTarget, ownedRecordMaterializationPlan, recordViewDispatchesArms, recordViewUsesOnlyDirectFields } from '../../conversion/record-view.js';
 import { cppStringObjectNativeType } from './regexp-types.js';
 import { viewPlanFor } from './emit-record-view.js';
 /** Called only after the native converting-constructor predicate has selected this pair. */
@@ -446,6 +446,37 @@ const dynamicCallablePair = (target) => {
         materializer: { id: 'gea::detail::DynamicCarrier::in', domain, allocates: true }
     };
 };
+/**
+ * A shared class handle among a sum's arms, at a record-shaped target it
+ * reaches by neither the chain nor the structural view.
+ *
+ * Nothing in the program proves that arm dead: an interface-typed slot holds
+ * whatever object the program put there (`semantics/interface-implementors.ts`),
+ * and a class this cannot view as the record is still a value the slot can be
+ * handed -- skytail's `const ctx: AudioContextLike | null = Ctor ? new Ctor()
+ * : createNativeAudioContext()`, whose `NativeAudioContext` carries class-typed
+ * fields and a promise the view cannot rebuild. Selecting the record arm
+ * there read the class instance's bytes as the record and crashed at launch,
+ * certified. A record arm beside the exact one is the opposite case: a record
+ * the view cannot rebuild as the target is not assignable to it either, so the
+ * checker's own narrowing is what put the pair here, and the selection stands.
+ *
+ * Asked by every table that could answer the pair -- `narrowing` and
+ * `staticRecipe` -- so the census refuses it outright rather than one table
+ * declining and the next selecting.
+ */
+const classArmWithoutHome = (layouts, source, target) => {
+    const union = source.kind === 'optional' ? source.payload : source;
+    const selected = target.kind === 'optional' ? target.payload : target;
+    if (union.kind !== 'tagged-union' || !isRecordViewTarget(selected))
+        return false;
+    const key = representationKey(selected);
+    return union.arms.some(({ value }) => value.kind === 'class-ref' &&
+        value.ownership === 'shared-refcount' &&
+        representationKey(value) !== key &&
+        conversionRecipeOf(value, selected)?.renders !== true &&
+        viewPlanFor(layouts, value, selected) === null);
+};
 export const createCppConversionRegistry = (layouts = defaultRecordLayoutPolicy) => {
     // A sum narrowing's contract is composed from the contracts this same
     // registry states for its leaf pairs (`native-narrowing-transport.ts`), so
@@ -791,6 +822,8 @@ const cppConversionTables = (layouts, nativeNarrowing, nativeWrappedPayload) =>
         // can see, and whose lifetime the program never stated.
         if ('ownership' in target && target.ownership === 'borrowed')
             return null;
+        if (classArmWithoutHome(layouts, source, target))
+            return null;
         const setPair = genericFunctionSetPair(source, target);
         if (setPair)
             return setPair;
@@ -949,6 +982,18 @@ const cppConversionTables = (layouts, nativeNarrowing, nativeWrappedPayload) =>
         const selected = source.kind === 'optional' && target.kind === 'optional' ? target.payload : target;
         if (union.kind !== 'tagged-union')
             return null;
+        // A record-shaped target some OTHER arm reaches only through the
+        // structural view is not a selection: that arm is live at a store, and a
+        // selection would read it as the exact arm. The view's `dispatch` plan
+        // (`conversion/record-view.ts`) is the conversion, installed by
+        // `staticRecipe` below once this table declines -- the same plan
+        // `emit-narrowing.ts`'s `narrowedLoadText` defers to, asked here so the
+        // admission and the render agree.
+        if (isRecordViewTarget(selected)) {
+            const view = viewPlanFor(layouts, source, target);
+            if (view !== null && recordViewDispatchesArms(view))
+                return null;
+        }
         const targetKey = representationKey(selected);
         // A SUB-union target: `selected` is still a tagged union, just missing one
         // or more of `union`'s arms -- `h instanceof Headers`'s `else` branch
@@ -1972,6 +2017,22 @@ const cppConversionTables = (layouts, nativeNarrowing, nativeWrappedPayload) =>
     staticRecipe: (source, target) => {
         if (!isSpellable(source) || !isSpellable(target))
             return null;
+        if (classArmWithoutHome(layouts, source, target))
+            return null;
+        // A sum some arm of which reaches the record-shaped target only through
+        // the structural view is that view's `dispatch` plan, asked BEFORE the
+        // chain: the chain answers the pair too, by selecting the exact arm, and
+        // that selection is the narrowing this table's `narrowing` entry has
+        // already declined for the pair (`recordViewDispatchesArms`). The
+        // printer renders in the same order (`emit-narrowing.ts`'s `recipeText`).
+        const dispatching = viewPlanFor(layouts, source, target);
+        if (dispatching !== null && recordViewDispatchesArms(dispatching))
+            return {
+                id: 'view:structural-record',
+                domain: 'static:structural-record-view',
+                allocates: true,
+                ...(recordViewUsesOnlyDirectFields(dispatching) ? { nativeFieldProtocol: 'unused' } : {})
+            };
         const recipe = conversionRecipeOf(source, target);
         if (recipe !== null && recipe.renders) {
             // `unreachable-value` spells either `unreachableValue<T>()` (a throw that
@@ -2022,6 +2083,7 @@ const allocatingRecipes = new Set([
     'record-recast',
     'optional-record-recast',
     'record-to-dictionary',
+    'dictionary-to-record',
     'record-to-array',
     'promise-payload'
 ]);

package/dist/targets/cpp/emit-callable.js

@@ -10,7 +10,7 @@ import { alignedValueText, bindsReceiver, callableObjectAbi, movedValueText, unb
 import { memberAccessOperator, reactiveRevisionText } from './emit-carrier-members.js';
 import { structuralRecordViewText } from './emit-record-view.js';
 import { emitDateConstruct, isDateCarrier } from './prototype/emit-prototype-date.js';
-import { unwrapPresentValue, bindingReference, cppConstructedThunkName, cppConstructThunkName, cppEnvironmentStructName, cppReceiverName, cppThunkName, createCppEmitBlockedError, declareCell, defineValue, defineValueAlias, isCppEmitBlockedError, isIntegerStorageValue, operandText, paddedArguments, captureFieldText } from './emit-context.js';
+import { unwrapPresentValue, bindingReference, cppConstructedThunkName, cppConstructThunkName, cppEnvironmentStructName, cppReceiverName, cppThunkEntryText, cppThunkName, createCppEmitBlockedError, declareCell, defineValue, defineValueAlias, isCppEmitBlockedError, isIntegerStorageValue, operandText, paddedArguments, captureFieldText } from './emit-context.js';
 import { classMemberOf, classStaticMemberOf, cppFieldInitializerStatements, lazyArrowFieldPlanOf } from './class-layout.js';
 import { declaredRecordFieldOf } from './records.js';
 import { hostArityCallLines, hostResultText } from './host/emit-host-arity.js';
@@ -1501,8 +1501,8 @@ export const emitAllocateCallable = (ctx, lines, operation) => {
     // Brace-initializing this carrier with two values is what used to leave every
     // pre-`class` constructor function in three.js's renderer unclaimed.
     const pointers = payloadCarrier.kind === 'function-and-constructor'
-        ? `&${cppThunkName(operation.functionId)}, &${cppConstructedThunkName(operation.functionId)}`
-        : `&${cppThunkName(operation.functionId)}`;
+        ? `${cppThunkEntryText(ctx, operation.functionId)}, &${cppConstructedThunkName(operation.functionId)}`
+        : cppThunkEntryText(ctx, operation.functionId);
     // Tagged by the SOURCE DECLARATION, not by this copy's thunk. Two
     // instantiations of one generic function are two thunks and one JavaScript
     // function object; the runtime's own `CallableDeclarationTag` comment says
@@ -1551,11 +1551,11 @@ export const emitAllocateCallable = (ctx, lines, operation) => {
             return `gea::Value::boxCallable<${abi.restFrom}>(${callable})`;
         };
         if (admission.kind === 'none') {
-            lines.push(`${name} = gea::host::installOrdinaryConstructorPrototype(${boxText(`${callableType}{&${cppThunkName(operation.functionId)}, nullptr}`)});`);
+            lines.push(`${name} = gea::host::installOrdinaryConstructorPrototype(${boxText(`${callableType}{${cppThunkEntryText(ctx, operation.functionId)}, nullptr}`)});`);
             return;
         }
         const dynamicEnvironment = packedEnvironmentText(ctx, lines, operation.functionId, admission);
-        lines.push(`${name} = gea::host::installOrdinaryConstructorPrototype(${boxText(`${callableType}{&${cppThunkName(operation.functionId)}, ${dynamicEnvironment}}`)});`);
+        lines.push(`${name} = gea::host::installOrdinaryConstructorPrototype(${boxText(`${callableType}{${cppThunkEntryText(ctx, operation.functionId)}, ${dynamicEnvironment}}`)});`);
         return;
     }
     if (admission.kind === 'none') {

package/dist/targets/cpp/emit-context.d.ts

@@ -678,6 +678,13 @@ export interface EmitContext {
     readonly generatorBody: boolean;
     /** The conventions of emitted bodies, shared with their signature renderer. */
     readonly abiOfCallable: (callable: FunctionId) => CallableAbi | null;
+    /**
+     * The `name`/`length`/source text each function object must be able to
+     * answer, keyed by the body -- empty when the program never reads any of
+     * them (`translation-unit.ts`'s `preserveFunctionFacts` census). Read by
+     * `cppThunkEntryText`, at the sites that mint a function object.
+     */
+    readonly functionFacts: ReadonlyMap<FunctionId, CallableFactsSpelling>;
     /** The execution context whose frame this body is, so a cell owned elsewhere is recognisable as one. */
     readonly owner: FunctionId | RegionId;
     /** See `emit-narrowing.ts`'s `PrinterDrift`; one program-wide list, shared by every body's context. */
@@ -1622,7 +1629,7 @@ export declare const directCalleesOf: (body: IrBody, abiOfCallable: (callable: F
     readonly directCallees: ReadonlyMap<IrValueId, string>;
     readonly directCalleeAbis: ReadonlyMap<IrValueId, CallableAbi>;
 };
-export declare const createEmitContext: (abi: CallableAbi | null, owner: FunctionId | RegionId, placements: ReadonlyMap<DeclarationId, BindingPlacement>, classes: ReadonlyMap<DeclarationId, ClassLayout>, hosts: HostSpellings, deriver: RepresentationDeriver, bodyFacts: EmitBodyFacts, wellKnownSymbols?: ReadonlyMap<DeclarationId, string>, captures?: CaptureIndex, symbolKeys?: Map<string, string>, templateObjects?: Map<string, TemplateObjectDefinition>, directCallableBindings?: ReadonlyMap<DeclarationId, FunctionId>, virtualDispatch?: ReadonlyMap<string, CallableAbi>, narrowedFormals?: ReadonlySet<number>, repeatedConstructors?: ReadonlyMap<DeclarationId, DeclarationId>, dyingArguments?: ReadonlySet<IrValueId>, instantiation?: InstantiationFacts, abiOfCallable?: (callable: FunctionId) => CallableAbi | null, hostMethodAliases?: ReadonlyMap<DeclarationId, HostMethodAlias>, callableMemberCandidates?: ReadonlyMap<string, FunctionId>, borrowableMemberBodies?: ReadonlySet<FunctionId>, stableBorrowEntries?: ReadonlyMap<string, StableBorrowEntry>, printerDrift?: PrinterDrift[], conversions?: ConversionCensus | null, nativeSelections?: ReadonlyMap<string, NativeSelectionHelper> | undefined, callableIdentityDemand?: CallableIdentityDemand, nativeIntegrityRestricted?: boolean, fixedFieldStateConstant?: boolean) => {
+export declare const createEmitContext: (abi: CallableAbi | null, owner: FunctionId | RegionId, placements: ReadonlyMap<DeclarationId, BindingPlacement>, classes: ReadonlyMap<DeclarationId, ClassLayout>, hosts: HostSpellings, deriver: RepresentationDeriver, bodyFacts: EmitBodyFacts, wellKnownSymbols?: ReadonlyMap<DeclarationId, string>, captures?: CaptureIndex, symbolKeys?: Map<string, string>, templateObjects?: Map<string, TemplateObjectDefinition>, directCallableBindings?: ReadonlyMap<DeclarationId, FunctionId>, virtualDispatch?: ReadonlyMap<string, CallableAbi>, narrowedFormals?: ReadonlySet<number>, repeatedConstructors?: ReadonlyMap<DeclarationId, DeclarationId>, dyingArguments?: ReadonlySet<IrValueId>, instantiation?: InstantiationFacts, abiOfCallable?: (callable: FunctionId) => CallableAbi | null, functionFacts?: ReadonlyMap<FunctionId, CallableFactsSpelling>, hostMethodAliases?: ReadonlyMap<DeclarationId, HostMethodAlias>, callableMemberCandidates?: ReadonlyMap<string, FunctionId>, borrowableMemberBodies?: ReadonlySet<FunctionId>, stableBorrowEntries?: ReadonlyMap<string, StableBorrowEntry>, printerDrift?: PrinterDrift[], conversions?: ConversionCensus | null, nativeSelections?: ReadonlyMap<string, NativeSelectionHelper> | undefined, callableIdentityDemand?: CallableIdentityDemand, nativeIntegrityRestricted?: boolean, fixedFieldStateConstant?: boolean) => {
     readonly ctx: EmitContext;
     readonly prepass: EmitBodyPrepassFacts;
 };
@@ -1739,6 +1746,36 @@ export declare const cppFormalName: (ordinal: number) => string;
 export declare const cppReceiverName = "gea_this";
 /** The thunk that adapts one function body to the environment-passing invoke pointer a callable carrier holds. */
 export declare const cppThunkName: (functionId: string) => string;
+/**
+ * What one function object answers for `name`, `length` and
+ * `Function.prototype.toString`, already spelled for the registration call:
+ * `abiType` is `cppAbiType` of the thunk's own convention, which the
+ * registry's `Invoke` template parameter must match exactly.
+ */
+export interface CallableFactsSpelling {
+    readonly abiType: string;
+    readonly name: string;
+    readonly length: number;
+    readonly source: string;
+}
+/**
+ * The invoke pointer a minting site stores in a callable carrier: `&thunk`,
+ * or -- when the program reads function facts -- `&thunk` handed back by
+ * `gea::CallableObject<Abi>::entryWithFacts<&thunk>(name, length, text)`,
+ * which registers the facts the first time any site mints this function.
+ *
+ * Registration lives HERE, at the mint, and not beside the thunk, because a
+ * namespace-scope `static const bool ... = registerSource<&thunk>(...)` is a
+ * static initializer that takes the thunk's address, and a static initializer
+ * with a side effect is a root the linker may not drop. Every emitted
+ * function, and its source text, then survived `--gc-sections` and LTO
+ * whether or not anything reached it: a raw HTTP server whose `EventEmitter`
+ * boxed one listener kept all 384 of its functions. A mint site is reachable
+ * exactly when a function object can exist, and only an existing function
+ * object can be asked for its facts, so registering there preserves every
+ * observable answer and pins nothing else.
+ */
+export declare const cppThunkEntryText: (ctx: EmitContext, functionId: FunctionId) => string;
 /** The thunk that adapts one class's construct function to the environment-passing construct pointer a constructor carrier holds. */
 export declare const cppConstructThunkName: (declaration: DeclarationId) => string;
 /**

package/dist/targets/cpp/emit-context.js

@@ -4,7 +4,7 @@ import { noInstantiationFacts } from '../../ir/instantiation.js';
 import { observesEveryCallableIdentity } from '../../ir/callable-identity-demand.js';
 import { hostCallName, hostMemberOf, statedHostIntrinsicLength } from './host/host-members.js';
 import { representationKey } from '../../representation/model.js';
-import { cppBodyName, cppConstructName, cppNarrowedIntegerType, cppStringLiteral, cppTypeOf, cppUndefinedIn } from './types.js';
+import { cppBodyName, cppConstructName, cppNarrowedIntegerType, cppStringLiteral, cppStringViewLiteral, cppTypeOf, cppUndefinedIn } from './types.js';
 import { hostBuiltinFunctionIdentityText, hostClassValueText, hostFunctionValueText, hostJsonMemberValueText, hostMemberValueText } from './host/emit-host-value.js';
 import { createConversionNodes } from '../../conversion/nodes.js';
 import { createCppConversionRegistry } from './conversions.js';
@@ -75,7 +75,7 @@ export const directCalleesOf = (body, abiOfCallable) => {
     }
     return { directCallees, directCalleeAbis };
 };
-export const createEmitContext = (abi, owner, placements, classes, hosts, deriver, bodyFacts, wellKnownSymbols = new Map(), captures = emptyCaptureIndex, symbolKeys = new Map(), templateObjects = new Map(), directCallableBindings = new Map(), virtualDispatch = new Map(), narrowedFormals = new Set(), repeatedConstructors = new Map(), dyingArguments = new Set(), instantiation = noInstantiationFacts, abiOfCallable = () => null, hostMethodAliases = new Map(), callableMemberCandidates = new Map(), borrowableMemberBodies = new Set(), stableBorrowEntries = new Map(), printerDrift = [], 
+export const createEmitContext = (abi, owner, placements, classes, hosts, deriver, bodyFacts, wellKnownSymbols = new Map(), captures = emptyCaptureIndex, symbolKeys = new Map(), templateObjects = new Map(), directCallableBindings = new Map(), virtualDispatch = new Map(), narrowedFormals = new Set(), repeatedConstructors = new Map(), dyingArguments = new Set(), instantiation = noInstantiationFacts, abiOfCallable = () => null, functionFacts = new Map(), hostMethodAliases = new Map(), callableMemberCandidates = new Map(), borrowableMemberBodies = new Set(), stableBorrowEntries = new Map(), printerDrift = [], 
 // A context built without the program's census (the value-contract
 // checks) gets one over the same tables with nothing pre-minted: the
 // registry answers every pair the eager graph would have, one node later.
@@ -126,6 +126,7 @@ conversions = null, nativeSelections = undefined, callableIdentityDemand = obser
     const ctx = {
         abi: effectiveAbiOf(abi, admission),
         abiOfCallable,
+        functionFacts,
         owner,
         placements,
         classes,
@@ -537,6 +538,31 @@ export const cppFormalName = (ordinal) => `gea_arg_${ordinal}`;
 export const cppReceiverName = 'gea_this';
 /** The thunk that adapts one function body to the environment-passing invoke pointer a callable carrier holds. */
 export const cppThunkName = (functionId) => `${cppBodyName(functionId)}_thunk`;
+/**
+ * The invoke pointer a minting site stores in a callable carrier: `&thunk`,
+ * or -- when the program reads function facts -- `&thunk` handed back by
+ * `gea::CallableObject<Abi>::entryWithFacts<&thunk>(name, length, text)`,
+ * which registers the facts the first time any site mints this function.
+ *
+ * Registration lives HERE, at the mint, and not beside the thunk, because a
+ * namespace-scope `static const bool ... = registerSource<&thunk>(...)` is a
+ * static initializer that takes the thunk's address, and a static initializer
+ * with a side effect is a root the linker may not drop. Every emitted
+ * function, and its source text, then survived `--gc-sections` and LTO
+ * whether or not anything reached it: a raw HTTP server whose `EventEmitter`
+ * boxed one listener kept all 384 of its functions. A mint site is reachable
+ * exactly when a function object can exist, and only an existing function
+ * object can be asked for its facts, so registering there preserves every
+ * observable answer and pins nothing else.
+ */
+export const cppThunkEntryText = (ctx, functionId) => {
+    const thunk = `&${cppThunkName(functionId)}`;
+    const facts = ctx.functionFacts.get(functionId);
+    if (facts === undefined)
+        return thunk;
+    return (`gea::CallableObject<${facts.abiType}>::entryWithFacts<${thunk}>(` +
+        `${cppStringViewLiteral(facts.name)}, ${facts.length}, ${cppStringViewLiteral(facts.source)})`);
+};
 /** The thunk that adapts one class's construct function to the environment-passing construct pointer a constructor carrier holds. */
 export const cppConstructThunkName = (declaration) => `${cppConstructName(declaration)}_thunk`;
 /**

package/dist/targets/cpp/emit-narrowing.d.ts

@@ -3,7 +3,7 @@ import type { CallableAbi, Representation, TaggedUnionArm } from '../../represen
 import type { IrOperand, MergeLiveArmRebuildOperation } from '../../ir/model.js';
 import type { DeclarationId, FunctionId } from '../../identity/ids.js';
 import type { ConversionNode } from '../../conversion/algebra.js';
-import type { ConversionCensus } from '../../conversion/nodes.js';
+import { type ConversionCensus } from '../../conversion/nodes.js';
 import type { RecordLayoutPolicy } from '../../representation/policies.js';
 import type { ClassLayout } from '../../projection/classes.js';
 import type { CaptureIndex } from './emit-context.js';

package/dist/targets/cpp/emit-narrowing.js

@@ -2,7 +2,9 @@ import { classRefTransportKind, constructorUpcastMember } from './class-ref-tran
 import { abiKey, arrayExtensionKey, containsUnresolved, isBooleanShapedMergeTarget, isCanonicalNumberPropertyKeyText, representationKey, walkRepresentation, carriesUndefined } from '../../representation/model.js';
 import { transferOf } from '../../ir/transfer.js';
 import { coercionText } from './emit-coercion.js';
-import { structuralRecordViewText } from './emit-record-view.js';
+import { EXACT_ARM_MATERIALIZER, exactArmIndexOf } from '../../conversion/nodes.js';
+import { structuralRecordViewText, viewPlanFor } from './emit-record-view.js';
+import { recordViewDispatchesArms } from '../../conversion/record-view.js';
 import { createCppEmitBlockedError, cppConstructThunkName, cppThunkName, defineValue, isCppEmitBlockedError, isDeferredValue, operandText } from './emit-context.js';
 import { booleanTestText } from './emit-presence.js';
 import { recastedRecordToArrayText } from './emit-arrays.js';
@@ -476,6 +478,16 @@ export const narrowedLoadText = (held, read, text) => {
     }
     if (inner.kind !== 'tagged-union')
         return null;
+    // Every arm search below SELECTS: it loads the arm the read names and
+    // trusts the narrowing that licensed the load to have killed the rest. A
+    // store into a declared slot has no such licence -- `const ctx:
+    // AudioContextLike | null = Ctor ? new Ctor() : createNativeAudioContext()`
+    // converts a `record | class` into the interface's record, and the class
+    // arm is as live as the record's. This chain cannot tell the two apart (a
+    // class viewed as a record needs the program's layouts), so the census
+    // decides it: a pair some arm reaches only through the structural view is
+    // `conversion/record-view.ts`'s `dispatch` plan, installed and rendered
+    // ahead of this chain (`conversions.ts`'s `staticRecipe`, `recipeText`).
     // A join may preserve another join (or an optional) as one physical arm.
     // Search that nested carrier before trying to compare the outer arm list
     // with the read's list. Otherwise a read of the preserved inner union is
@@ -1907,6 +1919,14 @@ export const dictionaryCastableToDictionary = (source, target) => {
         throw error;
     }
 };
+const dictionaryToRecordText = (source, target, text) => {
+    if (source.kind !== 'dictionary' || source.key !== 'string' || source.value.kind !== 'dynamic' || source.ownership !== 'shared-refcount')
+        return null;
+    if (target.kind !== 'record' || target.accessors.length !== 0 || target.ownership === 'borrowed')
+        return null;
+    const boxed = dynamicCarrierBoxText(source, text);
+    return boxed === null ? null : unboxedLoadText(target, boxed);
+};
 const recastedDictionaryText = (source, target, text) => {
     if (!dictionaryCastableToDictionary(source, target))
         return null;
@@ -3435,6 +3455,18 @@ export const conversionChain = [
         id: 'dictionary-to-dictionary',
         apply: (source, target, text) => source.kind === 'dictionary' && target.kind === 'dictionary' ? claimed(recastedDictionaryText(source, target, text)) : undefined
     },
+    // The mirror of `record-to-dictionary` for the one dictionary whose values
+    // are boxed: `globalThis as unknown as { AudioContext?: Ctor }` reads named
+    // fields out of the open string-keyed surface `references.ts` gives
+    // `globalThis`. The closed field list comes from the TARGET, so this is not
+    // the reconstruction `conversion/derive.ts` refuses (recovering a field list
+    // from an open dictionary); it is the dynamic-object product read
+    // (`unboxedLoadText`'s record branch) over that dictionary boxed, which
+    // `gea::detail::dynamicRecordHasField` already reads as a document.
+    {
+        id: 'dictionary-to-record',
+        apply: (source, target, text) => claimed(dictionaryToRecordText(source, target, text))
+    },
     // An Array of one element carrier copied into an Array of another, each
     // element through its own conversion. A copy, so only for an array that is
     // not written through both names afterwards: a matcher table built once
@@ -3695,6 +3727,11 @@ export const recipeText = (ctx, node, text) => {
     // `conversions.ts`'s read of a structural value as a class nothing instantiates.
     if (node.capability.kind === 'atom' && node.capability.materializer.id === 'gea::host::unreachableValue')
         return `((void)(${text}), gea::host::unreachableValue<${cppTypeOf(node.target)}>())`;
+    // The census's exact-arm projection (`nodes.ts`'s `exactArmFor`): the arm
+    // index is a function of the pair, so it is re-derived here rather than
+    // carried on the node.
+    if (node.capability.kind === 'static' && node.capability.materializer.id === EXACT_ARM_MATERIALIZER)
+        return `gea::host::exactArm<${exactArmIndexOf(node.source, node.target)}>(${text})`;
     // `conversions.ts`'s read of a class instance's structural view as the class: the boxed origin, narrowed.
     if (node.capability.kind === 'atom' && node.capability.materializer.id === 'gea::record::viewOrigin')
         return narrowedLoadText({ kind: 'dynamic', reason: 'declared-any-never-narrowed' }, node.target, node.source.kind === 'optional'
@@ -3706,6 +3743,15 @@ export const recipeText = (ctx, node, text) => {
             ? `${helper.name}(${text})`
             : nativeSelectionText(node.capability.materializer.nativeSelection, node.source, node.target, text);
     }
+    // A view that DISPATCHES on a sum's live arm is rendered ahead of the
+    // chain: the chain would select the exact arm and trust a narrowing that,
+    // at a store, never happened (`narrowedLoadText`'s arm search says why).
+    // `conversions.ts`'s `staticRecipe` installs the node in the same order.
+    if (node.capability.kind === 'static' && node.capability.materializer.id === 'view:structural-record') {
+        const view = viewPlanFor(ctx.layouts, node.source, node.target);
+        if (view !== null && recordViewDispatchesArms(view))
+            return structuralRecordViewText(ctx, node.source, node.target, text);
+    }
     return convertedValueText(node.source, node.target, text) ?? structuralRecordViewText(ctx, node.source, node.target, text);
 };
 /**

package/dist/targets/cpp/emit-record-view.js

@@ -266,6 +266,37 @@ const recordViewText = (ctx, plan, text) => {
             }
             return recastedUnionFromHomes(plan.source, plan.target, text, homes);
         }
+        case 'dispatch': {
+            // The same discriminant chain `taggedUnionArmText` spells, with the last
+            // arm untested: the plan admitted every arm, so one of them is live.
+            // Each home is spelled at the whole target's type so an optional target
+            // wraps once per arm and an absent arm is its empty state.
+            const targetType = cppTypeOf(plan.target);
+            const payload = plan.target.kind === 'optional' ? plan.target.payload : plan.target;
+            const homes = [];
+            for (const [index, arm] of plan.arms.entries()) {
+                const from = plan.source.arms[index];
+                if (from === undefined)
+                    return null;
+                const armText = `${text}.get<${index}>()`;
+                const rendered = arm.via === 'exact'
+                    ? armText
+                    : arm.via === 'absent'
+                        ? null
+                        : arm.via === 'convert'
+                            ? convertedValueText(from.value, payload, armText)
+                            : recordViewText(ctx, arm.via, armText);
+                if (arm.via !== 'absent' && rendered === null)
+                    return null;
+                homes.push(rendered === null ? `${targetType}()` : `${targetType}(${rendered})`);
+            }
+            let result = homes[homes.length - 1];
+            if (result === undefined)
+                return null;
+            for (let index = homes.length - 2; index >= 0; index--)
+                result = `${text}.is<${index}>() ? ${homes[index]} : (${result})`;
+            return `(${result})`;
+        }
         case 'fields':
             return recordFieldsViewText(ctx, plan, text);
     }

package/dist/targets/cpp/emit.d.ts

@@ -8,8 +8,8 @@ import type { CallableAbi } from '../../representation/model.js';
 import type { RepresentationDeriver } from '../../representation/derive.js';
 import type { CppArtifact } from './document.js';
 import type { HostSpellings } from './host/host-members.js';
-import { type CaptureIndex, type TemplateObjectDefinition } from './emit-context.js';
-import type { ConversionCensus } from '../../conversion/nodes.js';
+import { type CaptureIndex, type CallableFactsSpelling, type TemplateObjectDefinition } from './emit-context.js';
+import { type ConversionCensus } from '../../conversion/nodes.js';
 import { type PrinterDrift } from './emit-narrowing.js';
 import type { IntegerStorageFacts } from '../../ir/integers.js';
 import { type InstantiationFacts } from '../../ir/instantiation.js';
@@ -41,5 +41,5 @@ import type { HostMethodAlias } from './host/host-method-aliases.js';
  * the same namespace or an absent constant -- see the call site for why an
  * absent arm is the one thing that may accompany it.
  */
-export declare const emitBody: (body: IrBody, placements: ReadonlyMap<DeclarationId, BindingPlacement>, classes: ReadonlyMap<DeclarationId, ClassLayout>, hosts: HostSpellings, deriver: RepresentationDeriver, wellKnownSymbols: ReadonlyMap<DeclarationId, string> | undefined, captures: CaptureIndex | undefined, symbolKeys: Map<string, string>, templateObjects: Map<string, TemplateObjectDefinition>, directCallableBindings?: ReadonlyMap<DeclarationId, FunctionId>, virtualDispatch?: ReadonlyMap<string, CallableAbi>, narrowedStorage?: IntegerStorageFacts, narrowedFormals?: ReadonlySet<number>, repeatedConstructors?: ReadonlyMap<DeclarationId, DeclarationId>, dyingArguments?: ReadonlySet<IrValueId>, instantiation?: InstantiationFacts, abiOfCallable?: (callable: FunctionId) => IrBody["abi"], hostMethodAliases?: ReadonlyMap<DeclarationId, HostMethodAlias>, callableMemberCandidates?: ReadonlyMap<string, FunctionId>, borrowableMemberBodies?: ReadonlySet<FunctionId>, stableBorrowEntries?: ReadonlyMap<string, StableBorrowEntry>, printerDrift?: PrinterDrift[], conversions?: ConversionCensus | null, nativeSelections?: ReadonlyMap<string, NativeSelectionHelper> | undefined, callableIdentityDemand?: CallableIdentityDemand, nativeIntegrityRestricted?: boolean, fixedFieldStateConstant?: boolean) => readonly CppArtifact[];
+export declare const emitBody: (body: IrBody, placements: ReadonlyMap<DeclarationId, BindingPlacement>, classes: ReadonlyMap<DeclarationId, ClassLayout>, hosts: HostSpellings, deriver: RepresentationDeriver, wellKnownSymbols: ReadonlyMap<DeclarationId, string> | undefined, captures: CaptureIndex | undefined, symbolKeys: Map<string, string>, templateObjects: Map<string, TemplateObjectDefinition>, directCallableBindings?: ReadonlyMap<DeclarationId, FunctionId>, virtualDispatch?: ReadonlyMap<string, CallableAbi>, narrowedStorage?: IntegerStorageFacts, narrowedFormals?: ReadonlySet<number>, repeatedConstructors?: ReadonlyMap<DeclarationId, DeclarationId>, dyingArguments?: ReadonlySet<IrValueId>, instantiation?: InstantiationFacts, abiOfCallable?: (callable: FunctionId) => IrBody["abi"], functionFacts?: ReadonlyMap<FunctionId, CallableFactsSpelling>, hostMethodAliases?: ReadonlyMap<DeclarationId, HostMethodAlias>, callableMemberCandidates?: ReadonlyMap<string, FunctionId>, borrowableMemberBodies?: ReadonlySet<FunctionId>, stableBorrowEntries?: ReadonlyMap<string, StableBorrowEntry>, printerDrift?: PrinterDrift[], conversions?: ConversionCensus | null, nativeSelections?: ReadonlyMap<string, NativeSelectionHelper> | undefined, callableIdentityDemand?: CallableIdentityDemand, nativeIntegrityRestricted?: boolean, fixedFieldStateConstant?: boolean) => readonly CppArtifact[];
 export { cppConstructedThunkName, cppConstructThunkName, cppFormalName, cppReceiverName, cppThunkName, isCppEmitBlockedError } from './emit-context.js';

package/dist/targets/cpp/emit.js

@@ -7,7 +7,7 @@ import { constructedBaseOf } from '../../projection/classes.js';
 import { allOperationsOf } from '../../ir/model.js';
 import { resultOfIrOperation } from '../../ir/queries.js';
 import { representationKey } from '../../representation/model.js';
-import { cppFormalName, cppReceiverName, createCppEmitBlockedError, createEmitContext, defineValue, defineValueAlias, directCalleesOf, emptyCaptureIndex, isIntegerStorageValue, isCppEmitBlockedError, operandText, storageTypeOf, cppThunkName, sealFactFieldsForRender } from './emit-context.js';
+import { cppFormalName, cppReceiverName, createCppEmitBlockedError, createEmitContext, defineValue, defineValueAlias, directCalleesOf, emptyCaptureIndex, isIntegerStorageValue, isCppEmitBlockedError, operandText, storageTypeOf, cppThunkEntryText, sealFactFieldsForRender } from './emit-context.js';
 import { hostMemberReadsOf } from './host/emit-host-properties.js';
 import { hostNamespaceReadsOf } from './host-namespace-reads.js';
 import { functionSourceReadsOf } from './function-source-reads.js';
@@ -18,6 +18,7 @@ import { reactiveOriginsOf } from './reactive-origins.js';
 import { renderTryRegion } from './emit-exceptions.js';
 import { emitReturn } from './emit-return.js';
 import { collectDirectBindingSinks, classObjectReadsOf, hostClassReadsOf, collectFormalCells, earlyCapturedCellPrologue, emitBindingRead, emitBindingWrite } from './emit-bindings.js';
+import { EXACT_ARM_MATERIALIZER } from '../../conversion/nodes.js';
 import { alignedValueText, emitMergeLiveArmRebuild, namedConversionText, widenedStoreText } from './emit-narrowing.js';
 import { admitDenseWindows, collectCapacityHints, emitAllocateArrayObject, emitDenseSetup, emitFillLoop } from './emit-arrays.js';
 import { noInstantiationFacts } from '../../ir/instantiation.js';
@@ -888,7 +889,12 @@ const emitConvert = (ctx, lines, operation) => {
     // (`alignedValueText` asks the census for the same pair and renders the
     // same node; a pair the census refused is its drift row, and the chain's).
     const named = ctx.conversions.nodeById(operation.conversionUse);
-    const text = (named?.capability.kind === 'coercion'
+    // A coercion and an exact-arm projection each share their (source, target)
+    // pair with the store node `alignedValueText` would look up, so for those
+    // the instruction's own node is the only thing that says which one runs.
+    const namedOverPair = named?.capability.kind === 'coercion' ||
+        (named?.capability.kind === 'static' && named.capability.materializer.id === EXACT_ARM_MATERIALIZER);
+    const text = (namedOverPair
         ? namedConversionText(ctx, 'emit.ts:1026', named, sourceText)
         : alignedValueText(ctx, 'emit.ts:1026', operation.source.representation, operation.result.representation, sourceText)) ??
         // A method value escaping into a receiver-less slot: the receiver is
@@ -1456,7 +1462,7 @@ const settleDeadCalleeSideEffects = (ctx, operation) => {
             // updating.
             const carrier = operation.result.representation;
             if (carrier.kind === 'function-value-dispatch' && carrier.abi.parameters.length === 0 && carrier.abi.receiver === null) {
-                ctx.deferredTexts.set(operation.result.id, `${cppTypeOf(carrier)}{&${cppThunkName(operation.functionId)}, nullptr}`);
+                ctx.deferredTexts.set(operation.result.id, `${cppTypeOf(carrier)}{${cppThunkEntryText(ctx, operation.functionId)}, nullptr}`);
             }
         }
         return;
@@ -1618,7 +1624,7 @@ export const emitBody = (body, placements, classes, hosts, deriver, wellKnownSym
 symbolKeys, templateObjects, directCallableBindings = new Map(), 
 // `virtualDispatch` is every `class key` with a dispatch member (`virtual-methods.ts`);
 // `narrowedStorage`/`narrowedFormals` are what the integer census settled here.
-virtualDispatch = new Map(), narrowedStorage = { reads: new Map(), integral: new Set(), magnitudes: new Map() }, narrowedFormals = new Set(), repeatedConstructors = new Map(), dyingArguments = new Set(), instantiation = noInstantiationFacts, abiOfCallable = () => null, hostMethodAliases = new Map(), callableMemberCandidates = new Map(), borrowableMemberBodies = new Set(), stableBorrowEntries = new Map(), printerDrift = [], conversions = null, nativeSelections = undefined, callableIdentityDemand = observesEveryCallableIdentity, nativeIntegrityRestricted = true, fixedFieldStateConstant = false) => {
+virtualDispatch = new Map(), narrowedStorage = { reads: new Map(), integral: new Set(), magnitudes: new Map() }, narrowedFormals = new Set(), repeatedConstructors = new Map(), dyingArguments = new Set(), instantiation = noInstantiationFacts, abiOfCallable = () => null, functionFacts = new Map(), hostMethodAliases = new Map(), callableMemberCandidates = new Map(), borrowableMemberBodies = new Set(), stableBorrowEntries = new Map(), printerDrift = [], conversions = null, nativeSelections = undefined, callableIdentityDemand = observesEveryCallableIdentity, nativeIntegrityRestricted = true, fixedFieldStateConstant = false) => {
     // Every fact this body settles before a single line renders, computed here
     // -- from `body` and the plain, already-available inputs above -- and
     // handed to `createEmitContext` as one argument instead of mutated onto the
@@ -1707,7 +1713,7 @@ virtualDispatch = new Map(), narrowedStorage = { reads: new Map(), integral: new
         directCallees: directCalleeFacts.directCallees,
         directCalleeAbis: directCalleeFacts.directCalleeAbis
     };
-    const { ctx, prepass } = createEmitContext(body.abi, body.sourceOwner, placements, classes, hosts, deriver, bodyFacts, wellKnownSymbols, captures, symbolKeys, templateObjects, directCallableBindings, virtualDispatch, narrowedFormals, repeatedConstructors, dyingArguments, instantiation, abiOfCallable, hostMethodAliases, callableMemberCandidates, borrowableMemberBodies, stableBorrowEntries, printerDrift, conversions, nativeSelections, callableIdentityDemand, nativeIntegrityRestricted, fixedFieldStateConstant);
+    const { ctx, prepass } = createEmitContext(body.abi, body.sourceOwner, placements, classes, hosts, deriver, bodyFacts, wellKnownSymbols, captures, symbolKeys, templateObjects, directCallableBindings, virtualDispatch, narrowedFormals, repeatedConstructors, dyingArguments, instantiation, abiOfCallable, functionFacts, hostMethodAliases, callableMemberCandidates, borrowableMemberBodies, stableBorrowEntries, printerDrift, conversions, nativeSelections, callableIdentityDemand, nativeIntegrityRestricted, fixedFieldStateConstant);
     // `ownedValues` stays a genuine render-time OUTPUT buffer (`EmitContext`'s
     // own doc: `defineValue` grows it as each operation's result is named) --
     // unlike `ownedDyingValues` above, a formal argument's membership in it is

package/dist/targets/cpp/translation-unit.js

@@ -27,7 +27,7 @@ import { classesConstructedUnobservably, functionsIgnoringTheirReceiver } from '
 import { renderJsonStructDeclarations } from './emit-json.js';
 import { alignedValueText } from './emit-narrowing.js';
 import { recordLayoutPolicyOf } from '../../projection/fields.js';
-import { cppAbiParameterType, cppAbiType, cppStringLiteral, cppStringViewLiteral, cppBodyName, cppCallableDeclarationTagName, cppCommonJsModuleName, cppCommonJsRecordName, cppNarrowedIntegerType, cppRefcountedReceiver, cppBoxedType, cppClassName, cppConstructName, cppGlobalName, cppInitializeName, cppRecordFieldName, cppRecordStructName, cppResultTypeOf, cppTypeOf, sanitizeForCppIdentifier } from './types.js';
+import { cppAbiParameterType, cppAbiType, cppStringLiteral, cppBodyName, cppCallableDeclarationTagName, cppCommonJsModuleName, cppCommonJsRecordName, cppNarrowedIntegerType, cppRefcountedReceiver, cppBoxedType, cppClassName, cppConstructName, cppGlobalName, cppInitializeName, cppRecordFieldName, cppRecordStructName, cppResultTypeOf, cppTypeOf, sanitizeForCppIdentifier } from './types.js';
 import { buildHostMethodAliasIndex } from './host/host-method-aliases.js';
 import { cppRecursiveContainerDeclarations, cppRecursiveContainerTraceEdges } from './recursive-containers.js';
 /**
@@ -562,7 +562,7 @@ const signatureOf = (body, captures, narrowed = new Set(), narrowedResult = fals
     const formals = bodyFormalsOf(body.sourceOwner, effectiveAbi, admission, narrowed, borrowsReceiver(body), borrowed);
     return `${result} ${name}(${formals.join(', ')})`;
 };
-const thunkOf = (body, captures, narrowed, narrowedResult, linkage, preserveFunctionFacts) => {
+const thunkOf = (body, captures, narrowed, narrowedResult, linkage) => {
     if (!body.abi)
         return null;
     const abi = body.abi;
@@ -601,17 +601,11 @@ const thunkOf = (body, captures, narrowed, narrowedResult, linkage, preserveFunc
     const construct = constructThunkOf(body, abi, hasEnvironment, linkage);
     return {
         prototype: [`${signature};`, ...(construct === null ? [] : [construct.prototype])].join('\n'),
-        definition: [
-            `${signature} { ${statement} }`,
-            ...(!preserveFunctionFacts || body.functionSource === undefined
-                ? []
-                : [
-                    `[[maybe_unused]] static const bool ${cppThunkName(body.sourceOwner)}_source = ` +
-                        `gea::CallableObject<${cppAbiType(abi)}>::registerSource<&${cppThunkName(body.sourceOwner)}>(` +
-                        `${cppStringViewLiteral(body.functionName ?? '')}, ${body.functionLength ?? 0}, ${cppStringViewLiteral(body.functionSource)});`
-                ]),
-            ...(construct === null ? [] : [construct.definition])
-        ].join('\n')
+        // No `registerSource` beside the thunk any more: the function's
+        // `name`/`length`/source text register at the sites that mint a function
+        // object from it (`emit-context.ts`'s `cppThunkEntryText`), so a function
+        // nothing reaches is not pinned into the binary by its own registration.
+        definition: [`${signature} { ${statement} }`, ...(construct === null ? [] : [construct.definition])].join('\n')
     };
 };
 /**
@@ -1639,9 +1633,24 @@ export const renderTranslationUnit = (input) => {
             }
         return false;
     });
+    // The facts every mint site of a function registers (`cppThunkEntryText`),
+    // spelled once per body here rather than looked up through the thunk. Empty
+    // when the census above found no reader, so `&thunk` alone is stored.
+    const functionFacts = new Map();
+    if (preserveFunctionFacts)
+        for (const body of input.bodies) {
+            if (isRegionId(body.sourceOwner) || body.abi === null || body.functionSource === undefined)
+                continue;
+            functionFacts.set(body.sourceOwner, {
+                abiType: cppAbiType(body.abi),
+                name: body.functionName ?? '',
+                length: body.functionLength ?? 0,
+                source: body.functionSource
+            });
+        }
     const thunks = new Map();
     for (const body of input.bodies) {
-        const thunk = thunkOf(body, captures, formalsNarrowedIn(body.sourceOwner), resultNarrowedIn(body.sourceOwner), linkage, preserveFunctionFacts);
+        const thunk = thunkOf(body, captures, formalsNarrowedIn(body.sourceOwner), resultNarrowedIn(body.sourceOwner), linkage);
         if (thunk)
             thunks.set(body, thunk);
     }
@@ -1713,7 +1722,7 @@ export const renderTranslationUnit = (input) => {
             continue;
         }
         try {
-            const sections = emitBody(body, input.placements, input.classes, hosts, deriver, input.wellKnownSymbols, captures, symbolKeys, templateObjects, directCallables, virtuals.dispatched, narrowedStorage.factsOf(body.sourceOwner), formalsNarrowedIn(body.sourceOwner), repeatedConstructors, dyingArguments, instantiation, (callable) => abiByBody.get(String(callable)) ?? null, hostMethodAliases, callableMemberCandidates, borrowableMemberBodies, stableBorrowEntries, printerDrift, input.conversions, selectionHelpers, callableIdentityDemand, nativeIntegrityRestricted, fixedFieldStateConstant);
+            const sections = emitBody(body, input.placements, input.classes, hosts, deriver, input.wellKnownSymbols, captures, symbolKeys, templateObjects, directCallables, virtuals.dispatched, narrowedStorage.factsOf(body.sourceOwner), formalsNarrowedIn(body.sourceOwner), repeatedConstructors, dyingArguments, instantiation, (callable) => abiByBody.get(String(callable)) ?? null, functionFacts, hostMethodAliases, callableMemberCandidates, borrowableMemberBodies, stableBorrowEntries, printerDrift, input.conversions, selectionHelpers, callableIdentityDemand, nativeIntegrityRestricted, fixedFieldStateConstant);
             const stableEntry = stableBorrowEntries.get(cppBodyName(body.sourceOwner));
             const commonJsScope = commonJsOwner === null || commonJsOwner.nativeRecord
                 ? []

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@geastack/compiler",
-  "version": "1.0.16",
+  "version": "1.0.18",
   "description": "The geastack TypeScript-to-C++ compiler: one semantic spine, no source-shaped authority, no boxing of statically typed values.",
   "license": "Apache-2.0",
   "repository": {