@geastack/compiler 1.0.15

package/dist/semantics/host-declaration-provenance.d.ts

@@ -0,0 +1,11 @@
+import type ts from 'typescript';
+import type { HostOwnedDeclaration } from '../plugins/model.js';
+/**
+ * Authenticate a host claim against the checker's complete declaration set.
+ *
+ * Compatibility rows may explain declarations merged into the host's symbol,
+ * but they can never create that symbol on their own: at least one declaration
+ * must have the configured primary provenance. Every remaining declaration
+ * must then be an explicitly named compatible partner.
+ */
+export declare const hasExactHostDeclaration: (symbol: ts.Symbol, configured: HostOwnedDeclaration) => boolean;

package/dist/semantics/host-declaration-provenance.js

@@ -0,0 +1,18 @@
+import { resolve } from 'node:path';
+const matchesDeclaration = (symbol, declaration, configured) => configured.declarationName === symbol.name && resolve(declaration.getSourceFile().fileName) === resolve(configured.declarationFileName);
+/**
+ * Authenticate a host claim against the checker's complete declaration set.
+ *
+ * Compatibility rows may explain declarations merged into the host's symbol,
+ * but they can never create that symbol on their own: at least one declaration
+ * must have the configured primary provenance. Every remaining declaration
+ * must then be an explicitly named compatible partner.
+ */
+export const hasExactHostDeclaration = (symbol, configured) => {
+    const declarations = symbol.declarations ?? [];
+    if (!declarations.some((declaration) => matchesDeclaration(symbol, declaration, configured)))
+        return false;
+    const compatible = configured.compatibleDeclarations ?? [];
+    return declarations.every((declaration) => matchesDeclaration(symbol, declaration, configured) ||
+        compatible.some((candidate) => matchesDeclaration(symbol, declaration, candidate)));
+};

package/dist/semantics/host-methods.d.ts

@@ -0,0 +1,24 @@
+import ts from 'typescript';
+/** A host owns the implementation of this checker-resolved method declaration. */
+export interface HostMethodBinding {
+    readonly protocol: string;
+    readonly member: string;
+    /**
+     * This method returns a module selected at runtime from the native
+     * CommonJS-builtin registry.  The compiler retains records only for its
+     * literal, host-admitted calls; the C++ method still receives a dynamic
+     * string and answers `undefined` when no retained capability matches.
+     */
+    readonly builtinModuleLookup?: true;
+    /** Additional inherited declarations this implementation covers, only when
+     * this exact primary host declaration is also present in the member set.
+     * This does not register the inherited member for unrelated receivers. */
+    readonly inheritedDeclarations?: readonly {
+        readonly declarationFileName: string;
+        readonly owner: string;
+        readonly member: string;
+    }[];
+}
+/** Declaration file -> declared owner.member -> host protocol member. */
+export type HostMethodBindingTable = ReadonlyMap<string, ReadonlyMap<string, HostMethodBinding>>;
+export declare const resolveHostMethod: (checker: ts.TypeChecker, bindings: HostMethodBindingTable, node: ts.PropertyAccessExpression | ts.ElementAccessExpression) => HostMethodBinding | null;

package/dist/semantics/host-methods.js

