@geastack/compiler 1.0.15

package/dist/ir/native-class-origins.js

@@ -0,0 +1,237 @@
+import { nativeClassReferenceTransportMatches } from '../conversion/native-class-reference.js';
+import { representationKey } from '../representation/model.js';
+import { nativeCallFrameOf } from './call-entry.js';
+import { classConstructorBodyMatches, constructMatchesAbi } from './construct-entry.js';
+import { operandsOfIrOperation } from './queries.js';
+/** Allocation provenance is distinct from reflection demand: native callback
+ * inputs can have closed layouts without originating in this program. */
+export const nativeClassOriginsOf = (bodies, operations, producers, placements, classes, fieldSources, conversions) => {
+    const writes = new Map();
+    const observed = new Set();
+    const owners = new Map();
+    const bodiesById = new Map();
+    const local = (id) => {
+        const kind = placements.get(id)?.storage.kind;
+        return kind === 'local' || kind === 'region';
+    };
+    for (const body of bodies) {
+        const id = body.sourceOwner;
+        bodiesById.set(id, bodiesById.has(id) ? null : body);
+        for (const block of body.blocks.values())
+            for (const operation of [...block.operations, block.terminator])
+                owners.set(operation, id);
+    }
+    for (const operation of operations) {
+        for (const operand of operandsOfIrOperation(operation))
+            observed.add(operand.value);
+        if (operation.kind === 'binding-write') {
+            const values = writes.get(operation.declaration) ?? [];
+            values.push(operation.value);
+            writes.set(operation.declaration, values);
+        }
+    }
+    const constructorOf = (id, seen = new Set()) => {
+        if (seen.has(id))
+            return null;
+        const operation = producers.get(id);
+        if (operation?.kind === 'allocate-constructor')
+            return operation.declaration;
+        if (operation?.kind !== 'binding-read' || !local(operation.declaration))
+            return null;
+        seen.add(id);
+        const values = writes.get(operation.declaration)?.map((value) => constructorOf(value.value, seen));
+        seen.delete(id);
+        return values?.length && values[0] !== null && values.every((value) => value === values[0]) ? values[0] : null;
+    };
+    const functionsOf = (id, seen = new Set()) => {
+        if (seen.has(id))
+            return [];
+        const operation = producers.get(id);
+        if (operation?.kind === 'allocate-callable')
+            return [operation.functionId];
+        const constructor = constructorOf(id);
+        if (constructor !== null) {
+            const fn = classes.get(constructor)?.constructor;
+            return fn ? [fn] : [];
+        }
+        if (operation?.kind === 'get' || operation?.kind === 'binding-read') {
+            const identity = operation.closedCallable;
+            if (identity)
+                return identity.kind === 'exact' ? [identity.functionId] : identity.functionIds;
+        }
+        if (operation?.kind !== 'binding-read' || !local(operation.declaration))
+            return [];
+        seen.add(id);
+        const targets = writes.get(operation.declaration)?.map((value) => functionsOf(value.value, seen));
+        seen.delete(id);
+        return targets?.length && targets.every((target) => target.length > 0) ? [...new Set(targets.flat())] : [];
+    };
+    const unsafe = new Set();
+    const escapedConstructors = new Set();
+    const callers = new Map();
+    for (const layout of classes.values()) {
+        // Super entries and implicit derived constructors require their own incoming
+        // frame edges. Do not infer those edges from a matching class signature.
+        if (layout.base !== null) {
+            escapedConstructors.add(layout.declaration);
+            escapedConstructors.add(layout.base);
+            if (layout.constructor)
+                unsafe.add(layout.constructor);
+            const base = classes.get(layout.base)?.constructor;
+            if (base)
+                unsafe.add(base);
+        }
+    }
+    for (const operation of operations) {
+        for (const operand of operandsOfIrOperation(operation)) {
+            const functions = functionsOf(operand.value);
+            const constructor = constructorOf(operand.value);
+            const stored = operation.kind === 'binding-write' &&
+                local(operation.declaration) &&
+                writes
+                    .get(operation.declaration)
+                    ?.every((value) => (constructor !== null ? constructorOf(value.value) === constructor : functionsOf(value.value).length > 0));
+            const invoked = operation.kind === 'call' &&
+                operation.callee.value === operand.value &&
+                operation.receiver?.value !== operand.value &&
+                !operation.arguments.some((argument) => argument.value === operand.value);
+            const constructed = operation.kind === 'construct' &&
+                operation.callee.value === operand.value &&
+                operation.newTarget.value === operand.value &&
+                !operation.arguments.some((argument) => argument.value === operand.value);
+            if (stored || invoked || constructed)
+                continue;
+            for (const fn of functions)
+                unsafe.add(fn);
+            if (constructor !== null)
+                escapedConstructors.add(constructor);
+        }
+        if (operation.kind !== 'call' && operation.kind !== 'construct')
+            continue;
+        const functions = new Set(functionsOf(operation.callee.value));
+        if (operation.kind === 'call' && operation.closedCallee) {
+            const identity = operation.closedCallee;
+            for (const fn of identity.kind === 'exact' ? [identity.functionId] : identity.functionIds)
+                functions.add(fn);
+        }
+        if (operation.kind === 'construct') {
+            const targets = operation.target.kind === 'exact'
+                ? [operation.target.target]
+                : operation.target.kind === 'closed-family'
+                    ? operation.target.targets
+                    : [];
+            for (const target of targets)
+                if (target.kind === 'function')
+                    functions.add(target.functionId);
+        }
+        for (const fn of functions) {
+            const incoming = callers.get(fn) ?? [];
+            incoming.push(operation);
+            callers.set(fn, incoming);
+            const body = bodiesById.get(fn);
+            let matched = false;
+            if (body?.abi && functionsOf(operation.callee.value).includes(fn)) {
+                if (operation.kind === 'call')
+                    matched = nativeCallFrameOf(operation, body.abi, observed, conversions) !== undefined;
+                else {
+                    const declaration = constructorOf(operation.callee.value);
+                    const layout = declaration === null ? null : classes.get(declaration);
+                    matched =
+                        !!layout?.construct &&
+                            layout.constructor === fn &&
+                            classConstructorBodyMatches(layout, body) &&
+                            operation.callee.value === operation.newTarget.value &&
+                            constructMatchesAbi(operation, layout.construct, conversions);
+                }
+            }
+            if (!matched)
+                unsafe.add(fn);
+        }
+    }
+    const initializedClasses = new Map();
+    for (const layout of classes.values())
+        for (const field of layout.fields) {
+            if (!field.initializer)
+                continue;
+            const id = field.initializer;
+            const declarations = initializedClasses.get(id) ?? [];
+            declarations.push(layout.declaration);
+            initializedClasses.set(id, declarations);
+        }
+    const closedInitializer = (id) => {
+        const declarations = initializedClasses.get(id);
+        return !!declarations?.length && !unsafe.has(id) && declarations.every((declaration) => !escapedConstructors.has(declaration));
+    };
+    const cache = new Map();
+    const owned = (id, seen = new Set()) => {
+        if (cache.has(id))
+            return cache.get(id);
+        if (seen.has(id))
+            return false;
+        seen.add(id);
+        const operation = producers.get(id);
+        let sources = null;
+        // An absent alternative introduces no foreign object into a nullable
+        // reference. Its later presence load still has the conversion's guard.
+        let known = operation?.kind === 'constant' && (operation.literal === 'null' || operation.literal === 'undefined');
+        if (operation?.kind === 'construct') {
+            const declaration = constructorOf(operation.callee.value);
+            const layout = declaration === null ? null : classes.get(declaration);
+            known =
+                !!layout?.construct &&
+                    declaration !== null &&
+                    !escapedConstructors.has(declaration) &&
+                    operation.callee.value === operation.newTarget.value &&
+                    constructMatchesAbi(operation, layout.construct, conversions) &&
+                    (layout.constructor === null || (!unsafe.has(layout.constructor) && !!bodiesById.get(layout.constructor)));
+        }
+        else if (operation?.kind === 'binding-read' && local(operation.declaration))
+            sources = writes.get(operation.declaration) ?? null;
+        else if (operation?.kind === 'phi')
+            sources = operation.incoming.map((incoming) => incoming.value);
+        else if (operation?.kind === 'convert' &&
+            (representationKey(operation.source.representation) === representationKey(operation.result.representation) ||
+                nativeClassReferenceTransportMatches(operation.source.representation, operation.result.representation, conversions?.nodeById(operation.conversionUse))))
+            sources = [operation.source];
+        else if (operation?.kind === 'set')
+            sources = [operation.value];
+        else if (operation?.kind === 'define-own-property')
+            sources = [operation.receiver];
+        else if (operation?.kind === 'get' && owned(operation.receiver.value, seen))
+            sources = fieldSources(operation);
+        else if (operation?.kind === 'receiver' || operation?.kind === 'parameter') {
+            const owner = owners.get(operation);
+            const incoming = callers.get(owner);
+            if (!unsafe.has(owner) && incoming?.length) {
+                const values = incoming.map((caller) => operation.kind === 'parameter'
+                    ? caller.arguments[operation.ordinal]
+                    : caller.kind === 'call'
+                        ? caller.receiver
+                        : { value: caller.result.id, representation: caller.result.representation });
+                if (values.every((value) => value != null))
+                    sources = values;
+            }
+            // An initializer's implicit receiver is a fresh allocation, but only when
+            // its owning constructors cannot be called by an untracked consumer.
+            if (operation.kind === 'receiver' && closedInitializer(owner))
+                known = true;
+        }
+        else if (operation?.kind === 'call') {
+            const functions = functionsOf(operation.callee.value);
+            if (functions.length > 0 && functions.every((fn) => !unsafe.has(fn) && bodiesById.get(fn))) {
+                const returns = functions.flatMap((fn) => [...bodiesById.get(fn).blocks.values()].flatMap((block) => (block.terminator.kind === 'return' ? [block.terminator.value] : [])));
+                if (returns.length > 0 && returns.every((value) => value !== null))
+                    sources = returns;
+            }
+        }
+        if (sources?.length)
+            known = sources.every((source) => owned(source.value, seen));
+        seen.delete(id);
+        // A recursive path can become known through a later incoming edge. Failed
+        // queries are conservative and must not poison an independent query.
+        if (known)
+            cache.set(id, true);
+        return known;
+    };
+    return { owned, closedInitializer };
+};

