@geastack/compiler 1.0.15

package/dist/plugins/model.js

@@ -0,0 +1,47 @@
+import { noHostNamespaces } from '../targets/cpp/host/host-members.js';
+export const noPluginCapabilities = Object.freeze({
+    runtimeHelpers: new Set(),
+    propertyRecipes: new Set(),
+    nativeProtocols: new Set(),
+    typedArrayDeclarations: [],
+    commonJsGlobals: new Map(),
+    commonJsBuiltinModules: new Map(),
+    commonJsBuiltinModuleSources: new Map(),
+    nativeTypes: new Map(),
+    nativeTypesByDeclaration: new Map(),
+    ambientTypeRealizations: new Map(),
+    hostMembers: new Map(),
+    hostMemberVoidResults: new Set(),
+    hostConstructors: new Map(),
+    hostInvocations: new Map(),
+    hostFunctions: new Map(),
+    hostFunctionsByDeclaration: new Map(),
+    hostNamespaces: noHostNamespaces,
+    hostNamespaceRootsByDeclaration: new Map(),
+    hostNamespaceRootDeclarations: [],
+    hostNamespaceRootTypes: new Map(),
+    hostInstanceTests: new Map(),
+    hostSingletons: new Set(),
+    hostSingletonsByDeclaration: new Map(),
+    hostSingletonDeclarations: new Map(),
+    absentGlobals: new Set(),
+    hostPreambles: new Map(),
+    nativeBases: new Map(),
+    nativeIncludes: new Map(),
+    nativeConstants: new Map(),
+    hostConstantsByDeclaration: new Map(),
+    generatedSupportIncludes: [],
+    runtimeDefinitions: [],
+    elementFragment: null,
+    elementTextTags: [],
+    reachedMemberKeys: new Set(),
+    reactiveClassFields: new Map(),
+    nativeReactiveCell: null,
+    nativeReactiveCellPreamble: []
+});
+/** A plugin instance that changes nothing, for a compilation with none installed. */
+export const inertPluginInstance = Object.freeze({
+    producers: () => [],
+    lower: () => false,
+    capabilities: noPluginCapabilities
+});

package/dist/plugins/webgl/host.d.ts

