@geastack/compiler 1.0.15

package/dist/plugins/gea/lower.d.ts

@@ -0,0 +1,6 @@
+import type { OperationId } from '../../identity/ids.js';
+import type { SemanticOperation } from '../../semantics/model/operations.js';
+import { type LoweringContext } from '../../ir/lower-operands.js';
+import type { IrBlockId } from '../../ir/model.js';
+import { type GeaElementFacts } from './contract.js';
+export declare const lowerGeaElement: (ctx: LoweringContext, block: IrBlockId, operation: SemanticOperation, facts: ReadonlyMap<OperationId, GeaElementFacts>) => boolean;

package/dist/plugins/gea/lower.js

@@ -0,0 +1,195 @@
+import { representationKey } from '../../representation/model.js';
+import { operandOf } from '../../semantics/model/operands.js';
+import { IrLoweringBlockedError } from '../../ir/lower-graph.js';
+import { abiOfCallee, orderedOperandsOf, recordLayoutOf, registerResult, requireLineage, requireResultRepresentation, resolveOptionalOperand, enterRequiredOperand } from '../../ir/lower-operands.js';
+import { geaReconcilerAttributeName } from './contract.js';
+export const lowerGeaElement = (ctx, block, operation, facts) => {
+    if (operation.family !== 'element' || operation.form !== 'value')
+        return false;
+    const resolved = facts.get(operation.id);
+    if (!resolved)
+        return false;
+    const lineage = requireLineage(operation);
+    const keys = orderedOperandsOf(operation, 'prop-key');
+    const children = orderedOperandsOf(operation, 'child').map((child) => enterRequiredOperand(ctx, block, lineage, operation, child));
+    const tag = resolveOptionalOperand(ctx, block, lineage, operandOf(operation, 'tag', 0));
+    const representation = requireResultRepresentation(ctx, operation, 'value', 'an element construction');
+    if (resolved.invocation === 'construct') {
+        lowerClassComponent(ctx, block, operation, resolved, tag, keys, children, representation);
+        return true;
+    }
+    lowerFunctionComponent(ctx, block, operation, tag, keys, children, representation);
+    return true;
+};
+/**
+ * A function component element, lowered to what the checker checked: a call.
+ *
+ * No new emitter capability is involved: the record allocation and the generic
+ * call path are the same primitives an ordinary `C({a: x})` goes through.
+ */
+const lowerFunctionComponent = (ctx, block, operation, tag, keys, children, representation) => {
+    const lineage = requireLineage(operation);
+    if (!tag)
+        throw new IrLoweringBlockedError('a component element names no tag to invoke');
+    const abi = abiOfCallee(tag.representation);
+    if (!abi)
+        throw new IrLoweringBlockedError(`a component element's tag carries "${tag.representation.kind}", which declares no calling convention`);
+    // The caller builds the frame the callee declares -- so the arguments are
+    // the convention's parameters, each filled from the attributes. A component
+    // that declares none gets none, which falls out of mapping an empty list
+    // rather than being a case: `<Board/>`, whose whole state comes from a
+    // store, goes down exactly the same path as `<Row label={x}/>`.
+    if (abi.parameters.length > 1) {
+        throw new IrLoweringBlockedError(`an element supplies one attributes object, but its tag's convention declares ${abi.parameters.length} parameters; ` +
+            'the ones past the first have nothing in the element to fill them from');
+    }
+    const built = abi.parameters.map((parameter) => buildPropsRecord(ctx, block, operation, keys, children, parameter.value));
+    requireEveryAttributeConsumed(keys, children, built);
+    registerResult(ctx, operation, ctx.builder.call(block, lineage, tag, null, built, representation));
+};
+/**
+ * A class component element: construct the instance, then enter its render.
+ *
+ * The props carrier comes from the *render member's* convention, not the
+ * constructor's. A component element writes attributes for the thing that reads
+ * them, and it is the render member that declares a parameter for them; the
+ * constructor of a component class takes none.
+ */
+const lowerClassComponent = (ctx, block, operation, facts, tag, keys, children, representation) => {
+    const lineage = requireLineage(operation);
+    if (!facts.renderMember) {
+        throw new IrLoweringBlockedError('this element constructs a class this library does not claim: none of the classes it derives from is the base gea exports, ' +
+            'so nothing states which member constructing it is supposed to render through');
+    }
+    if (!tag)
+        throw new IrLoweringBlockedError('a class component element names no tag to construct');
+    const construct = abiOfCallee(tag.representation);
+    if (!construct) {
+        throw new IrLoweringBlockedError(`a class component element's tag carries "${tag.representation.kind}", which declares no construct convention`);
+    }
+    if (construct.parameters.length > 0) {
+        throw new IrLoweringBlockedError(`the component class this element constructs declares ${construct.parameters.length} constructor parameter(s), ` +
+            'and an element passes none; a component whose construction takes arguments has no place to get them from');
+    }
+    const instance = construct.result;
+    if (instance.kind !== 'class-ref') {
+        throw new IrLoweringBlockedError(`constructing this component yields "${representationKey(instance)}"; only a class instance names the class whose render member ` +
+            'this library points at');
+    }
+    const layout = ctx.program.classes.get(instance.declaration);
+    const member = layout?.methods.find((method) => method.key === facts.renderMember);
+    const callable = member?.callable;
+    if (!callable) {
+        throw new IrLoweringBlockedError(`this component class installs no member "${facts.renderMember}" of its own; a render inherited from a base is entered through ` +
+            'the base that declares it, which this lowering does not yet resolve');
+    }
+    const render = ctx.program.abis.get(callable);
+    if (!render)
+        throw new IrLoweringBlockedError(`the render member of this component class has no projected calling convention`);
+    if (representationKey(render.result) !== representationKey(representation)) {
+        throw new IrLoweringBlockedError(`this element is carried as "${representationKey(representation)}" but its component's render returns ` +
+            `"${representationKey(render.result)}"; an element is exactly what its render produces`);
+    }
+    const built = render.parameters.map((parameter) => buildPropsRecord(ctx, block, operation, keys, children, parameter.value));
+    requireEveryAttributeConsumed(keys, children, built);
+    const created = ctx.builder.construct(block, lineage, tag, tag, { kind: 'open', evidence: ['plugin-lowered-jsx-class-component'] }, [], instance);
+    const receiver = { value: created, representation: instance };
+    // The render member's function object, allocated with no environment: a
+    // method declared on a class captures nothing, and its receiver travels as
+    // the convention's own receiver rather than as a capture. The carrier is
+    // minted here rather than read from the plan because no *program* result has
+    // this value -- it exists only between this construction and the call that
+    // consumes it.
+    const bound = ctx.builder.allocateCallable(block, lineage, callable, [], { kind: 'function-value-dispatch', abi: render });
+    registerResult(ctx, operation, ctx.builder.call(block, lineage, { value: bound, representation: { kind: 'function-value-dispatch', abi: render } }, receiver, built, representation));
+};
+/**
+ * Nothing the author wrote may be dropped on the floor.
+ *
+ * An attribute the receiving layout has no field for, or a child with nowhere
+ * to go, is a disagreement between this lowering and the checker that resolved
+ * the element -- and the failure mode is the worst kind: the program compiles,
+ * renders, and is missing a prop. The checker will normally have rejected it
+ * first, which is exactly why reaching here means something is wrong rather
+ * than merely unsupported.
+ */
+const requireEveryAttributeConsumed = (keys, children, frames) => {
+    const consumed = new Set(frames.flatMap((frame) => [...frame.consumed]));
+    // One exemption, and it is not a relaxation: `key` is gea's own reconciler
+    // hint, declared on every element's props so an author may write it, and
+    // received by no component (`geaReconcilerAttributeName`). v1 drops it at the
+    // same point for the same reason. Everything else still has to land in a
+    // field, which is the whole of this guard.
+    const missed = keys.find((key) => key.source.kind !== 'constant' || (key.source.text !== geaReconcilerAttributeName && !consumed.has(key.source.text)));
+    if (missed) {
+        const named = missed.source.kind === 'constant' ? `"${missed.source.text}"` : 'a computed name';
+        throw new IrLoweringBlockedError(`an element writes the attribute ${named}, which no field of the carrier its tag declares receives; ` +
+            'passing the element without it would render a component the author did not write');
+    }
+    if (children.length > 0 && !frames.some((frame) => frame.tookChildren)) {
+        throw new IrLoweringBlockedError(`an element passes ${children.length} child(ren), which no field of the carrier its tag declares receives`);
+    }
+};
+/**
+ * The props object an element passes, built into the carrier the receiving
+ * convention declares.
+ *
+ * Both element forms build the same object -- a class component's render member
+ * takes props the same way a function component's parameter does -- so they
+ * build it here, once.
+ */
+const buildPropsRecord = (ctx, block, operation, keys, children, props) => {
+    const lineage = requireLineage(operation);
+    const layout = recordLayoutOf(ctx, props);
+    if (!layout) {
+        throw new IrLoweringBlockedError(`a component element builds its props object into the carrier its tag declares, which is "${representationKey(props)}"; ` +
+            'only a record layout states the named fields to fill');
+    }
+    // Keyed by the attribute name the producer published, so a field is filled by
+    // the attribute that names it rather than by position: the record's field
+    // order is the declared type's, and the attribute order is the author's.
+    const written = new Map();
+    for (const key of keys) {
+        if (key.source.kind !== 'constant') {
+            throw new IrLoweringBlockedError('a component element has an attribute whose name is not a constant, which no static record layout can place');
+        }
+        const value = operandOf(operation, 'prop-value', key.ordinal);
+        if (!value)
+            throw new IrLoweringBlockedError(`a component element property at ordinal ${key.ordinal} names a key with no value operand`);
+        written.set(key.source.text, value);
+    }
+    const child = children[0];
+    const consumed = new Set();
+    let tookChildren = false;
+    const fields = [];
+    for (const field of layout) {
+        if (operation.childrenKey !== null && field.key === operation.childrenKey) {
+            // One child is passed as itself, which is what a single-child element
+            // means. Two or more are an array the language builds, and the props
+            // field's own carrier is what would have to state that array -- it does
+            // not, so the gap is named instead of packing them into a carrier the
+            // convention never declared.
+            if (children.length > 1) {
+                throw new IrLoweringBlockedError(`a component element passes ${children.length} children, which the language groups into an array; ` +
+                    `the "${field.key}" field of its props carries ${representationKey(field.value)}, which states no such array`);
+            }
+            if (child)
+                fields.push({ key: field.key, value: child });
+            tookChildren = true;
+            continue;
+        }
+        const supplied = written.get(field.key);
+        if (supplied) {
+            consumed.add(field.key);
+            fields.push({ key: field.key, value: enterRequiredOperand(ctx, block, lineage, operation, supplied) });
+            continue;
+        }
+        // A required field with no attribute is a program the checker would have
+        // rejected, so reaching here means this lowering and the checker disagree
+        // about which fields the props type has.
+        if (field.required) {
+            throw new IrLoweringBlockedError(`a component element supplies no value for the required props field "${field.key}"`);
+        }
+    }
+    return { value: ctx.builder.allocateRecord(block, lineage, fields, props), representation: props, consumed, tookChildren };
+};