package/dist/ir/native-dictionary-transport.d.ts

@@ -0,0 +1,6 @@
+import type { IrOperation } from './model.js';
+/** Native dictionary storage transports its declared values. A computed key
+ * selects an entry; it does not reflect on the fields of that entry's value.
+ * Dynamic key coercions and value adapters are deliberately outside this proof.
+ */
+export declare const nativeDictionaryTransportOf: (operation: IrOperation) => boolean;

package/dist/ir/native-dictionary-transport.js

@@ -0,0 +1,37 @@
+import { representationKey } from '../representation/model.js';
+/** Native dictionary storage transports its declared values. A computed key
+ * selects an entry; it does not reflect on the fields of that entry's value.
+ * Dynamic key coercions and value adapters are deliberately outside this proof.
+ */
+export const nativeDictionaryTransportOf = (operation) => {
+    if (operation.kind === 'allocate-record' || operation.kind === 'allocate-ordinary-object') {
+        const target = operation.result.representation;
+        if (target.kind !== 'dictionary' || target.ownership !== 'shared-refcount')
+            return false;
+        return (operation.kind === 'allocate-ordinary-object' ||
+            operation.fields.every((field) => representationKey(field.value.representation) === representationKey(target.value)));
+    }
+    if (operation.kind !== 'get' &&
+        operation.kind !== 'set' &&
+        operation.kind !== 'define-own-property' &&
+        operation.kind !== 'delete' &&
+        operation.kind !== 'has-property')
+        return false;
+    const receiver = operation.receiver.representation;
+    if (receiver.kind !== 'dictionary' || receiver.ownership !== 'shared-refcount')
+        return false;
+    const key = operation.key.representation;
+    // String-keyed dictionaries also accept native numeric keys through their
+    // canonical spelling. Objects and erased keys can invoke user coercions.
+    if ((receiver.key !== 'string' && receiver.key !== 'number') ||
+        (key.kind !== 'string' && !(key.kind === 'scalar' && key.domain === 'number')))
+        return false;
+    if (operation.kind === 'delete' || operation.kind === 'has-property')
+        return true;
+    const value = operation.kind === 'get' ? operation.result.representation : operation.value.representation;
+    return (representationKey(value) === representationKey(receiver.value) ||
+        (operation.kind === 'get' &&
+            value.kind === 'optional' &&
+            value.absence === 'undefined' &&
+            representationKey(value.payload) === representationKey(receiver.value)));
+};

