@geastack/compiler 1.0.15

package/dist/targets/cpp/error-types.d.ts

@@ -0,0 +1,4 @@
+import type { Representation } from '../../representation/model.js';
+export declare const cppErrorNativeType = "gea::runtime::Error";
+export declare const errorConstructorNames: ReadonlyMap<string, string>;
+export declare const isNativeError: (carrier: Representation) => boolean;

package/dist/targets/cpp/error-types.js

@@ -0,0 +1,11 @@
+export const cppErrorNativeType = 'gea::runtime::Error';
+export const errorConstructorNames = new Map([
+    ['ErrorConstructor', 'Error'],
+    ['EvalErrorConstructor', 'EvalError'],
+    ['RangeErrorConstructor', 'RangeError'],
+    ['ReferenceErrorConstructor', 'ReferenceError'],
+    ['SyntaxErrorConstructor', 'SyntaxError'],
+    ['TypeErrorConstructor', 'TypeError'],
+    ['URIErrorConstructor', 'URIError']
+]);
+export const isNativeError = (carrier) => carrier.kind === 'native-record-ref' && carrier.native === cppErrorNativeType && carrier.ownership === 'shared-refcount';

package/dist/targets/cpp/function-source-reads.d.ts

@@ -0,0 +1,72 @@
+import type { IrValueId } from '../../identity/ids.js';
+import { type GetOperation, type IrBody } from '../../ir/model.js';
+/**
+ * Which deferred `Function.prototype.toString` shape a GET is.
+ *
+ * `'direct'` is a single callable receiver reading its own source
+ * (`emit-properties.ts`); `'union'` is a tagged union with a
+ * `function-value-dispatch` arm dispatching across itself and the union's
+ * other, string-typed arms (`emit-union-properties.ts`, the `string |
+ * Function` shape `request.ts`'s own `Result<T>` produces). A closed
+ * two-member union rather than a boolean because the two SPELLINGS differ --
+ * one snapshot of the receiver's own callable type versus one of the whole
+ * union's type, feeding a per-arm dispatch -- even though the FACT question,
+ * "does this GET need a snapshot before the call that follows can read a
+ * source string out of it", is one question both renderers ask.
+ */
+export type FunctionSourceReadClaim = 'direct' | 'union';
+/**
+ * The claim: is this GET a deferred function-source read, and of which
+ * shape.
+ *
+ * The ONE function with exactly two callers per
+ * the single-census architecture rule -- `functionSourceReadsOf`'s
+ * prepass walk below, and the two renderers (`emit-properties.ts`,
+ * `emit-union-properties.ts`) that ask it again as the gate for the branch
+ * that used to duplicate this same test inline. Both callers pass
+ * `ctx.staticKeyTexts`, never `ctx.constantTexts`: the latter is empty during
+ * the prepass and, at render time, additionally carries the `typeof`-fold
+ * results the render mints as it goes, which must never be treated as a
+ * property key the program actually wrote (`emit-context.ts`'s own doc on
+ * `staticKeyTexts` explains why every claim of this shape asks it instead).
+ */
+export declare const functionSourceReadClaimOf: (staticKeyTexts: ReadonlyMap<IrValueId, string>, operation: GetOperation) => FunctionSourceReadClaim | null;
+/** The settled answer for one body: every function-source-read GET's snapshot name, and the text its call reads. */
+export interface FunctionSourceReadCensus {
+    readonly names: ReadonlyMap<IrValueId, string>;
+    readonly reads: ReadonlyMap<IrValueId, string>;
+}
+/**
+ * Every deferred function-source read in this body, settled before anything
+ * renders.
+ *
+ * Walk order is `body.blockOrder` then `allOperationsOf(block)` (operations,
+ * then the block's terminator) -- the printer's own block loop
+ * (`emit.ts`: `for (const blockId of body.blockOrder)`), so the ordinal this
+ * mints matches the order the GETs would be reached in if every block in
+ * `blockOrder` rendered unconditionally. That is deliberately NOT the same
+ * as "the order the printer actually visits", because the printer also
+ * drops blocks a reachability pass proves dead before the first one renders
+ * (`emit.ts`'s local BFS inside its label pass) -- exactly like the other
+ * prepass censuses beside this one in this file's neighborhood
+ * (`virtualCalleesOf`, `unionMethodReadsOf`, the direct-callee walk in
+ * `emit.ts`), none of which filter for reachability either. A `toString`
+ * read of a callable inside genuinely dead code is rare enough, and each of
+ * those siblings has carried the same gap since it was settled, that this
+ * walk matches its neighbors rather than inventing a different, one-off
+ * answer to a question none of them ask.
+ *
+ * What this replaces: two writers (`emit-properties.ts`,
+ * `emit-union-properties.ts`) minted a name off ONE shared counter --
+ * `` `gea_function_source_${ctx.functionSourceReads.size}` `` and
+ * `` `gea_union_to_string_source_${ctx.functionSourceReads.size}` `` -- AT
+ * THE RENDER SITE. That counted however many claims had already been
+ * SPELLED by the time a given GET's line was about to print, which is a
+ * property of the render (which branch got there first, whether an
+ * unrelated later change made some path stop reaching a GET this walk still
+ * sees), not of the program. One counter across both claim kinds is kept
+ * here for the same reason it was fine to share before: the two prefixes
+ * never collide, and there is no reason for them to interleave differently
+ * than they used to.
+ */
+export declare const functionSourceReadsOf: (staticKeyTexts: ReadonlyMap<IrValueId, string>, body: IrBody) => FunctionSourceReadCensus;