package/dist/plugins/gea/members.d.ts

@@ -0,0 +1,22 @@
+import type { HostMemberTable } from '../../targets/cpp/host/host-members.js';
+export declare const geaHostMembers: () => HostMemberTable;
+/**
+ * `<carrier>.<member>` keys whose real C++ return is `void`, read from the
+ * same `nativeMemberMethods` table `geaHostMembers` derives its rows from.
+ *
+ * A second, narrower pass over the same data rather than a field folded into
+ * `HostMember` itself: 19 rows across the package state `returnType: "void"`
+ * (`removeAttribute`, `insertBefore`, the audio node family, ...), and most of
+ * those already agree with the checker's own declared (void) return -- this
+ * set is a superset of the actual mismatches, which costs nothing, because a
+ * member the checker already declares void publishes no `operation.result`
+ * for `emitCall` to discard either way. `OscillatorNode.connect` is the row
+ * that is NOT redundant: the ambient declaration states the Web Audio
+ * chaining convention (`connect(destination): AudioDestinationNode`), the
+ * real `gea::host::OscillatorNode::connect` is `void`, and only this table
+ * knows it. `emitCall` (emit-callable.ts) consults it to
+ * render the call as a bare statement, discarding whatever `operation.result`
+ * the checker's ABI would otherwise have this backend capture -- see
+ * `HostSpellings.voidResults` for the "no viable overloaded '='" this cures.
+ */
+export declare const geaHostMemberVoidResults: () => ReadonlySet<string>;

