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

package/dist/packages/compiler-runtime-contract/src/compilerRuntimeExternalConstructorAbiCompleteness.js

@@ -0,0 +1,110 @@
+import { compareTextCodeUnits } from '../../compiler-canonical-form/src/index.js';
+export function analyzeCompilerRuntimeExternalConstructorAbiCompleteness(requiredExternalConstructors, abiPlan) {
+    assertCompilerRuntimeExternalConstructorAbiContract(abiPlan);
+    const required = createSortedExternalConstructorInvocations(requiredExternalConstructors);
+    const constructorGroups = new Map();
+    for (const constructor of abiPlan.constructors) {
+        const normalized = normalizeExternalConstructorAbi(constructor);
+        const key = normalized.externalSymbol.sourceName;
+        constructorGroups.set(key, [...(constructorGroups.get(key) ?? []), normalized]);
+    }
+    const duplicateExternalConstructors = [...constructorGroups.values()]
+        .filter((constructors) => constructors.length > 1)
+        .map(([constructor]) => constructor.externalSymbol)
+        .sort(compareExternalConstructorIdentities);
+    const invalidExternalConstructors = [...constructorGroups.values()]
+        .flatMap((constructors) => constructors.filter((constructor) => !isExternalConstructorAbiValid(constructor)))
+        .map((constructor) => constructor.externalSymbol)
+        .filter((identity, index, identities) => identities.findIndex((candidate) => candidate.sourceName === identity.sourceName) === index)
+        .sort(compareExternalConstructorIdentities);
+    const missingExternalConstructors = required.filter((invocation) => {
+        const constructors = constructorGroups.get(invocation.externalSymbol.sourceName);
+        if (constructors?.length !== 1)
+            return true;
+        const [constructor] = constructors;
+        if (!constructor || !isExternalConstructorAbiValid(constructor))
+            return true;
+        return invocation.providedArgumentCount === 'dynamic'
+            ? !constructor.dynamicArguments
+            : !constructor.fixedArgumentCounts.includes(invocation.providedArgumentCount);
+    });
+    const common = {
+        contract: abiPlan.contract,
+        requiredExternalConstructors: required,
+        schema: 'flight-runtime-constructor-abi-completeness/1',
+    };
+    if (duplicateExternalConstructors.length === 0 &&
+        invalidExternalConstructors.length === 0 &&
+        missingExternalConstructors.length === 0) {
+        return { ...common, kind: 'complete' };
+    }
+    return {
+        ...common,
+        duplicateExternalConstructors,
+        invalidExternalConstructors,
+        kind: 'incomplete',
+        missingExternalConstructors,
+    };
+}
+export function isCompilerRuntimeExternalConstructorAbiContractMismatchFailure(value) {
+    return (value instanceof Error &&
+        'kind' in value &&
+        value.kind === 'runtime-external-constructor-abi-contract-mismatch' &&
+        'expected' in value &&
+        value.expected === 'flight-runtime-constructor-abi/1' &&
+        'received' in value &&
+        typeof value.received === 'string');
+}
+function assertCompilerRuntimeExternalConstructorAbiContract(abiPlan) {
+    if (abiPlan.contract === 'flight-runtime-constructor-abi/1')
+        return;
+    const failure = Object.assign(new Error(`Runtime external constructor ABI plan uses ${String(abiPlan.contract)}; expected flight-runtime-constructor-abi/1`), {
+        expected: 'flight-runtime-constructor-abi/1',
+        kind: 'runtime-external-constructor-abi-contract-mismatch',
+        received: String(abiPlan.contract),
+    });
+    failure.name = 'CompilerRuntimeExternalConstructorAbiContractMismatchError';
+    throw failure;
+}
+function compareExternalConstructorArgumentCounts(left, right) {
+    return ((left === 'dynamic' ? Number.MAX_SAFE_INTEGER : left) - (right === 'dynamic' ? Number.MAX_SAFE_INTEGER : right));
+}
+function compareExternalConstructorIdentities(left, right) {
+    return compareTextCodeUnits(left.sourceName, right.sourceName);
+}
+function compareExternalConstructorInvocations(left, right) {
+    return (compareExternalConstructorIdentities(left.externalSymbol, right.externalSymbol) ||
+        compareExternalConstructorArgumentCounts(left.providedArgumentCount, right.providedArgumentCount));
+}
+function createSortedExternalConstructorInvocations(invocations) {
+    const normalized = invocations.map((invocation) => ({
+        externalSymbol: normalizeExternalConstructorIdentity(invocation.externalSymbol),
+        providedArgumentCount: invocation.providedArgumentCount,
+    }));
+    return [
+        ...new Map(normalized.map((invocation) => [
+            JSON.stringify([invocation.externalSymbol.sourceName, invocation.providedArgumentCount]),
+            invocation,
+        ])).values(),
+    ].sort(compareExternalConstructorInvocations);
+}
+function isExternalConstructorAbiValid(constructor) {
+    return (constructor.externalSymbol.sourceName.length > 0 &&
+        constructor.externalSymbol.space === 'value' &&
+        typeof constructor.dynamicArguments === 'boolean' &&
+        Array.isArray(constructor.fixedArgumentCounts) &&
+        constructor.fixedArgumentCounts.every((count, index) => Number.isSafeInteger(count) &&
+            count >= 0 &&
+            (index === 0 || constructor.fixedArgumentCounts[index - 1] < count)));
+}
+function normalizeExternalConstructorAbi(constructor) {
+    return {
+        dynamicArguments: constructor.dynamicArguments,
+        externalSymbol: normalizeExternalConstructorIdentity(constructor.externalSymbol),
+        fixedArgumentCounts: [...constructor.fixedArgumentCounts],
+    };
+}
+function normalizeExternalConstructorIdentity(identity) {
+    return { sourceName: identity.sourceName.normalize('NFC'), space: 'value' };
+}
+//# sourceMappingURL=compilerRuntimeExternalConstructorAbiCompleteness.js.map