package/dist/targets/cpp/function-source-reads.js

@@ -0,0 +1,148 @@
+import { allOperationsOf } from '../../ir/model.js';
+import { dispatchedLeafExpression, unionPropertyLeaves } from './emit-union-properties.js';
+const directCallableKinds = new Set([
+    'function',
+    'function-family',
+    'function-value-dispatch',
+    'function-and-constructor'
+]);
+/**
+ * Whether every arm of a tagged union can spell a source string: a `string`
+ * arm returns itself, a `dynamic(untyped-callable)` arm asks the call table
+ * it retained for the source text it captured when the callable was boxed.
+ * Any other arm (a number, a record, ...) has no such spelling, and the
+ * whole union is refused by whichever caller finds no claim here -- exactly
+ * as an arm this file's `taggedUnionGetText` cannot reconcile refuses the
+ * WHOLE union rather than silently dropping one arm's read.
+ *
+ * Pure in the representation alone: `unionPropertyLeaves` is asked with the
+ * placeholder text `''`, because only each leaf's REPRESENTATION KIND
+ * decides viability here. The real, receiver-derived text is a render-time
+ * detail neither caller of `functionSourceReadClaimOf` needs in order to
+ * answer this question, and threading a real name through just to throw it
+ * away would make this predicate depend on something it does not need.
+ */
+const everyArmHasFunctionSourceText = (receiver) => {
+    const leaves = unionPropertyLeaves(receiver, '');
+    return (leaves.length > 0 &&
+        leaves.every((leaf) => leaf.representation.kind === 'string' ||
+            (leaf.representation.kind === 'dynamic' && leaf.representation.reason === 'untyped-callable')));
+};
+/**
+ * The claim: is this GET a deferred function-source read, and of which
+ * shape.
+ *
+ * The ONE function with exactly two callers per
+ * the single-census architecture rule -- `functionSourceReadsOf`'s
+ * prepass walk below, and the two renderers (`emit-properties.ts`,
+ * `emit-union-properties.ts`) that ask it again as the gate for the branch
+ * that used to duplicate this same test inline. Both callers pass
+ * `ctx.staticKeyTexts`, never `ctx.constantTexts`: the latter is empty during
+ * the prepass and, at render time, additionally carries the `typeof`-fold
+ * results the render mints as it goes, which must never be treated as a
+ * property key the program actually wrote (`emit-context.ts`'s own doc on
+ * `staticKeyTexts` explains why every claim of this shape asks it instead).
+ */
+export const functionSourceReadClaimOf = (staticKeyTexts, operation) => {
+    if (staticKeyTexts.get(operation.key.value) !== 'toString')
+        return null;
+    const receiver = operation.receiver.representation;
+    if (directCallableKinds.has(receiver.kind))
+        return 'direct';
+    if (receiver.kind === 'tagged-union' &&
+        operation.result.representation.kind === 'function-value-dispatch' &&
+        everyArmHasFunctionSourceText(receiver)) {
+        return 'union';
+    }
+    return null;
+};
+/**
+ * The exact C++ expression the following call reads a source string from,
+ * for a claim already proved viable by `functionSourceReadClaimOf`.
+ *
+ * Depends only on the claim kind, the receiver's representation and the
+ * snapshot's own name -- never on `operandText` or any other render-time
+ * value name -- which is what makes it safe to settle in the prepass
+ * alongside the name itself, rather than at the GET's render position where
+ * the ordering-sensitive DECLARATION and ASSIGNMENT still have to happen
+ * (see `emit-properties.ts`/`emit-union-properties.ts`: a following call
+ * argument may replace the binding the receiver came from, so the snapshot
+ * must be assigned before that argument runs -- but the STRING this
+ * expression reads out of the snapshot afterwards does not care when it was
+ * decided).
+ */
+const functionSourceReadTextOf = (claim, receiver, name) => {
+    if (claim === 'direct')
+        return `std::string(${name}.sourceText())`;
+    const leaves = unionPropertyLeaves(receiver, name);
+    const texts = leaves.map((leaf) => {
+        if (leaf.representation.kind === 'string')
+            return `std::string(${leaf.text})`;
+        if (leaf.representation.kind === 'dynamic' && leaf.representation.reason === 'untyped-callable')
+            return `std::string(${leaf.text}.functionSourceText())`;
+        return null;
+    });
+    // `functionSourceReadClaimOf` already proved every leaf has one of the two
+    // shapes above (`everyArmHasFunctionSourceText`) before minting this
+    // claim, and a non-empty leaf list, so this cannot actually be `null`. The
+    // check stays as a fail-closed guard rather than a cast: a future leaf
+    // kind added to one side of that proof and not this one must refuse
+    // loudly, not silently print a wrong dispatch.
+    const dispatched = texts.every((text) => text !== null) ? dispatchedLeafExpression(leaves, texts) : null;
+    if (dispatched === null)
+        throw new Error(`function-source-reads: 'union' claim proved viable but its dispatch text did not materialize for ${name}`);
+    return dispatched;
+};
+/**
+ * Every deferred function-source read in this body, settled before anything
+ * renders.
+ *
+ * Walk order is `body.blockOrder` then `allOperationsOf(block)` (operations,
+ * then the block's terminator) -- the printer's own block loop
+ * (`emit.ts`: `for (const blockId of body.blockOrder)`), so the ordinal this
+ * mints matches the order the GETs would be reached in if every block in
+ * `blockOrder` rendered unconditionally. That is deliberately NOT the same
+ * as "the order the printer actually visits", because the printer also
+ * drops blocks a reachability pass proves dead before the first one renders
+ * (`emit.ts`'s local BFS inside its label pass) -- exactly like the other
+ * prepass censuses beside this one in this file's neighborhood
+ * (`virtualCalleesOf`, `unionMethodReadsOf`, the direct-callee walk in
+ * `emit.ts`), none of which filter for reachability either. A `toString`
+ * read of a callable inside genuinely dead code is rare enough, and each of
+ * those siblings has carried the same gap since it was settled, that this
+ * walk matches its neighbors rather than inventing a different, one-off
+ * answer to a question none of them ask.
+ *
+ * What this replaces: two writers (`emit-properties.ts`,
+ * `emit-union-properties.ts`) minted a name off ONE shared counter --
+ * `` `gea_function_source_${ctx.functionSourceReads.size}` `` and
+ * `` `gea_union_to_string_source_${ctx.functionSourceReads.size}` `` -- AT
+ * THE RENDER SITE. That counted however many claims had already been
+ * SPELLED by the time a given GET's line was about to print, which is a
+ * property of the render (which branch got there first, whether an
+ * unrelated later change made some path stop reaching a GET this walk still
+ * sees), not of the program. One counter across both claim kinds is kept
+ * here for the same reason it was fine to share before: the two prefixes
+ * never collide, and there is no reason for them to interleave differently
+ * than they used to.
+ */
+export const functionSourceReadsOf = (staticKeyTexts, body) => {
+    const names = new Map();
+    const reads = new Map();
+    for (const blockId of body.blockOrder) {
+        const block = body.blocks.get(blockId);
+        if (!block)
+            continue;
+        for (const operation of allOperationsOf(block)) {
+            if (operation.kind !== 'get')
+                continue;
+            const claim = functionSourceReadClaimOf(staticKeyTexts, operation);
+            if (claim === null)
+                continue;
+            const name = `${claim === 'direct' ? 'gea_function_source_' : 'gea_union_to_string_source_'}${names.size}`;
+            names.set(operation.result.id, name);
+            reads.set(operation.result.id, functionSourceReadTextOf(claim, operation.receiver.representation, name));
+        }
+    }
+    return { names, reads };
+};

