@geastack/compiler 1.0.15 → 1.0.17

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';
@@ -523,7 +523,8 @@ const emitLazyArrowFieldCall = (ctx, lines, operation) => {
     // conversion below then adapts the stored result to the read's, or refuses
     // and declines the fusion.
     const storedField = ctx.classes.get(site.owner)?.fields.find((field) => field.key === fieldName)?.representation ?? null;
-    const storedAbi = storedField !== null && (storedField.kind === 'function' || storedField.kind === 'function-family' || storedField.kind === 'function-value-dispatch')
+    const storedAbi = storedField !== null &&
+        (storedField.kind === 'function' || storedField.kind === 'function-family' || storedField.kind === 'function-value-dispatch')
         ? storedField.abi
         : callee.abi;
     const bodyAbi = ctx.abiOfCallable(plan.body);
@@ -1500,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
@@ -1550,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);
 };
 /**
@@ -3828,6 +3874,13 @@ const ownsItsStorage = (carrier) => {
         return carrier.ownership === 'shared-refcount';
     if (carrier.kind === 'optional')
         return ownsItsStorage(carrier.payload);
+    // A sum owns whatever its live arm owns. `gea::TaggedUnion` has a real move
+    // constructor (`TaggedUnionOps::moveConstruct`), so a dying union hands its
+    // string or reference over instead of `copyConstruct`ing it and then
+    // destroying the original -- per header value, per request, in node-compat's
+    // `writeHead`, where this was three heap copies of one content-type string.
+    if (carrier.kind === 'tagged-union')
+        return carrier.arms.some((arm) => ownsItsStorage(arm.value));
     return false;
 };
 /**

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

@@ -592,7 +592,7 @@ export const emitGet = (ctx, lines, operation) => {
     // struct-member fallthrough at the end would take `re.test` and emit
     // `re->test`, which is a clang error naming a member instead of a refusal
     // naming the method.
-    const regexpMember = regexpMemberText(ctx, operation.receiver, operation.key, operation.result.id, operation.result.representation, (fieldName, storage) => narrowedFieldReadText(ctx, operation, fieldName, storage)) ?? stringObjectMemberText(ctx, operation.receiver, operation.key, operation.result.representation);
+    const regexpMember = regexpMemberText(ctx, operation.receiver, operation.key, operation.result.id, operation.result.representation, (fieldName, storage, declared) => narrowedFieldReadText(ctx, operation, fieldName, storage, null, declared)) ?? stringObjectMemberText(ctx, operation.receiver, operation.key, operation.result.representation);
     if (regexpMember !== null) {
         // An empty rendering is a deferred RegExp.prototype method read -- see
         // the identical comment on the array-access branch above.
@@ -911,8 +911,18 @@ const fixedFieldPresenceText = (ctx, receiver, fieldName) => {
  * the original defect got in. A disagreement it declines to convert is a
  * defect upstream, not a spelling this may invent, so that refuses by name.
  */