@@ -0,0 +1,77 @@
+import type { AmbientTypeRealization } from '../../semantics/ambient-type-realization-transform.js';
+import type { PluginSourceFile } from '../model.js';
+/**
+ * The ambient free functions this host defines, to the C++ each is.
+ *
+ * This is the WHOLE of what the plugin has to state, and the reason it is so
+ * small is the point. `NativeWebGL2RenderingContext` and `NativeWebGLCanvas`
+ * are not host types at all -- they are ordinary TypeScript classes, shipped as
+ * source in the package's own `src/nativeWebGL.ts`, whose methods this compiler
+ * compiles natively like any other class. What crosses into the host is one
+ * layer below them: `threeWebGLCreateBuffer()` and its 126 siblings, ambient
+ * names declared in `nativeWebGLHost.ts` and defined in `angle_webgl_host.mm`.
+ *
+ * v1 states much more -- 88 `runtimeMemberCalls` and 333 `runtimeMemberReads`
+ * that recognize a call ON the context object and emit the host call directly,
+ * erasing the class. That is an optimization for a compiler that could not
+ * compile the class; it is not the meaning of the program, and restating it
+ * here would put 421 hand-written rows between this compiler and a class it can
+ * already read. If a direct-call fast path is ever worth its cost, it is worth
+ * it as a measurement, not as the only way the program compiles.
+ */
+export declare const webglHostFunctions: () => ReadonlyMap<string, string>;
+/**
+ * What a unit must declare before it may name one of those spellings.
+ *
+ * Keyed by the spelling, which is how the package already states it: a program
+ * that calls two of these carries two `extern "C"` lines and not 127.
+ */
+export declare const webglHostPreambles: () => ReadonlyMap<string, readonly string[]>;
+/** Source compatibility owned by the native WebGL package itself. */
+export declare const webglSourceTransform: (input: PluginSourceFile) => string | null;
+/**
+ * The browser globals a native ANGLE context does not provide.
+ *
+ * Scoped deliberately to this host's own neighbourhood -- the image, canvas and
+ * video element types a WebGL renderer reaches for when it uploads a texture.
+ * That is the surface this plugin replaces: `NativeWebGLCanvas` is the canvas,
+ * and there is no DOM behind it.
+ *
+ * Every name here is one three.js itself guards with `typeof X !== 'undefined'`,
+ * because three is written to run where they may not exist. Stating the absence
+ * is what makes that guard mean what it says; without it the guard folds to
+ * `true`, three takes a branch that reads `image.displayWidth` off something
+ * that is not a `VideoFrame`, and the unit emits an `extern` for a symbol no
+ * object file defines.
+ *
+ * Names deliberately NOT here, and why -- absence is a CLAIM about the target,
+ * so a name goes in only when this host is sure:
+ *
+ * - `performance`, `URL`, `Blob`, `fetch` and the network types: nothing about
+ *   an ANGLE context says whether the target implements them, and `three` calls
+ *   `performance.now()` unguarded. That is a different host's answer.
+ * - `WebGL2RenderingContext`: its constructor identity needs a native binding
+ *   for programs that use it to detect WebGL 2. The WebGL 1 constructor is
+ *   absent: this host only creates NativeWebGL2RenderingContext. In three's
+ *   WebGL 1 rejection guard, absence correctly skips the rejected path.
+ * - `self`, `postMessage`, `importScripts`: worker globals, and whether this
+ *   target has workers is not a fact about its GL context.
+ */
+export declare const webglAbsentGlobals: ReadonlySet<string>;
+/**
+ * The ambient WebGL context names three's own source (and `@types/three`'s
+ * mirrored declarations) states, to the concrete class
+ * `@geastack/native-webgl-angle` actually hands a program.
+ *
+ * Both `WebGLRenderingContext` (`@types/three`'s stale declared type for
+ * three's internal `_gl` parameters -- see `WebGLRenderer`'s own comment in
+ * a three.js app's entry module) and `WebGL2RenderingContext` (what
+ * three's own JSDoc states for `WebGLRenderer~Options.context`) name it: two
+ * ambient interfaces, one real replacement, so both keys route to the same
+ * `NativeWebGL2RenderingContext`. A package with nothing to state here
+ * answers an empty map, and every ambient name keeps whatever the census
+ * already does with it -- exactly `nativeTypes`'s own convention.
+ */
+export declare const webglAmbientTypeRealizations: () => ReadonlyMap<string, AmbientTypeRealization>;
+export declare const webglHostArraySnapshotFunctions: () => ReadonlySet<string>;
+export declare const webglHostNativeArrayFunctions: () => ReadonlySet<string>;

package/dist/plugins/webgl/host.js