package/dist/packages/compiler-runtime-contract/src/compilerRuntimeExternalConstructorAbiCompleteness.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"compilerRuntimeExternalConstructorAbiCompleteness.js","sourceRoot":"","sources":["../../../../../compiler-runtime-contract/src/compilerRuntimeExternalConstructorAbiCompleteness.ts"],"names":[],"mappings":"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"}

package/dist/packages/compiler-runtime-contract/src/compilerRuntimeExternalConstructorReachability.d.ts

@@ -0,0 +1,3 @@
+import type { CompilerRuntimeExternalConstructorInvocation, IrModule } from '../../compiler-types/src/index.js';
+export declare function collectIrModulesRuntimeExternalConstructorInvocations(modules: readonly Readonly<IrModule>[]): readonly CompilerRuntimeExternalConstructorInvocation[];
+//# sourceMappingURL=compilerRuntimeExternalConstructorReachability.d.ts.map

package/dist/packages/compiler-runtime-contract/src/compilerRuntimeExternalConstructorReachability.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"compilerRuntimeExternalConstructorReachability.d.ts","sourceRoot":"","sources":["../../../../../compiler-runtime-contract/src/compilerRuntimeExternalConstructorReachability.ts"],"names":[],"mappings":"AAEA,OAAO,KAAK,EACV,4CAA4C,EAE5C,QAAQ,EACT,MAAM,mCAAmC,CAAC;AAE3C,wBAAgB,qDAAqD,CACnE,OAAO,EAAE,SAAS,QAAQ,CAAC,QAAQ,CAAC,EAAE,GACrC,SAAS,4CAA4C,EAAE,CAmBzD"}

package/dist/packages/compiler-runtime-contract/src/compilerRuntimeExternalConstructorReachability.js

@@ -0,0 +1,42 @@
+import { compareTextCodeUnits } from '../../compiler-canonical-form/src/index.js';
+import { analyzeIrModuleTraversal } from '../../compiler-ir-traversal/src/index.js';
+export function collectIrModulesRuntimeExternalConstructorInvocations(modules) {
+    const invocations = new Map();
+    for (const module of modules) {
+        analyzeIrModuleTraversal(module, {
+            expression(expression) {
+                if (expression.kind !== 'new')
+                    return;
+                const sourceName = getIrRuntimeExternalConstructorSourceName(expression.callee);
+                if (!sourceName)
+                    return;
+                const invocation = {
+                    externalSymbol: { sourceName: sourceName.normalize('NFC'), space: 'value' },
+                    providedArgumentCount: expression.arguments.some((argument) => argument.kind === 'spread')
+                        ? 'dynamic'
+                        : expression.arguments.length,
+                };
+                invocations.set(serializeExternalConstructorInvocation(invocation), invocation);
+            },
+        });
+    }
+    return [...invocations.values()].sort(compareExternalConstructorInvocations);
+}
+function getIrRuntimeExternalConstructorSourceName(callee) {
+    if (callee.kind === 'identifier' && callee.reference.kind === 'ambient')
+        return callee.reference.name;
+    if (callee.kind === 'property' && callee.namespaceMember?.kind === 'ambient')
+        return callee.namespaceMember.name;
+    return undefined;
+}
+function compareExternalConstructorInvocations(left, right) {
+    return (compareTextCodeUnits(left.externalSymbol.sourceName, right.externalSymbol.sourceName) ||
+        compareExternalConstructorArgumentCounts(left.providedArgumentCount, right.providedArgumentCount));
+}
+function compareExternalConstructorArgumentCounts(left, right) {
+    return ((left === 'dynamic' ? Number.MAX_SAFE_INTEGER : left) - (right === 'dynamic' ? Number.MAX_SAFE_INTEGER : right));
+}
+function serializeExternalConstructorInvocation(invocation) {
+    return JSON.stringify([invocation.externalSymbol.sourceName, invocation.providedArgumentCount]);
+}
+//# sourceMappingURL=compilerRuntimeExternalConstructorReachability.js.map