package/dist/targets/cpp/host/atomics.d.ts

@@ -0,0 +1,25 @@
+import type { Representation } from '../../../representation/model.js';
+/**
+ * The complete Atomics surface the C++ backend can render. This is deliberately
+ * representation-aware: the host-member table grants a syntactic member read,
+ * while this authority decides whether that particular call has an emitter.
+ * Preflight and emission consume this same predicate so neither can claim a
+ * dynamic, non-shared, float, or unsupported wait/notify call is available.
+ */
+export type AtomicsCallSupport = {
+    readonly supported: true;
+    readonly kind: 'is-lock-free';
+    readonly runtimeMember: null;
+} | {
+    readonly supported: true;
+    readonly kind: 'fixed';
+    readonly runtimeMember: string;
+} | {
+    readonly supported: true;
+    readonly kind: 'wait' | 'notify';
+    readonly runtimeMember: null;
+} | {
+    readonly supported: false;
+    readonly reason: string;
+};
+export declare const atomicsCallSupport: (member: string, arguments_: readonly Representation[]) => AtomicsCallSupport;

package/dist/targets/cpp/host/atomics.js

@@ -0,0 +1,63 @@
+const integerElements = new Set(['int8', 'uint8', 'int16', 'uint16', 'int32', 'uint32']);
+const fixedMembers = new Map([
+    ['load', [2, 'load']],
+    ['store', [3, 'store']],
+    ['add', [3, 'add']],
+    ['sub', [3, 'sub']],
+    ['and', [3, 'bitAnd']],
+    ['or', [3, 'bitOr']],
+    ['xor', [3, 'bitXor']],
+    ['exchange', [3, 'exchange']],
+    ['compareExchange', [4, 'compareExchange']]
+]);
+const isNumber = (representation) => representation?.kind === 'scalar' && representation.domain === 'number';
+const numberedArguments = (member, arguments_, count) => {
+    for (let position = 1; position < count; position += 1) {
+        if (!isNumber(arguments_[position])) {
+            return { supported: false, reason: `Atomics.${member} argument ${position + 1} must be a statically numeric carrier` };
+        }
+    }
+    return null;
+};
+export const atomicsCallSupport = (member, arguments_) => {
+    if (member === 'isLockFree') {
+        if (arguments_.length !== 1)
+            return { supported: false, reason: 'Atomics.isLockFree takes exactly one size argument' };
+        return isNumber(arguments_[0])
+            ? { supported: true, kind: 'is-lock-free', runtimeMember: null }
+            : { supported: false, reason: 'Atomics.isLockFree argument 1 must be a statically numeric carrier' };
+    }
+    const view = arguments_[0];
+    if (view?.kind !== 'typed-array') {
+        return { supported: false, reason: `Atomics.${member} requires a concrete typed-array carrier, never an any/dynamic value` };
+    }
+    if (!integerElements.has(view.element)) {
+        return {
+            supported: false,
+            reason: `Atomics.${member} requires an integer Number typed array; ${view.element} is refused (BigInt arrays have no native BigInt carrier)`
+        };
+    }
+    if (view.buffer !== 'shared-array-buffer') {
+        return {
+            supported: false,
+            reason: `Atomics.${member} requires a SharedArrayBuffer-backed view; this ${view.element} view is backed by ArrayBuffer`
+        };
+    }
+    const fixed = fixedMembers.get(member);
+    if (fixed) {
+        if (arguments_.length !== fixed[0])
+            return { supported: false, reason: `Atomics.${member} takes exactly ${fixed[0]} arguments` };
+        return numberedArguments(member, arguments_, fixed[0]) ?? { supported: true, kind: 'fixed', runtimeMember: fixed[1] };
+    }
+    if (member !== 'wait' && member !== 'notify')
+        return { supported: false, reason: `Atomics.${member} is not implemented` };
+    if (view.element !== 'int32') {
+        return { supported: false, reason: `Atomics.${member} is available only for Int32Array; BigInt64Array is deliberately unsupported` };
+    }
+    const count = arguments_.length;
+    if (member === 'wait' && (count < 3 || count > 4))
+        return { supported: false, reason: 'Atomics.wait takes three or four arguments' };
+    if (member === 'notify' && (count < 2 || count > 3))
+        return { supported: false, reason: 'Atomics.notify takes two or three arguments' };
+    return numberedArguments(member, arguments_, count) ?? { supported: true, kind: member, runtimeMember: null };
+};