@@ -0,0 +1,162 @@
+import { createRequire } from 'node:module';
+const require_ = createRequire(import.meta.url);
+let loaded;
+/**
+ * The package's own statement, loaded once.
+ *
+ * `require` rather than `import()`, and the same two failures told apart, for
+ * the reasons `geaNativeTypes` states in full: not installed is a
+ * configuration and answers empty, while a package that IS installed and does
+ * not answer is a defect and throws. `GEATSC2_WEBGL_PLUGIN` overrides the
+ * specifier with an explicit path, and naming one that does not resolve is a
+ * wrong path rather than an absent package -- so it throws too.
+ */
+const shims = () => {
+    if (loaded !== undefined)
+        return loaded;
+    const requested = process.env.GEATSC2_WEBGL_PLUGIN;
+    const specifier = requested ?? '@geastack/native-webgl-angle/geatsc-plugin';
+    let module_;
+    try {
+        module_ = require_(specifier);
+    }
+    catch (error) {
+        const absent = error.code === 'MODULE_NOT_FOUND';
+        if (!absent || requested !== undefined) {
+            throw new Error(`native-webgl-angle host shims failed to load from '${specifier}': ${String(error)}`);
+        }
+        loaded = null;
+        return null;
+    }
+    const plugin = module_.default;
+    if (typeof plugin?.configure !== 'function') {
+        throw new Error(`native-webgl-angle plugin at '${specifier}' exports no default plugin with a configure()`);
+    }
+    const configured = plugin.configure().hostShims;
+    if (!configured) {
+        throw new Error(`native-webgl-angle plugin at '${specifier}' configured no hostShims`);
+    }
+    loaded = configured;
+    return configured;
+};
+/**
+ * The ambient free functions this host defines, to the C++ each is.
+ *
+ * This is the WHOLE of what the plugin has to state, and the reason it is so
+ * small is the point. `NativeWebGL2RenderingContext` and `NativeWebGLCanvas`
+ * are not host types at all -- they are ordinary TypeScript classes, shipped as
+ * source in the package's own `src/nativeWebGL.ts`, whose methods this compiler
+ * compiles natively like any other class. What crosses into the host is one
+ * layer below them: `threeWebGLCreateBuffer()` and its 126 siblings, ambient
+ * names declared in `nativeWebGLHost.ts` and defined in `angle_webgl_host.mm`.
+ *
+ * v1 states much more -- 88 `runtimeMemberCalls` and 333 `runtimeMemberReads`
+ * that recognize a call ON the context object and emit the host call directly,
+ * erasing the class. That is an optimization for a compiler that could not
+ * compile the class; it is not the meaning of the program, and restating it
+ * here would put 421 hand-written rows between this compiler and a class it can
+ * already read. If a direct-call fast path is ever worth its cost, it is worth
+ * it as a measurement, not as the only way the program compiles.
+ */
+export const webglHostFunctions = () => {
+    const rows = new Map();
+    for (const [name, emit] of Object.entries(shims()?.embeddedHostFunctions ?? {})) {
+        if (typeof emit === 'string' && emit.length > 0)
+            rows.set(name, emit);
+    }
+    return rows;
+};
+/**
+ * What a unit must declare before it may name one of those spellings.
+ *
+ * Keyed by the spelling, which is how the package already states it: a program
+ * that calls two of these carries two `extern "C"` lines and not 127.
+ */
+export const webglHostPreambles = () => {
+    const rows = new Map();
+    for (const [emit, declarations] of Object.entries(shims()?.hostExternDeclarations ?? {})) {
+        const lines = (declarations ?? []).filter((line) => typeof line === 'string' && line.length > 0);
+        if (lines.length > 0)
+            rows.set(emit, lines);
+    }
+    return rows;
+};
+/** Source compatibility owned by the native WebGL package itself. */
+export const webglSourceTransform = (input) => shims()?.transformSource?.(input) ?? null;
+/**
+ * The browser globals a native ANGLE context does not provide.
+ *
+ * Scoped deliberately to this host's own neighbourhood -- the image, canvas and
+ * video element types a WebGL renderer reaches for when it uploads a texture.
+ * That is the surface this plugin replaces: `NativeWebGLCanvas` is the canvas,
+ * and there is no DOM behind it.
+ *
+ * Every name here is one three.js itself guards with `typeof X !== 'undefined'`,
+ * because three is written to run where they may not exist. Stating the absence
+ * is what makes that guard mean what it says; without it the guard folds to
+ * `true`, three takes a branch that reads `image.displayWidth` off something
+ * that is not a `VideoFrame`, and the unit emits an `extern` for a symbol no
+ * object file defines.
+ *
+ * Names deliberately NOT here, and why -- absence is a CLAIM about the target,
+ * so a name goes in only when this host is sure:
+ *
+ * - `performance`, `URL`, `Blob`, `fetch` and the network types: nothing about
+ *   an ANGLE context says whether the target implements them, and `three` calls
+ *   `performance.now()` unguarded. That is a different host's answer.
+ * - `WebGL2RenderingContext`: its constructor identity needs a native binding
+ *   for programs that use it to detect WebGL 2. The WebGL 1 constructor is
+ *   absent: this host only creates NativeWebGL2RenderingContext. In three's
+ *   WebGL 1 rejection guard, absence correctly skips the rejected path.
+ * - `self`, `postMessage`, `importScripts`: worker globals, and whether this
+ *   target has workers is not a fact about its GL context.
+ */
+export const webglAbsentGlobals = new Set([
+    ...(shims()?.absentGlobals ?? []),
+    'WebGLRenderingContext',
+    'ImageData',
+    'ImageBitmap',
+    'VideoFrame',
+    'OffscreenCanvas',
+    'HTMLCanvasElement',
+    'HTMLImageElement',
+    'HTMLVideoElement',
+    'createImageBitmap',
+    // WebXR. A native ANGLE context can no more start an XR session than it can
+    // decode an `ImageBitmap`, and three says so in its own source the same way:
+    // `const supportsGlBinding = typeof XRWebGLBinding !== 'undefined'`
+    // (`renderers/webxr/WebXRManager.js`, `renderers/common/XRManager.js`).
+    //
+    // These arrive from `@types/webxr` rather than `lib.dom.d.ts`, which is why
+    // `absent-globals.ts` asks whether a declaration is the PLATFORM's rather
+    // than whether TypeScript ships it -- see `platformDeclarationTest`. Both are
+    // `declare class`, the form that made a `declare var`-only value test unable
+    // to deny a single WebXR name.
+    'XRWebGLBinding',
+    'XRWebGLLayer'
+]);
+/**
+ * The ambient WebGL context names three's own source (and `@types/three`'s
+ * mirrored declarations) states, to the concrete class
+ * `@geastack/native-webgl-angle` actually hands a program.
+ *
+ * Both `WebGLRenderingContext` (`@types/three`'s stale declared type for
+ * three's internal `_gl` parameters -- see `WebGLRenderer`'s own comment in
+ * a three.js app's entry module) and `WebGL2RenderingContext` (what
+ * three's own JSDoc states for `WebGLRenderer~Options.context`) name it: two
+ * ambient interfaces, one real replacement, so both keys route to the same
+ * `NativeWebGL2RenderingContext`. A package with nothing to state here
+ * answers an empty map, and every ambient name keeps whatever the census
+ * already does with it -- exactly `nativeTypes`'s own convention.
+ */
+export const webglAmbientTypeRealizations = () => {
+    const rows = new Map();
+    for (const [name, realization] of Object.entries(shims()?.ambientTypeRealizations ?? {})) {
+        if (realization && typeof realization.type === 'string' && typeof realization.importedFrom === 'string') {
+            rows.set(name, { type: realization.type, importedFrom: realization.importedFrom });
+        }
+    }
+    return rows;
+};
+export const webglHostArraySnapshotFunctions = () => new Set(shims()?.hostArraySnapshotFunctions ?? []);
+export const webglHostNativeArrayFunctions = () => new Set(shims()?.hostNativeArrayFunctions ?? []);

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