package/dist/packages/compiler-runtime-contract/src/compilerRuntimeExternalConstructorReachability.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"compilerRuntimeExternalConstructorReachability.js","sourceRoot":"","sources":["../../../../../compiler-runtime-contract/src/compilerRuntimeExternalConstructorReachability.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,oBAAoB,EAAE,MAAM,4CAA4C,CAAC;AAClF,OAAO,EAAE,wBAAwB,EAAE,MAAM,0CAA0C,CAAC;AAOpF,MAAM,UAAU,qDAAqD,CACnE,OAAsC;IAEtC,MAAM,WAAW,GAAG,IAAI,GAAG,EAAwD,CAAC;IACpF,KAAK,MAAM,MAAM,IAAI,OAAO,EAAE,CAAC;QAC7B,wBAAwB,CAAC,MAAM,EAAE;YAC/B,UAAU,CAAC,UAAU;gBACnB,IAAI,UAAU,CAAC,IAAI,KAAK,KAAK;oBAAE,OAAO;gBACtC,MAAM,UAAU,GAAG,yCAAyC,CAAC,UAAU,CAAC,MAAM,CAAC,CAAC;gBAChF,IAAI,CAAC,UAAU;oBAAE,OAAO;gBACxB,MAAM,UAAU,GAAG;oBACjB,cAAc,EAAE,EAAE,UAAU,EAAE,UAAU,CAAC,SAAS,CAAC,KAAK,CAAC,EAAE,KAAK,EAAE,OAAO,EAAE;oBAC3E,qBAAqB,EAAE,UAAU,CAAC,SAAS,CAAC,IAAI,CAAC,CAAC,QAAQ,EAAE,EAAE,CAAC,QAAQ,CAAC,IAAI,KAAK,QAAQ,CAAC;wBACxF,CAAC,CAAE,SAAmB;wBACtB,CAAC,CAAC,UAAU,CAAC,SAAS,CAAC,MAAM;iBACuB,CAAC;gBACzD,WAAW,CAAC,GAAG,CAAC,sCAAsC,CAAC,UAAU,CAAC,EAAE,UAAU,CAAC,CAAC;YAClF,CAAC;SACF,CAAC,CAAC;IACL,CAAC;IACD,OAAO,CAAC,GAAG,WAAW,CAAC,MAAM,EAAE,CAAC,CAAC,IAAI,CAAC,qCAAqC,CAAC,CAAC;AAC/E,CAAC;AAED,SAAS,yCAAyC,CAAC,MAA8B;IAC/E,IAAI,MAAM,CAAC,IAAI,KAAK,YAAY,IAAI,MAAM,CAAC,SAAS,CAAC,IAAI,KAAK,SAAS;QAAE,OAAO,MAAM,CAAC,SAAS,CAAC,IAAI,CAAC;IACtG,IAAI,MAAM,CAAC,IAAI,KAAK,UAAU,IAAI,MAAM,CAAC,eAAe,EAAE,IAAI,KAAK,SAAS;QAAE,OAAO,MAAM,CAAC,eAAe,CAAC,IAAI,CAAC;IACjH,OAAO,SAAS,CAAC;AACnB,CAAC;AAED,SAAS,qCAAqC,CAC5C,IAA4D,EAC5D,KAA6D;IAE7D,OAAO,CACL,oBAAoB,CAAC,IAAI,CAAC,cAAc,CAAC,UAAU,EAAE,KAAK,CAAC,cAAc,CAAC,UAAU,CAAC;QACrF,wCAAwC,CAAC,IAAI,CAAC,qBAAqB,EAAE,KAAK,CAAC,qBAAqB,CAAC,CAClG,CAAC;AACJ,CAAC;AAED,SAAS,wCAAwC,CAC/C,IAA2E,EAC3E,KAA4E;IAE5E,OAAO,CACL,CAAC,IAAI,KAAK,SAAS,CAAC,CAAC,CAAC,MAAM,CAAC,gBAAgB,CAAC,CAAC,CAAC,IAAI,CAAC,GAAG,CAAC,KAAK,KAAK,SAAS,CAAC,CAAC,CAAC,MAAM,CAAC,gBAAgB,CAAC,CAAC,CAAC,KAAK,CAAC,CAChH,CAAC;AACJ,CAAC;AAED,SAAS,sCAAsC,CAC7C,UAAkE;IAElE,OAAO,IAAI,CAAC,SAAS,CAAC,CAAC,UAAU,CAAC,cAAc,CAAC,UAAU,EAAE,UAAU,CAAC,qBAAqB,CAAC,CAAC,CAAC;AAClG,CAAC"}

package/dist/packages/compiler-runtime-contract/src/compilerRuntimeExternalSymbolCompleteness.d.ts

@@ -0,0 +1,4 @@
+import type { CompilerRuntimeContractMismatchFailure, CompilerRuntimeExternalSymbolBindingPlan, CompilerRuntimeExternalSymbolCompleteness, CompilerRuntimeExternalSymbolIdentity } from '../../compiler-types/src/index.js';
+export declare function analyzeCompilerRuntimeExternalSymbolCompleteness(requiredExternalSymbols: readonly Readonly<CompilerRuntimeExternalSymbolIdentity>[], bindingPlan: Readonly<CompilerRuntimeExternalSymbolBindingPlan>): CompilerRuntimeExternalSymbolCompleteness;
+export declare function isCompilerRuntimeContractMismatchFailure(value: unknown): value is CompilerRuntimeContractMismatchFailure;
+//# sourceMappingURL=compilerRuntimeExternalSymbolCompleteness.d.ts.map