package/dist/ir/native-enumeration.d.ts

@@ -0,0 +1,14 @@
+import type { Representation } from '../representation/model.js';
+export type NativeEnumerationPlan = {
+    readonly kind: 'empty';
+} | {
+    readonly kind: 'fields';
+} | {
+    readonly kind: 'optional';
+    readonly present: NativeEnumerationPlan;
+} | {
+    readonly kind: 'union';
+    readonly arms: readonly NativeEnumerationPlan[];
+};
+/** Enumerate native field metadata without reading or boxing field values. */
+export declare const nativeEnumerationPlanOf: (source: Representation) => NativeEnumerationPlan | null;

package/dist/ir/native-enumeration.js

@@ -0,0 +1,26 @@
+/** Enumerate native field metadata without reading or boxing field values. */
+export const nativeEnumerationPlanOf = (source) => {
+    switch (source.kind) {
+        case 'null':
+        case 'undefined':
+            return { kind: 'empty' };
+        case 'optional': {
+            const present = nativeEnumerationPlanOf(source.payload);
+            return present ? { kind: 'optional', present } : null;
+        }
+        case 'tagged-union': {
+            const arms = source.arms.map((arm) => nativeEnumerationPlanOf(arm.value));
+            return arms.length > 0 && arms.every((arm) => arm !== null) ? { kind: 'union', arms } : null;
+        }
+        // Compiler-rendered records and classes share the native field-key protocol.
+        case 'native-record-ref':
+        case 'record':
+        case 'record-with-index':
+        case 'class-ref':
+            return source.ownership === 'shared-refcount' && (source.kind !== 'native-record-ref' || source.native === null)
+                ? { kind: 'fields' }
+                : null;
+        default:
+            return null;
+    }
+};