package/dist/targets/cpp/host/core-globals.d.ts

@@ -0,0 +1,108 @@
+/**
+ * The ECMAScript/WHATWG GLOBAL FUNCTIONS this backend implements itself, on
+ * the STANDARD-LIBRARY gate.
+ *
+ * ## Its sibling, and how the two divide
+ *
+ * `host-members.ts` has `coreHostFunctions`/`coreHostConstants`, which answer
+ * the same shape of question for `parseInt`/`parseFloat`/`isNaN`/`isFinite`
+ * and for `NaN`/`Infinity`. They are NOT this table: they are unioned into the
+ * PLUGIN maps (`compiler.ts`'s `hostFunctions`/`hostConstants`) and so are
+ * consulted for any declaration of that name, while every row here is gated on
+ * `standardLibraryExternals` -- the declaration's own file carrying
+ * `/// <reference no-default-lib="true"/>`.
+ *
+ * A NAME BELONGS IN EXACTLY ONE OF THE TWO. Two rows for one name would be two
+ * authorities over one question, and `hostStorageOf` consults the ungated pair
+ * first, so the gated row would silently never be reached. `NaN` and
+ * `Infinity` were briefly stated in both and are stated only in
+ * `coreHostConstants` now.
+ *
+ * `btoa`, `encodeURIComponent` and the rest are not a host's protocol: nothing
+ * installs them, no plugin declares them, and no target may decline them --
+ * they are part of the language surface the standard library declares, in
+ * exactly the same category as `Math`, `JSON` and the eight typed-array
+ * constructors (`native-protocols.ts`'s own comment says so of `JSON@1`). So
+ * their C++ spellings belong here, in the compiler's own table, and never in
+ * the gea plugin package: a plugin row would make an ECMAScript builtin
+ * conditional on which host happens to be installed.
+ *
+ * The table is the same shape a plugin's `hostFunctions` is -- an ambient NAME
+ * to the C++ path a call renders -- and `compiler.ts` unions it into the same
+ * `hostFunctions` map, so a name here reaches `projection/bindings.ts`'s
+ * `host-function` storage and `emit-callable.ts`'s host-call path with no
+ * second mechanism.
+ *
+ * ## Why a name is safe to key on here
+ *
+ * It is not, on its own. `projection/bindings.ts` consults this table ONLY for
+ * a declaration the frontend recorded in `standardLibraryBindings` -- an
+ * ambient declaration whose source file carries
+ * `/// <reference no-default-lib="true"/>`, which is the checker's own
+ * "this file IS a standard library" flag. A program that declares its own
+ * `btoa` keeps its own cell, both because it introduces one (the first
+ * placement loop wins) and because, if it merely *declares* one ambiently in
+ * its own `.d.ts`, that file is not a default library and this table is never
+ * reached.
+ *
+ * ## What is NOT here, and why
+ *
+ * `parseInt`, `parseFloat`, `isNaN` and `isFinite` are the other four
+ * ECMAScript global functions. Each has a real implementation available --
+ * `gea::host::detail::toNumber` is ECMAScript's own `ToNumber` -- but
+ * `parseInt`'s two-argument radix form and `parseFloat`'s prefix-parse rule
+ * (ECMA-262 19.2.5/19.2.4) are NOT `ToNumber`, and rendering them as it would
+ * be a silently different answer for `parseInt('08')`, `parseInt('0x10')` and
+ * `parseFloat('3px')`. They stay absent, which leaves them exactly where they
+ * were: an unresolved external cell whose link fails by name.
+ *
+ * `escape`/`unescape` (ECMA-262 B.2.1) ARE implemented in the runtime
+ * (`gea::runtime::uri::escapeImpl`/`unescapeImpl`, ported with the rest of
+ * v1's `uri.cpp`) but are deliberately not claimed here: `lib.es5.d.ts` does
+ * not declare them at all, so no program this compiler sees can name one, and
+ * a row for a name that cannot be reached would claim a surface nothing tests.
+ */
+export declare const coreGlobalFunctions: ReadonlyMap<string, string>;
+/**
+ * The standard library CLASSES this backend implements itself, and the C++
+ * type each one's values are carried in.
+ *
+ * The same category as the table above and the same reason for living here:
+ * `TextEncoder`/`TextDecoder` are the Encoding Standard's, not a host's, so a
+ * plugin row would make them conditional on which host is installed. What is
+ * different is only the shape of the answer -- a class has values, so what the
+ * compiler needs from this table is a CARRIER, not a call spelling.
+ *
+ * `compiler.ts` unions this into the same `nativeTypes` map a plugin's stated
+ * carriers arrive in, which is what gets each spelling to two places at once:
+ * `semantics/host-protocols.ts`'s `bindStandardClasses` (so the declared type
+ * derives `native-handle` with the spelling on it) and the manifest's
+ * `nativeProtocols` claim set, which is keyed by carrier -- so the protocol is
+ * claimed exactly where its implementation is, with no second list to drift.
+ *
+ * Members are stated in `host-members.ts`'s `coreHostMembers`, keyed by these
+ * same carrier strings; a member with no row there refuses by name at its own
+ * access (`TextEncoder.encodeInto` is the one this applies to today).
+ */
+export declare const coreNativeTypes: ReadonlyMap<string, string>;
+/**
+ * The same names again, as the CLASS OBJECTS a program reaches by name.
+ *
+ * `new TextEncoder()` names two different things: the instance type, bound
+ * above, and the constructor VALUE. The constructor's type is an anonymous
+ * type literal in `lib.dom.d.ts` (`{ prototype: TextEncoder; new(): TextEncoder }`),
+ * unlike `Uint8Array`'s named `Uint8ArrayConstructor` -- and an anonymous type
+ * has no declaration the representation layer's declaration-keyed binding can
+ * reach, so the class object derived a `constructor-family` carrier over the
+ * structural body and linked as `extern gea::ConstructorObject<...>` that
+ * nothing defines.
+ *
+ * `projection/bindings.ts` consults this set, on the same
+ * `standardLibraryExternals` gate as the two tables above, and gives those
+ * names `host-class` storage: no cell, no extern, the read renders nothing,
+ * and the construction is spelled whole at the site that performs it
+ * (`targets/cpp/emit-buffers.ts`'s `emitTextCodecConstruct`). The other names
+ * below have the same physical answer but need it for a different reason:
+ * their overloads deliberately have no single construct ABI.
+ */
+export declare const coreGlobalClasses: ReadonlySet<string>;