package/dist/packages/compiler-runtime-contract/src/compilerRuntimeExternalSymbolCompleteness.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"compilerRuntimeExternalSymbolCompleteness.d.ts","sourceRoot":"","sources":["../../../../../compiler-runtime-contract/src/compilerRuntimeExternalSymbolCompleteness.ts"],"names":[],"mappings":"AACA,OAAO,KAAK,EACV,sCAAsC,EACtC,wCAAwC,EACxC,yCAAyC,EACzC,qCAAqC,EACtC,MAAM,mCAAmC,CAAC;AAE3C,wBAAgB,gDAAgD,CAC9D,uBAAuB,EAAE,SAAS,QAAQ,CAAC,qCAAqC,CAAC,EAAE,EACnF,WAAW,EAAE,QAAQ,CAAC,wCAAwC,CAAC,GAC9D,yCAAyC,CA2C3C;AAED,wBAAgB,wCAAwC,CACtD,KAAK,EAAE,OAAO,GACb,KAAK,IAAI,sCAAsC,CAUjD"}

package/dist/packages/compiler-runtime-contract/src/compilerRuntimeExternalSymbolCompleteness.js

@@ -0,0 +1,64 @@
+import { compareTextCodeUnits } from '../../compiler-canonical-form/src/index.js';
+export function analyzeCompilerRuntimeExternalSymbolCompleteness(requiredExternalSymbols, bindingPlan) {
+    if (bindingPlan.contract !== 'flight-runtime-contract/2') {
+        const failure = Object.assign(new Error(`Runtime binding plan uses ${String(bindingPlan.contract)}; expected flight-runtime-contract/2`), {
+            expected: 'flight-runtime-contract/2',
+            kind: 'runtime-contract-mismatch',
+            received: String(bindingPlan.contract),
+        });
+        failure.name = 'CompilerRuntimeContractMismatchError';
+        throw failure;
+    }
+    const required = createSortedExternalSymbolIdentities(requiredExternalSymbols);
+    const bindingCounts = new Map();
+    for (const binding of bindingPlan.bindings) {
+        const identity = normalizeExternalSymbolIdentity(binding.externalSymbol);
+        const key = serializeExternalSymbolIdentity(identity);
+        const existing = bindingCounts.get(key);
+        bindingCounts.set(key, { count: (existing?.count ?? 0) + 1, identity });
+    }
+    const duplicateExternalSymbols = [...bindingCounts.values()]
+        .filter(({ count }) => count > 1)
+        .map(({ identity }) => identity)
+        .sort(compareExternalSymbolIdentities);
+    const missingExternalSymbols = required.filter((identity) => !bindingCounts.has(serializeExternalSymbolIdentity(identity)));
+    const common = {
+        contract: bindingPlan.contract,
+        requiredExternalSymbols: required,
+        schema: 'flight-runtime-contract-completeness/2',
+    };
+    if (duplicateExternalSymbols.length === 0 && missingExternalSymbols.length === 0) {
+        return { ...common, kind: 'complete' };
+    }
+    return {
+        ...common,
+        duplicateExternalSymbols,
+        kind: 'incomplete',
+        missingExternalSymbols,
+    };
+}
+export function isCompilerRuntimeContractMismatchFailure(value) {
+    return (value instanceof Error &&
+        'kind' in value &&
+        value.kind === 'runtime-contract-mismatch' &&
+        'expected' in value &&
+        value.expected === 'flight-runtime-contract/2' &&
+        'received' in value &&
+        typeof value.received === 'string');
+}
+function compareExternalSymbolIdentities(left, right) {
+    return compareTextCodeUnits(left.sourceName, right.sourceName) || compareTextCodeUnits(left.space, right.space);
+}
+function createSortedExternalSymbolIdentities(identities) {
+    const normalized = identities.map(normalizeExternalSymbolIdentity);
+    return [
+        ...new Map(normalized.map((identity) => [serializeExternalSymbolIdentity(identity), identity])).values(),
+    ].sort(compareExternalSymbolIdentities);
+}
+function normalizeExternalSymbolIdentity(identity) {
+    return { sourceName: identity.sourceName.normalize('NFC'), space: identity.space };
+}
+function serializeExternalSymbolIdentity(identity) {
+    return JSON.stringify([identity.sourceName, identity.space]);
+}
+//# sourceMappingURL=compilerRuntimeExternalSymbolCompleteness.js.map

package/dist/packages/compiler-runtime-contract/src/compilerRuntimeExternalSymbolCompleteness.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"compilerRuntimeExternalSymbolCompleteness.js","sourceRoot":"","sources":["../../../../../compiler-runtime-contract/src/compilerRuntimeExternalSymbolCompleteness.ts"],"names":[],"mappings":"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"}

package/dist/packages/compiler-runtime-contract/src/compilerRuntimeExternalSymbolReachability.d.ts