@@ -0,0 +1,40 @@
+import type { CompilerPlugin } from '../model.js';
+/**
+ * ANGLE's WebGL bridge, as a plugin.
+ *
+ * The third host in this build, and the smallest by a long way: it states its
+ * free functions and nothing else. That is not a stub. This host's surface
+ * really is 127 ambient functions -- `threeWebGLCreateBuffer`,
+ * `threeWebGLDrawElements`, `threeWebGLTexImage2D` -- declared in the package's
+ * `nativeWebGLHost.ts` and defined in its `angle_webgl_host.mm`. The
+ * `WebGL2RenderingContext` a three.js program actually holds is a TypeScript
+ * class in that same package, and this compiler compiles it as one.
+ *
+ * So there is no `nativeTypes` here, and its absence is a statement rather than
+ * a gap. `nativeTypes` says "this declared name is a host object, and here is
+ * the C++ type its values are carried in"; `NativeWebGL2RenderingContext` has
+ * no such type, because the ANGLE context is a process global and the class is
+ * a facade over free calls. Naming a carrier for it would mint an identity the
+ * runtime does not have. No constructors either, for the same reason -- `new
+ * NativeWebGLCanvas()` constructs an ordinary object -- and no members, no
+ * bases, no includes, no constants.
+ *
+ * `ambientTypeRealizations` is the one non-empty table below, and it exists
+ * for a fact `nativeTypes` cannot state: three's own `WebGLRenderer` and its
+ * `@types/three` declarations describe the context this program holds as an
+ * AMBIENT BROWSER interface (`WebGLRenderingContext`, `WebGL2RenderingContext`)
+ * -- structurally unrelated to `NativeWebGL2RenderingContext`, which is why a
+ * `renderbufferStorageMultisample`/`blitFramebuffer`/`invalidateFramebuffer`
+ * call, or a `DRAW_FRAMEBUFFER`/`READ_FRAMEBUFFER` constant read -- real
+ * WebGL2 members `WebGLRenderingContext` (WebGL1) lacks entirely -- typed
+ * `any` and boxed every one of the ~230 boxed carriers rooted at
+ * `WebGLTextures.js`'s own `_gl` parameter. The fix is not a carrier this
+ * layer invents; it is the ambient name meaning the class the value already
+ * is. See `webglAmbientTypeRealizations` (`host.ts`).
+ *
+ * No producer and no lowering: like Apple's, this host adds no meaning to a
+ * language form. A three.js program is ordinary TypeScript calling methods on
+ * ordinary classes; the only thing the core cannot know is that seven-score
+ * bare names are C++ functions somebody else links in.
+ */
+export declare const webglPlugin: CompilerPlugin;