package/dist/targets/cpp/host/core-globals.js

@@ -0,0 +1,158 @@
+/**
+ * The ECMAScript/WHATWG GLOBAL FUNCTIONS this backend implements itself, on
+ * the STANDARD-LIBRARY gate.
+ *
+ * ## Its sibling, and how the two divide
+ *
+ * `host-members.ts` has `coreHostFunctions`/`coreHostConstants`, which answer
+ * the same shape of question for `parseInt`/`parseFloat`/`isNaN`/`isFinite`
+ * and for `NaN`/`Infinity`. They are NOT this table: they are unioned into the
+ * PLUGIN maps (`compiler.ts`'s `hostFunctions`/`hostConstants`) and so are
+ * consulted for any declaration of that name, while every row here is gated on
+ * `standardLibraryExternals` -- the declaration's own file carrying
+ * `/// <reference no-default-lib="true"/>`.
+ *
+ * A NAME BELONGS IN EXACTLY ONE OF THE TWO. Two rows for one name would be two
+ * authorities over one question, and `hostStorageOf` consults the ungated pair
+ * first, so the gated row would silently never be reached. `NaN` and
+ * `Infinity` were briefly stated in both and are stated only in
+ * `coreHostConstants` now.
+ *
+ * `btoa`, `encodeURIComponent` and the rest are not a host's protocol: nothing
+ * installs them, no plugin declares them, and no target may decline them --
+ * they are part of the language surface the standard library declares, in
+ * exactly the same category as `Math`, `JSON` and the eight typed-array
+ * constructors (`native-protocols.ts`'s own comment says so of `JSON@1`). So
+ * their C++ spellings belong here, in the compiler's own table, and never in
+ * the gea plugin package: a plugin row would make an ECMAScript builtin
+ * conditional on which host happens to be installed.
+ *
+ * The table is the same shape a plugin's `hostFunctions` is -- an ambient NAME
+ * to the C++ path a call renders -- and `compiler.ts` unions it into the same
+ * `hostFunctions` map, so a name here reaches `projection/bindings.ts`'s
+ * `host-function` storage and `emit-callable.ts`'s host-call path with no
+ * second mechanism.
+ *
+ * ## Why a name is safe to key on here
+ *
+ * It is not, on its own. `projection/bindings.ts` consults this table ONLY for
+ * a declaration the frontend recorded in `standardLibraryBindings` -- an
+ * ambient declaration whose source file carries
+ * `/// <reference no-default-lib="true"/>`, which is the checker's own
+ * "this file IS a standard library" flag. A program that declares its own
+ * `btoa` keeps its own cell, both because it introduces one (the first
+ * placement loop wins) and because, if it merely *declares* one ambiently in
+ * its own `.d.ts`, that file is not a default library and this table is never
+ * reached.
+ *
+ * ## What is NOT here, and why
+ *
+ * `parseInt`, `parseFloat`, `isNaN` and `isFinite` are the other four
+ * ECMAScript global functions. Each has a real implementation available --
+ * `gea::host::detail::toNumber` is ECMAScript's own `ToNumber` -- but
+ * `parseInt`'s two-argument radix form and `parseFloat`'s prefix-parse rule
+ * (ECMA-262 19.2.5/19.2.4) are NOT `ToNumber`, and rendering them as it would
+ * be a silently different answer for `parseInt('08')`, `parseInt('0x10')` and
+ * `parseFloat('3px')`. They stay absent, which leaves them exactly where they
+ * were: an unresolved external cell whose link fails by name.
+ *
+ * `escape`/`unescape` (ECMA-262 B.2.1) ARE implemented in the runtime
+ * (`gea::runtime::uri::escapeImpl`/`unescapeImpl`, ported with the rest of
+ * v1's `uri.cpp`) but are deliberately not claimed here: `lib.es5.d.ts` does
+ * not declare them at all, so no program this compiler sees can name one, and
+ * a row for a name that cannot be reached would claim a surface nothing tests.
+ */
+export const coreGlobalFunctions = new Map([
+    // HTML Standard 8.3. `btoa` is defined over Latin-1 code points and `atob`
+    // over the forgiving-base64 grammar; see `gea::runtime::base64` in
+    // `runtime/gea_runtime.h` for both, ported from v1's `base64.cpp`.
+    ['btoa', 'gea::runtime::base64::encode'],
+    ['atob', 'gea::runtime::base64::decode'],
+    // ECMA-262 19.2.6.2 / 19.2.6.3 / 19.2.6.1 / 19.2.6.5 -- four spellings of
+    // two algorithms (`Encode`/`Decode`) differing only in whether
+    // `uriReserved` is preserved. `encodeURIComponent`/`decodeURIComponent`
+    // declare `string | number | boolean`, which the program carries as a
+    // tagged union; `host/emit-host-arity.ts` picks the live arm at the call
+    // and each arm lands on one of the three overloads the runtime states.
+    ['encodeURI', 'gea::runtime::uri::encodeUri'],
+    ['encodeURIComponent', 'gea::runtime::uri::encodeUriComponent'],
+    ['decodeURI', 'gea::runtime::uri::decodeUri'],
+    ['decodeURIComponent', 'gea::runtime::uri::decodeUriComponent']
+]);
+/**
+ * The standard library CLASSES this backend implements itself, and the C++
+ * type each one's values are carried in.
+ *
+ * The same category as the table above and the same reason for living here:
+ * `TextEncoder`/`TextDecoder` are the Encoding Standard's, not a host's, so a
+ * plugin row would make them conditional on which host is installed. What is
+ * different is only the shape of the answer -- a class has values, so what the
+ * compiler needs from this table is a CARRIER, not a call spelling.
+ *
+ * `compiler.ts` unions this into the same `nativeTypes` map a plugin's stated
+ * carriers arrive in, which is what gets each spelling to two places at once:
+ * `semantics/host-protocols.ts`'s `bindStandardClasses` (so the declared type
+ * derives `native-handle` with the spelling on it) and the manifest's
+ * `nativeProtocols` claim set, which is keyed by carrier -- so the protocol is
+ * claimed exactly where its implementation is, with no second list to drift.
+ *
+ * Members are stated in `host-members.ts`'s `coreHostMembers`, keyed by these
+ * same carrier strings; a member with no row there refuses by name at its own
+ * access (`TextEncoder.encodeInto` is the one this applies to today).
+ */
+export const coreNativeTypes = new Map([
+    ['TextEncoder', 'gea::runtime::textcodec::TextEncoder'],
+    ['TextDecoder', 'gea::runtime::textcodec::TextDecoder']
+]);
+/**
+ * The same names again, as the CLASS OBJECTS a program reaches by name.
+ *
+ * `new TextEncoder()` names two different things: the instance type, bound
+ * above, and the constructor VALUE. The constructor's type is an anonymous
+ * type literal in `lib.dom.d.ts` (`{ prototype: TextEncoder; new(): TextEncoder }`),
+ * unlike `Uint8Array`'s named `Uint8ArrayConstructor` -- and an anonymous type
+ * has no declaration the representation layer's declaration-keyed binding can
+ * reach, so the class object derived a `constructor-family` carrier over the
+ * structural body and linked as `extern gea::ConstructorObject<...>` that
+ * nothing defines.
+ *
+ * `projection/bindings.ts` consults this set, on the same
+ * `standardLibraryExternals` gate as the two tables above, and gives those
+ * names `host-class` storage: no cell, no extern, the read renders nothing,
+ * and the construction is spelled whole at the site that performs it
+ * (`targets/cpp/emit-buffers.ts`'s `emitTextCodecConstruct`). The other names
+ * below have the same physical answer but need it for a different reason:
+ * their overloads deliberately have no single construct ABI.
+ */
+export const coreGlobalClasses = new Set([
+    ...coreNativeTypes.keys(),
+    // These constructor protocols deliberately have no joined [[Construct]]
+    // ABI: their overloads take physically different first arguments, and the
+    // construct emitter dispatches from the already-selected result and
+    // argument carriers instead. That means the native-handle representation
+    // cannot be used as the test for whether the global is a class object. A
+    // constructor read that flows through an intersection or generic can lose
+    // even the partial construct convention and would otherwise become an
+    // `extern Uint8Array`-style cell that no runtime defines. The standard-lib
+    // identity gate in `projection/bindings.ts` keeps program declarations with
+    // the same names ordinary cells.
+    'Int8Array',
+    'Uint8Array',
+    'Uint8ClampedArray',
+    'Int16Array',
+    'Uint16Array',
+    'Int32Array',
+    'Uint32Array',
+    'Float32Array',
+    'Float64Array',
+    'ArrayBuffer',
+    'SharedArrayBuffer',
+    'DataView',
+    'Array',
+    'Map',
+    'Set',
+    'WeakMap',
+    'WeakSet',
+    'RegExp',
+    'Date'
+]);