@@ -0,0 +1,3 @@
+import type { CompilerRuntimeExternalSymbolIdentity, IrModule } from '../../compiler-types/src/index.js';
+export declare function collectIrModulesRuntimeExternalSymbolIdentities(modules: readonly Readonly<IrModule>[]): readonly CompilerRuntimeExternalSymbolIdentity[];
+//# sourceMappingURL=compilerRuntimeExternalSymbolReachability.d.ts.map

package/dist/packages/compiler-runtime-contract/src/compilerRuntimeExternalSymbolReachability.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"compilerRuntimeExternalSymbolReachability.d.ts","sourceRoot":"","sources":["../../../../../compiler-runtime-contract/src/compilerRuntimeExternalSymbolReachability.ts"],"names":[],"mappings":"AAEA,OAAO,KAAK,EAAE,qCAAqC,EAAgB,QAAQ,EAAE,MAAM,mCAAmC,CAAC;AAEvH,wBAAgB,+CAA+C,CAC7D,OAAO,EAAE,SAAS,QAAQ,CAAC,QAAQ,CAAC,EAAE,GACrC,SAAS,qCAAqC,EAAE,CA4ClD"}

package/dist/packages/compiler-runtime-contract/src/compilerRuntimeExternalSymbolReachability.js

@@ -0,0 +1,89 @@
+import { compareTextCodeUnits } from '../../compiler-canonical-form/src/index.js';
+import { analyzeIrModuleTraversal } from '../../compiler-ir-traversal/src/index.js';
+export function collectIrModulesRuntimeExternalSymbolIdentities(modules) {
+    const identities = new Map();
+    const add = (sourceName, space) => {
+        const normalized = sourceName.normalize('NFC');
+        if (space === 'type' && compilerIntrinsicTypeNames.has(normalized))
+            return;
+        if (space === 'value' && compilerIntrinsicValueNames.has(normalized))
+            return;
+        const identity = { sourceName: normalized, space };
+        identities.set(JSON.stringify([identity.sourceName, identity.space]), identity);
+    };
+    for (const module of modules) {
+        const erasedTypeArgumentPaths = [];
+        // `typeof x` asks whether a global exists; it does not use it. ECMAScript evaluates a typeof
+        // operand naming an undeclared identifier to "undefined" rather than throwing, so a module that
+        // only probes a symbol makes no runtime claim on it and must not require a binding. Only a bare
+        // identifier is protected this way: `typeof a.b` still evaluates `a`, so it remains a use.
+        const presenceQueryOperands = new Set();
+        analyzeIrModuleTraversal(module, {
+            expression(expression) {
+                if (expression.kind === 'unary' && expression.operator === 'typeof') {
+                    presenceQueryOperands.add(expression.operand);
+                    return;
+                }
+                if (expression.kind === 'identifier' &&
+                    expression.reference.kind === 'ambient' &&
+                    !presenceQueryOperands.has(expression)) {
+                    add(expression.reference.name, 'value');
+                }
+            },
+            type(type, path) {
+                if (isCompilerOptionalChainValueTypePath(path))
+                    return;
+                if (erasedTypeArgumentPaths.some((prefix) => isCompilerIrTraversalPathWithin(path, prefix)))
+                    return;
+                if (type.kind === 'named' && type.reference.kind === 'ambient') {
+                    for (const index of compilerErasedTypeArgumentIndexes.get(type.reference.name) ?? []) {
+                        erasedTypeArgumentPaths.push([...path, 'typeArguments', index]);
+                    }
+                }
+                if (type.kind === 'named' && type.reference.kind === 'ambient')
+                    add(type.reference.name, 'type');
+                if (type.kind === 'typeOf' && type.reference.kind === 'ambient')
+                    add(type.reference.name, 'value');
+            },
+        });
+    }
+    return [...identities.values()].sort(compareIrRuntimeExternalSymbolIdentities);
+}
+// Optional-chain valueType is checker evidence used to classify the source operation. It is not a
+// value representation that the selected runtime must provide; the concrete resultType remains
+// independently reachable and authoritative for emitted storage.
+function isCompilerOptionalChainValueTypePath(path) {
+    return path.some((part, index) => part === 'optionalChain' && path[index + 1] === 'valueType');
+}
+function isCompilerIrTraversalPathWithin(path, prefix) {
+    return prefix.length <= path.length && prefix.every((part, index) => path[index] === part);
+}
+function compareIrRuntimeExternalSymbolIdentities(left, right) {
+    return compareTextCodeUnits(left.sourceName, right.sourceName) || compareTextCodeUnits(left.space, right.space);
+}
+// These TypeScript utility wrappers change compile-time type meaning but do not name runtime storage.
+const compilerIntrinsicTypeNames = new Set([
+    'Awaited',
+    'Exclude',
+    'Extract',
+    'FlatArray',
+    'NonNullable',
+    'NoInfer',
+    'Omit',
+    'Parameters',
+    'Partial',
+    'Pick',
+    'PropertyKey',
+    'Readonly',
+    'ReturnType',
+    'Required',
+    'ThisType',
+]);
+const compilerErasedTypeArgumentIndexes = new Map([
+    ['Exclude', [1]],
+    ['Extract', [1]],
+    ['Omit', [1]],
+    ['Pick', [1]],
+]);
+const compilerIntrinsicValueNames = new Set(['undefined']);
+//# sourceMappingURL=compilerRuntimeExternalSymbolReachability.js.map

