@flighthq/tool-compiler 0.5.1-edge.1687.b63c819

package/LICENSE.md

@@ -0,0 +1,9 @@
+# MIT License
+
+Copyright (c) 2013-2026 Joshua Granick and other contributors
+
+Permission is hereby granted, free of charge, to any person obtaining a copy of this software and associated documentation files (the "Software"), to deal in the Software without restriction, including without limitation the rights to use, copy, modify, merge, publish, distribute, sublicense, and/or sell copies of the Software, and to permit persons to whom the Software is furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.

package/README.md

@@ -0,0 +1,74 @@
+# Flight Compiler
+
+`@flighthq/tool-compiler` is being built as the shared TypeScript compiler for mechanical ports of the [Flight SDK](https://github.com/flighthq/flight).
+
+The package's intended ownership is the complete source-compilation path:
+
+- Flight workspace, package, export-lane, and symbol analysis
+- normalized declaration fingerprints and source provenance
+- a target-neutral intermediate representation
+- deterministic, identity-based semantic patches and patch audits
+- coverage and API inventory models
+- compiler orchestration and target-backend infrastructure
+- concrete C++, Haxe, and Rust lowering and source emission
+
+[flight-hx](https://github.com/flighthq/flight-hx) is the first integration target; [flight-rs](https://github.com/flighthq/flight-rs) is the second. Those repositories retain their target ecosystem: runtime and standard-library support, project layout, examples, and integration tests. Compiler-owned target rules and emitters live here so both ports use one versioned toolchain.
+
+Development follows Flight's package-per-domain architecture. Private `@flighthq/compiler-*` workspaces isolate contracts, analysis, provenance, completion, patches, structural semantics, emission, target backends, and orchestration; the public `packages/tool-compiler` workspace assembles them into one self-contained artifact. The repository root is a private development workspace. Source trees are flat, contracts are centralized in `compiler-types`, and implementations use functions and plain data instead of classes.
+
+The architecture and health foundation are in place, but the current compiler is not yet a drop-in replacement for the generators in `flight-hx` or `flight-rs`. Work proceeds from the dependency floor described in [Compiler foundations](https://github.com/flighthq/flight-compiler/blob/main/agents/compiler-foundations.md); the [compiler migration roadmap](https://github.com/flighthq/flight-compiler/blob/main/agents/compiler-migration-roadmap.md) tracks the later parity and extraction sequence.
+
+## Install
+
+```sh
+npm install @flighthq/tool-compiler
+```
+
+The package is not published yet. During extraction, target repositories can install a packed local build after each target reaches its parity gate.
+
+## Usage
+
+Compile a directory directly. The C++ command elects the semantic `flight-cpp` runtime by default; `--runtime-profile standard-library` retains the provisional compatibility output.
+
+```sh
+flight-compile src --target cpp --out generated
+```
+
+Check a workspace without generating anything. `check` reads the workspace through the same inventory the compiler uses everywhere else -- the package manifests, their declared `flight.environment`, and their export lanes -- compiles the selected packages as one module graph, and writes no generated sources at all: the check capability record has no output directory. One graph rather than one run per package is what makes a refused dependency a cascade of the finding behind it instead of a second finding in every importer.
+
+It exits 0 when the run is admitted, 1 when a package introduces a finding that gates, and 2 when the invocation itself could not be carried out. The report itself comes from `compiler-check`: the findings, the policy class each one carries, and the dependency cascades. `--environment` is deliberately one per run: two environments have two profiles behind them, so checking both means two reports and two baselines.
+
+What a run checks depends on how it is asked. `--package` asks for exactly those packages, each pulling in the workspace packages it depends on, and a package whose closure needs an environment the run did not select is refused with the dependency path that shows why. With no `--package`, the run starts from the packages the workspace's own manifest depends on and keeps the maximal dependency-closed subset those roots allow under the selected environment -- an unmarked package is compatible with every environment, so selecting one adds the packages that declare it. A root left out that way is summarized on the verdict line and is not a finding: nothing was compiled for it, so there is nothing the compiler refused. A workspace that declares none of its own packages as a dependency is treated as its own root set. `--baseline` compares findings against the JSON baseline `createCompilerPackageCheckBaseline` writes, and never rewrites it -- there is deliberately no baseline-update action in the same invocation. A baseline that is absent, malformed, or of another schema is an invocation failure rather than a run that compares against nothing. `--report` writes the report to a file while the stream keeps the one-line verdict. The refusal's own producer classifies it: the strict policy gates an introduced `compiler-restriction`, `source-portability`, or `unclassified` finding and reports `target-runtime` and `compiler-defect` findings without gating on them -- a `RegExp` the runtime has to supply is not the compiler's to fix. The run records the revision of the workspace it read from that workspace's own Git checkout, and says `unversioned` for a workspace that is not one and for the compiler and target revisions it cannot read.
+
+```sh
+flight-compile check <workspace> --target cpp [--environment web] [--baseline check.baseline] [--format json]
+```
+
+Programmatic package and workspace compilation uses `compileTypeScriptPackageGraph`. Its versioned graph names package roots, declared package dependencies, entry modules, and exact importer-to-module edges. The result contains normalized output, a deterministic per-module refusal ledger, source-to-output ownership, required include paths, and the module initialization plan. C++ callers can supply `packageTargets` and `externalBindings` without adding SDL, Dawn, native GL, or another host SDK to the compiler.
+
+See [C++ package compilation](https://github.com/flighthq/flight-compiler/blob/main/docs/cpp-package-compilation.md) for the request and downstream boundary.
+
+```ts
+import { analyzeFlightWorkspace } from '@flighthq/tool-compiler';
+
+const inventory = analyzeFlightWorkspace({
+  upstreamDirectory: '/path/to/flight',
+});
+```
+
+The upstream directory must be an initialized Flight Git checkout. Analysis is read-only and deterministic for a fixed checkout and compiler version.
+
+## Development
+
+```sh
+npm install
+npm run fix
+npm run check
+npm run test
+```
+
+`npm run check` runs the static correctness gates, while `npm run test` runs the unit suite without coverage instrumentation. `npm run verify` is the explicit full sweep for CI and releases: it adds isolated-package tests, coverage ratchets, emitted-source compilation, behavioral oracles, and package assembly. See the repository [AGENTS.md](https://github.com/flighthq/flight-compiler/blob/main/AGENTS.md) for architecture and contribution rules.
+
+## License
+
+[MIT](LICENSE.md)

package/dist/packages/compiler-ambient/src/compilerAmbientSurface.d.ts

@@ -0,0 +1,3 @@
+export declare function createCompilerAmbientSurfaceSource(): string;
+export declare function getCompilerAmbientSurfaceFileName(): string;
+//# sourceMappingURL=compilerAmbientSurface.d.ts.map

package/dist/packages/compiler-ambient/src/compilerAmbientSurface.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"compilerAmbientSurface.d.ts","sourceRoot":"","sources":["../../../../../compiler-ambient/src/compilerAmbientSurface.ts"],"names":[],"mappings":"AAaA,wBAAgB,kCAAkC,IAAI,MAAM,CAE3D;AAKD,wBAAgB,iCAAiC,IAAI,MAAM,CAE1D"}

package/dist/packages/compiler-ambient/src/compilerAmbientSurface.js

@@ -0,0 +1,564 @@
+// The ambient surface generated code may assume, described in TypeScript so the analysis checker can
+// type ordinary source against it.
+//
+// This is the other projection of what the backends' runtime binding tables already name. A table
+// says `Promise` becomes `FlightTask`; this says what `Promise` has on it. Without the second half
+// the checker cannot type a callback parameter, cannot say what `join` returns, and every operator
+// over those values collapses to unknown — which is the difference between compiling a library whose
+// every type is written out and compiling ordinary application code.
+//
+// Authored here rather than taken from a published library definition: the repository does not carry
+// third-party definition files, and a surface this compiler must bind member by member is better
+// stated deliberately than inherited wholesale. It is intentionally smaller than the language's real
+// library — a member absent here is a member the compiler has not decided how to lower.
+export function createCompilerAmbientSurfaceSource() {
+    return ambientSurfaceSource;
+}
+// The file the surface is presented to the checker as. A node reached through it does not belong to
+// the module being lowered, and every reader that walks back to a declaration compares against this
+// to tell.
+export function getCompilerAmbientSurfaceFileName() {
+    return ambientSurfaceFileName;
+}
+const ambientSurfaceSource = `
+interface Object {}
+interface ObjectConstructor {
+  assign<Target extends object, Source extends object>(target: Target, source: Source): Target & Source;
+  entries(value: object): [string, unknown][];
+  is(left: unknown, right: unknown): boolean;
+  keys(value: object): string[];
+}
+declare var Object: ObjectConstructor;
+interface Function {}
+interface IArguments {}
+interface RegExp {
+  exec(value: string): RegExpExecArray | null;
+  test(value: string): boolean;
+}
+interface RegExpExecArray extends Array<string> {
+  readonly index: number;
+  readonly input: string;
+}
+interface RegExpConstructor {
+  new (pattern: string | RegExp, flags?: string): RegExp;
+}
+declare var RegExp: RegExpConstructor;
+
+interface Boolean {}
+
+interface Number {
+  toFixed(digits?: number): string;
+  toString(radix?: number): string;
+}
+
+interface NumberConstructor {
+  (value?: unknown): number;
+  readonly EPSILON: number;
+  readonly MAX_SAFE_INTEGER: number;
+  readonly MIN_SAFE_INTEGER: number;
+  readonly NaN: number;
+  isFinite(value: number): boolean;
+  isInteger(value: number): boolean;
+  isNaN(value: number): boolean;
+  parseFloat(value: string): number;
+  parseInt(value: string, radix?: number): number;
+}
+declare var Number: NumberConstructor;
+declare function parseInt(value: string, radix?: number): number;
+
+interface String {
+  readonly length: number;
+  charAt(index: number): string;
+  charCodeAt(index: number): number;
+  concat(...values: string[]): string;
+  endsWith(search: string): boolean;
+  includes(search: string): boolean;
+  indexOf(search: string, position?: number): number;
+  lastIndexOf(search: string, position?: number): number;
+  padStart(length: number, fill?: string): string;
+  repeat(count: number): string;
+  replace(search: string, replacement: string): string;
+  replace(search: RegExp, replacement: string): string;
+  replace(search: RegExp, replacement: (...values: string[]) => string): string;
+  match(expression: RegExp): RegExpExecArray | null;
+  slice(start?: number, end?: number): string;
+  split(separator: string): string[];
+  startsWith(search: string): boolean;
+  substring(start: number, end?: number): string;
+  toLowerCase(): string;
+  toUpperCase(): string;
+  trim(): string;
+}
+
+interface StringConstructor {
+  fromCharCode(...codes: number[]): string;
+  fromCodePoint(...codePoints: number[]): string;
+}
+declare var String: StringConstructor;
+
+interface ReadonlyArray<T> {
+  readonly length: number;
+  readonly [index: number]: T;
+  concat(...values: readonly T[][]): T[];
+  every(predicate: (value: T, index: number) => boolean): boolean;
+  filter(predicate: (value: T, index: number) => boolean): T[];
+  flatMap<U>(project: (value: T, index: number) => U[]): U[];
+  find(predicate: (value: T, index: number) => boolean): T | undefined;
+  findIndex(predicate: (value: T, index: number) => boolean): number;
+  forEach(visit: (value: T, index: number) => void): void;
+  includes(value: T): boolean;
+  indexOf(value: T): number;
+  join(separator?: string): string;
+  lastIndexOf(value: T): number;
+  map<U>(project: (value: T, index: number) => U): U[];
+  reduce<U>(fold: (accumulated: U, value: T, index: number) => U, initial: U): U;
+  slice(start?: number, end?: number): T[];
+  some(predicate: (value: T, index: number) => boolean): boolean;
+  [Symbol.iterator](): Iterator<T>;
+}
+
+interface Array<T> {
+  length: number;
+  [index: number]: T;
+  concat(...values: readonly T[][]): T[];
+  every(predicate: (value: T, index: number) => boolean): boolean;
+  fill(value: T, start?: number, end?: number): T[];
+  filter(predicate: (value: T, index: number) => boolean): T[];
+  flatMap<U>(project: (value: T, index: number) => U[]): U[];
+  find(predicate: (value: T, index: number) => boolean): T | undefined;
+  findIndex(predicate: (value: T, index: number) => boolean): number;
+  forEach(visit: (value: T, index: number) => void): void;
+  includes(value: T): boolean;
+  indexOf(value: T): number;
+  join(separator?: string): string;
+  lastIndexOf(value: T): number;
+  map<U>(project: (value: T, index: number) => U): U[];
+  pop(): T | undefined;
+  push(...values: T[]): number;
+  reduce<U>(fold: (accumulated: U, value: T, index: number) => U, initial: U): U;
+  reverse(): T[];
+  shift(): T | undefined;
+  slice(start?: number, end?: number): T[];
+  some(predicate: (value: T, index: number) => boolean): boolean;
+  sort(compare?: (left: T, right: T) => number): T[];
+  splice(start: number, count?: number, ...items: T[]): T[];
+  unshift(...values: T[]): number;
+  [Symbol.iterator](): Iterator<T>;
+}
+
+interface ArrayConstructor {
+  new <T>(length?: number): T[];
+  isArray(value: unknown): boolean;
+  of<T>(...values: T[]): T[];
+}
+declare var Array: ArrayConstructor;
+
+interface Iterator<T> {
+  next(): { done?: boolean; value: T };
+}
+
+interface Iterable<T> {
+  [Symbol.iterator](): Iterator<T>;
+}
+
+interface IterableIterator<T> extends Iterator<T> {
+  [Symbol.iterator](): IterableIterator<T>;
+}
+
+interface SymbolConstructor {
+  for(key: string): symbol;
+  readonly iterator: unique symbol;
+}
+declare var Symbol: SymbolConstructor;
+
+interface Math {
+  readonly E: number;
+  readonly PI: number;
+  abs(value: number): number;
+  asin(value: number): number;
+  ceil(value: number): number;
+  cos(value: number): number;
+  exp(value: number): number;
+  floor(value: number): number;
+  log(value: number): number;
+  max(...values: number[]): number;
+  min(...values: number[]): number;
+  pow(base: number, exponent: number): number;
+  round(value: number): number;
+  sign(value: number): number;
+  sin(value: number): number;
+  sqrt(value: number): number;
+  trunc(value: number): number;
+}
+declare var Math: Math;
+
+interface Error {
+  message: string;
+  name: string;
+}
+
+interface ErrorConstructor {
+  new (message?: string): Error;
+}
+declare var Error: ErrorConstructor;
+
+interface PromiseLike<T> {
+  then<U>(onValue: (value: T) => U | PromiseLike<U>, onError?: (error: unknown) => U | PromiseLike<U>): PromiseLike<U>;
+}
+
+interface Promise<T> {
+  catch(onError: (error: unknown) => T | PromiseLike<T>): Promise<T>;
+  finally(onSettled: () => void): Promise<T>;
+  then<U>(onValue: (value: T) => U | PromiseLike<U>, onError?: (error: unknown) => U | PromiseLike<U>): Promise<U>;
+}
+
+interface PromiseConstructor {
+  new <T>(executor: (resolve: (value: T) => void, reject: (error: unknown) => void) => void): Promise<T>;
+  all<T>(tasks: readonly Promise<T>[]): Promise<T[]>;
+  reject<T>(error: unknown): Promise<T>;
+  resolve<T>(value: T): Promise<T>;
+}
+declare var Promise: PromiseConstructor;
+
+interface Map<K, V> {
+  readonly size: number;
+  clear(): void;
+  delete(key: K): boolean;
+  forEach(visit: (value: V, key: K) => void): void;
+  get(key: K): V | undefined;
+  has(key: K): boolean;
+  set(key: K, value: V): Map<K, V>;
+  [Symbol.iterator](): Iterator<readonly [K, V]>;
+}
+
+interface MapConstructor {
+  new <K, V>(entries?: readonly (readonly [K, V])[]): Map<K, V>;
+}
+declare var Map: MapConstructor;
+
+interface WeakMap<K extends object, V> {
+  delete(key: K): boolean;
+  get(key: K): V | undefined;
+  has(key: K): boolean;
+  set(key: K, value: V): WeakMap<K, V>;
+}
+
+interface WeakMapConstructor {
+  new <K extends object, V>(entries?: readonly (readonly [K, V])[]): WeakMap<K, V>;
+}
+declare var WeakMap: WeakMapConstructor;
+
+interface Set<T> {
+  readonly size: number;
+  add(value: T): Set<T>;
+  clear(): void;
+  delete(value: T): boolean;
+  forEach(visit: (value: T) => void): void;
+  has(value: T): boolean;
+  [Symbol.iterator](): Iterator<T>;
+}
+
+interface SetConstructor {
+  new <T>(values?: readonly T[]): Set<T>;
+}
+declare var Set: SetConstructor;
+
+interface Date {
+  getDate(): number;
+  getDay(): number;
+  getFullYear(): number;
+  getHours(): number;
+  getMilliseconds(): number;
+  getMinutes(): number;
+  getMonth(): number;
+  getSeconds(): number;
+  getTime(): number;
+  toISOString(): string;
+  toString(): string;
+}
+
+interface DateConstructor {
+  new (): Date;
+  new (value: number): Date;
+  now(): number;
+}
+declare var Date: DateConstructor;
+
+interface JSON {
+  parse(text: string): unknown;
+  stringify(value: unknown, replacer?: unknown, space?: number | string): string;
+}
+declare var JSON: JSON;
+
+interface ArrayBuffer {
+  readonly byteLength: number;
+}
+interface ArrayBufferConstructor {
+  new (byteLength: number): ArrayBuffer;
+}
+declare var ArrayBuffer: ArrayBufferConstructor;
+
+interface DataView {
+  readonly buffer: ArrayBuffer;
+  readonly byteLength: number;
+  readonly byteOffset: number;
+  getFloat32(byteOffset: number, littleEndian?: boolean): number;
+  getFloat64(byteOffset: number, littleEndian?: boolean): number;
+  getInt8(byteOffset: number): number;
+  getInt16(byteOffset: number, littleEndian?: boolean): number;
+  getInt32(byteOffset: number, littleEndian?: boolean): number;
+  getUint8(byteOffset: number): number;
+  getUint16(byteOffset: number, littleEndian?: boolean): number;
+  getUint32(byteOffset: number, littleEndian?: boolean): number;
+  setFloat32(byteOffset: number, value: number, littleEndian?: boolean): void;
+  setFloat64(byteOffset: number, value: number, littleEndian?: boolean): void;
+  setInt8(byteOffset: number, value: number): void;
+  setInt16(byteOffset: number, value: number, littleEndian?: boolean): void;
+  setInt32(byteOffset: number, value: number, littleEndian?: boolean): void;
+  setUint8(byteOffset: number, value: number): void;
+  setUint16(byteOffset: number, value: number, littleEndian?: boolean): void;
+  setUint32(byteOffset: number, value: number, littleEndian?: boolean): void;
+}
+interface DataViewConstructor {
+  new (buffer: ArrayBuffer, byteOffset?: number, byteLength?: number): DataView;
+}
+declare var DataView: DataViewConstructor;
+
+interface TextDecoder {
+  decode(input?: Uint8Array): string;
+}
+interface TextDecoderConstructor {
+  new (): TextDecoder;
+}
+declare var TextDecoder: TextDecoderConstructor;
+
+interface URL {
+  readonly origin: string;
+  readonly protocol: string;
+}
+interface URLConstructor {
+  new (url: string, base?: string | URL): URL;
+}
+declare var URL: URLConstructor;
+
+declare namespace Intl {
+  interface CollatorOptions {}
+  class Collator {
+    constructor(locales?: string | string[], options?: CollatorOptions);
+    compare(left: string, right: string): number;
+  }
+  interface DateTimeFormatOptions {}
+  class DateTimeFormat {
+    constructor(locales?: string | string[], options?: DateTimeFormatOptions);
+    format(value: Date | number): string;
+  }
+  interface ListFormatOptions {}
+  class ListFormat {
+    constructor(locales?: string | string[], options?: ListFormatOptions);
+    format(value: string[]): string;
+  }
+  type LDMLPluralRule = 'zero' | 'one' | 'two' | 'few' | 'many' | 'other';
+  interface NumberFormatOptions {}
+  class NumberFormat {
+    constructor(locales?: string | string[], options?: NumberFormatOptions);
+    format(value: number): string;
+  }
+  interface PluralRulesOptions {}
+  class PluralRules {
+    constructor(locales?: string | string[], options?: PluralRulesOptions);
+    select(value: number): LDMLPluralRule;
+  }
+  interface RelativeTimeFormatOptions {}
+  type RelativeTimeFormatUnit = 'year' | 'quarter' | 'month' | 'week' | 'day' | 'hour' | 'minute' | 'second';
+  class RelativeTimeFormat {
+    constructor(locales?: string | string[], options?: RelativeTimeFormatOptions);
+    format(value: number, unit: RelativeTimeFormatUnit): string;
+  }
+}
+
+interface Console {
+  error(...values: unknown[]): void;
+  log(...values: unknown[]): void;
+  warn(...values: unknown[]): void;
+}
+declare var console: Console;
+
+interface Int8Array {
+  readonly buffer: ArrayBuffer;
+  readonly byteLength: number;
+  readonly byteOffset: number;
+  readonly length: number;
+  [index: number]: number;
+  fill(value: number, start?: number, end?: number): Int8Array;
+  slice(begin?: number, end?: number): Int8Array;
+  subarray(begin?: number, end?: number): Int8Array;
+}
+
+interface Int8ArrayConstructor {
+  new (): Int8Array;
+  new (length: number): Int8Array;
+  new (array: number[]): Int8Array;
+  new (buffer: ArrayBuffer): Int8Array;
+}
+declare var Int8Array: Int8ArrayConstructor;
+
+interface Uint8Array {
+  readonly buffer: ArrayBuffer;
+  readonly byteLength: number;
+  readonly byteOffset: number;
+  readonly length: number;
+  [index: number]: number;
+  fill(value: number, start?: number, end?: number): Uint8Array;
+  slice(begin?: number, end?: number): Uint8Array;
+  subarray(begin?: number, end?: number): Uint8Array;
+}
+
+interface Uint8ArrayConstructor {
+  new (): Uint8Array;
+  new (length: number): Uint8Array;
+  new (array: number[]): Uint8Array;
+  new (buffer: ArrayBuffer): Uint8Array;
+}
+declare var Uint8Array: Uint8ArrayConstructor;
+
+interface Uint8ClampedArray {
+  readonly buffer: ArrayBuffer;
+  readonly byteLength: number;
+  readonly byteOffset: number;
+  readonly length: number;
+  [index: number]: number;
+  fill(value: number, start?: number, end?: number): Uint8ClampedArray;
+  slice(begin?: number, end?: number): Uint8ClampedArray;
+  subarray(begin?: number, end?: number): Uint8ClampedArray;
+}
+
+interface Uint8ClampedArrayConstructor {
+  new (): Uint8ClampedArray;
+  new (length: number): Uint8ClampedArray;
+  new (array: number[]): Uint8ClampedArray;
+  new (buffer: ArrayBuffer): Uint8ClampedArray;
+}
+declare var Uint8ClampedArray: Uint8ClampedArrayConstructor;
+
+interface Int16Array {
+  readonly buffer: ArrayBuffer;
+  readonly byteLength: number;
+  readonly byteOffset: number;
+  readonly length: number;
+  [index: number]: number;
+  fill(value: number, start?: number, end?: number): Int16Array;
+  slice(begin?: number, end?: number): Int16Array;
+  subarray(begin?: number, end?: number): Int16Array;
+}
+
+interface Int16ArrayConstructor {
+  new (): Int16Array;
+  new (length: number): Int16Array;
+  new (array: number[]): Int16Array;
+  new (buffer: ArrayBuffer): Int16Array;
+}
+declare var Int16Array: Int16ArrayConstructor;
+
+interface Uint16Array {
+  readonly buffer: ArrayBuffer;
+  readonly byteLength: number;
+  readonly byteOffset: number;
+  readonly length: number;
+  [index: number]: number;
+  fill(value: number, start?: number, end?: number): Uint16Array;
+  slice(begin?: number, end?: number): Uint16Array;
+  subarray(begin?: number, end?: number): Uint16Array;
+}
+
+interface Uint16ArrayConstructor {
+  new (): Uint16Array;
+  new (length: number): Uint16Array;
+  new (array: number[]): Uint16Array;
+  new (buffer: ArrayBuffer): Uint16Array;
+}
+declare var Uint16Array: Uint16ArrayConstructor;
+
+interface Int32Array {
+  readonly buffer: ArrayBuffer;
+  readonly byteLength: number;
+  readonly byteOffset: number;
+  readonly length: number;
+  [index: number]: number;
+  fill(value: number, start?: number, end?: number): Int32Array;
+  slice(begin?: number, end?: number): Int32Array;
+  subarray(begin?: number, end?: number): Int32Array;
+}
+
+interface Int32ArrayConstructor {
+  new (): Int32Array;
+  new (length: number): Int32Array;
+  new (array: number[]): Int32Array;
+  new (buffer: ArrayBuffer): Int32Array;
+}
+declare var Int32Array: Int32ArrayConstructor;
+
+interface Uint32Array {
+  readonly buffer: ArrayBuffer;
+  readonly byteLength: number;
+  readonly byteOffset: number;
+  readonly length: number;
+  [index: number]: number;
+  fill(value: number, start?: number, end?: number): Uint32Array;
+  slice(begin?: number, end?: number): Uint32Array;
+  subarray(begin?: number, end?: number): Uint32Array;
+}
+
+interface Uint32ArrayConstructor {
+  new (): Uint32Array;
+  new (length: number): Uint32Array;
+  new (array: number[]): Uint32Array;
+  new (buffer: ArrayBuffer): Uint32Array;
+}
+declare var Uint32Array: Uint32ArrayConstructor;
+
+interface Float32Array {
+  readonly buffer: ArrayBuffer;
+  readonly byteLength: number;
+  readonly byteOffset: number;
+  readonly length: number;
+  [index: number]: number;
+  fill(value: number, start?: number, end?: number): Float32Array;
+  slice(begin?: number, end?: number): Float32Array;
+  subarray(begin?: number, end?: number): Float32Array;
+}
+
+interface Float32ArrayConstructor {
+  new (): Float32Array;
+  new (length: number): Float32Array;
+  new (array: number[]): Float32Array;
+  new (buffer: ArrayBuffer): Float32Array;
+}
+declare var Float32Array: Float32ArrayConstructor;
+
+interface Float64Array {
+  readonly buffer: ArrayBuffer;
+  readonly byteLength: number;
+  readonly byteOffset: number;
+  readonly length: number;
+  [index: number]: number;
+  fill(value: number, start?: number, end?: number): Float64Array;
+  slice(begin?: number, end?: number): Float64Array;
+  subarray(begin?: number, end?: number): Float64Array;
+}
+
+interface Float64ArrayConstructor {
+  new (): Float64Array;
+  new (length: number): Float64Array;
+  new (array: number[]): Float64Array;
+  new (buffer: ArrayBuffer): Float64Array;
+}
+declare var Float64Array: Float64ArrayConstructor;
+
+// The mapped and conditional type aliases the language provides — \`Partial\`, \`Record\`, \`Pick\` and
+// their relatives — are deliberately absent. The backends already recognise them by name as ambient
+// references and decide a spelling from that; declaring them here would make the checker resolve
+// them to mapped types the neutral model does not carry, and a declaration that mentions one would
+// stop lowering. A surface entry is only worth adding once something can lower what it resolves to.
+`;
+const ambientSurfaceFileName = '/flight-compiler/ambient-surface.d.ts';
+//# sourceMappingURL=compilerAmbientSurface.js.map

package/dist/packages/compiler-ambient/src/compilerAmbientSurface.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"compilerAmbientSurface.js","sourceRoot":"","sources":["../../../../../compiler-ambient/src/compilerAmbientSurface.ts"],"names":[],"mappings":"AAAA,qGAAqG;AACrG,mCAAmC;AACnC,EAAE;AACF,kGAAkG;AAClG,mGAAmG;AACnG,mGAAmG;AACnG,qGAAqG;AACrG,qEAAqE;AACrE,EAAE;AACF,qGAAqG;AACrG,iGAAiG;AACjG,qGAAqG;AACrG,wFAAwF;AACxF,MAAM,UAAU,kCAAkC;IAChD,OAAO,oBAAoB,CAAC;AAC9B,CAAC;AAED,oGAAoG;AACpG,oGAAoG;AACpG,WAAW;AACX,MAAM,UAAU,iCAAiC;IAC/C,OAAO,sBAAsB,CAAC;AAChC,CAAC;AAED,MAAM,oBAAoB,GAAG;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;CA2hB5B,CAAC;AAEF,MAAM,sBAAsB,GAAG,uCAAuC,CAAC"}

package/dist/packages/compiler-ambient/src/index.d.ts

@@ -0,0 +1,2 @@
+export { createCompilerAmbientSurfaceSource, getCompilerAmbientSurfaceFileName } from './compilerAmbientSurface.js';
+//# sourceMappingURL=index.d.ts.map

package/dist/packages/compiler-ambient/src/index.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../../../../compiler-ambient/src/index.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,kCAAkC,EAAE,iCAAiC,EAAE,MAAM,6BAA6B,CAAC"}

package/dist/packages/compiler-ambient/src/index.js

@@ -0,0 +1,2 @@
+export { createCompilerAmbientSurfaceSource, getCompilerAmbientSurfaceFileName } from './compilerAmbientSurface.js';
+//# sourceMappingURL=index.js.map

package/dist/packages/compiler-ambient/src/index.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.js","sourceRoot":"","sources":["../../../../../compiler-ambient/src/index.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,kCAAkC,EAAE,iCAAiC,EAAE,MAAM,6BAA6B,CAAC"}

package/dist/packages/compiler-backend-cpp/src/cppAmbientMemberBinding.d.ts

@@ -0,0 +1,3 @@
+import type { CompilerCppAmbientMemberBinding, CppCompilerRuntimeProfile, IrResolvedMember } from '../../compiler-types/src/index.js';
+export declare function getCompilerCppAmbientMemberBinding(member: Readonly<IrResolvedMember>, runtimeProfile?: CppCompilerRuntimeProfile): CompilerCppAmbientMemberBinding | undefined;
+//# sourceMappingURL=cppAmbientMemberBinding.d.ts.map