@@ -0,0 +1,74 @@
+import ts from 'typescript';
+import { resolve } from 'node:path';
+/** The named declaration that owns a callable member, including a function-valued property in a type alias. */
+const memberOwnerName = (declaration) => {
+    let owner = declaration.parent;
+    while (owner && (ts.isTypeLiteralNode(owner) || ts.isIntersectionTypeNode(owner) || ts.isParenthesizedTypeNode(owner))) {
+        owner = owner.parent;
+    }
+    return owner && (ts.isInterfaceDeclaration(owner) || ts.isClassDeclaration(owner) || ts.isTypeAliasDeclaration(owner)) && owner.name
+        ? owner.name.text
+        : null;
+};
+/** Whether an ambient declaration denotes a method-shaped value a host may explicitly bind. */
+const isBindableMethodDeclaration = (checker, declaration) => {
+    if (ts.isMethodDeclaration(declaration))
+        return declaration.body === undefined;
+    if (ts.isMethodSignature(declaration))
+        return true;
+    return ts.isPropertySignature(declaration) && checker.getTypeAtLocation(declaration).getCallSignatures().length > 0;
+};
+export const resolveHostMethod = (checker, bindings, node) => {
+    // This binding names a native invocation, not a bound JS function object.
+    // Extracted methods retain JavaScript's unbound-this semantics and must go
+    // through a first-class callable implementation before this host can claim them.
+    let callee = node;
+    while (ts.isParenthesizedExpression(callee.parent))
+        callee = callee.parent;
+    if (!ts.isCallExpression(callee.parent) || callee.parent.expression !== callee)
+        return null;
+    const key = ts.isPropertyAccessExpression(node) ? node.name : node.argumentExpression;
+    const symbol = checker.getSymbolAtLocation(key) ??
+        (ts.isStringLiteralLike(key) ? checker.getPropertyOfType(checker.getTypeAtLocation(node.expression), key.text) : undefined);
+    if (!symbol)
+        return null;
+    const declarations = symbol.getDeclarations() ?? [];
+    if (declarations.length === 0)
+        return null;
+    const claimed = [];
+    const inherited = [];
+    for (const declaration of declarations) {
+        // A concrete implementation always wins over a host claim, even when an
+        // intersection also contributes a declaration the plugin recognizes.
+        if (ts.isMethodDeclaration(declaration) && declaration.body)
+            return null;
+        const owner = memberOwnerName(declaration);
+        if (owner === null)
+            return null;
+        // A plugin states its table against paths it built itself, and the
+        // checker spells a file name its own way -- forward slashes, whatever
+        // the platform's separator is. Resolving on the miss costs one lookup
+        // and is the difference between a host method being claimed and the
+        // whole binding table being invisible on Windows.
+        const declarationFile = declaration.getSourceFile().fileName;
+        const table = bindings.get(declarationFile) ?? bindings.get(resolve(declarationFile));
+        const binding = table?.get(`${owner}.${symbol.getName()}`);
+        if (!isBindableMethodDeclaration(checker, declaration))
+            return null;
+        if (binding)
+            claimed.push(binding);
+        else
+            inherited.push({ declarationFileName: declaration.getSourceFile().fileName, owner, member: symbol.getName() });
+    }
+    const selected = claimed[0];
+    if (!selected || !claimed.every((claim) => claim.protocol === selected.protocol && claim.member === selected.member))
+        return null;
+    // Every declaration is still accounted for. Coverage is an explicit host
+    // fact anchored to a primary declaration, not permission to ignore another
+    // overload. A caller augmentation in any other file remains unclaimed.
+    if (!inherited.every((declaration) => claimed.some((claim) => claim.inheritedDeclarations?.some((coverage) => coverage.declarationFileName === declaration.declarationFileName &&
+        coverage.owner === declaration.owner &&
+        coverage.member === declaration.member))))
+        return null;
+    return selected;
+};

package/dist/semantics/host-protocols.d.ts