package/dist/packages/compiler-runtime-contract/src/compilerRuntimeExternalSymbolReachability.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"compilerRuntimeExternalSymbolReachability.js","sourceRoot":"","sources":["../../../../../compiler-runtime-contract/src/compilerRuntimeExternalSymbolReachability.ts"],"names":[],"mappings":"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"}

package/dist/packages/compiler-runtime-contract/src/compilerRuntimeTaskCapability.d.ts

@@ -0,0 +1,6 @@
+import type { CompilerAsyncStateMachineAnalysis, CompilerAsyncTaskInventory, CompilerRuntimeTaskCapabilityAnalysisMismatchFailure, CompilerRuntimeTaskCapabilityCompleteness, CompilerRuntimeTaskCapabilityContractMismatchFailure, CompilerRuntimeTaskCapabilityPlan, CompilerRuntimeTaskCapabilityRequirements } from '../../compiler-types/src/index.js';
+export declare function analyzeCompilerRuntimeTaskCapabilityCompleteness(requirements: Readonly<CompilerRuntimeTaskCapabilityRequirements>, plan: Readonly<CompilerRuntimeTaskCapabilityPlan>): CompilerRuntimeTaskCapabilityCompleteness;
+export declare function collectCompilerRuntimeTaskCapabilityRequirements(taskInventory: Readonly<CompilerAsyncTaskInventory>, stateMachines: Readonly<CompilerAsyncStateMachineAnalysis>): CompilerRuntimeTaskCapabilityRequirements;
+export declare function isCompilerRuntimeTaskCapabilityAnalysisMismatchFailure(value: unknown): value is CompilerRuntimeTaskCapabilityAnalysisMismatchFailure;
+export declare function isCompilerRuntimeTaskCapabilityContractMismatchFailure(value: unknown): value is CompilerRuntimeTaskCapabilityContractMismatchFailure;
+//# sourceMappingURL=compilerRuntimeTaskCapability.d.ts.map

package/dist/packages/compiler-runtime-contract/src/compilerRuntimeTaskCapability.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"compilerRuntimeTaskCapability.d.ts","sourceRoot":"","sources":["../../../../../compiler-runtime-contract/src/compilerRuntimeTaskCapability.ts"],"names":[],"mappings":"AACA,OAAO,KAAK,EACV,iCAAiC,EACjC,0BAA0B,EAI1B,oDAAoD,EACpD,yCAAyC,EACzC,oDAAoD,EAEpD,iCAAiC,EAEjC,yCAAyC,EAC1C,MAAM,mCAAmC,CAAC;AAE3C,wBAAgB,gDAAgD,CAC9D,YAAY,EAAE,QAAQ,CAAC,yCAAyC,CAAC,EACjE,IAAI,EAAE,QAAQ,CAAC,iCAAiC,CAAC,GAChD,yCAAyC,CAsC3C;AAED,wBAAgB,gDAAgD,CAC9D,aAAa,EAAE,QAAQ,CAAC,0BAA0B,CAAC,EACnD,aAAa,EAAE,QAAQ,CAAC,iCAAiC,CAAC,GACzD,yCAAyC,CAoD3C;AAED,wBAAgB,sDAAsD,CACpE,KAAK,EAAE,OAAO,GACb,KAAK,IAAI,oDAAoD,CAY/D;AAED,wBAAgB,sDAAsD,CACpE,KAAK,EAAE,OAAO,GACb,KAAK,IAAI,oDAAoD,CAU/D"}

package/dist/packages/compiler-runtime-contract/src/compilerRuntimeTaskCapability.js

