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

package/dist/packages/compiler-backend-cpp/src/cppRuntimeExternalSymbolBinding.js

@@ -0,0 +1,1060 @@
+export function createCompilerRuntimeExternalSymbolBindingPlanCpp(runtimeProfile = 'standard-library', externalBindings) {
+    return {
+        bindings: getCppRuntimeExternalSymbolBindings(runtimeProfile, externalBindings).map((binding) => binding.kind === 'runtime'
+            ? {
+                capability: binding.capability,
+                externalSymbol: { sourceName: binding.sourceName, space: binding.space },
+                kind: binding.kind,
+            }
+            : {
+                externalSymbol: { sourceName: binding.sourceName, space: binding.space },
+                kind: binding.kind,
+            }),
+        contract: 'flight-runtime-contract/2',
+    };
+}
+export function getCompilerExternalBindingCallResultAbsenceCpp(sourceName, externalBindings) {
+    return getCppCompilerExternalBindings(externalBindings).find((binding) => binding.sourceName === sourceName.normalize('NFC') && binding.space === 'value')?.callResultAbsence;
+}
+export function getCompilerExternalBindingCallResultTypeCpp(sourceName, externalBindings) {
+    return getCppCompilerExternalBindings(externalBindings).find((binding) => binding.sourceName === sourceName.normalize('NFC') && binding.space === 'value')?.callResultType;
+}
+export function getCompilerExternalBindingConstructionCpp(sourceName, externalBindings) {
+    return getCppCompilerExternalBindings(externalBindings).find((binding) => binding.sourceName === sourceName.normalize('NFC') && binding.space === 'value')?.construction;
+}
+export function getCompilerExternalBindingEvidenceCpp(sourceName, space, externalBindings) {
+    const binding = getCppCompilerExternalBindings(externalBindings).find((candidate) => candidate.sourceName === sourceName.normalize('NFC') && candidate.space === space);
+    return binding
+        ? Object.freeze({
+            nullability: binding.nullability,
+            ownership: binding.ownership,
+            sourceName: binding.sourceName,
+            space: binding.space,
+            targetName: binding.targetName,
+        })
+        : undefined;
+}
+export function getCompilerExternalBindingHeadersCpp(sourceName, space, externalBindings, runtimeProfile = 'standard-library') {
+    return (getCppRuntimeExternalSymbolBindings(runtimeProfile, externalBindings).find((binding) => binding.sourceName === sourceName.normalize('NFC') && binding.space === space)?.headers ?? []);
+}
+export function getCompilerExternalBindingNumericPropertyViewCpp(sourceName, externalBindings) {
+    const binding = getCppCompilerExternalBindings(externalBindings).find((candidate) => candidate.sourceName === sourceName.normalize('NFC') && candidate.space === 'type');
+    return binding?.numericPropertyView ? Object.freeze({ ...binding.numericPropertyView }) : undefined;
+}
+export function getCompilerExternalBindingObjectConstructionCpp(sourceName, externalBindings) {
+    const binding = getCppCompilerExternalBindings(externalBindings).find((candidate) => candidate.sourceName === sourceName.normalize('NFC') && candidate.space === 'type');
+    return binding?.objectConstruction
+        ? Object.freeze({ ...binding.objectConstruction, targetName: binding.targetName })
+        : undefined;
+}
+export function getCompilerExternalBindingWeakKeyPolicyTargetCpp(sourceName, externalBindings) {
+    return getCppCompilerExternalBindings(externalBindings).find((binding) => binding.sourceName === sourceName.normalize('NFC') && binding.space === 'type')?.weakKeyPolicyTargetName;
+}
+export function getCompilerRuntimeExternalInstanceMemberCallResultAbsenceCpp(sourceName, member, runtimeProfile = 'standard-library', externalBindings) {
+    const normalized = sourceName.normalize('NFC');
+    const binding = getCppRuntimeExternalSymbolBindings(runtimeProfile, externalBindings).find((candidate) => candidate.sourceName === normalized && candidate.space === 'type');
+    return binding?.members?.find((candidate) => candidate.sourceMember === member.normalize('NFC'))?.callResultAbsence;
+}
+export function getCompilerRuntimeExternalInstanceMemberCallResultTypeCpp(sourceName, member, runtimeProfile = 'standard-library', externalBindings) {
+    const normalized = sourceName.normalize('NFC');
+    const binding = getCppRuntimeExternalSymbolBindings(runtimeProfile, externalBindings).find((candidate) => candidate.sourceName === normalized && candidate.space === 'type');
+    return binding?.members?.find((candidate) => candidate.sourceMember === member.normalize('NFC'))?.callResultType;
+}
+export function getCompilerRuntimeExternalInstanceMemberCpp(typeSourceName, member, runtimeProfile = 'standard-library', externalBindings) {
+    const normalized = typeSourceName.normalize('NFC');
+    const memberName = member.normalize('NFC');
+    const bindings = getCppRuntimeExternalSymbolBindings(runtimeProfile, externalBindings);
+    const typeBindings = bindings.filter((candidate) => candidate.sourceName === normalized && candidate.space === 'type');
+    if (typeBindings.length === 0)
+        return undefined;
+    if (typeBindings.length > 1)
+        return { kind: 'ambiguous' };
+    const declared = typeBindings[0].members?.filter((entry) => entry.sourceMember === memberName) ?? [];
+    if (declared.length > 1)
+        return { kind: 'ambiguous' };
+    const entry = declared[0];
+    if (!entry) {
+        const valueSpace = bindings.some((candidate) => candidate.sourceName === normalized &&
+            candidate.space === 'value' &&
+            candidate.members?.some((candidateEntry) => candidateEntry.sourceMember === memberName));
+        return valueSpace ? { kind: 'wrongSpace' } : undefined;
+    }
+    const declaresPropertyResult = entry.propertyResultType !== undefined || entry.propertyOwnership !== undefined;
+    if (!declaresPropertyResult)
+        return { kind: 'callable', targetName: entry.targetName };
+    // A declaration that names one half of the property result and not the other is incomplete: the read
+    // needs both the type and the storage, and a half-declared member is a profile that meant to opt in.
+    if (entry.propertyResultType === undefined || entry.propertyOwnership === undefined)
+        return { kind: 'incomplete' };
+    // The storage the profile named: a shared result is held by reference, a value result by itself, and a
+    // nullable result wraps whichever of those in an optional. Nothing else is spelled here, so an
+    // ownership this does not know keeps the read incomplete rather than inventing a wrapper.
+    const storage = entry.propertyOwnership === 'shared' ? `flight::Ref<${entry.propertyResultType}>` : entry.propertyResultType;
+    return {
+        kind: 'resolved',
+        storageType: entry.propertyNullability === 'nullable' ? `std::optional<${storage}>` : storage,
+        targetName: entry.targetName,
+    };
+}
+export function getCompilerRuntimeExternalInstanceMemberParameterTypeCpp(sourceName, member, position, runtimeProfile = 'standard-library', externalBindings) {
+    const normalized = sourceName.normalize('NFC');
+    const binding = getCppRuntimeExternalSymbolBindings(runtimeProfile, externalBindings).find((candidate) => candidate.sourceName === normalized && candidate.space === 'type');
+    return binding?.members
+        ?.find((candidate) => candidate.sourceMember === member.normalize('NFC'))
+        ?.parameters?.find((parameter) => parameter.position === position)?.sourceType;
+}
+export function getCompilerRuntimeExternalInstanceMemberTargetCpp(sourceName, member, runtimeProfile = 'standard-library', externalBindings) {
+    const normalized = sourceName.normalize('NFC');
+    const binding = getCppRuntimeExternalSymbolBindings(runtimeProfile, externalBindings).find((candidate) => candidate.sourceName === normalized && candidate.space === 'type');
+    if (!binding)
+        return undefined;
+    return binding.members?.find((candidate) => candidate.sourceMember === member.normalize('NFC'))?.targetName;
+}
+export function getCompilerRuntimeExternalMemberCallResultAbsenceCpp(sourceName, member, runtimeProfile = 'standard-library', externalBindings) {
+    const normalized = sourceName.normalize('NFC');
+    const binding = getCppRuntimeExternalSymbolBindings(runtimeProfile, externalBindings).find((candidate) => candidate.sourceName === normalized && candidate.space === 'value');
+    return binding?.members?.find((candidate) => candidate.sourceMember === member.normalize('NFC'))?.callResultAbsence;
+}
+export function getCompilerRuntimeExternalMemberCallResultTypeCpp(sourceName, member, runtimeProfile = 'standard-library', externalBindings) {
+    const normalized = sourceName.normalize('NFC');
+    const binding = getCppRuntimeExternalSymbolBindings(runtimeProfile, externalBindings).find((candidate) => candidate.sourceName === normalized && candidate.space === 'value');
+    return binding?.members?.find((candidate) => candidate.sourceMember === member.normalize('NFC'))?.callResultType;
+}
+export function getCompilerRuntimeExternalMemberRecordConversionCpp(receiverSourceName, member, runtimeProfile = 'standard-library', externalBindings) {
+    const normalized = receiverSourceName.normalize('NFC');
+    const memberName = member.normalize('NFC');
+    const bindings = getCppRuntimeExternalSymbolBindings(runtimeProfile, externalBindings).filter((candidate) => candidate.sourceName === normalized);
+    const typeBindings = bindings.filter((candidate) => candidate.space === 'type');
+    const declarations = bindings.flatMap((binding) => (binding.members ?? [])
+        .filter((candidate) => candidate.sourceMember === memberName)
+        .map((candidate) => ({ binding, member: candidate })));
+    if (typeBindings.length > 1 || declarations.length > 1)
+        return { kind: 'ambiguous' };
+    if (declarations[0]?.binding.space === 'value')
+        return { kind: 'wrongSpace' };
+    const binding = typeBindings[0];
+    if (!binding)
+        return { kind: 'missing' };
+    const declaration = binding.members?.find((candidate) => candidate.sourceMember === memberName);
+    if (binding.kind !== 'native' || !declaration?.callResultType || !declaration.recordConversion) {
+        return { kind: 'incomplete' };
+    }
+    return Object.freeze({
+        conversion: Object.freeze({ ...declaration.recordConversion }),
+        kind: 'resolved',
+        resultType: declaration.callResultType,
+    });
+}
+export function getCompilerRuntimeExternalMemberTargetCpp(sourceName, member, runtimeProfile = 'standard-library', externalBindings) {
+    const normalized = sourceName.normalize('NFC');
+    const binding = getCppRuntimeExternalSymbolBindings(runtimeProfile, externalBindings).find((candidate) => candidate.sourceName === normalized && candidate.space === 'value');
+    if (!binding)
+        return undefined;
+    return binding.members?.find((candidate) => candidate.sourceMember === member.normalize('NFC'))?.targetName;
+}
+export function getCompilerRuntimeExternalSymbolCallResultAbsenceCpp(sourceName, runtimeProfile = 'standard-library', externalBindings) {
+    const normalized = sourceName.normalize('NFC');
+    return getCppRuntimeExternalSymbolBindings(runtimeProfile, externalBindings).find((candidate) => candidate.sourceName === normalized && candidate.space === 'value')?.callResultAbsence;
+}
+export function getCompilerRuntimeExternalSymbolCallResultTypeCpp(sourceName, runtimeProfile = 'standard-library', externalBindings) {
+    const normalized = sourceName.normalize('NFC');
+    return getCppRuntimeExternalSymbolBindings(runtimeProfile, externalBindings).find((candidate) => candidate.sourceName === normalized && candidate.space === 'value')?.callResultType;
+}
+export function getCompilerRuntimeExternalSymbolTargetCpp(sourceName, space, runtimeProfile = 'standard-library', externalBindings) {
+    const normalized = sourceName.normalize('NFC');
+    return getCppRuntimeExternalSymbolBindings(runtimeProfile, externalBindings).find((candidate) => candidate.sourceName === normalized && candidate.space === space)?.targetName;
+}
+export function isCompilerRuntimeExternalSymbolProvidedCpp(sourceName, space, runtimeProfile = 'standard-library', externalBindings) {
+    const normalized = sourceName.normalize('NFC');
+    return (getCppRuntimeExternalSymbolBindings(runtimeProfile, externalBindings).find((candidate) => candidate.sourceName === normalized && candidate.space === space)?.kind === 'runtime');
+}
+function getCppRuntimeExternalSymbolBindings(runtimeProfile, externalBindings) {
+    const runtime = runtimeProfile === 'flight-cpp' ? cppFlightRuntimeExternalSymbolBindings : cppRuntimeExternalSymbolBindings;
+    return [
+        ...runtime,
+        ...getCppCompilerExternalBindings(externalBindings).map((binding) => ({ ...binding, kind: 'native' })),
+    ];
+}
+function getCppCompilerExternalBindings(manifest) {
+    if (!manifest)
+        return [];
+    if (manifest.schema !== 'flight-cpp-external-bindings/1' || !Array.isArray(manifest.bindings)) {
+        throw new TypeError('C++ external bindings require flight-cpp-external-bindings/1');
+    }
+    const bindings = manifest.bindings.map((binding, index) => {
+        const subject = `C++ external binding ${String(index)}`;
+        if (!binding ||
+            typeof binding.sourceName !== 'string' ||
+            binding.sourceName.length === 0 ||
+            (binding.space !== 'type' && binding.space !== 'value') ||
+            typeof binding.targetName !== 'string' ||
+            binding.targetName.length === 0 ||
+            !Array.isArray(binding.headers) ||
+            binding.headers.some((header) => !isCppExternalBindingHeader(header)) ||
+            (binding.nullability !== 'non-null' && binding.nullability !== 'nullable') ||
+            !cppExternalBindingOwnerships.has(binding.ownership)) {
+            throw new TypeError(`${subject} is malformed`);
+        }
+        if (binding.members?.some((member) => !member ||
+            typeof member.sourceMember !== 'string' ||
+            member.sourceMember.length === 0 ||
+            typeof member.targetName !== 'string' ||
+            member.targetName.length === 0 ||
+            (member.callResultType !== undefined &&
+                (typeof member.callResultType !== 'string' || member.callResultType.length === 0)) ||
+            (member.callResultAbsence !== undefined &&
+                member.callResultAbsence !== 'null' &&
+                member.callResultAbsence !== 'undefined') ||
+            (member.callResultAbsence !== undefined && member.callResultType === undefined) ||
+            member.parameters?.some((parameter) => !parameter ||
+                !Number.isSafeInteger(parameter.position) ||
+                parameter.position < 0 ||
+                typeof parameter.sourceType !== 'string' ||
+                parameter.sourceType.length === 0) ||
+            (member.parameters !== undefined &&
+                new Set(member.parameters.map((parameter) => parameter.position)).size !== member.parameters.length))) {
+            throw new TypeError(`${subject} has malformed static-member mappings`);
+        }
+        if (binding.members?.some((member) => member.recordConversion !== undefined &&
+            (!member.recordConversion ||
+                (member.recordConversion.invocation !== 'carrier-function' &&
+                    member.recordConversion.invocation !== 'member') ||
+                member.recordConversion.keyType !== 'string' ||
+                member.recordConversion.valueType !== 'number' ||
+                typeof member.recordConversion.targetName !== 'string' ||
+                (member.recordConversion.invocation === 'member'
+                    ? !isCppExternalBindingFieldTarget(member.recordConversion.targetName)
+                    : !isCppExternalBindingQualifiedTarget(member.recordConversion.targetName)) ||
+                !cppExternalBindingOwnerships.has(member.recordConversion.resultOwnership) ||
+                (member.recordConversion.resultNullability !== 'non-null' &&
+                    member.recordConversion.resultNullability !== 'nullable')))) {
+            throw new TypeError(`${subject} has a malformed record conversion`);
+        }
+        if (binding.construction &&
+            (binding.space !== 'value' ||
+                (binding.construction.kind !== 'constructor' && binding.construction.kind !== 'factory') ||
+                typeof binding.construction.targetName !== 'string' ||
+                binding.construction.targetName.length === 0)) {
+            throw new TypeError(`${subject} has a malformed construction mapping`);
+        }
+        if (binding.callResultType !== undefined &&
+            (binding.space !== 'value' || typeof binding.callResultType !== 'string' || binding.callResultType.length === 0)) {
+            throw new TypeError(`${subject} has a malformed call-result type`);
+        }
+        if (binding.callResultAbsence !== undefined &&
+            (binding.space !== 'value' ||
+                binding.callResultType === undefined ||
+                (binding.callResultAbsence !== 'null' && binding.callResultAbsence !== 'undefined'))) {
+            throw new TypeError(`${subject} has a malformed call-result absence`);
+        }
+        if (binding.objectConstruction &&
+            (binding.space !== 'type' ||
+                binding.ownership !== 'value' ||
+                binding.nullability !== 'non-null' ||
+                binding.objectConstruction.kind !== 'field-assignment' ||
+                !Array.isArray(binding.objectConstruction.fields) ||
+                binding.objectConstruction.fields.some((field) => !field ||
+                    typeof field.sourceField !== 'string' ||
+                    field.sourceField.length === 0 ||
+                    typeof field.targetName !== 'string' ||
+                    !isCppExternalBindingFieldTarget(field.targetName)) ||
+                new Set(binding.objectConstruction.fields.map((field) => field.sourceField.normalize('NFC'))).size !==
+                    binding.objectConstruction.fields.length ||
+                new Set(binding.objectConstruction.fields.map((field) => field.targetName)).size !==
+                    binding.objectConstruction.fields.length)) {
+            throw new TypeError(`${subject} has a malformed or ambiguous object-construction field contract`);
+        }
+        if (binding.numericPropertyView !== undefined &&
+            (binding.space !== 'type' ||
+                typeof binding.numericPropertyView.targetName !== 'string' ||
+                !isCppExternalBindingFieldTarget(binding.numericPropertyView.targetName))) {
+            throw new TypeError(`${subject} has a malformed numeric-property view`);
+        }
+        if (binding.weakKeyPolicyTargetName !== undefined &&
+            (binding.space !== 'type' ||
+                binding.ownership !== 'shared' ||
+                binding.nullability !== 'non-null' ||
+                typeof binding.weakKeyPolicyTargetName !== 'string' ||
+                binding.weakKeyPolicyTargetName.length === 0)) {
+            throw new TypeError(`${subject} has a malformed weak-key policy target`);
+        }
+        return {
+            ...(binding.callResultAbsence ? { callResultAbsence: binding.callResultAbsence } : {}),
+            ...(binding.callResultType ? { callResultType: binding.callResultType } : {}),
+            ...(binding.construction ? { construction: { ...binding.construction } } : {}),
+            headers: [...binding.headers],
+            ...(binding.members
+                ? {
+                    members: binding.members.map((member) => ({
+                        ...member,
+                        ...(member.parameters
+                            ? {
+                                parameters: member.parameters.map((parameter) => ({
+                                    position: parameter.position,
+                                    sourceType: parameter.sourceType.normalize('NFC'),
+                                })),
+                            }
+                            : {}),
+                        ...(member.recordConversion ? { recordConversion: { ...member.recordConversion } } : {}),
+                    })),
+                }
+                : {}),
+            ...(binding.numericPropertyView
+                ? { numericPropertyView: { targetName: binding.numericPropertyView.targetName } }
+                : {}),
+            nullability: binding.nullability,
+            ...(binding.objectConstruction
+                ? {
+                    objectConstruction: {
+                        fields: binding.objectConstruction.fields.map((field) => ({
+                            sourceField: field.sourceField.normalize('NFC'),
+                            targetName: field.targetName,
+                        })),
+                        kind: binding.objectConstruction.kind,
+                    },
+                }
+                : {}),
+            ownership: binding.ownership,
+            sourceName: binding.sourceName.normalize('NFC'),
+            space: binding.space,
+            targetName: binding.targetName,
+            ...(binding.weakKeyPolicyTargetName ? { weakKeyPolicyTargetName: binding.weakKeyPolicyTargetName } : {}),
+        };
+    });
+    const identities = new Set();
+    for (const binding of bindings) {
+        const identity = `${binding.sourceName}\0${binding.space}`;
+        if (identities.has(identity)) {
+            throw new TypeError(`C++ external binding manifest is ambiguous for ${binding.sourceName}[${binding.space}]`);
+        }
+        identities.add(identity);
+    }
+    for (const binding of bindings) {
+        for (const member of binding.members ?? []) {
+            for (const parameter of member.parameters ?? []) {
+                const parameterType = bindings.find((candidate) => candidate.sourceName === parameter.sourceType && candidate.space === 'type');
+                if (!parameterType?.objectConstruction) {
+                    throw new TypeError(`C++ external binding ${binding.sourceName}.${member.sourceMember} parameter ${String(parameter.position)} requires an exact object-construction contract for ${parameter.sourceType}`);
+                }
+            }
+        }
+    }
+    return bindings;
+}
+function isCppExternalBindingHeader(value) {
+    return (typeof value === 'string' &&
+        value.length > 0 &&
+        !value.startsWith('/') &&
+        !value.includes('\\') &&
+        !/[<>"\r\n]/u.test(value) &&
+        value.split('/').every((segment) => segment.length > 0 && segment !== '.' && segment !== '..'));
+}
+function isCppExternalBindingFieldTarget(value) {
+    return /^[A-Za-z_][A-Za-z0-9_]*$/u.test(value);
+}
+function isCppExternalBindingQualifiedTarget(value) {
+    return /^[A-Za-z_][A-Za-z0-9_]*(?:::[A-Za-z_][A-Za-z0-9_]*)*$/u.test(value);
+}
+const cppExternalBindingOwnerships = new Set(['borrowed', 'owned', 'shared', 'value']);
+const cppMathImulTarget = '([](double left, double right) noexcept { const auto to_uint32 = [](double value) noexcept { if (!std::isfinite(value) || value == 0.0) return std::uint32_t{0}; constexpr double modulus = 4294967296.0; double remainder = std::fmod(std::trunc(value), modulus); if (remainder < 0.0) remainder += modulus; return static_cast<std::uint32_t>(remainder); }; const std::uint32_t product = to_uint32(left) * to_uint32(right); return product < 0x80000000U ? static_cast<double>(product) : static_cast<double>(static_cast<std::int64_t>(product) - 0x100000000LL); })';
+const cppMathRandomTarget = '([]() { static thread_local std::mt19937_64 engine(std::random_device{}()); return std::generate_canonical<double, 53>(engine); })';
+const cppObjectIsTarget = '([](const auto& left, const auto& right) { using Left = std::remove_cvref_t<decltype(left)>; using Right = std::remove_cvref_t<decltype(right)>; if constexpr (!std::is_same_v<Left, Right>) { return false; } else if constexpr (std::is_floating_point_v<Left>) { if (std::isnan(left) && std::isnan(right)) return true; if (left == 0.0 && right == 0.0) return std::signbit(left) == std::signbit(right); return left == right; } else { return left == right; } })';
+const cppObjectKeysTarget = '([](const auto& value) { using Key = std::remove_cvref_t<decltype(value.begin()->first)>; std::vector<Key> keys; keys.reserve(value.size()); for (const auto& entry : value) keys.push_back(entry.first); return keys; })';
+const cppObjectEntriesTarget = '([](const auto& value) { using Key = std::remove_cvref_t<decltype(value.begin()->first)>; using Value = std::remove_cvref_t<decltype(value.begin()->second)>; using Entry = std::tuple<Key, Value>; std::vector<Entry> entries; entries.reserve(value.size()); for (const auto& entry : value) entries.emplace_back(entry.first, entry.second); return entries; })';
+const cppIntlRuntimeTypeTargets = [
+    ['Intl.Collator', 'flight::IntlCollator'],
+    ['Intl.CollatorOptions', 'flight::IntlCollatorOptions'],
+    ['Intl.DateTimeFormat', 'flight::IntlDateTimeFormat'],
+    ['Intl.DateTimeFormatOptions', 'flight::IntlDateTimeFormatOptions'],
+    ['Intl.LDMLPluralRule', 'flight::IntlPluralRule'],
+    ['Intl.ListFormat', 'flight::IntlListFormat'],
+    ['Intl.ListFormatOptions', 'flight::IntlListFormatOptions'],
+    ['Intl.NumberFormat', 'flight::IntlNumberFormat'],
+    ['Intl.NumberFormatOptions', 'flight::IntlNumberFormatOptions'],
+    ['Intl.PluralRules', 'flight::IntlPluralRules'],
+    ['Intl.PluralRulesOptions', 'flight::IntlPluralRulesOptions'],
+    ['Intl.RelativeTimeFormat', 'flight::IntlRelativeTimeFormat'],
+    ['Intl.RelativeTimeFormatOptions', 'flight::IntlRelativeTimeFormatOptions'],
+    ['Intl.RelativeTimeFormatUnit', 'flight::IntlRelativeTimeFormatUnit'],
+];
+const cppFlightRuntimeExternalSymbolBindings = [
+    {
+        headers: ['cmath', 'cstdint', 'random'],
+        kind: 'native',
+        members: [
+            { sourceMember: 'E', targetName: 'flight::e' },
+            // The runtime carries `e` and `pi` and no other Math constant, so the two square-root
+            // constants are computed from the standard library rather than baked in as digits. Haxe binds
+            // `Math.SQRT2` to exactly this expression; what matters is that the value is the best double
+            // and that the compiler carries no constant the runtime does not own.
+            { sourceMember: 'PI', targetName: 'flight::pi' },
+            { sourceMember: 'SQRT1_2', targetName: 'std::sqrt(0.5)' },
+            { sourceMember: 'SQRT2', targetName: 'std::sqrt(2.0)' },
+            { sourceMember: 'abs', targetName: 'std::abs' },
+            { sourceMember: 'acos', targetName: 'std::acos' },
+            { sourceMember: 'asin', targetName: 'std::asin' },
+            { sourceMember: 'atan', targetName: 'std::atan' },
+            { sourceMember: 'atan2', targetName: 'std::atan2' },
+            { sourceMember: 'cbrt', targetName: 'std::cbrt' },
+            { sourceMember: 'ceil', targetName: 'std::ceil' },
+            { sourceMember: 'cos', targetName: 'std::cos' },
+            { sourceMember: 'exp', targetName: 'std::exp' },
+            { sourceMember: 'floor', targetName: 'std::floor' },
+            { sourceMember: 'fround', targetName: 'flight::fround' },
+            { sourceMember: 'hypot', targetName: 'std::hypot' },
+            { sourceMember: 'imul', targetName: cppMathImulTarget },
+            { sourceMember: 'log', targetName: 'std::log' },
+            { sourceMember: 'log10', targetName: 'std::log10' },
+            { sourceMember: 'log2', targetName: 'std::log2' },
+            { sourceMember: 'max', targetName: 'flight::maximum' },
+            { sourceMember: 'min', targetName: 'flight::minimum' },
+            { sourceMember: 'pow', targetName: 'flight::power' },
+            { sourceMember: 'random', targetName: cppMathRandomTarget },
+            { sourceMember: 'round', targetName: 'flight::round' },
+            { sourceMember: 'sign', targetName: 'flight::sign' },
+            { sourceMember: 'sin', targetName: 'std::sin' },
+            { sourceMember: 'sqrt', targetName: 'std::sqrt' },
+            { sourceMember: 'tan', targetName: 'std::tan' },
+            { sourceMember: 'trunc', targetName: 'std::trunc' },
+        ],
+        sourceName: 'Math',
+        space: 'value',
+        targetName: 'cmath',
+    },
+    { capability: 'array', kind: 'runtime', sourceName: 'Array', space: 'type', targetName: 'flight::Array' },
+    {
+        capability: 'array',
+        kind: 'runtime',
+        members: [{ sourceMember: 'isArray', targetName: 'flight::is_array' }],
+        sourceName: 'Array',
+        space: 'value',
+        targetName: 'flight::Array',
+    },
+    {
+        capability: 'array-buffer',
+        headers: ['flight/array_buffer.hpp'],
+        kind: 'runtime',
+        sourceName: 'ArrayBuffer',
+        space: 'type',
+        targetName: 'flight::ArrayBuffer',
+    },
+    {
+        capability: 'array-buffer',
+        headers: ['flight/array_buffer.hpp'],
+        kind: 'runtime',
+        sourceName: 'ArrayBuffer',
+        space: 'value',
+        targetName: 'flight::ArrayBuffer',
+    },
+    { kind: 'native', sourceName: 'Boolean', space: 'type', targetName: 'bool' },
+    { capability: 'date', kind: 'runtime', sourceName: 'Date', space: 'type', targetName: 'flight::Date' },
+    {
+        capability: 'date',
+        kind: 'runtime',
+        members: [{ sourceMember: 'now', targetName: 'flight::Date::now' }],
+        sourceName: 'Date',
+        space: 'value',
+        targetName: 'flight::Date',
+    },
+    {
+        capability: 'data-view',
+        headers: ['flight/data_view.hpp'],
+        kind: 'runtime',
+        sourceName: 'DataView',
+        space: 'type',
+        targetName: 'flight::DataView',
+    },
+    {
+        capability: 'data-view',
+        headers: ['flight/data_view.hpp'],
+        kind: 'runtime',
+        sourceName: 'DataView',
+        space: 'value',
+        targetName: 'flight::DataView',
+    },
+    { capability: 'error', kind: 'runtime', sourceName: 'Error', space: 'type', targetName: 'flight::Error' },
+    { capability: 'error', kind: 'runtime', sourceName: 'Error', space: 'value', targetName: 'flight::Error' },
+    {
+        capability: 'float32-array',
+        kind: 'runtime',
+        sourceName: 'Float32Array',
+        space: 'type',
+        targetName: 'flight::Float32Array',
+    },
+    {
+        capability: 'float32-array',
+        kind: 'runtime',
+        sourceName: 'Float32Array',
+        space: 'value',
+        targetName: 'flight::Float32Array',
+    },
+    {
+        capability: 'float64-array',
+        kind: 'runtime',
+        sourceName: 'Float64Array',
+        space: 'type',
+        targetName: 'flight::Float64Array',
+    },
+    {
+        capability: 'float64-array',
+        kind: 'runtime',
+        sourceName: 'Float64Array',
+        space: 'value',
+        targetName: 'flight::Float64Array',
+    },
+    {
+        kind: 'native',
+        sourceName: 'Infinity',
+        space: 'value',
+        targetName: 'std::numeric_limits<double>::infinity()',
+    },
+    {
+        capability: 'int16-array',
+        kind: 'runtime',
+        sourceName: 'Int16Array',
+        space: 'type',
+        targetName: 'flight::Int16Array',
+    },
+    {
+        capability: 'int16-array',
+        kind: 'runtime',
+        sourceName: 'Int16Array',
+        space: 'value',
+        targetName: 'flight::Int16Array',
+    },
+    {
+        capability: 'int32-array',
+        kind: 'runtime',
+        sourceName: 'Int32Array',
+        space: 'type',
+        targetName: 'flight::Int32Array',
+    },
+    {
+        capability: 'int32-array',
+        kind: 'runtime',
+        sourceName: 'Int32Array',
+        space: 'value',
+        targetName: 'flight::Int32Array',
+    },
+    {
+        capability: 'int8-array',
+        kind: 'runtime',
+        sourceName: 'Int8Array',
+        space: 'type',
+        targetName: 'flight::Int8Array',
+    },
+    {
+        capability: 'int8-array',
+        kind: 'runtime',
+        sourceName: 'Int8Array',
+        space: 'value',
+        targetName: 'flight::Int8Array',
+    },
+    {
+        capability: 'internationalization',
+        headers: ['flight/intl.hpp'],
+        kind: 'runtime',
+        members: [
+            { sourceMember: 'Collator', targetName: 'flight::IntlCollator' },
+            { sourceMember: 'DateTimeFormat', targetName: 'flight::IntlDateTimeFormat' },
+            { sourceMember: 'ListFormat', targetName: 'flight::IntlListFormat' },
+            { sourceMember: 'NumberFormat', targetName: 'flight::IntlNumberFormat' },
+            { sourceMember: 'PluralRules', targetName: 'flight::IntlPluralRules' },
+            { sourceMember: 'RelativeTimeFormat', targetName: 'flight::IntlRelativeTimeFormat' },
+        ],
+        sourceName: 'Intl',
+        space: 'value',
+        targetName: 'flight::Intl',
+    },
+    ...cppIntlRuntimeTypeTargets.map(([sourceName, targetName]) => ({
+        capability: 'internationalization',
+        headers: ['flight/intl.hpp'],
+        kind: 'runtime',
+        sourceName,
+        space: 'type',
+        targetName,
+    })),
+    {
+        capability: 'json',
+        headers: ['flight/json.hpp'],
+        kind: 'runtime',
+        members: [
+            { sourceMember: 'parse', targetName: 'flight::Json::parse' },
+            { sourceMember: 'stringify', targetName: 'flight::Json::stringify' },
+        ],
+        sourceName: 'JSON',
+        space: 'value',
+        targetName: 'flight::Json',
+    },
+    { capability: 'map', kind: 'runtime', sourceName: 'Map', space: 'type', targetName: 'flight::Map' },
+    { capability: 'map', kind: 'runtime', sourceName: 'Map', space: 'value', targetName: 'flight::Map' },
+    {
+        kind: 'native',
+        sourceName: 'NaN',
+        space: 'value',
+        targetName: 'std::numeric_limits<double>::quiet_NaN()',
+    },
+    { kind: 'native', sourceName: 'Number', space: 'type', targetName: 'double' },
+    {
+        headers: ['cmath'],
+        kind: 'native',
+        sourceName: 'isNaN',
+        space: 'value',
+        targetName: 'std::isnan',
+    },
+    {
+        capability: 'number-parsing',
+        headers: ['flight/number.hpp'],
+        kind: 'runtime',
+        members: [
+            { sourceMember: 'EPSILON', targetName: 'std::numeric_limits<double>::epsilon()' },
+            { sourceMember: 'MAX_SAFE_INTEGER', targetName: '9007199254740991.0' },
+            { sourceMember: 'MAX_VALUE', targetName: 'std::numeric_limits<double>::max()' },
+            { sourceMember: 'MIN_VALUE', targetName: 'std::numeric_limits<double>::denorm_min()' },
+            { sourceMember: 'NaN', targetName: 'std::numeric_limits<double>::quiet_NaN()' },
+            { sourceMember: 'NEGATIVE_INFINITY', targetName: '-std::numeric_limits<double>::infinity()' },
+            { sourceMember: 'POSITIVE_INFINITY', targetName: 'std::numeric_limits<double>::infinity()' },
+            { sourceMember: 'isFinite', targetName: 'std::isfinite' },
+            { sourceMember: 'isInteger', targetName: 'flight::is_integer' },
+            { sourceMember: 'isNaN', targetName: 'std::isnan' },
+            { sourceMember: 'isSafeInteger', targetName: 'flight::is_safe_integer' },
+            { sourceMember: 'parseFloat', targetName: 'flight::parse_float' },
+            { sourceMember: 'parseInt', targetName: 'flight::parse_int' },
+        ],
+        sourceName: 'Number',
+        space: 'value',
+        targetName: 'flight::to_number',
+    },
+    {
+        capability: 'object',
+        headers: ['cmath', 'flight/object.hpp', 'type_traits'],
+        kind: 'runtime',
+        members: [
+            { sourceMember: 'assign', targetName: 'flight::object_assign' },
+            { sourceMember: 'entries', targetName: 'flight::object_entries' },
+            { sourceMember: 'is', targetName: cppObjectIsTarget },
+            { sourceMember: 'keys', targetName: 'flight::object_keys' },
+        ],
+        sourceName: 'Object',
+        space: 'value',
+        targetName: 'flight::Object',
+    },
+    { capability: 'task', kind: 'runtime', sourceName: 'Promise', space: 'type', targetName: 'flight::Task' },
+    {
+        capability: 'task',
+        kind: 'runtime',
+        members: [
+            { sourceMember: 'all', targetName: 'flight::all_tasks' },
+            { sourceMember: 'reject', targetName: 'flight::reject_task' },
+            { sourceMember: 'resolve', targetName: 'flight::resolve_task' },
+        ],
+        sourceName: 'Promise',
+        space: 'value',
+        targetName: 'flight::Task',
+    },
+    {
+        capability: 'error',
+        headers: ['flight/error.hpp'],
+        kind: 'runtime',
+        sourceName: 'RangeError',
+        space: 'type',
+        targetName: 'flight::RangeError',
+    },
+    {
+        capability: 'error',
+        headers: ['flight/error.hpp'],
+        kind: 'runtime',
+        sourceName: 'RangeError',
+        space: 'value',
+        targetName: 'flight::RangeError',
+    },
+    {
+        capability: 'regexp',
+        headers: ['flight/regexp.hpp'],
+        kind: 'runtime',
+        sourceName: 'RegExp',
+        space: 'type',
+        targetName: 'flight::RegExp',
+    },
+    {
+        capability: 'regexp',
+        headers: ['flight/regexp.hpp'],
+        kind: 'runtime',
+        sourceName: 'RegExp',
+        space: 'value',
+        targetName: 'flight::RegExp',
+    },
+    {
+        capability: 'regexp',
+        headers: ['flight/regexp.hpp'],
+        kind: 'runtime',
+        sourceName: 'RegExpExecArray',
+        space: 'type',
+        targetName: 'flight::RegExpExecArray',
+    },
+    {
+        capability: 'map',
+        headers: ['flight/map.hpp'],
+        kind: 'runtime',
+        sourceName: 'ReadonlyMap',
+        space: 'type',
+        targetName: 'flight::Map',
+    },
+    {
+        capability: 'set',
+        kind: 'runtime',
+        sourceName: 'ReadonlySet',
+        space: 'type',
+        targetName: 'flight::Set',
+    },
+    {
+        capability: 'record',
+        headers: ['flight/record.hpp'],
+        kind: 'runtime',
+        sourceName: 'Record',
+        space: 'type',
+        targetName: 'flight::Record',
+    },
+    { capability: 'set', kind: 'runtime', sourceName: 'Set', space: 'type', targetName: 'flight::Set' },
+    { capability: 'set', kind: 'runtime', sourceName: 'Set', space: 'value', targetName: 'flight::Set' },
+    { capability: 'string', kind: 'runtime', sourceName: 'String', space: 'type', targetName: 'flight::String' },
+    {
+        capability: 'string',
+        kind: 'runtime',
+        members: [
+            { sourceMember: 'fromCharCode', targetName: 'flight::String::from_char_code' },
+            { sourceMember: 'fromCodePoint', targetName: 'flight::String::from_code_point' },
+        ],
+        sourceName: 'String',
+        space: 'value',
+        targetName: 'flight::String',
+    },
+    {
+        callResultType: 'flight::Symbol',
+        capability: 'symbol',
+        headers: ['flight/symbol.hpp'],
+        kind: 'runtime',
+        members: [{ callResultType: 'flight::Symbol', sourceMember: 'for', targetName: 'flight::Symbol::for_key' }],
+        sourceName: 'Symbol',
+        space: 'value',
+        targetName: 'flight::Symbol',
+    },
+    {
+        capability: 'structural-proxy',
+        headers: ['flight/structural_ref.hpp'],
+        kind: 'runtime',
+        sourceName: 'Proxy',
+        space: 'value',
+        targetName: 'flight::make_structural_write_proxy',
+    },
+    {
+        capability: 'text-decoder',
+        headers: ['flight/text_decoder.hpp'],
+        kind: 'runtime',
+        sourceName: 'TextDecoder',
+        space: 'type',
+        targetName: 'flight::TextDecoder',
+    },
+    {
+        capability: 'text-decoder',
+        headers: ['flight/text_decoder.hpp'],
+        kind: 'runtime',
+        sourceName: 'TextDecoder',
+        space: 'value',
+        targetName: 'flight::TextDecoder',
+    },
+    {
+        capability: 'error',
+        headers: ['flight/error.hpp'],
+        kind: 'runtime',
+        sourceName: 'TypeError',
+        space: 'type',
+        targetName: 'flight::TypeError',
+    },
+    {
+        capability: 'error',
+        headers: ['flight/error.hpp'],
+        kind: 'runtime',
+        sourceName: 'TypeError',
+        space: 'value',
+        targetName: 'flight::TypeError',
+    },
+    {
+        capability: 'uint16-array',
+        kind: 'runtime',
+        sourceName: 'Uint16Array',
+        space: 'type',
+        targetName: 'flight::Uint16Array',
+    },
+    {
+        capability: 'uint16-array',
+        kind: 'runtime',
+        sourceName: 'Uint16Array',
+        space: 'value',
+        targetName: 'flight::Uint16Array',
+    },
+    {
+        capability: 'uint32-array',
+        kind: 'runtime',
+        sourceName: 'Uint32Array',
+        space: 'type',
+        targetName: 'flight::Uint32Array',
+    },
+    {
+        capability: 'uint32-array',
+        kind: 'runtime',
+        sourceName: 'Uint32Array',
+        space: 'value',
+        targetName: 'flight::Uint32Array',
+    },
+    {
+        capability: 'uint8-array',
+        kind: 'runtime',
+        sourceName: 'Uint8Array',
+        space: 'type',
+        targetName: 'flight::Uint8Array',
+    },
+    {
+        capability: 'uint8-array',
+        kind: 'runtime',
+        sourceName: 'Uint8Array',
+        space: 'value',
+        targetName: 'flight::Uint8Array',
+    },
+    {
+        capability: 'uint8-clamped-array',
+        kind: 'runtime',
+        sourceName: 'Uint8ClampedArray',
+        space: 'type',
+        targetName: 'flight::Uint8ClampedArray',
+    },
+    {
+        capability: 'url',
+        headers: ['flight/url.hpp'],
+        kind: 'runtime',
+        sourceName: 'URL',
+        space: 'type',
+        targetName: 'flight::Url',
+    },
+    {
+        capability: 'url',
+        headers: ['flight/url.hpp'],
+        kind: 'runtime',
+        sourceName: 'URL',
+        space: 'value',
+        targetName: 'flight::Url',
+    },
+    {
+        capability: 'uint8-clamped-array',
+        kind: 'runtime',
+        sourceName: 'Uint8ClampedArray',
+        space: 'value',
+        targetName: 'flight::Uint8ClampedArray',
+    },
+    {
+        capability: 'weak-map',
+        headers: ['flight/weak_map.hpp'],
+        kind: 'runtime',
+        sourceName: 'WeakMap',
+        space: 'type',
+        targetName: 'flight::WeakMap',
+    },
+    {
+        capability: 'weak-map',
+        headers: ['flight/weak_map.hpp'],
+        kind: 'runtime',
+        sourceName: 'WeakMap',
+        space: 'value',
+        targetName: 'flight::WeakMap',
+    },
+    {
+        capability: 'number-parsing',
+        headers: ['flight/number.hpp'],
+        kind: 'runtime',
+        sourceName: 'parseInt',
+        space: 'value',
+        targetName: 'flight::parse_int',
+    },
+];
+const cppRuntimeExternalSymbolBindings = [
+    {
+        headers: ['cmath', 'cstdint', 'random'],
+        kind: 'native',
+        members: [
+            { sourceMember: 'E', targetName: 'M_E' },
+            { sourceMember: 'PI', targetName: 'M_PI' },
+            { sourceMember: 'abs', targetName: 'std::abs' },
+            { sourceMember: 'acos', targetName: 'std::acos' },
+            { sourceMember: 'asin', targetName: 'std::asin' },
+            { sourceMember: 'atan', targetName: 'std::atan' },
+            { sourceMember: 'atan2', targetName: 'std::atan2' },
+            { sourceMember: 'cbrt', targetName: 'std::cbrt' },
+            { sourceMember: 'ceil', targetName: 'std::ceil' },
+            { sourceMember: 'cos', targetName: 'std::cos' },
+            { sourceMember: 'exp', targetName: 'std::exp' },
+            { sourceMember: 'floor', targetName: 'std::floor' },
+            { sourceMember: 'hypot', targetName: 'std::hypot' },
+            { sourceMember: 'imul', targetName: cppMathImulTarget },
+            { sourceMember: 'log', targetName: 'std::log' },
+            { sourceMember: 'log10', targetName: 'std::log10' },
+            { sourceMember: 'log2', targetName: 'std::log2' },
+            { sourceMember: 'max', targetName: 'std::max' },
+            { sourceMember: 'min', targetName: 'std::min' },
+            { sourceMember: 'pow', targetName: 'std::pow' },
+            { sourceMember: 'random', targetName: cppMathRandomTarget },
+            { sourceMember: 'round', targetName: 'std::round' },
+            { sourceMember: 'sign', targetName: 'flight::sign' },
+            { sourceMember: 'sin', targetName: 'std::sin' },
+            { sourceMember: 'sqrt', targetName: 'std::sqrt' },
+            { sourceMember: 'tan', targetName: 'std::tan' },
+            { sourceMember: 'trunc', targetName: 'std::trunc' },
+        ],
+        sourceName: 'Math',
+        space: 'value',
+        targetName: 'cmath',
+    },
+    { kind: 'native', sourceName: 'Array', space: 'type', targetName: 'std::vector' },
+    { kind: 'native', sourceName: 'Array', space: 'value', targetName: 'std::vector' },
+    {
+        headers: ['cstdint', 'vector'],
+        kind: 'native',
+        sourceName: 'ArrayBuffer',
+        space: 'type',
+        targetName: 'std::vector<uint8_t>',
+    },
+    { kind: 'native', sourceName: 'Boolean', space: 'type', targetName: 'bool' },
+    { capability: 'date', kind: 'runtime', sourceName: 'Date', space: 'type', targetName: 'FlightDate' },
+    { capability: 'date', kind: 'runtime', sourceName: 'Date', space: 'value', targetName: 'FlightDate' },
+    { kind: 'native', sourceName: 'Error', space: 'type', targetName: 'std::runtime_error' },
+    { kind: 'native', sourceName: 'Error', space: 'value', targetName: 'std::runtime_error' },
+    { kind: 'native', sourceName: 'Float32Array', space: 'type', targetName: 'std::vector<float>' },
+    { kind: 'native', sourceName: 'Float32Array', space: 'value', targetName: 'std::vector<float>' },
+    { kind: 'native', sourceName: 'Float64Array', space: 'type', targetName: 'std::vector<double>' },
+    { kind: 'native', sourceName: 'Float64Array', space: 'value', targetName: 'std::vector<double>' },
+    {
+        headers: ['cmath'],
+        kind: 'native',
+        sourceName: 'isNaN',
+        space: 'value',
+        targetName: 'std::isnan',
+    },
+    {
+        kind: 'native',
+        sourceName: 'Infinity',
+        space: 'value',
+        targetName: 'std::numeric_limits<double>::infinity()',
+    },
+    { kind: 'native', sourceName: 'Int16Array', space: 'type', targetName: 'std::vector<int16_t>' },
+    { kind: 'native', sourceName: 'Int16Array', space: 'value', targetName: 'std::vector<int16_t>' },
+    { kind: 'native', sourceName: 'Int32Array', space: 'type', targetName: 'std::vector<int32_t>' },
+    { kind: 'native', sourceName: 'Int32Array', space: 'value', targetName: 'std::vector<int32_t>' },
+    { kind: 'native', sourceName: 'Int8Array', space: 'type', targetName: 'std::vector<int8_t>' },
+    { kind: 'native', sourceName: 'Int8Array', space: 'value', targetName: 'std::vector<int8_t>' },
+    { kind: 'native', sourceName: 'Map', space: 'type', targetName: 'std::unordered_map' },
+    { kind: 'native', sourceName: 'Map', space: 'value', targetName: 'std::unordered_map' },
+    {
+        kind: 'native',
+        sourceName: 'NaN',
+        space: 'value',
+        targetName: 'std::numeric_limits<double>::quiet_NaN()',
+    },
+    { kind: 'native', sourceName: 'Number', space: 'type', targetName: 'double' },
+    {
+        kind: 'native',
+        members: [
+            { sourceMember: 'EPSILON', targetName: 'std::numeric_limits<double>::epsilon()' },
+            { sourceMember: 'MAX_SAFE_INTEGER', targetName: '9007199254740991.0' },
+            { sourceMember: 'MAX_VALUE', targetName: 'std::numeric_limits<double>::max()' },
+            { sourceMember: 'MIN_VALUE', targetName: 'std::numeric_limits<double>::denorm_min()' },
+            { sourceMember: 'NaN', targetName: 'std::numeric_limits<double>::quiet_NaN()' },
+            { sourceMember: 'NEGATIVE_INFINITY', targetName: '-std::numeric_limits<double>::infinity()' },
+            { sourceMember: 'POSITIVE_INFINITY', targetName: 'std::numeric_limits<double>::infinity()' },
+            { sourceMember: 'isFinite', targetName: 'std::isfinite' },
+            {
+                sourceMember: 'isInteger',
+                targetName: '[](double value) noexcept { return std::isfinite(value) && std::trunc(value) == value; }',
+            },
+            { sourceMember: 'isNaN', targetName: 'std::isnan' },
+        ],
+        sourceName: 'Number',
+        space: 'value',
+        targetName: 'double',
+    },
+    {
+        headers: ['cmath', 'tuple', 'type_traits', 'vector'],
+        kind: 'native',
+        members: [
+            { sourceMember: 'entries', targetName: cppObjectEntriesTarget },
+            { sourceMember: 'is', targetName: cppObjectIsTarget },
+            { sourceMember: 'keys', targetName: cppObjectKeysTarget },
+        ],
+        sourceName: 'Object',
+        space: 'value',
+        targetName: cppObjectIsTarget,
+    },
+    { capability: 'task', kind: 'runtime', sourceName: 'Promise', space: 'type', targetName: 'FlightTask' },
+    {
+        capability: 'task',
+        kind: 'runtime',
+        members: [
+            { sourceMember: 'all', targetName: 'FlightTask::all' },
+            { sourceMember: 'reject', targetName: 'FlightTask::reject' },
+            { sourceMember: 'resolve', targetName: 'FlightTask::resolve' },
+        ],
+        sourceName: 'Promise',
+        space: 'value',
+        targetName: 'FlightTask',
+    },
+    { kind: 'native', sourceName: 'RangeError', space: 'type', targetName: 'std::range_error' },
+    { kind: 'native', sourceName: 'RangeError', space: 'value', targetName: 'std::range_error' },
+    {
+        headers: ['unordered_map'],
+        kind: 'native',
+        sourceName: 'ReadonlyMap',
+        space: 'type',
+        targetName: 'std::unordered_map',
+    },
+    {
+        headers: ['unordered_set'],
+        kind: 'native',
+        sourceName: 'ReadonlySet',
+        space: 'type',
+        targetName: 'std::unordered_set',
+    },
+    {
+        headers: ['unordered_map'],
+        kind: 'native',
+        sourceName: 'Record',
+        space: 'type',
+        targetName: 'std::unordered_map',
+    },
+    { kind: 'native', sourceName: 'Set', space: 'type', targetName: 'std::unordered_set' },
+    { kind: 'native', sourceName: 'Set', space: 'value', targetName: 'std::unordered_set' },
+    { kind: 'native', sourceName: 'String', space: 'type', targetName: 'std::string' },
+    { kind: 'native', sourceName: 'String', space: 'value', targetName: 'std::string' },
+    { kind: 'native', sourceName: 'TypeError', space: 'type', targetName: 'std::runtime_error' },
+    { kind: 'native', sourceName: 'TypeError', space: 'value', targetName: 'std::runtime_error' },
+    { kind: 'native', sourceName: 'Uint16Array', space: 'type', targetName: 'std::vector<uint16_t>' },
+    { kind: 'native', sourceName: 'Uint16Array', space: 'value', targetName: 'std::vector<uint16_t>' },
+    { kind: 'native', sourceName: 'Uint32Array', space: 'type', targetName: 'std::vector<uint32_t>' },
+    { kind: 'native', sourceName: 'Uint32Array', space: 'value', targetName: 'std::vector<uint32_t>' },
+    { kind: 'native', sourceName: 'Uint8Array', space: 'type', targetName: 'std::vector<uint8_t>' },
+    { kind: 'native', sourceName: 'Uint8Array', space: 'value', targetName: 'std::vector<uint8_t>' },
+    { kind: 'native', sourceName: 'Uint8ClampedArray', space: 'type', targetName: 'std::vector<uint8_t>' },
+    { kind: 'native', sourceName: 'Uint8ClampedArray', space: 'value', targetName: 'std::vector<uint8_t>' },
+    {
+        headers: ['unordered_map'],
+        kind: 'native',
+        sourceName: 'WeakMap',
+        space: 'type',
+        targetName: 'std::unordered_map',
+    },
+    {
+        headers: ['unordered_map'],
+        kind: 'native',
+        sourceName: 'WeakMap',
+        space: 'value',
+        targetName: 'std::unordered_map',
+    },
+];
+//# sourceMappingURL=cppRuntimeExternalSymbolBinding.js.map