package/dist/plugins/gea/members.js

@@ -0,0 +1,221 @@
+import { templateArity } from '../../targets/cpp/host/host-members.js';
+import { canvasSlotSpelling, geaCanvasContextCarrier, geaMemberTables } from './host.js';
+/**
+ * gea's host member spellings, from the package that generates them.
+ *
+ * The same transposition `plugins/apple/members.ts` performs, over a different
+ * package: the tables are keyed by member name with each binding listing the
+ * receiver types it accepts, because that is the shape the package's own
+ * emitter looks a member up in, and this backend keys by `<carrier>.<member>`.
+ * Transposing is not restating -- every template stays in the package.
+ *
+ * What this replaces is eleven rows written by hand here, which was a second
+ * authority over a question the package already answers, and which answered it
+ * with this compiler's OWN spellings (`gea::host::document::getElementById`)
+ * rather than the engine's (`gea::embedded::ui::Document::instance()
+ * .getElementById(...)`). Two spellings for one member is how an emitted unit
+ * compiles against this compiler's runtime header and fails to link against the
+ * engine it is actually built into.
+ */
+const addRows = (rows, table, member, defaultEmit) => {
+    for (const [name, bindings] of Object.entries(table ?? {})) {
+        for (const binding of bindings) {
+            const emit = typeof binding.emit === 'string' && binding.emit.length > 0 ? binding.emit : defaultEmit?.(name);
+            if (typeof emit !== 'string' || emit.length === 0)
+                continue;
+            for (const carrier of binding.receiverTypes ?? []) {
+                // `gea_cpp_value` is v1's boxed receiver -- the dynamic fallback that
+                // lets a member resolve off a value whose type was erased. Admitting it
+                // would make every member reachable through the box this compiler
+                // exists not to produce, so it is dropped here as it is for Apple.
+                if (carrier === 'gea_cpp_value')
+                    continue;
+                const key = `${carrier}.${name}`;
+                const row = member(emit, rows.get(key));
+                if (row)
+                    rows.set(key, row);
+            }
+        }
+    }
+};
+/**
+ * The document's own methods, which the package states without a receiver list.
+ *
+ * There is one document, so the table names the member and the spelling and
+ * leaves the receiver implied. The carrier it is implied to be is the one
+ * `nativeTypes` gives the `Document` declaration, read from the same statement
+ * rather than written out here -- a program whose `Document` carries something
+ * else would then file these rows under that, which is the correct answer and
+ * not a coincidence.
+ */
+const addDocumentRows = (rows, carrier) => {
+    if (carrier === undefined)
+        return;
+    for (const [name, method] of Object.entries(geaMemberTables()?.nativeDocumentMethods ?? {})) {
+        const emit = method?.emit;
+        if (typeof emit !== 'string' || emit.length === 0)
+            continue;
+        rows.set(`${carrier}.${name}`, { kind: 'method', emit, arity: templateArity(emit) });
+    }
+};
+/**
+ * The 2D canvas context, through the plugin package's own dispatch.
+ *
+ * These call `gea_ir::canvasFillRect(ctx, ...)` and its siblings -- the
+ * package's shipped wrappers, emitted into the unit by `geaCanvasInterop` --
+ * rather than the engine method each one forwards to. The difference is not
+ * cosmetic. The wrappers carry decisions the engine requires of any caller and
+ * that the member name alone does not state:
+ *
+ *   - a colour argument is authored `0xRRGGBBAA` and the engine takes a native
+ *     pixel, so `fillCircleRgb565`'s fill goes through `canvasRgb565`. A direct
+ *     call converts `double` to `std::uint16_t` instead and draws the WRONG
+ *     COLOUR, silently;
+ *   - `fillStyle` is `string | number` and the engine has two setters
+ *     (`setFillStyle`, `setFillStyleRgb565`);
+ *   - `fillCirclesRgb565` has a pointer+count overload that a per-frame scratch
+ *     view must reach, and a `std::vector` overload for everything else, and
+ *     the choice is made from the argument's element type;
+ *   - `drawImage`'s first argument is an image handle, not an id.
+ *
+ * A second copy of that in this compiler would be a second authority over a
+ * question the package already answers, free to drift from it. So the row is
+ * the package's own template, and what defines it is the package's own
+ * generator.
+ *
+ * `pass-through`, not a fixed arity: several wrappers take a trailing
+ * `count = -1`, `fillCircle`'s fill is optional, and which overload a call
+ * means is what C++ answers from the argument types rather than something to
+ * decide by counting here.
+ *
+ * The properties are stated write-only, which is what the package states: it
+ * ships `canvasContextPropertySetters` and no getter table, and the engine has
+ * `setFillStyle` with no `fillStyle()`. A read is refused by name at the access
+ * rather than rendered through the setter's text.
+ */
+const addCanvasRows = (rows, methods, setters) => {
+    for (const [name, emit] of Object.entries(methods ?? {})) {
+        if (typeof emit !== 'string' || emit.length === 0)
+            continue;
+        rows.set(`${geaCanvasContextCarrier}.${name}`, { kind: 'method', emit: canvasSlotSpelling(emit), arity: 'pass-through' });
+    }
+    for (const [name, emit] of Object.entries(setters ?? {})) {
+        if (typeof emit !== 'string' || emit.length === 0)
+            continue;
+        rows.set(`${geaCanvasContextCarrier}.${name}`, { kind: 'property', emit: null, store: canvasSlotSpelling(emit) });
+    }
+};
+/**
+ * How a program gets a 2D context off an element it holds.
+ *
+ * `domElementMethods` is one row, `getContext`, and its template is another of
+ * the package's wrappers -- `gea_ir::getCanvasContext(node, kind)`, which tests
+ * `kind == "2d"` and hands back `CanvasElement(node.id()).getContext2D()`. It
+ * is carried through for the same reason the context's own members are: the
+ * wrapper is where the acquisition is decided, including the overloads that
+ * unwrap a `Component<T>`'s nullable `el`.
+ *
+ * The receiver carrier comes from the package's `nativeTypes`, which is what
+ * says which declared type this member hangs off.
+ */
+const addElementMethodRows = (rows, methods, elementCarrier) => {
+    if (elementCarrier === undefined || elementCarrier.length === 0)
+        return;
+    for (const [name, emit] of Object.entries(methods ?? {})) {
+        if (typeof emit !== 'string' || emit.length === 0)
+            continue;
+        rows.set(`${elementCarrier}.${name}`, { kind: 'method', emit: canvasSlotSpelling(emit), arity: 'pass-through' });
+    }
+};
+export const geaHostMembers = () => {
+    const shims = geaMemberTables();
+    if (!shims)
+        return new Map();
+    const rows = new Map();
+    // `templateArity` counts `{argN}` occurrences, and a template that instead
+    // names the single `{args}` slot -- `({receiver}).createOscillator({args})`,
+    // `({receiver}).connect({args})`, thirteen of the thirty rows the package
+    // states here -- has none, so it derived a FIXED arity of 0 for every one of
+    // them regardless of how many arguments the C++ overload actually takes.
+    // `hostCallText` (emit-host-invoke.ts) only ever fills `{args}` on a
+    // `variadic` or `pass-through` row; a fixed-arity row never passes a
+    // `variadicArgs` string, so `fillHostTemplate` found `{args}` unfillable and
+    // refused every one of these calls by name ("host template names a slot this
+    // call cannot fill") -- including `createOscillator`, which takes none.
+    // `{args}` is exactly `pass-through`'s own slot -- "each argument in order,
+    // however many there are", host-members.ts's own words -- so a template
+    // naming it gets that arity instead of a count `templateArity` cannot derive
+    // from a slot name it does not recognise.
+    addRows(rows, shims.nativeMemberMethods, (emit, existing) => (existing ? null : { kind: 'method', emit, arity: emit.includes('{args}') ? 'pass-through' : templateArity(emit) }), 
+    // A method row with NO template is not an incomplete row -- it is the
+    // package saying this member is an ordinary native method, called the way
+    // C++ calls one. The package's own comments say so in as many words
+    // ("`play()`/`pause()`/`seek()`/`dispose()` are methods (handled by the
+    // default native method-call path)"), and its `NativeMemberBinding.emit`
+    // is declared optional for exactly this. A template is stated only where
+    // the call is NOT the obvious one -- a differently-spelled engine
+    // function, a wrapper that makes a conversion, a free function taking the
+    // receiver first.
+    //
+    // Dropping these rows -- which is what this table did until now -- turns
+    // "the package states this member" into "no host member table claims it",
+    // and a program calling one is refused for a member the package plainly
+    // ships. `await fetch(url).text()` is the case that found it: `text`,
+    // `bytes`, `arrayBuffer`, `getTracks` and `getAudioTracks` are the five
+    // members stated this way, and `examples/weather` refuses on the first.
+    //
+    // Methods ONLY. A property getter with no template has no such default: a
+    // native data member is read as `({receiver}).name` and a native accessor
+    // as `({receiver}).name()`, the package's own comments show it ships both
+    // kinds, and nothing in the row says which. Guessing there would emit a
+    // call to a field or a read of a function; those rows stay dropped and
+    // refuse by name.
+    (name) => `({receiver}).${name}({args})`);
+    addRows(rows, shims.nativeMemberPropertyGetters, (emit, existing) => existing?.kind === 'property' ? (existing.emit === null ? { ...existing, emit } : null) : { kind: 'property', emit, store: null });
+    addRows(rows, shims.nativeMemberPropertySetters, (emit, existing) => existing?.kind === 'property'
+        ? existing.store === null
+            ? { ...existing, store: emit }
+            : null
+        : existing
+            ? null
+            : { kind: 'property', emit: null, store: emit });
+    addDocumentRows(rows, shims.nativeTypes?.Document);
+    addCanvasRows(rows, shims.canvasContextMethods, shims.canvasContextPropertySetters);
+    addElementMethodRows(rows, shims.domElementMethods, shims.nativeTypes?.GeaCanvasElement);
+    return rows;
+};
+/**
+ * `<carrier>.<member>` keys whose real C++ return is `void`, read from the
+ * same `nativeMemberMethods` table `geaHostMembers` derives its rows from.
+ *
+ * A second, narrower pass over the same data rather than a field folded into
+ * `HostMember` itself: 19 rows across the package state `returnType: "void"`
+ * (`removeAttribute`, `insertBefore`, the audio node family, ...), and most of
+ * those already agree with the checker's own declared (void) return -- this
+ * set is a superset of the actual mismatches, which costs nothing, because a
+ * member the checker already declares void publishes no `operation.result`
+ * for `emitCall` to discard either way. `OscillatorNode.connect` is the row
+ * that is NOT redundant: the ambient declaration states the Web Audio
+ * chaining convention (`connect(destination): AudioDestinationNode`), the
+ * real `gea::host::OscillatorNode::connect` is `void`, and only this table
+ * knows it. `emitCall` (emit-callable.ts) consults it to
+ * render the call as a bare statement, discarding whatever `operation.result`
+ * the checker's ABI would otherwise have this backend capture -- see
+ * `HostSpellings.voidResults` for the "no viable overloaded '='" this cures.
+ */
+export const geaHostMemberVoidResults = () => {
+    const shims = geaMemberTables();
+    const keys = new Set();
+    for (const [name, bindings] of Object.entries(shims?.nativeMemberMethods ?? {})) {
+        for (const binding of bindings) {
+            if (binding.returnType !== 'void')
+                continue;
+            for (const carrier of binding.receiverTypes ?? []) {
+                if (carrier === 'gea_cpp_value')
+                    continue;
+                keys.add(`${carrier}.${name}`);
+            }
+        }
+    }
+    return keys;
+};

package/dist/plugins/gea/plugin.d.ts

@@ -0,0 +1,22 @@
+import type { CompilerPlugin } from '../model.js';
+/**
+ * gea, as a plugin.
+ *
+ * Everything this library adds to TypeScript lives behind this one object: what
+ * an element whose tag names a value means, which member of a constructed
+ * component produces its tree, and the runtime rows that make those claims
+ * checkable. Nothing in `src/` outside this directory knows any of it.
+ *
+ * The facts map is the whole of the state, and it is per-compilation by
+ * construction: `instantiate` creates it, the producer fills it while
+ * normalizing one program, and the lowering reads it while lowering that same
+ * program. A registry of long-lived instances would let a fact derived from one
+ * program be read back while compiling another -- a defect that reproduces only
+ * in whatever order the programs happened to be compiled in.
+ *
+ * `componentClasses` is the same shape of state for a different question:
+ * which class *declarations*, not which JSX elements, are gea's own. Both are
+ * filled while normalizing and read only while lowering, for the identical
+ * reason -- see `component-classes.ts` and `render-bridge.ts`.
+ */
+export declare const geaPlugin: CompilerPlugin;