package/dist/plugins/webgl/plugin.js

@@ -0,0 +1,99 @@
+import { noHostNamespaces } from '../../targets/cpp/host/host-members.js';
+import { webglAbsentGlobals, webglAmbientTypeRealizations, webglHostFunctions, webglHostArraySnapshotFunctions, webglHostNativeArrayFunctions, webglHostPreambles, webglSourceTransform } from './host.js';
+/**
+ * ANGLE's WebGL bridge, as a plugin.
+ *
+ * The third host in this build, and the smallest by a long way: it states its
+ * free functions and nothing else. That is not a stub. This host's surface
+ * really is 127 ambient functions -- `threeWebGLCreateBuffer`,
+ * `threeWebGLDrawElements`, `threeWebGLTexImage2D` -- declared in the package's
+ * `nativeWebGLHost.ts` and defined in its `angle_webgl_host.mm`. The
+ * `WebGL2RenderingContext` a three.js program actually holds is a TypeScript
+ * class in that same package, and this compiler compiles it as one.
+ *
+ * So there is no `nativeTypes` here, and its absence is a statement rather than
+ * a gap. `nativeTypes` says "this declared name is a host object, and here is
+ * the C++ type its values are carried in"; `NativeWebGL2RenderingContext` has
+ * no such type, because the ANGLE context is a process global and the class is
+ * a facade over free calls. Naming a carrier for it would mint an identity the
+ * runtime does not have. No constructors either, for the same reason -- `new
+ * NativeWebGLCanvas()` constructs an ordinary object -- and no members, no
+ * bases, no includes, no constants.
+ *
+ * `ambientTypeRealizations` is the one non-empty table below, and it exists
+ * for a fact `nativeTypes` cannot state: three's own `WebGLRenderer` and its
+ * `@types/three` declarations describe the context this program holds as an
+ * AMBIENT BROWSER interface (`WebGLRenderingContext`, `WebGL2RenderingContext`)
+ * -- structurally unrelated to `NativeWebGL2RenderingContext`, which is why a
+ * `renderbufferStorageMultisample`/`blitFramebuffer`/`invalidateFramebuffer`
+ * call, or a `DRAW_FRAMEBUFFER`/`READ_FRAMEBUFFER` constant read -- real
+ * WebGL2 members `WebGLRenderingContext` (WebGL1) lacks entirely -- typed
+ * `any` and boxed every one of the ~230 boxed carriers rooted at
+ * `WebGLTextures.js`'s own `_gl` parameter. The fix is not a carrier this
+ * layer invents; it is the ambient name meaning the class the value already
+ * is. See `webglAmbientTypeRealizations` (`host.ts`).
+ *
+ * No producer and no lowering: like Apple's, this host adds no meaning to a
+ * language form. A three.js program is ordinary TypeScript calling methods on
+ * ordinary classes; the only thing the core cannot know is that seven-score
+ * bare names are C++ functions somebody else links in.
+ */
+export const webglPlugin = {
+    name: 'native-webgl-angle-host',
+    instantiate: () => ({
+        producers: () => [],
+        transformSource: webglSourceTransform,
+        lower: () => false,
+        capabilities: {
+            runtimeHelpers: new Set(),
+            propertyRecipes: new Set(),
+            // Protocols are derived from the carriers in `nativeTypes`, and this host
+            // states none -- see the class-is-not-a-host-object note above.
+            nativeProtocols: new Set(),
+            nativeTypes: new Map(),
+            ambientTypeRealizations: webglAmbientTypeRealizations(),
+            hostMembers: new Map(),
+            hostMemberVoidResults: new Set(),
+            hostConstructors: new Map(),
+            hostFunctions: webglHostFunctions(),
+            hostArraySnapshotFunctions: webglHostArraySnapshotFunctions(),
+            hostNativeArrayFunctions: webglHostNativeArrayFunctions(),
+            // One name, one function: nothing in this host is declared twice.
+            hostFunctionsByDeclaration: new Map(),
+            hostNamespaces: noHostNamespaces,
+            hostNamespaceRootsByDeclaration: new Map(),
+            hostNamespaceRootTypes: new Map(),
+            hostSingletons: new Set(),
+            hostSingletonsByDeclaration: new Map(),
+            absentGlobals: webglAbsentGlobals,
+            hostPreambles: webglHostPreambles(),
+            nativeBases: new Map(),
+            // Declarations arrive per spelling through `hostPreambles`, not per
+            // carrier -- this host has no carriers to key a header by.
+            nativeIncludes: new Map(),
+            nativeConstants: new Map(),
+            hostConstantsByDeclaration: new Map(),
+            // The WebGL constants a program reads (`gl.RGBA`, `gl.TRIANGLES`) are
+            // `readonly` fields of the TypeScript class, initialized to their
+            // numeric literals in the package's own source. They are the program's
+            // own data, and this compiler reads them as such.
+            // WebGL's declarations reach a unit through `nativeIncludes`, per
+            // carrier the plan actually selected. Nothing about this host is true of
+            // a unit that names none of its types, so the support header states
+            // nothing on its behalf.
+            generatedSupportIncludes: [],
+            runtimeDefinitions: [],
+            elementFragment: null,
+            elementTextTags: [],
+            // Nothing this host lowers calls a class member the program does not name.
+            reachedMemberKeys: new Set(),
+            // three's programs take the host mutation census's `*` wildcard through
+            // this host, under which no Object-prototype obligation is ever
+            // discharged; see `PluginCapabilities.refusesObjectPrototypeAbsenceProofs`.
+            refusesObjectPrototypeAbsenceProofs: true,
+            reactiveClassFields: new Map(),
+            nativeReactiveCell: null,
+            nativeReactiveCellPreamble: []
+        }
+    })
+};