@@ -0,0 +1,429 @@
+import ts from 'typescript';
+import type { NamespacePathCensus } from './normalize/namespace-paths.js';
+import type { DeclarationId, StructuralTypeId } from '../identity/ids.js';
+import type { TypedArrayElementDomain } from '../representation/model.js';
+import type { KeyedCollectionFamily, RegExpDeclarationKind, StandardBufferKind } from '../representation/policies.js';
+import type { CensusCandidate } from './normalize/census.js';
+import type { IdentityTable } from './normalize/identities.js';
+import type { StructuralMapper } from './normalize/structural.js';
+import type { StructuralTypeTable } from './model/structural-type-table.js';
+import type { CommonJsWrapperDeclaration, HostNativeTypeDeclaration, HostOwnedDeclaration } from '../plugins/model.js';
+/**
+ * The ambient host-protocol census: what this program's own declarations say
+ * a host owns, split out of `frontend.ts` on its own (the architecture gate's
+ * 800-line ceiling) rather than for any conceptual reason -- `runFrontend`
+ * calls exactly three things here (`hostProtocolBindings`, `ambientHostBindings`,
+ * `promiseDeclarationOf`) and owns the rest of the pipeline itself.
+ */
+/**
+ * A declared type this program's own language surface binds to a host protocol.
+ *
+ * `protocol`/`version` name the runtime contract; nothing here names a
+ * framework, a package, or a file. See `hostProtocolBindings` for what
+ * authenticates one.
+ */
+export interface HostProtocolBinding {
+    readonly protocol: string;
+    readonly version: number;
+    /**
+     * The type the host's own runtime carries values of this protocol in, when
+     * the plugin that installs the protocol stated one; `null` when it did not.
+     *
+     * This is the host's name for its own type, not a C++ spelling this compiler
+     * invented -- which is why it can travel through the target-neutral carrier
+     * and be spelled verbatim by the backend. A protocol with no stated carrier
+     * keeps the opaque tagged handle, which is the honest physical answer for a
+     * boundary nothing has described.
+     *
+     * It is also the join key everything downstream uses: the preflight claim,
+     * and the host member table's lookup. Thirteen declared names carry one
+     * `NodeHandle`, so keying on the carrier states the fact once.
+     */
+    readonly native: string | null;
+    /**
+     * The protocol's own members, as the checker's lib declaration states them --
+     * `null` for a protocol this walk did not classify (every construction site
+     * but `bindAmbientValue`'s own, and that one only for a carrier with no
+     * stated host type: see `hostIntrinsicMembersOf`'s own comment for why).
+     *
+     * This is the one static fact ECMA-262's own reflection questions over an
+     * intrinsic (`Object.getOwnPropertyDescriptor(Math, k)`, `k in Math`,
+     * `Object.getOwnPropertyNames(Math)`, `delete Math.k`) all reduce to: WHICH
+     * names are own properties, and for each, whether reading it calls into a
+     * signature or hands back a value. Nothing downstream may hand-list `Math`'s
+     * members instead of reading them from here -- that would be a second,
+     * syntax-free but still HAND-MAINTAINED table the checker's own lib
+     * declaration could silently drift out from under.
+     */
+    readonly members?: readonly HostIntrinsicMember[] | null;
+    /**
+     * True when the values of this protocol are built by the HOST rather than by
+     * the program, so the declared body is not a layout at any size.
+     *
+     * `derive.ts` otherwise reads a bound declaration with a data-only body as a
+     * struct the host returns by value (`GeolocationPosition`, `TouchSample`):
+     * the program receives one and reads its fields, and spelling the host's own
+     * struct makes clang check every member name. That rule is right for a type
+     * a host *hands out* and wrong for one a host *is asked to construct*: a JSX
+     * element is produced by an element expression, never by the program writing
+     * its members, so its declared body -- `{}` in gea's `JSX.Element`, `{ readonly
+     * nodeKind: number }` in a fixture's -- describes nothing physical at all.
+     * Reading it as a layout turned every element in such a program into a struct
+     * copy and refused emission by name.
+     */
+    readonly opaque: boolean;
+}
+/**
+ * The declared type the language gives a JSX element, bound to the JSX host
+ * protocol.
+ *
+ * A JSX element is the one construction whose result type the *language*
+ * defines by lookup rather than the program defining it by declaration: the
+ * checker resolves `JSX.Element` through the JSX namespace in scope, and every
+ * element expression in the program has that type. So asking the checker for
+ * the type of an element -- which the element producer already does -- is what
+ * identifies the declaration, and no name, path, or package is consulted to do
+ * it.
+ *
+ * Binding it matters because the answer would otherwise be structurally
+ * plausible and physically wrong. `interface Element extends GeaJsxElement {}`
+ * where `GeaJsxElement` is `{}` derives a `native-record-ref` to an empty
+ * struct: C++ that compiles, holds nothing, and renders nothing. An element is
+ * an opaque host handle, and `native-handle` is the carrier that says so.
+ *
+ * The binding is only a *claim* -- `preflight/run.ts` still censuses the
+ * protocol against `manifest.nativeProtocols`, so a target that has not
+ * implemented it refuses the program instead of emitting against glue that
+ * does not exist.
+ *
+ * An element the checker types `any` binds nothing: no JSX namespace was in
+ * scope, and binding a protocol to `any`'s declaration -- if it even had one --
+ * would claim a contract the program never established. The element producer
+ * refuses that program by its own route, and this stays silent rather than
+ * manufacturing a second, weaker answer to the same question.
+ *
+ * The carrier is asked of the host by the protocol's own name, exactly as every
+ * other host protocol's is (`declaredHostShape` below): a host that states what
+ * it holds a JSX element in gets its own type spelled, and one that states
+ * nothing gets the tagged handle. Leaving it unconditionally unstated is what
+ * made every element in a gea program a `gea::NativeHandle<...jsx_element_v1>`
+ * -- a tag type with no tree behind it, so an app compiled, ran, and rendered
+ * nothing, while the engine's real `NodeHandle` sat in the same table one
+ * lookup away.
+ */
+export declare const hostProtocolBindings: (input: HostProtocolInput, census: HostCensus) => void;
+export interface HostProtocolInput {
+    readonly checker: ts.TypeChecker;
+    readonly identities: IdentityTable;
+    readonly files: readonly ts.SourceFile[];
+    readonly census: readonly CensusCandidate[];
+    readonly types: StructuralMapper;
+    readonly table: StructuralTypeTable;
+    /** See `FrontendInput.nativeTypes`. Empty means no host states a carrier for anything. */
+    readonly nativeTypes: ReadonlyMap<string, string>;
+    /** Exact declaration-owned native type rows, which take precedence over name-only rows. */
+    readonly nativeTypesByDeclaration: ReadonlyMap<string, HostNativeTypeDeclaration>;
+    /** Exact declaration-owned singleton rows. */
+    readonly hostSingletonDeclarations: ReadonlyMap<string, HostOwnedDeclaration>;
+    /** See `FrontendInput.hostNamespaceRoots`. A name in here is a path, never a value. */
+    readonly hostNamespaceRoots: ReadonlySet<string>;
+    /** Exact declaration-owned namespace roots; configured names mask the name-only table. */
+    readonly hostNamespaceRootDeclarations: readonly HostOwnedDeclaration[];
+    /** See `FrontendInput.hostNamespacePaths`. A dotted path with one of these as a prefix is a path segment, never a value. */
+    readonly hostNamespacePaths: ReadonlySet<string>;
+    /** See `FrontendInput.hostNamespaceRootTypes`. The type a host carries the one object behind a root in. */
+    readonly hostNamespaceRootTypes: ReadonlyMap<string, string>;
+    readonly commonJsGlobals: ReadonlyMap<string, CommonJsWrapperDeclaration>;
+    /** The exact declaration files named by `commonJsGlobals`, as loaded by this Program. */
+    readonly commonJsDeclarationFiles: readonly ts.SourceFile[];
+    /** The program's own namespace paths (`normalize/namespace-paths.ts`), for the census's `isValueReference` rule. */
+    readonly namespacePaths: NamespacePathCensus;
+    /** TypeScript's declarationless intrinsic global object, distinguished from a caller-owned binding with the same spelling. */
+    readonly isIntrinsicGlobalThis: (node: ts.Node) => boolean;
+}
+/** What one walk of the program's own files learns about the declarations a host owns. */
+export interface HostCensus {
+    readonly protocols: Map<DeclarationId, HostProtocolBinding>;
+    /** The ABI name a host defines a cell under, for every ambient value this program reads. */
+    readonly externals: Map<DeclarationId, string>;
+    readonly externalFiles: Map<DeclarationId, string>;
+    /**
+     * The structural type of every host NAMESPACE ROOT this program names, to
+     * the C++ type the host carries that root's one object in.
+     *
+     * Keyed by structural type rather than by declaration -- the one key in this
+     * census that is not a `DeclarationId`, and the difference is forced, not a
+     * choice. A namespace root is a VALUE, so what needs an answer is the
+     * carrier of the value's own type; and that type routinely has no
+     * declaration to key by. `window`'s is `Window & typeof globalThis`, an
+     * intersection whose `getSymbol()` is `undefined`, and a host is equally
+     * free to declare a root with an anonymous object type
+     * (`declare const __gea_Display: { ... }`). `representation/derive.ts` is
+     * keyed by structural type throughout, so this is also the key it can
+     * actually read; see `HostNamespaceRootPolicy`.
+     *
+     * Interning is free here: `bindAmbientValue` already asks
+     * `types.typeOf(type)` for the shape it looks up, so this records an id that
+     * exists either way rather than interning a type nothing else asked about --
+     * which is what `bindNativeType`'s own comment warns is order-sensitive.
+     */
+    readonly namespaceRoots: Map<StructuralTypeId, string>;
+    /**
+     * Which of those ambient declarations the STANDARD LIBRARY declares, rather
+     * than a host, a framework, or the program's own declaration file.
+     *
+     * `SourceFile.hasNoDefaultLib` is the answer, and it is the checker's own
+     * fact rather than a path guess: every `lib.*.d.ts` TypeScript ships opens
+     * with `/// <reference no-default-lib="true"/>`, which is precisely the
+     * directive that says "this file IS a standard library", and nothing else
+     * sets it.
+     *
+     * Read by `projection/bindings.ts` for exactly one question: whether an
+     * ambient name may resolve to one of the ECMAScript/WHATWG globals this
+     * backend implements itself (`btoa`, `encodeURIComponent`, ...). Those are
+     * language builtins, so the compiler owns their C++ spellings -- but the
+     * table is keyed by NAME, and a name match alone would silently redirect a
+     * program's own `declare function btoa` to this runtime's base64 codec.
+     * Requiring the declaration to be the standard library's is what makes the
+     * name safe to key on.
+     */
+    readonly standardLibrary: Set<DeclarationId>;
+    readonly commonJsBindings: Map<DeclarationId, 'require' | 'exports' | 'module'>;
+    /** Ambient declarations using a reserved wrapper spelling without the host identity. */
+    readonly commonJsProvenanceFailures: Set<DeclarationId>;
+    /** Ambient values whose complete Symbol declaration set is owned by a host singleton row. */
+    readonly hostSingletonBindings: Set<DeclarationId>;
+    /** Ambient namespace roots authenticated by their complete Symbol declaration set. */
+    readonly hostNamespaceBindings: Set<DeclarationId>;
+}
+export declare const ambientHostBindings: (input: HostProtocolInput, census: HostCensus, typedArrayElements: Map<DeclarationId, TypedArrayElementDomain>) => void;
+/**
+ * The same nine names, for a caller that only needs to ask "is this receiver
+ * one of the standard TypedArray instance interfaces" and has no
+ * `IdentityTable`/`DeclarationId` machinery available yet to consume
+ * `typedArrayDeclarationsOf` below -- `flow/value-flow.ts` is built in
+ * `frontend.ts` before `identities` exists (see that file's own doc comment
+ * on `isStandardInterfaceType`). Exported so that caller can resolve each
+ * name through the checker itself rather than re-typing this list as a
+ * second, independently-maintained answer to "which nine names."
+ */
+export declare const typedArrayInstanceInterfaceNames: readonly string[];
+/** The nine instance interfaces' declaration identities, resolved by name exactly as `standardBufferDeclarationsOf` resolves `ArrayBuffer`/`DataView` -- see `typedArrayInstanceDomains`. */
+export declare const typedArrayDeclarationsOf: (checker: ts.TypeChecker, identities: IdentityTable, files: readonly ts.SourceFile[], program: ts.Program, hostDeclarations?: readonly HostOwnedDeclaration[]) => Map<DeclarationId, TypedArrayElementDomain>;
+/**
+ * The declaration identity of the standard library's own `Promise<T>`
+ * interface -- resolved independent of whether the program's own text ever
+ * names `Promise`, because an `async` function's return type mentions it
+ * without a single textual reference the ambient-value seed walk above could
+ * pick up (`typedArrayElementBindings`/`bindHostObjectClosure` both start
+ * from identifiers actually written in value position; `async function f()
+ * {}` has none).
+ *
+ * `checker.resolveName` is the public TypeChecker API for exactly this:
+ * "what does this name mean here", independent of any use site. Any source
+ * file anchors the lookup -- `Promise` is a single ambient global, not
+ * scoped per-file, so which file supplies the location does not change the
+ * answer.
+ *
+ * Routed through `identities.symbolDeclarationId` rather than a bespoke
+ * declaration walk: it already does alias-following and specialization-path
+ * resolution the same way every other declaration identity in this file is
+ * computed, so a program that re-exports or augments `Promise` is not a
+ * second code path to get wrong.
+ */
+export declare const promiseDeclarationOf: (checker: ts.TypeChecker, identities: IdentityTable, files: readonly ts.SourceFile[]) => DeclarationId | null;
+/**
+ * The declaration identity of the standard library's own `Date` INTERFACE --
+ * `lib.es5.d.ts`'s `interface Date`, the type of a Date instance, never the
+ * `DateConstructor` the global `Date` VALUE has.
+ *
+ * Resolved exactly the way `promiseDeclarationOf` above resolves `Promise`,
+ * and for the same reason: a program can receive a Date purely through an
+ * imported signature and never name the type itself, so `checker.resolveName`
+ * -- which answers "what does this name mean here" with no use site at all --
+ * is what makes the policy installable either way.
+ *
+ * Date is core ECMAScript with a compiler-owned native layout, the category
+ * `Promise<T>`, the eight TypedArray views and the four keyed collections are
+ * already in -- NOT a host protocol. Nothing installs it; `lib.es5.d.ts`
+ * declares it, and `gea::runtime::Date` (runtime/gea_runtime.h) implements
+ * it. Its C++ spelling therefore belongs to the backend's own tables
+ * (`targets/cpp/prototype/emit-prototype-date.ts`), never to a plugin package.
+ *
+ * Consulted ahead of `HostBindingPolicy` in `derive.ts` for the reason
+ * `PromiseDeclarationPolicy` states for itself: `Date`'s ambient interface
+ * body, run through `declaredBodyOf`'s data-only member stripping, is an
+ * EMPTY object shape (every member of `interface Date` is a method), so
+ * falling through seals a layout of nothing and the emitter then spells
+ * `d.getFullYear` as a struct field that does not exist.
+ */
+export declare const dateDeclarationOf: (checker: ts.TypeChecker, identities: IdentityTable, files: readonly ts.SourceFile[]) => DeclarationId | null;
+/**
+ * The declaration identity of the standard `String` WRAPPER-OBJECT interface
+ * (`lib.es5.d.ts`'s `interface String`), resolved exactly the way
+ * `dateDeclarationOf` immediately above resolves `Date`, and for the same
+ * reasons: `new String(x)` can reach the type through an imported signature's
+ * return type and never name it directly, so `checker.resolveName` -- which
+ * answers "what does this name mean here" independent of any use site -- is
+ * what makes the policy installable either way.
+ *
+ * `String` (the interface, not the `string` primitive or `StringConstructor`
+ * the value `String` resolves to) is core ECMAScript with a compiler-owned
+ * native layout, the same category `Date` is in -- see
+ * `StringObjectDeclarationPolicy` (representation/policies.ts) for the full
+ * reasoning on why this must be resolved and checked ahead of
+ * `HostBindingPolicy`.
+ */
+export declare const stringObjectDeclarationOf: (checker: ts.TypeChecker, identities: IdentityTable, files: readonly ts.SourceFile[]) => DeclarationId | null;
+/** Resolve intrinsic Error interfaces by declaration identity, never at a property use site. */
+export declare const errorDeclarationsOf: (checker: ts.TypeChecker, identities: IdentityTable, files: readonly ts.SourceFile[]) => ReadonlySet<DeclarationId>;
+/**
+ * The declaration identity of the standard `Generator<T, TReturn, TNext>`
+ * interface, resolved exactly the way `promiseDeclarationOf` above resolves
+ * `Promise` and for the same reasons: independence from whether the program
+ * ever writes the name, and one alias-following implementation shared with
+ * every other declaration identity in this file.
+ *
+ * `ts.SymbolFlags.Interface`, because that is what `lib.es2015.generator.d.ts`
+ * declares it as. A `lib` that does not install it (an `ES5`-only project)
+ * answers `null`, and every `function*` in such a program is then refused
+ * rather than mis-carried -- which is correct, since `function*` is not
+ * expressible under that `lib` either.
+ */
+/**
+ * The declaration identity of the bare `Function` interface (`lib.es5.d.ts`'s
+ * `interface Function`), resolved exactly the way `stringObjectDeclarationOf`
+ * above resolves `String` and for the same reason: a program almost never
+ * writes the name, yet reaches the type constantly --
+ * `typeof x === 'function'` narrows an `unknown` to it, and
+ * `Object.prototype.constructor` is declared as it -- so `checker.resolveName`,
+ * which answers "what does this name mean here" independent of any use site,
+ * is what makes the policy installable at all.
+ *
+ * `ts.SymbolFlags.Interface`, because that is what declares it; the value
+ * `Function` resolves to `FunctionConstructor`, which is a different symbol
+ * and deliberately untouched -- an ambient constructor object really is a host
+ * boundary. See `FunctionDeclarationPolicy` (representation/policies.ts).
+ */
+export declare const functionDeclarationOf: (checker: ts.TypeChecker, identities: IdentityTable, files: readonly ts.SourceFile[]) => DeclarationId | null;
+/** Standard `SymbolConstructor` unique-symbol declarations, keyed by declaration identity. */
+export declare const wellKnownSymbolDeclarationsOf: (checker: ts.TypeChecker, identities: IdentityTable, files: readonly ts.SourceFile[]) => ReadonlyMap<DeclarationId, string>;
+/**
+ * The declaration identity of the standard `AsyncGenerator<T, TReturn, TNext>`
+ * interface -- what an `async function*` returns -- resolved exactly the way
+ * `generatorDeclarationOf` below resolves `Generator`.
+ *
+ * It carries the SAME `iterator(T)` cursor, and that is not an approximation:
+ * `gea::Promise<V>` is a settled-value box with no job queue, so every `await`
+ * this compiler emits is a synchronous read and an async body has run to
+ * completion by the time it returns. Under that model an async generator's
+ * `next()` hands back an already-settled result, which is exactly what the
+ * synchronous cursor already is (see `producers/control.ts`'s yield comment
+ * for the full argument, and for what a port with a real job queue would have
+ * to revisit alongside it).
+ */
+export declare const asyncGeneratorDeclarationOf: (checker: ts.TypeChecker, identities: IdentityTable, files: readonly ts.SourceFile[]) => DeclarationId | null;
+export declare const generatorDeclarationOf: (checker: ts.TypeChecker, identities: IdentityTable, files: readonly ts.SourceFile[]) => DeclarationId | null;
+/** The standard `MapIterator<T>` returned by `Map.prototype.entries()`. */
+export declare const mapIteratorDeclarationOf: (checker: ts.TypeChecker, identities: IdentityTable, files: readonly ts.SourceFile[]) => DeclarationId | null;
+/**
+ * The declaration identity of the standard `ArrayBuffer` and `DataView`
+ * interfaces, resolved exactly the way `keyedCollectionDeclarationsOf` below
+ * resolves `Map`/`Set` and for the same two reasons.
+ *
+ * Independence from the program's own text is the first: `three.js` writes
+ * `function f(b: ArrayBuffer)` in files that never construct one, and a
+ * program that only ever receives a `DataView` from a signature names neither
+ * as a value. `checker.resolveName` answers "what does this name mean here"
+ * with no use site at all.
+ *
+ * The second is the same collision the `Map` comment describes: the
+ * ambient-value census ALREADY reaches `ArrayBuffer` -- through
+ * `Uint8ArrayConstructor`'s own modern return type `Uint8Array<ArrayBuffer>`,
+ * among others -- and binds it as an opaque host protocol, which is what the
+ * corpus's three `native-boundary:ArrayBufferConstructor@1` rows were. Consulted
+ * first in `derive.ts`, this policy gives the concrete byte-block carrier
+ * instead; the CONSTRUCTOR's own handle stays a host boundary, which is
+ * correct, because `ArrayBuffer` the value really is a constructor object.
+ */
+export declare const standardBufferDeclarationsOf: (checker: ts.TypeChecker, identities: IdentityTable, files: readonly ts.SourceFile[]) => Map<DeclarationId, StandardBufferKind>;
+/**
+ * The standard library's own NATIVE-BACKED CLASSES, bound to the carrier the
+ * backend implements them in.
+ *
+ * `TextEncoder` and `TextDecoder` are the pair this exists for. They are not a
+ * host's protocol -- nothing installs them, no plugin declares them -- and they
+ * are not `ArrayBuffer`'s shape either: each is a real object with methods, so
+ * the honest carrier is the backend's own C++ class, spelled verbatim through
+ * `native-handle`, exactly as an installed host's stated `nativeTypes` carrier
+ * is. Which names are in the set, and what each is spelled as, is the
+ * BACKEND's answer (`targets/cpp/host/core-globals.ts`); this function knows
+ * only how to resolve a name to the two declarations that carry it.
+ *
+ * Only the INSTANCE type is bound here, and the reason the CONSTRUCTOR is not
+ * is worth stating, because it is what shapes the rest of the route:
+ *
+ *   interface TextEncoder extends TextEncoderCommon { encode(...): Uint8Array }
+ *   declare var TextEncoder: { prototype: TextEncoder; new(): TextEncoder }
+ *
+ * The instance type is a named interface, so it binds the way every other
+ * declared type does. The constructor's type is an ANONYMOUS type literal --
+ * unlike `Uint8Array`, whose constructor is the named `Uint8ArrayConstructor`
+ * -- and an anonymous type reaches `representation/derive.ts` through its
+ * structural body, never through the declaration-keyed binding this function
+ * writes, so a row for it here would be a claim nothing reads. The class
+ * OBJECT is answered one layer down instead, by name:
+ * `projection/bindings.ts` gives it `host-class` storage (no cell, no extern)
+ * and `targets/cpp/emit-buffers.ts`'s `emitTextCodecConstruct` spells the
+ * construction whole. See `coreGlobalClasses`.
+ *
+ * Run AFTER `ambientHostBindings`, so it overwrites the weaker binding that
+ * census may already have made from the same declaration -- the identical
+ * precedence `standardBufferDeclarationsOf` states for `ArrayBuffer`.
+ */
+export declare const bindStandardClasses: (input: HostProtocolInput, census: HostCensus, names: ReadonlySet<string>) => void;
+export declare const keyedCollectionDeclarationsOf: (checker: ts.TypeChecker, identities: IdentityTable, files: readonly ts.SourceFile[]) => Map<DeclarationId, KeyedCollectionFamily>;
+/**
+ * The declaration identity of each standard regular-expression interface this
+ * compilation's `lib` installs.
+ *
+ * Resolved exactly the way `keyedCollectionDeclarationsOf` above resolves
+ * `Map`, and for both of the same reasons. Independence from the program's own
+ * text first: a regexp LITERAL (`/ab+c/g`) names `RegExp` nowhere, and neither
+ * does `s.match(re)`'s `RegExpMatchArray | null` result -- the ambient-VALUE
+ * seed walk starts from identifiers written in value position, and a literal
+ * writes none. `checker.resolveName` answers "what does this name mean here"
+ * with no use site at all.
+ *
+ * Second, and again the reason this cannot be left to the host census: that
+ * census ALREADY reaches `RegExp` and binds it as a host protocol, through
+ * `RegExpConstructor`'s `new (pattern: string): RegExp` result. That binding
+ * gives every pattern an opaque `native-handle` with no layout -- so
+ * `re.source` has nowhere to go, and `re.lastIndex = 0` has nothing to store
+ * into. `derive.ts` consults this policy first, so the concrete record carrier
+ * wins over the opaque handle; `RegExpConstructor@1` itself is untouched.
+ */
+export declare const regexpDeclarationsOf: (checker: ts.TypeChecker, identities: IdentityTable, files: readonly ts.SourceFile[]) => Map<DeclarationId, RegExpDeclarationKind>;
+/** One own member of a reflectable host intrinsic, as `hostIntrinsicMembersOf` classifies it. */
+export interface HostIntrinsicMember {
+    readonly name: string;
+    /**
+     * `'method'` when reading this member calls a signature (`Math.pow`);
+     * `'value'` when the member itself IS the thing handed back (`Math.SQRT2`).
+     * ECMA-262 gives the two different default attributes (21.3.1's constants
+     * are non-writable/non-configurable data properties; a builtin's own
+     * methods are writable/configurable, 10.2.4) -- this is the one bit that
+     * decides which set of defaults a reflection question answers from, and it
+     * comes from the SAME call-signature test `bindHostObjectClosure` above
+     * already uses to tell a method from a data member.
+     */
+    readonly kind: 'value' | 'method';
+    /**
+     * The signature's own declared arity for a `'method'`, optional and rest
+     * parameters excluded (`requiredArityOf`) -- ECMA-262's `length` for a
+     * builtin function (10.2.4 `SetFunctionLength`) counts only the leading
+     * required parameters. `null` for a `'value'`, which has no signature to
+     * measure.
+     */
+    readonly arity: number | null;
+}