package/dist/ir/native-equality.d.ts

@@ -0,0 +1,10 @@
+import type { Representation } from '../representation/model.js';
+/** A strict comparison reads the dynamic discriminant; its typed operand needs no carrier conversion. */
+export interface NativeEqualityRecipe {
+    readonly dynamicOperand: 0 | 1;
+    readonly primitive: 'number' | 'boolean' | 'string' | 'symbol' | 'bigint';
+    readonly negate: boolean;
+}
+export declare const nativeEqualityOf: (operator: string, operands: readonly {
+    readonly representation: Representation;
+}[]) => NativeEqualityRecipe | null;

package/dist/ir/native-equality.js

@@ -0,0 +1,18 @@
+export const nativeEqualityOf = (operator, operands) => {
+    if ((operator !== '===' && operator !== '!==') || operands.length !== 2)
+        return null;
+    const left = operands[0].representation;
+    const right = operands[1].representation;
+    const dynamicOperand = left.kind === 'dynamic' ? 0 : right.kind === 'dynamic' ? 1 : null;
+    if (dynamicOperand === null)
+        return null;
+    const typed = dynamicOperand === 0 ? right : left;
+    const primitive = typed.kind === 'string' || typed.kind === 'symbol'
+        ? typed.kind
+        : typed.kind === 'scalar'
+            ? typed.domain === 'boolean' || typed.domain === 'bigint'
+                ? typed.domain
+                : 'number'
+            : null;
+    return primitive === null ? null : { dynamicOperand, primitive, negate: operator === '!==' };
+};

package/dist/ir/native-field-owner.d.ts