-const narrowedFieldReadText = (ctx, operation, fieldName, storage, presence = null) => {
-    const declared = declaredFieldRepresentation(ctx, operation.receiver, fieldName);
+const narrowedFieldReadText = (ctx, operation, fieldName, storage, presence = null, 
+/**
+ * The member's physical carrier, supplied by a caller that HAS it where the
+ * lookup below cannot. A compiler-owned native layout
+ * (`ExecResult`/`MatchResult`) never gets a sealed record layout, so
+ * `declaredFieldRepresentation` answers null for its members and this
+ * function would hand back the bare load -- correct until the read is
+ * narrowed, and a type error the moment it is. The caller that knows the
+ * struct says so instead of this function guessing.
+ */
+declaredStorage = null) => {
+    const declared = declaredStorage ?? declaredFieldRepresentation(ctx, operation.receiver, fieldName);
     if (declared === null)
         return storage;
     const published = operation.result.representation;

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/prototype/emit-prototype-regexp.d.ts

@@ -72,7 +72,7 @@ export declare const regExpConstructionFromObject: (ctx: EmitContext, argument:
  * Stated once; `regexpMemberText` and the prototype-read walk both ask it.
  */
 export declare const deferredRegexpMethodClaim: (staticKeyTexts: ReadonlyMap<IrValueId, string>, receiver: IrOperand, key: IrOperand) => PrototypeMethodRead | null;
-export declare const regexpMemberText: (ctx: EmitContext, receiver: IrOperand, key: IrOperand, result: IrValueId | null, resultRepresentation: Representation | undefined, narrow: (fieldName: string, storage: string) => string) => string | null;
+export declare const regexpMemberText: (ctx: EmitContext, receiver: IrOperand, key: IrOperand, result: IrValueId | null, resultRepresentation: Representation | undefined, narrow: (fieldName: string, storage: string, declared: Representation | null) => string) => string | null;
 /**
  * `regexpStoreRefusal`'s whole decision, spelled as three outcomes rather than
  * collapsed into "throws or doesn't":

package/dist/targets/cpp/prototype/emit-prototype-regexp.js

@@ -216,6 +216,57 @@ const patternMethods = new Set(['test', 'exec', 'toString']);
  * report group positions for non-participating groups at all.
  */
 const resultDataMembers = new Set(['index', 'input', 'length', 'groups']);
+/**
+ * What each of those members PHYSICALLY holds, per role.
+ *
+ * Stated here because nothing else can state it. These two structs are
+ * compiler-owned native layouts: `representation/derive.ts` deliberately does
+ * NOT seal a record layout for `RegExpExecArray`/`RegExpMatchArray` -- see its
+ * own comment on why sealing "a plausible-looking struct" for them would emit
+ * a program that compiles and is not a regular expression -- so
+ * `recordFieldsOfShape` answers nothing for their shape id and the generic
+ * `narrowedFieldReadText` has no declared carrier to reconcile against. It
+ * therefore returned the bare member load for every read, which is right only
+ * while the read is NOT narrowed.
+ *
+ * It is wrong the moment it is. `if (m.groups !== undefined) m.groups['id']`
+ * publishes the payload while the field stores the optional, and the bare load
+ * emitted `Optional<Ref<Dictionary<std::string>>>` where a
+ * `Ref<Dictionary<std::string>>` was wanted -- `->has` then resolved on
+ * `gea::Ref`, which has no such member, and every program that read a named
+ * capture group by key failed to compile (node-compat's `apps/http-parity`
+ * router was the first). The narrowing obligation the `narrow` parameter
+ * documents was being honoured at the call and dropped inside it, for want of
+ * this table.
+ *
+ * The three optionals are the two interfaces' own `?`, and they differ by
+ * role on purpose: `RegExpExecArray` declares `index`/`input` REQUIRED and
+ * `RegExpMatchArray` declares them optional, because a global pattern's match
+ * really does answer an array with neither. `length` is `double` on an exec
+ * result and the inherited `ArrayObject::length()` on a match result; neither
+ * is optional. Keep this in step with `ExecResult`/`MatchResult` in
+ * `runtime/gea_runtime.h` -- they are the same two facts, and clang checks
+ * only one of them.
+ */
+const namedGroupsStorage = {
+    kind: 'optional',
+    payload: { kind: 'dictionary', key: 'string', value: { kind: 'string' }, ownership: 'shared-refcount' },
+    absence: 'undefined'
+};
+const numberStorage = { kind: 'scalar', domain: 'number' };
+const stringStorage = { kind: 'string' };
+const optionalOf = (payload) => ({ kind: 'optional', payload, absence: 'undefined' });
+const resultDataMemberStorage = (role, key) => {
+    if (key === 'groups')
+        return namedGroupsStorage;
+    if (key === 'length')
+        return numberStorage;
+    if (key === 'index')
+        return role === 'match-result' ? optionalOf(numberStorage) : numberStorage;
+    if (key === 'input')
+        return role === 'match-result' ? optionalOf(stringStorage) : stringStorage;
+    return null;
+};
 /** Whether `text` is a canonical array index -- a run of digits with no sign, point, or leading zero. */
 const canonicalCaptureSlot = (text) => {
     if (text.length === 0)
@@ -318,6 +369,11 @@ export const regexpMemberText = (ctx, receiver, key, result, resultRepresentatio
 // fails to assign. The capture reads below do NOT go through it: they choose
 // between `capture` and `capturedOrAbsent` on the published carrier already,
 // and are not fields at all.
+//
+// `declared` is what the member physically holds. The caller cannot look it
+// up for these two receivers -- their layout is never sealed -- so this
+// supplies it from `resultDataMemberStorage`, and passing `null` (a RegExp
+// pattern member) leaves the caller on its own lookup exactly as before.
 narrow) => {
     const role = regexpRoleOf(receiver.representation);
     if (role === null)
@@ -349,7 +405,7 @@ narrow) => {
             return unboxedReadText(resultRepresentation ?? { kind: 'dynamic', reason: 'declared-any-never-narrowed' }, `gea::runtime::regex::dynamicGet(${receiverText}, ${propertyKeyText(ctx, key, site)})`, site);
         }
         if (patternDataMembers.has(staticKey))
-            return narrow(staticKey, `${receiverText}->${staticKey}`);
+            return narrow(staticKey, `${receiverText}->${staticKey}`, null);
         if (deferredRegexpMethodClaim(ctx.staticKeyTexts, receiver, key) !== null) {
             if (result === null) {
                 throw createCppEmitBlockedError(`host-invocation:RegExp.prototype.${staticKey}`, `"${staticKey}" is a RegExp.prototype method, and this access publishes no value for its call to consume`);
@@ -369,7 +425,7 @@ narrow) => {
         // `MatchResult`; one spelling for both compiled the exec result's read as
         // a call on a `double`.
         const member = staticKey === 'length' && role === 'match-result' ? 'length()' : staticKey;
-        return narrow(staticKey, `${receiverText}->${member}`);
+        return narrow(staticKey, `${receiverText}->${member}`, resultDataMemberStorage(role, staticKey));
     }
     if (canonicalCaptureSlot(staticKey))
         return captureReadText(role, receiverText, staticKey, resultRepresentation);