package/dist/targets/cpp/host/dynamic-argument-members.d.ts

@@ -0,0 +1,42 @@
+/**
+ * The host members whose call-site renderer takes a `dynamic` argument through
+ * unconditionally -- the C++ backend's half of
+ * `TargetRuntimeManifest.dynamicArgumentHostParameters`
+ * (preflight/obligations.ts), which states what listing one WAIVES and why
+ * the key includes member, argument role and ordinal.
+ *
+ * Here rather than in `manifest.ts` because the fact is a property of the
+ * renderers, not of the manifest: every entry below is an `objectMemberText`
+ * arm (`emit-host-object.ts`), and a member added there without a row here --
+ * or a row here whose arm was deleted -- is a drift best noticed by the two
+ * living side by side. `manifest.ts` cites this set; it does not own it.
+ *
+ * ## Why each of these needs the waiver and the others do not
+ *
+ * Each row passes that one argument's box straight into a host call-site
+ * renderer. So there is no conversion for the emitted line to perform and
+ * none for preflight to demand at that position. No row grants anything to a
+ * sibling parameter of the same member.
+ *
+ * `Object.keys`, `getOwnPropertyNames`, `freeze` and `isFrozen` are
+ * deliberately ABSENT even though they take the same dynamic receiver. Their
+ * declared parameter is `object` / `T`, which already derives a carrier a
+ * `dynamic` converts into, so the ordinary obligation is satisfied on its own
+ * -- and waiving a check that passes hides a real one for no gain.
+ *
+ * What these positions have in common is a declared parameter nothing
+ * converts into:
+ * `{ [s: string]: T } | ArrayLike<T>` for `values`/`entries`, which derives a
+ * `tagged-union(dictionary | native-record-ref)`; and `PropertyKey` -- a
+ * `string | number | symbol` union -- for the key parameter of `hasOwn`,
+ * `defineProperty` and `getOwnPropertyDescriptor`. `assign`'s variadic source
+ * parameter is the same shape as `values`'.
+ *
+ * `Object.defineProperty:argument:2` is deliberately absent. The emitter
+ * materializes descriptors only from an exact descriptor carrier; a dynamic
+ * box does not state which descriptor fields and attributes are present.
+ * `Object.defineProperties` is absent wholesale: its source transform accepts
+ * only a closed descriptor-map literal and lowers it to singular operations,
+ * while an open/dynamic map must remain fail-closed.
+ */
+export declare const cppDynamicArgumentHostParameters: ReadonlySet<string>;