@@ -0,0 +1,37 @@
+import type { ConversionNodeId } from '../conversion/algebra.js';
+import type { ConversionCensus } from '../conversion/nodes.js';
+import { type DeclarationId, type OperationId, type PhysicalBodyId } from '../identity/ids.js';
+import type { ClassLayout } from '../projection/classes.js';
+import type { RepresentationDeriver } from '../representation/derive.js';
+import { type Representation } from '../representation/model.js';
+import { type GetOperation, type IrBody } from './model.js';
+import type { ReflectionExposure } from './reflection-demand.js';
+type ClassRef = Extract<Representation, {
+    kind: 'class-ref';
+}>;
+/** The physical class identity selects a native field; a missing field remains undefined. */
+export interface NativeFieldOwnerRead {
+    readonly receiver: string;
+    readonly result: string;
+    readonly key: string;
+    readonly members: readonly ClassRef[];
+    readonly arms: readonly {
+        readonly member: ClassRef;
+        readonly source: Representation;
+        readonly conversion: ConversionNodeId;
+    }[];
+    readonly missing: ConversionNodeId;
+}
+/** Certification checks the exact field layout, class coverage and conversion citations. */
+export declare const nativeFieldOwnerReadMatches: (operation: GetOperation, key: string | null, classes: ReadonlyMap<DeclarationId, ClassLayout>, conversions: Pick<ConversionCensus, "nodeById">, exposure: ReflectionExposure | undefined) => boolean;
+/**
+ * Relocate storage and its reads as one publication, after the existing
+ * reflection census has proved the family cannot acquire unknown properties.
+ * Structural views and writes still contribute demand through the same slot
+ * census as the initial layout. A candidate read never removes those demands.
+ */
+export declare const finalizeNativeFieldOwnership: (bodies: ReadonlyMap<PhysicalBodyId, IrBody>, classes: ReadonlyMap<DeclarationId, ClassLayout>, deriver: RepresentationDeriver, conversions: ConversionCensus, exposure: ReflectionExposure, usesWithoutReads: (reads: ReadonlySet<OperationId>) => ReadonlyMap<DeclarationId, ReadonlySet<string>>) => {
+    readonly bodies: ReadonlyMap<PhysicalBodyId, IrBody>;
+    readonly classes: ReadonlyMap<DeclarationId, ClassLayout>;
+};
+export {};

package/dist/ir/native-field-owner.js