@@ -0,0 +1,247 @@
+import { compareTextCodeUnits } from '../../compiler-canonical-form/src/index.js';
+export function analyzeCompilerRuntimeTaskCapabilityCompleteness(requirements, plan) {
+    assertCompilerRuntimeTaskCapabilityContract(plan);
+    const capabilities = plan.capabilities.map(normalizeCompilerRuntimeTaskCapability).sort(compareTaskCapabilities);
+    const capabilityGroups = new Map();
+    for (const capability of capabilities) {
+        const group = capabilityGroups.get(capability.capability) ?? [];
+        group.push(capability);
+        capabilityGroups.set(capability.capability, group);
+    }
+    const duplicateCapabilities = compilerRuntimeTaskCapabilityOrder.filter((capability) => (capabilityGroups.get(capability)?.length ?? 0) > 1);
+    const invalidCapabilities = compilerRuntimeTaskCapabilityOrder.filter((capability) => capabilityGroups.get(capability)?.some((candidate) => !isCompilerRuntimeTaskCapabilityValid(candidate)));
+    const missingCapabilities = requirements.requirements
+        .map((requirement) => requirement.capability)
+        .filter((capability) => {
+        const group = capabilityGroups.get(capability);
+        return group?.length !== 1 || !isCompilerRuntimeTaskCapabilityValid(group[0]);
+    });
+    const common = {
+        capabilities,
+        contract: plan.contract,
+        requirements,
+        schema: 'flight-runtime-task-capability-completeness/1',
+    };
+    return cloneCompilerRuntimeTaskCapabilityValue(duplicateCapabilities.length === 0 && invalidCapabilities.length === 0 && missingCapabilities.length === 0
+        ? { ...common, kind: 'complete' }
+        : {
+            ...common,
+            duplicateCapabilities,
+            invalidCapabilities,
+            kind: 'incomplete',
+            missingCapabilities,
+        });
+}
+export function collectCompilerRuntimeTaskCapabilityRequirements(taskInventory, stateMachines) {
+    if (!isCompilerRuntimeTaskCapabilityModuleEqual(taskInventory.module, stateMachines.module)) {
+        throw createCompilerRuntimeTaskCapabilityAnalysisMismatchFailure(taskInventory.module, stateMachines.module);
+    }
+    const evidence = new Map();
+    for (const machine of stateMachines.machines) {
+        addCompilerRuntimeTaskCapabilityEvidence(evidence, 'construct', {
+            kind: 'stateMachine',
+            path: machine.path,
+            reason: 'construction',
+        });
+        for (const step of machine.states.flatMap((state) => state.steps)) {
+            if (step.kind === 'resolve') {
+                addCompilerRuntimeTaskCapabilityEvidence(evidence, 'normalize', {
+                    kind: 'stateMachine',
+                    path: step.path,
+                    reason: 'assimilation',
+                });
+            }
+            if (step.kind === 'suspend') {
+                addCompilerRuntimeTaskCapabilityEvidence(evidence, 'continue', {
+                    kind: 'stateMachine',
+                    path: step.path,
+                    reason: 'continuation',
+                });
+            }
+        }
+    }
+    for (const operation of taskInventory.operations) {
+        const capability = getCompilerAsyncTaskOperationRuntimeCapability(operation);
+        if (!capability)
+            continue;
+        addCompilerRuntimeTaskCapabilityEvidence(evidence, capability, {
+            kind: 'taskOperation',
+            operation: operation.operation,
+            path: operation.path,
+        });
+    }
+    return cloneCompilerRuntimeTaskCapabilityValue({
+        module: taskInventory.module,
+        requirements: compilerRuntimeTaskCapabilityOrder.flatMap((capability) => {
+            const capabilityEvidence = evidence.get(capability);
+            return capabilityEvidence
+                ? [
+                    {
+                        capability,
+                        evidence: createCompilerRuntimeTaskCapabilityEvidenceSet(capabilityEvidence),
+                    },
+                ]
+                : [];
+        }),
+        schema: 'flight-runtime-task-capability-requirements/1',
+    });
+}
+export function isCompilerRuntimeTaskCapabilityAnalysisMismatchFailure(value) {
+    return (value instanceof Error &&
+        'kind' in value &&
+        value.kind === 'runtime-task-capability-analysis-mismatch' &&
+        'code' in value &&
+        value.code === 'module-identity' &&
+        'taskInventoryModule' in value &&
+        isCompilerRuntimeTaskCapabilityModuleIdentity(value.taskInventoryModule) &&
+        'stateMachineModule' in value &&
+        isCompilerRuntimeTaskCapabilityModuleIdentity(value.stateMachineModule));
+}
+export function isCompilerRuntimeTaskCapabilityContractMismatchFailure(value) {
+    return (value instanceof Error &&
+        'kind' in value &&
+        value.kind === 'runtime-task-capability-contract-mismatch' &&
+        'expected' in value &&
+        value.expected === 'flight-runtime-task-capability-abi/1' &&
+        'received' in value &&
+        typeof value.received === 'string');
+}
+function addCompilerRuntimeTaskCapabilityEvidence(evidence, capability, item) {
+    const existing = evidence.get(capability) ?? [];
+    existing.push(item);
+    evidence.set(capability, existing);
+}
+function assertCompilerRuntimeTaskCapabilityContract(plan) {
+    if (plan.contract === 'flight-runtime-task-capability-abi/1')
+        return;
+    const failure = Object.assign(new Error(`Runtime task capability plan uses ${String(plan.contract)}; expected flight-runtime-task-capability-abi/1`), {
+        expected: 'flight-runtime-task-capability-abi/1',
+        kind: 'runtime-task-capability-contract-mismatch',
+        received: String(plan.contract),
+    });
+    failure.name = 'CompilerRuntimeTaskCapabilityContractMismatchError';
+    throw failure;
+}
+function cloneCompilerRuntimeTaskCapabilityValue(value) {
+    const clone = structuredClone(value);
+    freezeCompilerRuntimeTaskCapabilityValue(clone, new WeakSet());
+    return clone;
+}
+function compareTaskCapabilities(left, right) {
+    return (compilerRuntimeTaskCapabilityOrder.indexOf(left.capability) -
+        compilerRuntimeTaskCapabilityOrder.indexOf(right.capability) ||
+        compareTextCodeUnits(JSON.stringify(left), JSON.stringify(right)));
+}
+function createCompilerRuntimeTaskCapabilityAnalysisMismatchFailure(taskInventoryModule, stateMachineModule) {
+    const failure = Object.assign(new Error('Task inventory and state-machine analysis identify different modules'), {
+        code: 'module-identity',
+        kind: 'runtime-task-capability-analysis-mismatch',
+        stateMachineModule: structuredClone(stateMachineModule),
+        taskInventoryModule: structuredClone(taskInventoryModule),
+    });
+    failure.name = 'CompilerRuntimeTaskCapabilityAnalysisMismatchError';
+    return failure;
+}
+function createCompilerRuntimeTaskCapabilityEvidenceSet(evidence) {
+    return [
+        ...new Map(evidence.map((item) => [getCompilerRuntimeTaskCapabilityEvidenceIdentity(item), item])).values(),
+    ].sort((left, right) => compareTextCodeUnits(getCompilerRuntimeTaskCapabilityEvidenceIdentity(left), getCompilerRuntimeTaskCapabilityEvidenceIdentity(right)));
+}
+function freezeCompilerRuntimeTaskCapabilityValue(value, seen) {
+    if (!value || typeof value !== 'object' || seen.has(value))
+        return;
+    seen.add(value);
+    for (const child of Object.values(value))
+        freezeCompilerRuntimeTaskCapabilityValue(child, seen);
+    Object.freeze(value);
+}
+function getCompilerAsyncTaskOperationRuntimeCapability(operation) {
+    switch (operation.operation) {
+        case 'catch':
+        case 'then':
+            return 'continue';
+        case 'construct':
+            return 'construct';
+        case 'finally':
+            return 'cleanup';
+        case 'joinAll':
+            return 'joinAll';
+        case 'ready':
+            return 'normalize';
+        case 'reject':
+            return 'reject';
+        case 'invokeAsync':
+            return undefined;
+    }
+}
+function getCompilerRuntimeTaskCapabilityEvidenceIdentity(evidence) {
+    return JSON.stringify(evidence.kind === 'stateMachine'
+        ? [evidence.path, evidence.kind, evidence.reason]
+        : [evidence.path, evidence.kind, evidence.operation]);
+}
+function isCompilerRuntimeTaskCapabilityModuleEqual(left, right) {
+    return left.name === right.name && left.packageName === right.packageName && left.source === right.source;
+}
+function isCompilerRuntimeTaskCapabilityModuleIdentity(value) {
+    return (!!value &&
+        typeof value === 'object' &&
+        'name' in value &&
+        typeof value.name === 'string' &&
+        'packageName' in value &&
+        typeof value.packageName === 'string' &&
+        'source' in value &&
+        typeof value.source === 'string');
+}
+function isCompilerRuntimeTaskCapabilityValid(capability) {
+    switch (capability.capability) {
+        case 'cleanup':
+            return (capability.invocation === 'instanceMethod' &&
+                isCompilerRuntimeTaskCapabilityMemberNameValid(capability.memberName) &&
+                capability.operation === 'finally' &&
+                capability.operationSemantics === 'flight-compiler-task-operation-semantics/1');
+        case 'construct':
+            return (capability.completionSemantics === 'flight-compiler-async-task-completion/1' &&
+                capability.executorInvocation === 'synchronous' &&
+                Array.isArray(capability.executorParameters) &&
+                capability.executorParameters.length === 2 &&
+                capability.executorParameters[0] === 'resolve' &&
+                capability.executorParameters[1] === 'reject' &&
+                capability.invocation === 'constructor' &&
+                capability.settlementCallbacks === 'first-call-wins-assimilating-resolve-exact-reject');
+        case 'continue':
+            return (capability.awaitSemantics === 'flight-compiler-await-semantics/1' &&
+                capability.invocation === 'instanceMethod' &&
+                isCompilerRuntimeTaskCapabilityMemberNameValid(capability.memberName) &&
+                capability.operation === 'then' &&
+                capability.operationSemantics === 'flight-compiler-task-operation-semantics/1');
+        case 'joinAll':
+        case 'normalize':
+        case 'reject':
+            return (capability.invocation === 'staticMethod' &&
+                isCompilerRuntimeTaskCapabilityMemberNameValid(capability.memberName) &&
+                capability.operation === compilerRuntimeTaskCapabilityOperation[capability.capability] &&
+                capability.operationSemantics === 'flight-compiler-task-operation-semantics/1');
+    }
+}
+function isCompilerRuntimeTaskCapabilityMemberNameValid(memberName) {
+    return memberName.length > 0 && memberName === memberName.normalize('NFC');
+}
+function normalizeCompilerRuntimeTaskCapability(capability) {
+    return capability.capability === 'construct'
+        ? { ...capability, executorParameters: [...capability.executorParameters] }
+        : { ...capability, memberName: capability.memberName.normalize('NFC') };
+}
+const compilerRuntimeTaskCapabilityOperation = {
+    joinAll: 'joinAll',
+    normalize: 'ready',
+    reject: 'reject',
+};
+const compilerRuntimeTaskCapabilityOrder = [
+    'cleanup',
+    'construct',
+    'continue',
+    'joinAll',
+    'normalize',
+    'reject',
+];
+//# sourceMappingURL=compilerRuntimeTaskCapability.js.map