@geastack/compiler 1.0.15

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

@@ -0,0 +1,505 @@
+import type { DeclarationId, FunctionId, RegionId } from '../../../identity/ids.js';
+import type { ReactiveDependency } from '../reactive-dependencies.js';
+import type { HostIntrinsicMember } from '../../../semantics/host-protocols.js';
+import type { Representation } from '../../../representation/model.js';
+/**
+ * What a host protocol's members lower to.
+ *
+ * A host object is not a struct this compiler lays out: its members are the
+ * host's own implementation, reached by a spelling the host defines. So a
+ * member is rendered from a template naming that spelling, exactly as the v1
+ * plugin's host shims do (`geatsc-plugin-gea/src/host-shims.ts`), rather than
+ * by inventing a field offset or a calling convention.
+ *
+ * Two kinds, because a host member is one of two things and the difference is
+ * observable. A `property` is read at the access itself -- `el.scrollTop` is a
+ * value. A `method` is NOT: `el.setAttribute` on its own is a function, and
+ * what the program does is *call* it, so the template renders at the call and
+ * the access alone renders nothing. Treating a method as a property would
+ * materialise a callable no host symbol corresponds to.
+ *
+ * `{receiver}` is the object the member was reached through, `{arg0}`,
+ * `{arg1}`, ... are the call's own arguments, and `{value}` -- in a `store`
+ * template only -- is what is being written. A template naming a slot the site
+ * does not supply is refused rather than rendered with a hole, so an arity the
+ * host does not implement cannot reach C++.
+ */
+export type HostMember = 
+/**
+ * A data property, with one template per direction.
+ *
+ * Read and write are separate host spellings, not one spelling used twice:
+ * `view.frame` reads as `(...).frame` and writes as `(...).frame = {value}`,
+ * and a numeric setter may need a cast the getter does not. Either may be
+ * `null` -- a read-only member states no `store`, and an access in the
+ * direction a member does not state is refused by name at the site rather
+ * than rendered from the other direction's text. A row states at least one;
+ * a row stating neither would claim a member it cannot render at all.
+ */
+{
+    readonly kind: 'property';
+    readonly emit: string | null;
+    readonly store: string | null;
+    /** Fixed carrier returned by the host template, when it differs from a site's checker result. */
+    readonly resultRepresentation?: Representation;
+    /** Direct numeric operands can use this borrowed sequence spelling; reads and spreads retain the callable ABI. */
+    readonly numericRestCall?: string;
+} | {
+    readonly kind: 'method';
+    readonly emit: string;
+    readonly arity: number;
+    readonly receiver?: 'host' | 'raw';
+    /** The host returns a dynamic Value that must be checked at the result boundary. */
+    readonly result?: 'dynamic';
+} | {
+    readonly kind: 'method';
+    readonly emit: string;
+    readonly arity: 'variadic';
+    readonly receiver?: 'host' | 'raw';
+    readonly result?: 'dynamic';
+} | {
+    readonly kind: 'method';
+    readonly emit: string;
+    readonly arity: 'call-site';
+    readonly receiver?: 'host' | 'raw';
+    readonly result?: 'dynamic';
+} | {
+    readonly kind: 'method';
+    readonly emit: string;
+    readonly arity: 'pass-through';
+    readonly receiver?: 'host' | 'raw';
+    readonly result?: 'dynamic';
+};
+/** Key: `<protocol>.<member>`, the same protocol string the checker bound. */
+export type HostMemberTable = ReadonlyMap<string, HostMember>;
+/**
+ * What constructing one of a host's own types costs, as the host spells it.
+ *
+ * A separate table from `HostMemberTable` for the same reason `hostInvocations`
+ * and `hostMemberRenderers` are two maps in `emit-host-invoke.ts`: they answer
+ * about two different things. A protocol may have constructible values, callable
+ * members, or both, and one map keyed by protocol could not say which.
+ *
+ * The template carries `{argN}` slots and NO `{receiver}`: a construction has no
+ * receiver, and `fillHostTemplate` refuses a template that names one -- which is
+ * the fail-closed answer for a host row that was written for the wrong position.
+ *
+ * `arity` is a fixed count for a template naming `{argN}` slots, and the string
+ * `'pass-through'` for one naming the single `{args}` slot instead -- the same
+ * distinction `HostMember`'s own `'pass-through'` arm makes, for the same
+ * reason: `new MediaStream({args})`, `new AudioContext({args})` and the like
+ * take however many constructor arguments the program wrote, and which of the
+ * host's overloads that means is for C++'s own overload resolution to decide
+ * from the argument types, not something to count here. A fixed number would
+ * refuse every call whose argument count did not match the one call site the
+ * number happened to be read from.
+ */
+export interface HostConstructor {
+    readonly emit: string;
+    readonly arity: number | 'pass-through';
+}
+/**
+ * Key: the carrier the host stated for the protocol, falling back to the
+ * declared protocol name for a host that stated none -- the same key
+ * `HostMemberTable` uses, so one host's rows are all filed under one name.
+ */
+export type HostConstructorTable = ReadonlyMap<string, HostConstructor>;
+/**
+ * One host handle's `[[Call]]` spelling, keyed `${carrier}.call`.
+ *
+ * Hosts can expose a callable value which itself has typed members. Keeping
+ * that callable as a host handle lets both halves remain authenticated by the
+ * checker instead of inventing a language-level function object.
+ */
+export type HostInvocationTable = ReadonlyMap<string, HostConstructor>;
+/**
+ * Which host type each host type derives from: carrier to immediate base
+ * carrier.
+ *
+ * A host's own inheritance, stated by the host. AppKit's `NSStackView` IS an
+ * `NSView` -- passing one where the other is declared is not a conversion at
+ * all, and the generated bridge makes it free in C++ by giving the wrapper
+ * structs the same inheritance (`struct NSStackView : gea::apple::AppKit::NSView`).
+ * But nothing in TypeScript's structural view says two opaque handles are
+ * related, so without this the backend refuses an upcast the target performs
+ * implicitly.
+ *
+ * The chain is walked exactly once, by `compiler.ts`, into the transitive
+ * answer each `native-handle` carrier then STATES (`Representation`'s
+ * `native-handle` arm). Nothing reads this table at emission: the two
+ * questions that need the fact -- the conversion census admitting the pair and
+ * the printer rendering it -- are both pure carrier-to-carrier, and a table
+ * only one of them could reach is what let a certificate refuse an upcast the
+ * printer knew how to write.
+ *
+ * A host that states no inheritance gets an empty table and every handle stays
+ * unrelated to every other, which is the correct answer for a host whose types
+ * really are unrelated.
+ */
+export type HostBaseTable = ReadonlyMap<string, string>;
+/**
+ * Everything the hosts installed in one compilation say about their own types.
+ *
+ * Bundled rather than threaded one map per question: they are all the same
+ * plugin's answer about the same protocols, they are all unioned once by
+ * `compiler.ts`, and they all reach emission by the same route. A signature
+ * that grew a parameter per table would say they were independent, and the
+ * next host fact would be a fourth.
+ */
+/**
+ * The header that declares each host carrier.
+ *
+ * Keyed by carrier rather than by plugin so a unit includes exactly the hosts
+ * it used: a program that never touches AppKit must not carry an AppKit header,
+ * and "which plugin was installed" is the wrong question -- installing a plugin
+ * is what makes a host available, not what makes a program use it.
+ */
+export type HostIncludeTable = ReadonlyMap<string, string>;
+/**
+ * The free functions a host defines, keyed by the name a program writes.
+ *
+ * A host function is not a member of anything and not a constructor of
+ * anything: `installRootViewController(vc)` and `requestAnimationFrame(f)` are
+ * ambient names that resolve to a C++ free function the host's own runtime
+ * defines. Nothing declares a C++ *variable* of that name, so a compiler with
+ * no table for it emits `extern gea::CallableObject<...> installRootViewController;`
+ * and calls through it -- text that compiles and never links, because the
+ * symbol the host exports is a function and this named a global.
+ *
+ * The host states the qualified spelling itself (`embeddedHostFunctions` in
+ * v1's plugin packages, verbatim), so the call renders as the call it always
+ * was.
+ */
+export type HostFunctionTable = ReadonlyMap<string, string>;
+/**
+ * The same, for the names one host declares more than once.
+ *
+ * Keyed by the *declaration file* the program's binding resolved to, because
+ * that is what tells two same-named functions apart: Apple's UIKit and AppKit
+ * each declare an `installRootView`, taking different views and calling
+ * different thunks, and a table keyed by name can only hold one of them. This
+ * one is consulted first and the flat table answers everything it does not
+ * cover, so a host with no such collisions states nothing and nothing changes.
+ */
+export type HostFunctionFileTable = ReadonlyMap<string, ReadonlyMap<string, string>>;
+/**
+ * The declaration-file-keyed sibling of `HostFunctionFileTable` for a table
+ * whose flat form is a set of claimed names rather than a name-to-spelling
+ * map -- `PluginCapabilities.nativeConstants`'s keys, `hostNamespaces.roots`,
+ * `hostSingletons`. A name claimed twice by one host, under two of its own
+ * files, means two different things by it exactly as a doubly-declared
+ * function does; this states which declaration this program actually
+ * resolved to answers, the same way the file-keyed function table does,
+ * consulted first and answered by the flat set for every host with no such
+ * collision.
+ */
+export type HostNameFileTable = ReadonlyMap<string, ReadonlySet<string>>;
+/**
+ * How a host names something the program CALLS.
+ *
+ * Two forms, because hosts state two genuinely different things and the
+ * difference is not recoverable from the text:
+ *
+ * - a PATH is the function's own name, and the call is that name with the
+ *   arguments appended -- `gea::host::device_info::deviceId(a, b)`;
+ * - a TEMPLATE places the arguments itself, and can therefore do something to
+ *   the call that the name alone cannot -- wrap the result
+ *   (`gea::host::MediaStream(gea::host::media::get_user_media_audio({args}))`,
+ *   which turns a raw handle into the typed value the program's carrier
+ *   actually holds), reorder, or take the receiver first.
+ *
+ * This used to be one `string`, always a path, and a package row that stated a
+ * template was reduced to the bare symbol inside it or dropped -- so a member a
+ * host described twice, once bare and once typed, silently rendered as the bare
+ * one and the wrapper went missing. That is a *carrier* difference, not a
+ * cosmetic one: `get_user_media_audio` returns a `NativeMediaStreamHandle`
+ * (`unsigned int`) where the program holds `gea::Promise<gea::host::MediaStream>`.
+ * Naming the two forms apart is what lets the typed row win without the
+ * renderer having to guess which kind of string it was handed.
+ */
+export type HostCallSpelling = ({
+    readonly kind: 'path';
+    readonly text: string;
+} | {
+    readonly kind: 'template';
+    readonly emit: string;
+}) & {
+    readonly arrayArguments?: 'snapshot' | 'native';
+    readonly arguments?: 'dynamic';
+    /**
+     * The host hands back a `gea::Value`, whatever carrier the PROGRAM holds the
+     * result in. `Reflect.get` is the case: its target is boxed, so the runtime
+     * can only answer with a boxed value -- while the compiler may well know the
+     * result is a `number`, because the target it reflects over is a
+     * `Record<string, number>` whose values are numbers no matter how the key is
+     * spelled. Without this the call assigned a `Value` straight into a `double`
+     * and clang refused the unit; the crossing back is an unbox, and it is stated
+     * by the host rather than guessed from the spelling's name.
+     */
+    readonly result?: 'dynamic';
+};
+/** The one string that identifies a call spelling -- for a diagnostic, and as the key its preamble is stated under. */
+export declare const hostCallName: (spelling: HostCallSpelling) => string;
+/**
+ * A host's NAMESPACE surface: global names that are paths, not values.
+ *
+ * `deviceInfo`, `Display`, `navigator` are not objects a program can hold.
+ * Every use is a path to a C++ spelling -- `deviceInfo.deviceId(...)` is
+ * `gea::host::device_info::deviceId(...)`, `Display.width` is `gea::host::Display.width`
+ * -- and the object itself never exists at run time. Given no table for them
+ * the backend has one shape left for "a global you read members off": a
+ * structural record, so it emits `extern std::shared_ptr<gea_record_type_801>
+ * deviceInfo;` and member reads through it. That compiles and never links,
+ * the same way a host free function declared as a callable global does.
+ *
+ * Keyed by the PROGRAM's path rather than the host's prefix. The package states
+ * a nested namespace by spelling its whole program-facing path
+ * (`navigator.bluetooth.keyboard`), so following that spelling makes "what does
+ * this member render to" and "is this path itself a namespace" one lookup and
+ * one prefix test over one key space -- where translating to the host's prefix
+ * first would be a second naming rule, free to disagree with the tables.
+ */
+export interface HostNamespaceTable {
+    /** The global names that begin a namespace path. */
+    readonly roots: ReadonlySet<string>;
+    /**
+     * Namespace paths whose JavaScript `typeof` differs from the carrier used
+     * only to resolve their members. `Buffer` is both a callable constructor
+     * object and a namespace of statics, while `performance` is an object; the
+     * host owns that distinction because neither path is materialized as a C++
+     * value the generic carrier table can inspect.
+     */
+    readonly typeofs: ReadonlyMap<string, 'function' | 'object'>;
+    /** `path.member` to the C++ spelling a CALL through it renders. */
+    readonly methods: ReadonlyMap<string, HostCallSpelling>;
+    /** `path.member` to the C++ spelling a READ of it renders. */
+    readonly properties: ReadonlyMap<string, string>;
+    /**
+     * `path.member` to the C++ spelling a WRITE of it renders.
+     *
+     * A separate map from `properties`, never merged in: the host states a
+     * different spelling for each direction -- `Display.autoRotate` READS
+     * `gea::host::Display.autoRotate()` and WRITES
+     * `gea::host::Display.setAutoRotate(...)` -- so one map keyed by `path.member`
+     * could hold only one of the two, exactly the reason `HostMemberTable`'s own
+     * `property` arm carries an `emit` and a `store` rather than one `emit` field.
+     */
+    readonly propertySetters: ReadonlyMap<string, string>;
+}
+export declare const noHostNamespaces: HostNamespaceTable;
+/**
+ * Whether a path names a namespace rather than a member of one.
+ *
+ * Asked of the member tables' own keys: `navigator.bluetooth` is a namespace
+ * exactly because members are stated under it. A prefix test rather than a
+ * separate list, so a path cannot be a namespace here and have no members
+ * there.
+ */
+export declare const isHostNamespacePath: (namespaces: HostNamespaceTable, path: string) => boolean;
+/**
+ * Which class fields are held in a reactive cell, and what that cell is spelled.
+ *
+ * The two halves travel together because neither is usable alone: a set of
+ * fields with no cell spelling names storage nothing can render, and a spelling
+ * with no fields is a type nothing uses. Both come from the same plugin
+ * statement (`PluginCapabilities.reactiveClassFields` / `nativeReactiveCell`),
+ * so keeping them in one object is what stops a compilation from marking fields
+ * reactive under one plugin and spelling the cell from another.
+ */
+export interface ReactiveCellPlan {
+    readonly fields: ReadonlyMap<DeclarationId, ReadonlySet<string>>;
+    readonly cell: string | null;
+    /**
+     * What a unit must carry before it may name `cell`, from the plugin that
+     * stated the spelling (`PluginCapabilities.nativeReactiveCellPreamble`).
+     *
+     * `cell` says what the cell is spelled and this says what that spelling
+     * needs -- the same fact, one step on, which is why it travels beside it
+     * rather than as its own emitter channel. `translation-unit.ts` emits it only
+     * where a field is actually celled: gea's cell lives in the engine's own
+     * `ui/signal.h`, which is on the include path for an engine build only.
+     */
+    readonly cellPreamble: readonly string[];
+    /**
+     * Which reactive fields each BODY reads, so a caller can subscribe a thunk
+     * it cannot see inside of -- see `targets/cpp/reactive-dependencies.ts`.
+     *
+     * It lives on the reactive plan rather than travelling as its own emitter
+     * parameter because it answers the same question the two fields above do,
+     * one step further along: `fields` says which storage is a cell, `cell` says
+     * what the cell is spelled, and this says which cells a given body depends
+     * on. A consumer that has one always wants the others. `compiler.ts` states
+     * it empty -- the plugins that decide `fields` have no IR -- and
+     * `translation-unit.ts`, which does, fills it in for the emission it runs.
+     */
+    readonly dependencies: ReadonlyMap<FunctionId | RegionId, readonly ReactiveDependency[]>;
+    /**
+     * The same census narrowed for a NODE slot, where re-running a binding means
+     * rebuilding a subtree rather than rewriting a value -- so a dependency
+     * carried in from a callee is kept only when the callee BRANCHES on it. See
+     * `ReactiveDependencyCensus` in `targets/cpp/reactive-dependencies.ts` for
+     * why the two censuses cannot be one.
+     */
+    readonly nodeDependencies: ReadonlyMap<FunctionId | RegionId, readonly ReactiveDependency[]>;
+    /**
+     * Which reactive fields hold a COMPANION revision cell rather than a cell of
+     * their own -- `records.ts`'s own decision, reported by it and read back
+     * here. See `cppReactiveRevisionFieldName`.
+     *
+     * Like `dependencies`, `compiler.ts` states it empty (the plugins that decide
+     * `fields` have no carriers) and `translation-unit.ts` fills it in from the
+     * struct rendering that just made the call.
+     */
+    readonly revisions: ReadonlyMap<string, ReadonlySet<string>>;
+    /**
+     * Which struct members are held in a cell, by struct name -- `records.ts`'s
+     * own decision, read back.
+     *
+     * Keyed by struct rather than by class declaration because a reactive struct
+     * is not only a class: the ELEMENT record of a reactive array is reactive
+     * too, so `cell.filled = 1` notifies exactly the row props that read it, and
+     * an element record has no declaration to key by.
+     */
+    readonly celled: ReadonlyMap<string, ReadonlySet<string>>;
+    /**
+     * Which struct members a JSX slot actually BINDS, by struct name --
+     * `reactive-dependencies.ts`'s `reactiveBoundRecordFields`.
+     *
+     * Two consumers, one question. `records.ts` cells an element record's member
+     * only when a row renders it, and the emitter skips the companion revision
+     * notify for a member no row renders: writing `cell.piece = -1` when nothing
+     * displays `piece` would otherwise tick the array's revision and rebuild
+     * every row, which is both wasted work and the trigger for a real defect
+     * (the rebuild re-subscribes the surviving element records, so effects
+     * accumulate).
+     */
+    readonly boundRecordFields: ReadonlyMap<string, ReadonlySet<string>>;
+}
+export interface HostSpellings {
+    readonly members: HostMemberTable;
+    readonly constructors: HostConstructorTable;
+    readonly invocations: HostInvocationTable;
+    readonly arraySnapshotFunctions?: ReadonlySet<string>;
+    readonly nativeArrayFunctions?: ReadonlySet<string>;
+    readonly functions: HostFunctionTable;
+    /** The global names the hosts own as PATHS rather than as values. */
+    readonly namespaces: HostNamespaceTable;
+    /** A host's own `[[HasInstance]]` per namespace-root carrier -- see `PluginCapabilities.hostInstanceTests`. */
+    readonly instanceTests: ReadonlyMap<string, string>;
+    /** The global names a host holds one instance of and reaches by name -- see `PluginCapabilities.hostSingletons`. */
+    readonly singletons: ReadonlySet<string>;
+    /** What a unit must declare before it may name a spelling, keyed by the spelling. */
+    readonly preambles: ReadonlyMap<string, readonly string[]>;
+    readonly includes: HostIncludeTable;
+    /** What a JSX fragment builds, in the host's own C++; `null` when no installed host has one -- see `PluginCapabilities.elementFragment`. */
+    readonly fragment: string | null;
+    /** Which class fields this compilation holds in a reactive cell, and the cell's own spelling. */
+    readonly reactive: ReactiveCellPlan;
+    /**
+     * `<carrier>.<member>` keys (the same key space `HostMemberTable` uses) whose
+     * REAL C++ return is `void`, when the checker's declared return is not.
+     *
+     * `OscillatorNode.connect` is the case this exists for: `lib`'s ambient
+     * `connect(destination): AudioDestinationNode` states the Web Audio
+     * chaining convention, but `gea::host::OscillatorNode::connect` (the actual
+     * function this compiler calls) returns `void` -- the package's own
+     * `nativeMemberMethods` states as much per row (`returnType: "void"`), and
+     * that is the truth an emitted call has to render against, not the checker's
+     * declared shape. Without this, `emitCall` mints a variable of the CHECKER's
+     * non-void carrier and assigns a void expression to it, which certifies and
+     * emits (the call itself has a real host spelling) and fails only in clang:
+     * "no viable overloaded '='". A member listed here is always emitted as a
+     * bare statement, discarding whatever `operation.result` the checker's ABI
+     * would otherwise have this backend capture.
+     */
+    readonly voidResults: ReadonlySet<string>;
+    /**
+     * A reflectable host intrinsic's own member list, keyed by protocol name --
+     * the SAME data `semantics/host-protocols.ts`'s `HostProtocolBinding.members`
+     * carries per declaration, collected here into one flat table because a
+     * reflection call (`Object.getOwnPropertyDescriptor(Math, k)`) has only the
+     * receiver's `native-handle` REPRESENTATION in hand at emission, which
+     * carries a protocol NAME and no declaration id to look a binding up by.
+     *
+     * Absent (no entry) for a protocol `bindAmbientValue` never classified --
+     * every host-carried protocol (`native !== null`), and every protocol
+     * reached through a route other than an ambient global read. A reflection
+     * renderer must tell that apart from a classified-but-EMPTY list: absence
+     * means "no static answer exists" and refuses by name, where an empty list
+     * is itself the true, checked answer "this intrinsic has no own members".
+     */
+    readonly intrinsicMembers: ReadonlyMap<string, readonly HostIntrinsicMember[]>;
+}
+export declare const coreHostMembers: HostMemberTable;
+/**
+ * The ambient FREE FUNCTIONS the language itself defines on the global object,
+ * to the C++ each is -- the `hostFunctions` half of what `coreHostMembers` is
+ * to `hostMembers`.
+ *
+ * These are ECMAScript's, not any host's, so they belong here and not in a
+ * plugin package: `parseInt` is defined by ECMA-262 §19.2.5 and is present in
+ * every conforming environment, gea or otherwise. Before this table they had
+ * no claim anywhere, so `projection/bindings.ts` fell through to the ordinary
+ * external-cell case and `translation-unit.ts` declared `extern
+ * gea::CallableObject<double(std::string, gea::Optional<double>)> parseInt;`
+ * -- a global VARIABLE no object file defines. That passes a `-fsyntax-only`
+ * check, never links, and (if something does define the symbol) calls through
+ * a null invoke pointer. `plugins/model.ts`'s own `hostFunctions` comment
+ * describes exactly that failure for the host case.
+ *
+ * `parseInt` and `parseFloat` name `NumberConstructor`'s functions rather than
+ * twins of their own, because ECMA-262 21.1.2.13 and 21.1.2.12 define
+ * `Number.parseInt`/`Number.parseFloat` as *the same function objects* as the
+ * globals. `isNaN`/`isFinite` do get their own spellings, because the global
+ * pair and the `Number` pair are genuinely different functions -- see
+ * `gea::host::globalIsNaN` in `gea_runtime.h`.
+ */
+export declare const coreHostFunctions: HostFunctionTable;
+/**
+ * The ambient CONSTANTS the language defines on the global object, to the text
+ * each read renders.
+ *
+ * `NaN` (ECMA-262 §19.1.1) and `Infinity` (§19.1.2) are `declare var`s in
+ * `lib.es5.d.ts`, so without a claim here they were placed as ordinary
+ * external cells and the unit emitted `extern double NaN;` -- again a symbol
+ * nothing defines. A constant is the right storage rather than a function or a
+ * cell: neither name is readable-and-writable in any meaningful sense (both
+ * are non-writable, non-configurable properties of the global object), so
+ * every read is the value, spelled inline, exactly as
+ * `BindingStorage`'s `host-constant` describes for an Objective-C enumerator.
+ *
+ * `undefined` (§19.1.3) is not here: TypeScript treats it as a keyword with
+ * its own type rather than a binding this projection ever asks about, so it
+ * needs no cell and has none.
+ */
+export declare const coreHostConstants: ReadonlyMap<string, string>;
+/**
+ * The member a protocol states, looked up in the table this compilation built.
+ *
+ * The table is passed rather than imported: a plugin installs host protocols of
+ * its own, and a lookup that read a module-level map could only ever see this
+ * file's half of the answer.
+ */
+export declare const hostMemberOf: (table: HostMemberTable, protocol: string, member: string) => HostMember | undefined;
+/**
+ * The spec's own `length` for a builtin, or `null` where none is stated here.
+ *
+ * Separated from `hostIntrinsicLengthOf` because a builtin read as a VALUE has
+ * no census arity to fall back to: `0` would be a fabricated answer, and the
+ * reader refuses by name instead. Same map, so the two readers cannot drift.
+ */
+export declare const statedHostIntrinsicLength: (protocol: string, member: string) => number | null;
+export declare const hostIntrinsicLengthOf: (protocol: string, member: string, censusArity: number | null) => number;
+export declare const fillHostTemplate: (emit: string, receiver: string | null, args: readonly string[], variadicArgs?: string | null, value?: string | null) => string | null;
+/**
+ * How many arguments a host template consumes, read from the template itself.
+ *
+ * The template is the authority on this and nothing else is: it names
+ * `{arg0}`, `{arg1}`, ... exactly as many times as the host spelling needs, and
+ * `fillHostTemplate` refuses a slot the call cannot fill. Taking the count from
+ * the declared parameter list instead would be a second answer to the same
+ * question, free to drift from the text that actually gets rendered -- and a
+ * declared optional parameter the spelling does not mention would make the two
+ * disagree immediately.
+ */
+export declare const templateArity: (emit: string) => number;