@@ -0,0 +1,183 @@
+import { nativeSumPlan } from '../conversion/native-sum.js';
+import { operationOfResult } from '../identity/ids.js';
+import { projectNativeClassStorage } from '../projection/class-storage.js';
+import { extendsClass } from '../projection/dispatch.js';
+import { classMemberOf } from '../projection/fields.js';
+import { representationKey } from '../representation/model.js';
+import { allOperationsOf } from './model.js';
+const familyOf = (classes, declaration) => [...classes.values()].filter((entry) => entry.declaration === declaration || extendsClass(classes, entry.declaration, declaration));
+const nativeConversion = (source, target, conversions) => {
+    if (nativeSumPlan(source, target) === null)
+        return null;
+    const node = conversions.nodeFor(source, target);
+    const capability = node.capability;
+    return capability.kind === 'identity' ||
+        ((capability.kind === 'atom' || capability.kind === 'static' || capability.kind === 'class-family') &&
+            capability.materializer.nativeFieldProtocol === 'unused')
+        ? node.id
+        : null;
+};
+const readRecipeOf = (operation, key, classes, conversions) => {
+    const receiver = operation.receiver.representation;
+    if (receiver.kind !== 'class-ref')
+        return null;
+    const missing = nativeConversion({ kind: 'undefined' }, operation.result.representation, conversions);
+    if (missing === null)
+        return null;
+    const members = [];
+    const arms = [];
+    for (const layout of familyOf(classes, receiver.declaration)) {
+        if (layout.instance?.kind !== 'class-ref' || layout.nativeBase !== null || layout.nativeStorage === undefined)
+            return null;
+        const site = classMemberOf(classes, layout.declaration, key);
+        if (site !== null && site.kind !== 'field')
+            return null;
+        members.push(layout.instance);
+        const field = layout.nativeStorage.fields.find((entry) => entry.key === key);
+        if (!field)
+            continue;
+        const conversion = nativeConversion(field.value, operation.result.representation, conversions);
+        if (conversion === null)
+            return null;
+        arms.push({ member: layout.instance, source: field.value, conversion });
+    }
+    return { receiver: representationKey(receiver), result: representationKey(operation.result.representation), key, members, arms, missing };
+};
+/** Certification checks the exact field layout, class coverage and conversion citations. */
+export const nativeFieldOwnerReadMatches = (operation, key, classes, conversions, exposure) => {
+    const recipe = operation.nativeFieldOwnerRead;
+    const receiver = operation.receiver.representation;
+    if (!recipe ||
+        !exposure?.complete ||
+        receiver.kind !== 'class-ref' ||
+        recipe.key !== key ||
+        recipe.receiver !== representationKey(receiver) ||
+        recipe.result !== representationKey(operation.result.representation))
+        return false;
+    const family = familyOf(classes, receiver.declaration);
+    if (family.length !== recipe.members.length || new Set(recipe.members.map((member) => member.declaration)).size !== family.length)
+        return false;
+    const matches = (id, source) => {
+        const node = conversions.nodeById(id);
+        if (!node || representationKey(node.source) !== representationKey(source) || representationKey(node.target) !== recipe.result)
+            return false;
+        const capability = node.capability;
+        return (capability.kind === 'identity' ||
+            ((capability.kind === 'atom' || capability.kind === 'static' || capability.kind === 'class-family') &&
+                capability.materializer.nativeFieldProtocol === 'unused'));
+    };
+    let fields = 0;
+    for (const layout of family) {
+        if (exposure.classes.get(layout.declaration)?.level !== 'keys-only' || layout.nativeStorage === undefined || layout.nativeBase !== null)
+            return false;
+        const site = classMemberOf(classes, layout.declaration, recipe.key);
+        if (site !== null && site.kind !== 'field')
+            return false;
+        const member = recipe.members.find((entry) => entry.declaration === layout.declaration);
+        if (!member || !layout.instance || representationKey(member) !== representationKey(layout.instance))
+            return false;
+        const field = layout.nativeStorage.fields.find((entry) => entry.key === key);
+        const arms = recipe.arms.filter((entry) => entry.member.declaration === layout.declaration);
+        if (!field) {
+            if (arms.length !== 0)
+                return false;
+            continue;
+        }
+        fields++;
+        const arm = arms[0];
+        if (arms.length !== 1 ||
+            !arm ||
+            representationKey(arm.member) !== representationKey(member) ||
+            representationKey(arm.source) !== representationKey(field.value) ||
+            !matches(arm.conversion, field.value))
+            return false;
+    }
+    return fields === recipe.arms.length && matches(recipe.missing, { kind: 'undefined' });
+};
+/**
+ * Relocate storage and its reads as one publication, after the existing
+ * reflection census has proved the family cannot acquire unknown properties.
+ * Structural views and writes still contribute demand through the same slot
+ * census as the initial layout. A candidate read never removes those demands.
+ */
+export const finalizeNativeFieldOwnership = (bodies, classes, deriver, conversions, exposure, usesWithoutReads) => {
+    const unchanged = { bodies, classes };
+    if (!exposure.complete)
+        return unchanged;
+    const reads = new Map();
+    const readKeys = new Map();
+    const ignored = new Set();
+    for (const body of bodies.values()) {
+        const constants = new Map([...body.blocks.values()].flatMap((block) => block.operations.flatMap((op) => (op.kind === 'constant' && op.literal === 'string' ? [[op.result.id, op.text]] : []))));
+        for (const block of body.blocks.values())
+            for (const operation of allOperationsOf(block)) {
+                if (operation.kind !== 'get' || operation.receiver.representation.kind !== 'class-ref')
+                    continue;
+                const key = constants.get(operation.key.value);
+                if (key === undefined)
+                    continue;
+                readKeys.set(operation, key);
+                if (operation.reactive || operation.hostMethod || !block.operations.includes(operation))
+                    continue;
+                const site = classMemberOf(classes, operation.receiver.representation.declaration, key);
+                if (site?.kind !== 'field')
+                    continue;
+                const ownership = classes.get(site.owner)?.fieldOwnership.find((entry) => entry.key === key);
+                if (!ownership || ownership.physicalOwners.length === 0)
+                    continue;
+                if (!familyOf(classes, site.owner).every((entry) => exposure.classes.get(entry.declaration)?.level === 'keys-only'))
+                    continue;
+                if (!readRecipeOf(operation, key, classes, conversions))
+                    continue;
+                reads.set(operation, key);
+                ignored.add(operationOfResult(operation.lineage));
+            }
+    }
+    if (reads.size === 0)
+        return unchanged;
+    const storage = projectNativeClassStorage(classes, deriver, usesWithoutReads(ignored));
+    const relocated = new Map([...classes].map(([id, layout]) => [id, storage.has(id) ? { ...layout, nativeStorage: storage.get(id) } : layout]));
+    const replacements = new Map();
+    // Validate every surviving read whose old slot vanished, including reads
+    // introduced by lowering rather than a source property operation.
+    for (const body of bodies.values())
+        for (const block of body.blocks.values())
+            for (const operation of allOperationsOf(block)) {
+                if (operation.kind !== 'get' || operation.receiver.representation.kind !== 'class-ref')
+                    continue;
+                const key = readKeys.get(operation);
+                if (key === undefined)
+                    continue;
+                const old = classes.get(operation.receiver.representation.declaration);
+                if (!old?.nativeStorage?.fields.some((field) => field.key === key))
+                    continue;
+                const layout = relocated.get(operation.receiver.representation.declaration);
+                if (layout?.nativeStorage?.fields.some((field) => field.key === key))
+                    continue;
+                if (!reads.has(operation))
+                    return unchanged;
+                const recipe = readRecipeOf(operation, key, relocated, conversions);
+                if (!recipe)
+                    return unchanged;
+                const replacement = { ...operation, nativeFieldOwnerRead: recipe };
+                if (!nativeFieldOwnerReadMatches(replacement, key, relocated, conversions, exposure))
+                    return unchanged;
+                replacements.set(operation, replacement);
+            }
+    if (replacements.size === 0)
+        return unchanged;
+    const finalized = new Map([...bodies].map(([id, body]) => [
+        id,
+        {
+            ...body,
+            blocks: new Map([...body.blocks].map(([blockId, block]) => [
+                blockId,
+                {
+                    ...block,
+                    operations: block.operations.map((operation) => operation.kind === 'get' ? (replacements.get(operation) ?? operation) : operation)
+                }
+            ]))
+        }
+    ]));
+    return { bodies: finalized, classes: relocated };
+};