package/dist/preflight/obligations.d.ts

@@ -0,0 +1,206 @@
+import type { ComponentId, DeclarationId, FunctionId, SemanticResultId } from '../identity/ids.js';
+import type { Representation } from '../representation/model.js';
+/**
+ * The obligation model.
+ *
+ * An obligation is one demanded thing the PLAN needs already installed: a
+ * selected carrier, a call path, a native boundary, a verifier recipe, an
+ * emitter recipe, a physical C++ type. It is not a proof and it does not
+ * compute anything -- it names what was checked, what was expected, what was
+ * actually found, and whether the two agree. `run.ts` walks the sealed
+ * semantic graph and representation plan to build these; nothing here may
+ * synthesize a carrier or invent a fact the earlier layers did not already
+ * publish. Site-level demands -- which conversion a slot needs, which recipe
+ * a receiver takes, which helper a protocol step calls -- are not obligations
+ * any more: `ir/certify.ts` reads them off the lowered IR as capability keys
+ * (the plan's census).
+ */
+export declare const obligationKinds: readonly ["binding-carrier", "expression-carrier", "return-carrier", "call-abi", "native-boundary", "physical-cpp-type", "verifier-recipe", "emitter-recipe"];
+export type ObligationKind = (typeof obligationKinds)[number];
+/**
+ * `blocked-by-upstream` is never assigned by a local check. It is the one
+ * status `run.ts`'s propagation step may raise a `satisfied` obligation to,
+ * when an obligation it depends on is itself not satisfied -- so a row that
+ * reads `missing`/`unsupported` always names an independently provable
+ * defect, never a downstream echo of somebody else's.
+ */
+export type ObligationStatus = 'satisfied' | 'missing' | 'unsupported' | 'blocked-by-upstream';
+/**
+ * The four fields the spec this module implements requires on every
+ * predicate. A reader must be able to see what was expected and what was
+ * actually found without reverse-engineering either from the pass bit.
+ */
+export interface ObligationPredicate {
+    readonly id: string;
+    readonly expected: string;
+    readonly actual: string;
+    readonly pass: boolean;
+}
+export declare const predicate: (id: string, expected: string, actual: string) => ObligationPredicate;
+declare const obligationBrand: unique symbol;
+/** Opaque the same way `identity/ids.ts` identities are, minted only here. */
+export type ObligationId = string & {
+    readonly [obligationBrand]: 'ObligationId';
+};
+export declare const obligationId: (component: ComponentId, kind: ObligationKind, discriminator: string) => ObligationId;
+/**
+ * One demanded thing. `derivesFrom` anchors every obligation kind to the
+ * semantic result whose lineage it is about, including operation-level
+ * obligations such as `call-abi`, which anchor to the invocation's own
+ * published result rather than to one of its operands.
+ *
+ * `optional` marks a fast-path optimization capability rather than the
+ * mandatory generic primitive it accelerates -- per the doc, a missing fast
+ * path must never read as a compilation failure when the generic path is
+ * installed, so only `optional: false` rows can hold back a certificate.
+ */
+export interface Obligation {
+    readonly id: ObligationId;
+    readonly kind: ObligationKind;
+    readonly component: ComponentId;
+    readonly derivesFrom: SemanticResultId;
+    readonly predicate: ObligationPredicate;
+    readonly optional: boolean;
+    /**
+     * The status this obligation's own check produced, considering nothing but
+     * its own predicate. `run.ts`'s propagation may compute a higher-level
+     * `blocked-by-upstream` status from this, but never edits this field: it is
+     * the row's permanent, independently-provable evidence.
+     */
+    readonly localStatus: 'satisfied' | 'missing' | 'unsupported';
+}
+/**
+ * A failed predicate is `unsupported` only when the model it queried already
+ * gives an authoritative "never" answer for this coordinate -- a `Never`
+ * conversion node, a helper the manifest lists as never-installable. Every
+ * other failure is `missing`: capability that has not been installed yet, not
+ * capability that cannot exist. Collapsing the two would make an ordinary gap
+ * in an unfinished primitive read as a permanent language limitation.
+ */
+export declare const localStatusOf: (check: ObligationPredicate, declaredUnsupported: boolean) => "satisfied" | "missing" | "unsupported";
+/**
+ * Sealed backend registries the census checks against. Every field is a
+ * closed set: presence means installed, absence means not yet, and the
+ * `unsupported*` sets mean never by design -- the same three-way split the
+ * doc draws between generic lowering, optimization, and genuine unsupported
+ * behavior. Preflight never writes to this; it is frozen by whoever seals the
+ * backend registries before calling `runPreflight`.
+ */
+export interface TargetRuntimeManifest {
+    /** The generic dynamic-dispatch call path every invocation may fall back to. */
+    readonly hasGenericCallPath: boolean;
+    /**
+     * Whether the box itself can be CALLED -- `const fn: any = table[i]; fn(x)`.
+     *
+     * Separate from `hasGenericCallPath`, which is about calling through a
+     * callable CARRIER whose ABI the plan published: there the frame is known
+     * and the call is an ordinary indirect one. This is the case where the
+     * callee's carrier is `dynamic` and there is no ABI at all, so the arguments
+     * cross as boxes and the callable's own declared parameters are recovered at
+     * runtime. A target without it refuses such a call rather than dropping to
+     * the generic path, which has no frame to use.
+     */
+    readonly hasDynamicCallPath: boolean;
+    /** Exact-target callable ABIs registered as a devirtualization fast path. */
+    readonly functionAbis: ReadonlySet<FunctionId>;
+    /** ABIs for classes with no written constructor, keyed by the class itself. */
+    readonly implicitConstructorAbis: ReadonlySet<DeclarationId>;
+    /** Authenticated plugin host `[[Call]]` spellings, keyed `${carrier}.call`. */
+    readonly hostInvocations?: ReadonlySet<string>;
+    /** Authenticated plugin host `[[Construct]]` spellings, keyed by carrier. */
+    readonly hostConstructors?: ReadonlySet<string>;
+    /**
+     * Every `${protocol}.${member}` the installed host member tables claim a
+     * spelling for -- the backend's own `host-members.ts` rows unioned with each
+     * plugin's. This is the set the printer's `nativeHostMemberText` decides a
+     * host property read against, so a constant-keyed read off a `native-handle`
+     * receiver is certified against the same rows it will later be rendered
+     * from; without it the printer's "claimed by no host member table" refusal
+     * was the first place a certified program learned the member did not exist.
+     */
+    readonly hostMembers?: ReadonlySet<string>;
+    /** Property-access recipes, keyed `${internalMethod}:${keyIsComputed}`. */
+    readonly propertyRecipes: ReadonlySet<string>;
+    /** Ownerships (`Ownership` values, plus `'value'`) the capture path can transport. */
+    readonly captureOwnershipSupport: ReadonlySet<string>;
+    /** Authenticated host protocols, keyed `${protocol}@${version}`. */
+    readonly nativeProtocols: ReadonlySet<string>;
+    /**
+     * `${protocol}.${member}:argument:${ordinal | "*"}` keys whose CALL the
+     * target spells at the site, from that argument's own carrier, and which
+     * take a `dynamic` argument at that exact position unconditionally.
+     *
+     * The narrow twin of `nativeProtocols`, and narrow for a reason. A call
+     * through an ordinary callee reaches the emitter's argument alignment, which
+     * reconciles each argument against the callee's DECLARED parameter -- so a
+     * dynamic argument there needs an installed conversion, and
+     * `invocation-arguments.ts` rightly demands one. A member listed here never
+     * reaches that path: the target intercepted the call before it and renders
+     * from the operands themselves. `lib`'s declared parameter is then a
+     * statement about what the LANGUAGE permits, not about any physical frame,
+     * and requiring a conversion into it asks for machinery no emitted line
+     * performs.
+     *
+     * `Object.values(o)` is the case that made this necessary. Its declared
+     * parameter is `{ [s: string]: T } | ArrayLike<T>`, which derives a
+     * `tagged-union(dictionary | native-record-ref)`; nothing converts a
+     * `dynamic` into that union and nothing should, because the emitted call is
+     * `gea::host::ObjectConstructor::values(v)` and passes the box straight
+     * through to a real own-property enumeration.
+     *
+     * Keyed per MEMBER, ROLE and POSITION, never per protocol or whole call,
+     * because even one intercepted member's arguments differ. In particular,
+     * `Object.defineProperty(target, key, descriptor)` accepts a dynamic target
+     * and PropertyKey, but its descriptor renderer requires an exact typed
+     * descriptor record. A member-wide waiver would certify the descriptor and
+     * let emission refuse afterward. `*` is reserved for a genuinely variadic
+     * intercepted role such as Object.assign's source list.
+     *
+     * Optional, and absent reads as empty: a manifest sealed before this
+     * existed keeps demanding the conversion, which is the fail-closed default
+     * every other optional field in this interface takes.
+     */
+    readonly dynamicArgumentHostParameters?: ReadonlySet<string>;
+    /**
+     * Whether this target can render an ambient value declaration's introducing
+     * cell as an `extern` reference to a host-defined symbol.
+     *
+     * This is one flag rather than a `nativeProtocols`-shaped set keyed per
+     * declaration. `nativeProtocols` exists because a `native-handle`'s
+     * `protocol`/`version` selects genuinely different runtime glue -- a
+     * different materializer, a different opaque layout -- so authenticating one
+     * protocol must never be read as authenticating another. An ambient value
+     * binding carries no such per-declaration machinery: its carrier is derived
+     * from its declared type exactly like any other binding's, and rendering it
+     * is one uniform recipe (`extern <carrier-type> <linkageName>;`) that does
+     * not vary by which global it is. What genuinely differs per declaration --
+     * whether a real host-side definition exists for its specific linkage name
+     * -- is a link-time fact this static census cannot see and an ordinary
+     * linker already reports; claiming to verify it here would be inventing
+     * proof this stage does not have. Optional so a manifest sealed before this
+     * capability existed still satisfies this interface: absence reads as
+     * `false`, the same fail-closed default `unsupportedRuntimeHelpers` and its
+     * siblings use elsewhere in this file.
+     */
+    readonly supportsExternalBindings?: boolean;
+    readonly runtimeHelpers: ReadonlySet<string>;
+    readonly unsupportedRuntimeHelpers: ReadonlySet<string>;
+    /** Physical C++ type mappings, keyed by `representationKey`. */
+    readonly physicalTypes: ReadonlySet<string>;
+    /**
+     * The predicate `physicalTypes` is the plan's projection of. Preflight
+     * asks about the carriers the plan selected, which the set enumerates;
+     * `ir/certify.ts` asks about every carrier the IR holds, including slot
+     * and conversion-result carriers the plan never selected, so it needs the
+     * predicate itself. Optional: a manifest without it is asked through the
+     * set, which is fail-closed for a carrier the set never saw.
+     */
+    readonly spellable?: (representation: Representation) => boolean;
+    /** Verifier recipes, keyed by `representationKey`. */
+    readonly verifierRecipes: ReadonlySet<string>;
+    /** Emitter recipes, keyed by `representationKey`. */
+    readonly emitterRecipes: ReadonlySet<string>;
+    /** Installed abrupt-completion handlers, keyed by completion kind. */
+    readonly abruptEdgeHandlers: ReadonlySet<string>;
+}
+export {};