package/dist/ir/native-fixed-layout.d.ts

@@ -0,0 +1,41 @@
+import type { DeclarationId } from '../identity/ids.js';
+import type { ClassLayout } from '../projection/classes.js';
+import type { RepresentationDeriver } from '../representation/derive.js';
+import { type Representation } from '../representation/model.js';
+/**
+ * Whether a native object has only compiler-owned, fixed slots.
+ *
+ * This is a fact about the object's own slots, not the protocol of their
+ * payloads. An array, optional, callable or host reference in a fixed field
+ * does not make reading that field dynamic. `directChildrenOf` separately
+ * censuses those payloads, and `promoteFull` closes over them when an actual
+ * operation exposes the enclosing object. Requiring a child's layout to be
+ * closed here retains unused boxed reads on an otherwise closed parent.
+ * `native-record-ref` is admitted only when it names a compiler-owned record
+ * layout from the sealed deriver. Host layouts, index sidecars and record
+ * accessors still require their own full protocol. Class prototype accessors
+ * are body entries, not own storage; their effects belong to accessor flow.
+ * Recursive native wrappers remain
+ * excluded because their physical layout is not the ordinary record layout.
+ *
+ * A container with an intrinsically open element/key domain -- `array-object`,
+ * `dictionary`, `keyed-collection` -- asks a narrower version of the same
+ * question. Their indexed/keyed storage is never finite (that openness is
+ * what makes them a container rather than a record) and is never what this
+ * function is being asked about: reads and writes through it are served by
+ * their own dedicated native transports (`native-array-transport.ts`,
+ * `native-dictionary-transport.ts`, direct `get`/`set`/`has` method calls),
+ * never by the generic `gea_readOwnField`/`gea_ownFieldDescriptor` hooks this
+ * proof gates. What is left to check is only the OWN NAMED-FIELD surface
+ * beyond that index -- an array's `extension`, or nothing at all for a plain
+ * array, a bare dictionary, or a Map/Set/WeakMap/WeakSet -- which can be
+ * exactly as closed as an ordinary record's fields even though the container
+ * around it is open-ended.
+ */
+export declare const hasClosedFixedLayout: (representation: Representation, deriver: Pick<RepresentationDeriver, "layoutOf"> | null, classes: ReadonlyMap<DeclarationId, ClassLayout>, visiting?: Set<string>, completed?: Map<string, boolean>) => boolean;
+/** A typed native index has a complete property protocol even though its key
+ * set changes at runtime. Key enumeration consumes that protocol, not the
+ * values stored in it. Keep fixed-slot proofs separate: an index must never
+ * qualify a record for a finite-field lookup or fixed-layout conversion.
+ */
+export declare const hasNativePropertyLayout: (representation: Representation, deriver: Pick<RepresentationDeriver, "layoutOf"> | null, classes: ReadonlyMap<DeclarationId, ClassLayout>, visiting?: Set<string>, completed?: Map<string, boolean>) => boolean;