@aws-cdk-testing/cli-integ 3.6.0 → 3.7.1

package/lib/npm.js

@@ -1,9 +1,39 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
+exports.npmMostRecentMatching = npmMostRecentMatching;
+exports.npmQueryInstalledVersion = npmQueryInstalledVersion;
 exports.typescriptVersionsSync = typescriptVersionsSync;
 exports.typescriptVersionsYoungerThanDaysSync = typescriptVersionsYoungerThanDaysSync;
 const child_process_1 = require("child_process");
+const semver = require("semver");
+const shell_1 = require("./shell");
 const MINIMUM_VERSION = '3.9';
+async function npmMostRecentMatching(packageName, range) {
+    const output = JSON.parse(await (0, shell_1.shell)(['node', require.resolve('npm'), '--silent', 'view', `${packageName}@${range}`, 'version', '--json'], {
+        show: 'error',
+    }));
+    if (typeof output === 'string') {
+        return output;
+    }
+    if (!Array.isArray(output)) {
+        throw new Error(`Expected array from npm, got: ${JSON.stringify(output)}`);
+    }
+    if (output.length === 0) {
+        throw new Error(`Found no package matching ${packageName}@${range}`);
+    }
+    // Otherwise an array that may or may not be sorted. Sort it then get the top one.
+    output.sort((a, b) => semver.compare(a, b));
+    return output[output.length - 1];
+}
+async function npmQueryInstalledVersion(packageName, dir) {
+    const reportStr = await (0, shell_1.shell)(['node', require.resolve('npm'), 'list', '--json', '--depth', '0', packageName], {
+        cwd: dir,
+        show: 'error',
+        captureStderr: false,
+    });
+    const report = JSON.parse(reportStr);
+    return report.dependencies[packageName].version;
+}
 /**
  * Use NPM preinstalled on the machine to look up a list of TypeScript versions
  */
@@ -35,4 +65,4 @@ function typescriptVersionsYoungerThanDaysSync(days, versions) {
 function reQuote(str) {
     return str.replace(/[.*+?^${}()|[\]\\]/g, '\\$&');
 }
-//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoibnBtLmpzIiwic291cmNlUm9vdCI6IiIsInNvdXJjZXMiOlsibnBtLnRzIl0sIm5hbWVzIjpbXSwibWFwcGluZ3MiOiI7O0FBT0Esd0RBS0M7QUFLRCxzRkFtQkM7QUFwQ0QsaURBQTBDO0FBRTFDLE1BQU0sZUFBZSxHQUFHLEtBQUssQ0FBQztBQUU5Qjs7R0FFRztBQUNILFNBQWdCLHNCQUFzQjtJQUNwQyxNQUFNLEVBQUUsTUFBTSxFQUFFLEdBQUcsSUFBQSx5QkFBUyxFQUFDLEtBQUssRUFBRSxDQUFDLFVBQVUsRUFBRSxNQUFNLEVBQUUsZ0JBQWdCLGVBQWUsRUFBRSxFQUFFLFNBQVMsRUFBRSxRQUFRLENBQUMsRUFBRSxFQUFFLFFBQVEsRUFBRSxPQUFPLEVBQUUsQ0FBQyxDQUFDO0lBRXpJLE1BQU0sUUFBUSxHQUFhLElBQUksQ0FBQyxLQUFLLENBQUMsTUFBTSxDQUFDLENBQUM7SUFDOUMsT0FBTyxLQUFLLENBQUMsSUFBSSxDQUFDLElBQUksR0FBRyxDQUFDLFFBQVEsQ0FBQyxHQUFHLENBQUMsQ0FBQyxDQUFDLEVBQUUsQ0FBQyxDQUFDLENBQUMsS0FBSyxDQUFDLEdBQUcsQ0FBQyxDQUFDLEtBQUssQ0FBQyxDQUFDLEVBQUUsQ0FBQyxDQUFDLENBQUMsSUFBSSxDQUFDLEdBQUcsQ0FBQyxDQUFDLENBQUMsQ0FBQyxDQUFDO0FBQ3BGLENBQUM7QUFFRDs7R0FFRztBQUNILFNBQWdCLHFDQUFxQyxDQUFDLElBQVksRUFBRSxRQUFrQjtJQUNwRixNQUFNLEVBQUUsTUFBTSxFQUFFLEdBQUcsSUFBQSx5QkFBUyxFQUFDLEtBQUssRUFBRSxDQUFDLFVBQVUsRUFBRSxNQUFNLEVBQUUsWUFBWSxFQUFFLE1BQU0sRUFBRSxRQUFRLENBQUMsRUFBRSxFQUFFLFFBQVEsRUFBRSxPQUFPLEVBQUUsQ0FBQyxDQUFDO0lBQ2pILE1BQU0sWUFBWSxHQUEyQixJQUFJLENBQUMsS0FBSyxDQUFDLE1BQU0sQ0FBQyxDQUFDO0lBRWhFLE1BQU0sVUFBVSxHQUFHLElBQUksSUFBSSxDQUFDLElBQUksQ0FBQyxHQUFHLEVBQUUsR0FBRyxDQUFDLElBQUksR0FBRyxFQUFFLEdBQUcsSUFBSSxHQUFHLElBQUksQ0FBQyxDQUFDLENBQUM7SUFDcEUsTUFBTSxXQUFXLEdBQUcsVUFBVSxDQUFDLFdBQVcsRUFBRSxDQUFDO0lBRTdDLE1BQU0sY0FBYyxHQUFHLE1BQU0sQ0FBQyxPQUFPLENBQUMsWUFBWSxDQUFDO1NBQ2hELE1BQU0sQ0FBQyxDQUFDLENBQUMsQ0FBQyxFQUFFLEtBQUssQ0FBQyxFQUFFLEVBQUUsQ0FBQyxLQUFLLEdBQUcsV0FBVyxDQUFDO1NBQzNDLEdBQUcsQ0FBQyxDQUFDLENBQUMsQ0FBQyxDQUFDLEVBQUUsRUFBRSxDQUFDLENBQUMsQ0FBQyxDQUFDO0lBRW5CLGdEQUFnRDtJQUNoRCxrRUFBa0U7SUFDbEUsd0dBQXdHO0lBQ3hHLHFGQUFxRjtJQUNyRixPQUFPLFFBQVEsQ0FBQyxNQUFNLENBQUMsQ0FBQyxJQUFJLEVBQUUsRUFBRTtRQUM5QixNQUFNLEVBQUUsR0FBRyxJQUFJLE1BQU0sQ0FBQyxJQUFJLE9BQU8sQ0FBQyxJQUFJLENBQUMsVUFBVSxDQUFDLENBQUM7UUFDbkQsT0FBTyxjQUFjLENBQUMsSUFBSSxDQUFDLEtBQUssQ0FBQyxFQUFFLENBQUMsS0FBSyxDQUFDLEtBQUssQ0FBQyxFQUFFLENBQUMsQ0FBQyxDQUFDO0lBQ3ZELENBQUMsQ0FBQyxDQUFDO0FBQ0wsQ0FBQztBQUVELFNBQVMsT0FBTyxDQUFDLEdBQVc7SUFDMUIsT0FBTyxHQUFHLENBQUMsT0FBTyxDQUFDLHFCQUFxQixFQUFFLE1BQU0sQ0FBQyxDQUFDO0FBQ3BELENBQUMiLCJzb3VyY2VzQ29udGVudCI6WyJpbXBvcnQgeyBzcGF3blN5bmMgfSBmcm9tICdjaGlsZF9wcm9jZXNzJztcblxuY29uc3QgTUlOSU1VTV9WRVJTSU9OID0gJzMuOSc7XG5cbi8qKlxuICogVXNlIE5QTSBwcmVpbnN0YWxsZWQgb24gdGhlIG1hY2hpbmUgdG8gbG9vayB1cCBhIGxpc3Qgb2YgVHlwZVNjcmlwdCB2ZXJzaW9uc1xuICovXG5leHBvcnQgZnVuY3Rpb24gdHlwZXNjcmlwdFZlcnNpb25zU3luYygpOiBzdHJpbmdbXSB7XG4gIGNvbnN0IHsgc3Rkb3V0IH0gPSBzcGF3blN5bmMoJ25wbScsIFsnLS1zaWxlbnQnLCAndmlldycsIGB0eXBlc2NyaXB0QD49JHtNSU5JTVVNX1ZFUlNJT059YCwgJ3ZlcnNpb24nLCAnLS1qc29uJ10sIHsgZW5jb2Rpbmc6ICd1dGYtOCcgfSk7XG5cbiAgY29uc3QgdmVyc2lvbnM6IHN0cmluZ1tdID0gSlNPTi5wYXJzZShzdGRvdXQpO1xuICByZXR1cm4gQXJyYXkuZnJvbShuZXcgU2V0KHZlcnNpb25zLm1hcCh2ID0+IHYuc3BsaXQoJy4nKS5zbGljZSgwLCAyKS5qb2luKCcuJykpKSk7XG59XG5cbi8qKlxuICogVXNlIE5QTSBwcmVpbnN0YWxsZWQgb24gdGhlIG1hY2hpbmUgdG8gcXVlcnkgcHVibGlzaCB0aW1lcyBvZiB2ZXJzaW9uc1xuICovXG5leHBvcnQgZnVuY3Rpb24gdHlwZXNjcmlwdFZlcnNpb25zWW91bmdlclRoYW5EYXlzU3luYyhkYXlzOiBudW1iZXIsIHZlcnNpb25zOiBzdHJpbmdbXSk6IHN0cmluZ1tdIHtcbiAgY29uc3QgeyBzdGRvdXQgfSA9IHNwYXduU3luYygnbnBtJywgWyctLXNpbGVudCcsICd2aWV3JywgJ3R5cGVzY3JpcHQnLCAndGltZScsICctLWpzb24nXSwgeyBlbmNvZGluZzogJ3V0Zi04JyB9KTtcbiAgY29uc3QgdmVyc2lvblRzTWFwOiBSZWNvcmQ8c3RyaW5nLCBzdHJpbmc+ID0gSlNPTi5wYXJzZShzdGRvdXQpO1xuXG4gIGNvbnN0IGN1dG9mZkRhdGUgPSBuZXcgRGF0ZShEYXRlLm5vdygpIC0gKGRheXMgKiAyNCAqIDM2MDAgKiAxMDAwKSk7XG4gIGNvbnN0IGN1dG9mZkRhdGVTID0gY3V0b2ZmRGF0ZS50b0lTT1N0cmluZygpO1xuXG4gIGNvbnN0IHJlY2VudFZlcnNpb25zID0gT2JqZWN0LmVudHJpZXModmVyc2lvblRzTWFwKVxuICAgIC5maWx0ZXIoKFtfLCBkYXRlU10pID0+IGRhdGVTID4gY3V0b2ZmRGF0ZVMpXG4gICAgLm1hcCgoW3ZdKSA9PiB2KTtcblxuICAvLyBJbnB1dCB2ZXJzaW9ucyBhcmUgb2YgdGhlIGZvcm0gMy45LCA1LjIsIGV0Yy5cbiAgLy8gQWN0dWFsIHZlcnNpb25zIGFyZSBvZiB0aGUgZm9ybSBgMy45LjE1YCwgYDUuMy4wLWRldi4yMDUxMTMxMWAuXG4gIC8vIFJldHVybiBvbmx5IDItZGlnaXQgdmVyc2lvbnMgZm9yIHdoaWNoIHRoZXJlIGlzIGEgbm9uLXByZXJlbGVhc2UgdmVyc2lvbiBpbiB0aGUgc2V0IG9mIHJlY2VudFZlcnNpb25zXG4gIC8vIFNvIGEgMi1kaWdpdCB2ZXJzaW9ucyB0aGF0IGlzIGZvbGxvd2VkIGJ5IGAuPGRpZ2l0cz5gIHVudGlsIHRoZSBlbmQgb2YgdGhlIHN0cmluZy5cbiAgcmV0dXJuIHZlcnNpb25zLmZpbHRlcigodHdvVikgPT4ge1xuICAgIGNvbnN0IHJlID0gbmV3IFJlZ0V4cChgXiR7cmVRdW90ZSh0d29WKX1cXFxcLlxcXFxkKyRgKTtcbiAgICByZXR1cm4gcmVjZW50VmVyc2lvbnMuc29tZShmdWxsViA9PiBmdWxsVi5tYXRjaChyZSkpO1xuICB9KTtcbn1cblxuZnVuY3Rpb24gcmVRdW90ZShzdHI6IHN0cmluZyk6IHN0cmluZyB7XG4gIHJldHVybiBzdHIucmVwbGFjZSgvWy4qKz9eJHt9KCl8W1xcXVxcXFxdL2csICdcXFxcJCYnKTtcbn1cbiJdfQ==
+//# sourceMappingURL=data:application/json;base64,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

package/lib/package-sources/cli-npm-source.d.ts

@@ -0,0 +1,14 @@
+import type { IRunnerSource, ITestCliSource, IPreparedRunnerSource } from './source';
+export declare class RunnerCliNpmSource implements IRunnerSource<ITestCliSource> {
+    private readonly range;
+    readonly sourceDescription: string;
+    constructor(range: string);
+    runnerPrepare(): Promise<IPreparedRunnerSource<ITestCliSource>>;
+}
+export declare class TestCliNpmSource implements ITestCliSource {
+    private readonly installRoot;
+    private readonly range;
+    constructor(installRoot: string, range: string);
+    makeCliAvailable(): Promise<void>;
+    requestedVersion(): string;
+}

package/lib/package-sources/cli-npm-source.js

@@ -0,0 +1,50 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.TestCliNpmSource = exports.RunnerCliNpmSource = void 0;
+const os = require("os");
+const path = require("path");
+const fs = require("fs-extra");
+const npm_1 = require("../npm");
+const shell_1 = require("../shell");
+class RunnerCliNpmSource {
+    range;
+    sourceDescription;
+    constructor(range) {
+        this.range = range;
+        this.sourceDescription = `${this.range} (npm)`;
+    }
+    async runnerPrepare() {
+        const tempDir = fs.mkdtempSync(path.join(os.tmpdir(), 'tmpcdk'));
+        fs.mkdirSync(tempDir, { recursive: true });
+        await (0, shell_1.shell)(['node', require.resolve('npm'), 'install', `aws-cdk@${this.range}`], {
+            cwd: tempDir,
+        });
+        const installedVersion = await (0, npm_1.npmQueryInstalledVersion)('aws-cdk', tempDir);
+        return {
+            version: installedVersion,
+            async dispose() {
+                (0, shell_1.rimraf)(tempDir);
+            },
+            serialize: () => {
+                return [TestCliNpmSource, [tempDir, this.range]];
+            },
+        };
+    }
+}
+exports.RunnerCliNpmSource = RunnerCliNpmSource;
+class TestCliNpmSource {
+    installRoot;
+    range;
+    constructor(installRoot, range) {
+        this.installRoot = installRoot;
+        this.range = range;
+    }
+    async makeCliAvailable() {
+        (0, shell_1.addToShellPath)(path.join(this.installRoot, 'node_modules', '.bin'));
+    }
+    requestedVersion() {
+        return this.range;
+    }
+}
+exports.TestCliNpmSource = TestCliNpmSource;
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiY2xpLW5wbS1zb3VyY2UuanMiLCJzb3VyY2VSb290IjoiIiwic291cmNlcyI6WyJjbGktbnBtLXNvdXJjZS50cyJdLCJuYW1lcyI6W10sIm1hcHBpbmdzIjoiOzs7QUFBQSx5QkFBeUI7QUFDekIsNkJBQTZCO0FBQzdCLCtCQUErQjtBQUUvQixnQ0FBa0Q7QUFDbEQsb0NBQXlEO0FBRXpELE1BQWEsa0JBQWtCO0lBR0E7SUFGYixpQkFBaUIsQ0FBUztJQUUxQyxZQUE2QixLQUFhO1FBQWIsVUFBSyxHQUFMLEtBQUssQ0FBUTtRQUN4QyxJQUFJLENBQUMsaUJBQWlCLEdBQUcsR0FBRyxJQUFJLENBQUMsS0FBSyxRQUFRLENBQUM7SUFDakQsQ0FBQztJQUVNLEtBQUssQ0FBQyxhQUFhO1FBQ3hCLE1BQU0sT0FBTyxHQUFHLEVBQUUsQ0FBQyxXQUFXLENBQUMsSUFBSSxDQUFDLElBQUksQ0FBQyxFQUFFLENBQUMsTUFBTSxFQUFFLEVBQUUsUUFBUSxDQUFDLENBQUMsQ0FBQztRQUNqRSxFQUFFLENBQUMsU0FBUyxDQUFDLE9BQU8sRUFBRSxFQUFFLFNBQVMsRUFBRSxJQUFJLEVBQUUsQ0FBQyxDQUFDO1FBRTNDLE1BQU0sSUFBQSxhQUFLLEVBQUMsQ0FBQyxNQUFNLEVBQUUsT0FBTyxDQUFDLE9BQU8sQ0FBQyxLQUFLLENBQUMsRUFBRSxTQUFTLEVBQUUsV0FBVyxJQUFJLENBQUMsS0FBSyxFQUFFLENBQUMsRUFBRTtZQUNoRixHQUFHLEVBQUUsT0FBTztTQUNiLENBQUMsQ0FBQztRQUNILE1BQU0sZ0JBQWdCLEdBQUcsTUFBTSxJQUFBLDhCQUF3QixFQUFDLFNBQVMsRUFBRSxPQUFPLENBQUMsQ0FBQztRQUU1RSxPQUFPO1lBQ0wsT0FBTyxFQUFFLGdCQUFnQjtZQUN6QixLQUFLLENBQUMsT0FBTztnQkFDWCxJQUFBLGNBQU0sRUFBQyxPQUFPLENBQUMsQ0FBQztZQUNsQixDQUFDO1lBQ0QsU0FBUyxFQUFFLEdBQUcsRUFBRTtnQkFDZCxPQUFPLENBQUMsZ0JBQWdCLEVBQUUsQ0FBQyxPQUFPLEVBQUUsSUFBSSxDQUFDLEtBQUssQ0FBQyxDQUFDLENBQUM7WUFDbkQsQ0FBQztTQUNGLENBQUM7SUFDSixDQUFDO0NBQ0Y7QUExQkQsZ0RBMEJDO0FBRUQsTUFBYSxnQkFBZ0I7SUFDRTtJQUFzQztJQUFuRSxZQUE2QixXQUFtQixFQUFtQixLQUFhO1FBQW5ELGdCQUFXLEdBQVgsV0FBVyxDQUFRO1FBQW1CLFVBQUssR0FBTCxLQUFLLENBQVE7SUFDaEYsQ0FBQztJQUVNLEtBQUssQ0FBQyxnQkFBZ0I7UUFDM0IsSUFBQSxzQkFBYyxFQUFDLElBQUksQ0FBQyxJQUFJLENBQUMsSUFBSSxDQUFDLFdBQVcsRUFBRSxjQUFjLEVBQUUsTUFBTSxDQUFDLENBQUMsQ0FBQztJQUN0RSxDQUFDO0lBRU0sZ0JBQWdCO1FBQ3JCLE9BQU8sSUFBSSxDQUFDLEtBQUssQ0FBQztJQUNwQixDQUFDO0NBQ0Y7QUFYRCw0Q0FXQyIsInNvdXJjZXNDb250ZW50IjpbImltcG9ydCAqIGFzIG9zIGZyb20gJ29zJztcbmltcG9ydCAqIGFzIHBhdGggZnJvbSAncGF0aCc7XG5pbXBvcnQgKiBhcyBmcyBmcm9tICdmcy1leHRyYSc7XG5pbXBvcnQgdHlwZSB7IElSdW5uZXJTb3VyY2UsIElUZXN0Q2xpU291cmNlLCBJUHJlcGFyZWRSdW5uZXJTb3VyY2UgfSBmcm9tICcuL3NvdXJjZSc7XG5pbXBvcnQgeyBucG1RdWVyeUluc3RhbGxlZFZlcnNpb24gfSBmcm9tICcuLi9ucG0nO1xuaW1wb3J0IHsgYWRkVG9TaGVsbFBhdGgsIHJpbXJhZiwgc2hlbGwgfSBmcm9tICcuLi9zaGVsbCc7XG5cbmV4cG9ydCBjbGFzcyBSdW5uZXJDbGlOcG1Tb3VyY2UgaW1wbGVtZW50cyBJUnVubmVyU291cmNlPElUZXN0Q2xpU291cmNlPiB7XG4gIHB1YmxpYyByZWFkb25seSBzb3VyY2VEZXNjcmlwdGlvbjogc3RyaW5nO1xuXG4gIGNvbnN0cnVjdG9yKHByaXZhdGUgcmVhZG9ubHkgcmFuZ2U6IHN0cmluZykge1xuICAgIHRoaXMuc291cmNlRGVzY3JpcHRpb24gPSBgJHt0aGlzLnJhbmdlfSAobnBtKWA7XG4gIH1cblxuICBwdWJsaWMgYXN5bmMgcnVubmVyUHJlcGFyZSgpOiBQcm9taXNlPElQcmVwYXJlZFJ1bm5lclNvdXJjZTxJVGVzdENsaVNvdXJjZT4+IHtcbiAgICBjb25zdCB0ZW1wRGlyID0gZnMubWtkdGVtcFN5bmMocGF0aC5qb2luKG9zLnRtcGRpcigpLCAndG1wY2RrJykpO1xuICAgIGZzLm1rZGlyU3luYyh0ZW1wRGlyLCB7IHJlY3Vyc2l2ZTogdHJ1ZSB9KTtcblxuICAgIGF3YWl0IHNoZWxsKFsnbm9kZScsIHJlcXVpcmUucmVzb2x2ZSgnbnBtJyksICdpbnN0YWxsJywgYGF3cy1jZGtAJHt0aGlzLnJhbmdlfWBdLCB7XG4gICAgICBjd2Q6IHRlbXBEaXIsXG4gICAgfSk7XG4gICAgY29uc3QgaW5zdGFsbGVkVmVyc2lvbiA9IGF3YWl0IG5wbVF1ZXJ5SW5zdGFsbGVkVmVyc2lvbignYXdzLWNkaycsIHRlbXBEaXIpO1xuXG4gICAgcmV0dXJuIHtcbiAgICAgIHZlcnNpb246IGluc3RhbGxlZFZlcnNpb24sXG4gICAgICBhc3luYyBkaXNwb3NlKCkge1xuICAgICAgICByaW1yYWYodGVtcERpcik7XG4gICAgICB9LFxuICAgICAgc2VyaWFsaXplOiAoKSA9PiB7XG4gICAgICAgIHJldHVybiBbVGVzdENsaU5wbVNvdXJjZSwgW3RlbXBEaXIsIHRoaXMucmFuZ2VdXTtcbiAgICAgIH0sXG4gICAgfTtcbiAgfVxufVxuXG5leHBvcnQgY2xhc3MgVGVzdENsaU5wbVNvdXJjZSBpbXBsZW1lbnRzIElUZXN0Q2xpU291cmNlIHtcbiAgY29uc3RydWN0b3IocHJpdmF0ZSByZWFkb25seSBpbnN0YWxsUm9vdDogc3RyaW5nLCBwcml2YXRlIHJlYWRvbmx5IHJhbmdlOiBzdHJpbmcpIHtcbiAgfVxuXG4gIHB1YmxpYyBhc3luYyBtYWtlQ2xpQXZhaWxhYmxlKCkge1xuICAgIGFkZFRvU2hlbGxQYXRoKHBhdGguam9pbih0aGlzLmluc3RhbGxSb290LCAnbm9kZV9tb2R1bGVzJywgJy5iaW4nKSk7XG4gIH1cblxuICBwdWJsaWMgcmVxdWVzdGVkVmVyc2lvbigpIHtcbiAgICByZXR1cm4gdGhpcy5yYW5nZTtcbiAgfVxufVxuXG4iXX0=

package/lib/package-sources/cli-repo-source.d.ts

@@ -0,0 +1,19 @@
+import type { IRunnerSource, ITestCliSource, IPreparedRunnerSource } from './source';
+/**
+ * Repo source for the CLI
+ *
+ * Just puts the repo path on the $PATH. The CLI should already be compiled to be executable
+ */
+export declare class RunnerCliRepoSource implements IRunnerSource<ITestCliSource> {
+    private readonly repoRoot;
+    readonly sourceDescription: string;
+    private readonly cliBinPath;
+    constructor(repoRoot: string);
+    runnerPrepare(): Promise<IPreparedRunnerSource<ITestCliSource>>;
+}
+export declare class TestCliRepoSource implements ITestCliSource {
+    private readonly cliPath;
+    constructor(cliPath: string);
+    makeCliAvailable(): Promise<void>;
+    requestedVersion(): string;
+}

package/lib/package-sources/cli-repo-source.js

@@ -0,0 +1,49 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.TestCliRepoSource = exports.RunnerCliRepoSource = void 0;
+const path = require("path");
+const fs = require("fs-extra");
+const shell_1 = require("../shell");
+/**
+ * Repo source for the CLI
+ *
+ * Just puts the repo path on the $PATH. The CLI should already be compiled to be executable
+ */
+class RunnerCliRepoSource {
+    repoRoot;
+    sourceDescription;
+    cliBinPath;
+    constructor(repoRoot) {
+        this.repoRoot = repoRoot;
+        this.cliBinPath = path.join(this.repoRoot, 'packages', 'aws-cdk', 'bin');
+        this.sourceDescription = this.cliBinPath;
+    }
+    async runnerPrepare() {
+        if (!await fs.pathExists(path.join(this.repoRoot, 'package.json')) || !await fs.pathExists(path.join(this.repoRoot, 'yarn.lock'))) {
+            throw new Error(`${this.repoRoot}: does not look like the repository root`);
+        }
+        const pj = JSON.parse(await fs.readFile(path.join(this.cliBinPath, '..', 'package.json'), 'utf-8'));
+        return {
+            version: pj.version,
+            dispose: () => Promise.resolve(),
+            serialize: () => {
+                return [TestCliRepoSource, [this.cliBinPath]];
+            },
+        };
+    }
+}
+exports.RunnerCliRepoSource = RunnerCliRepoSource;
+class TestCliRepoSource {
+    cliPath;
+    constructor(cliPath) {
+        this.cliPath = cliPath;
+    }
+    async makeCliAvailable() {
+        (0, shell_1.addToShellPath)(this.cliPath);
+    }
+    requestedVersion() {
+        return '*';
+    }
+}
+exports.TestCliRepoSource = TestCliRepoSource;
+//# sourceMappingURL=data:application/json;base64,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

package/lib/package-sources/find-root.d.ts

@@ -0,0 +1,6 @@
+/**
+ * Find the root directory of the repo from the current directory
+ *
+ * We look for a file that is present only in the root of our AWS CDK CLI repository.
+ */
+export declare function autoFindRepoRoot(): Promise<string>;

package/lib/package-sources/find-root.js

@@ -0,0 +1,18 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.autoFindRepoRoot = autoFindRepoRoot;
+const path = require("path");
+const files_1 = require("../files");
+/**
+ * Find the root directory of the repo from the current directory
+ *
+ * We look for a file that is present only in the root of our AWS CDK CLI repository.
+ */
+async function autoFindRepoRoot() {
+    const found = (0, files_1.findUp)('yarn.lock');
+    if (!found) {
+        throw new Error(`Could not determine repository root: 'yarn.lock' not found from ${process.cwd()}`);
+    }
+    return path.dirname(found);
+}
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiZmluZC1yb290LmpzIiwic291cmNlUm9vdCI6IiIsInNvdXJjZXMiOlsiZmluZC1yb290LnRzIl0sIm5hbWVzIjpbXSwibWFwcGluZ3MiOiI7O0FBUUEsNENBTUM7QUFkRCw2QkFBNkI7QUFDN0Isb0NBQWtDO0FBRWxDOzs7O0dBSUc7QUFDSSxLQUFLLFVBQVUsZ0JBQWdCO0lBQ3BDLE1BQU0sS0FBSyxHQUFHLElBQUEsY0FBTSxFQUFDLFdBQVcsQ0FBQyxDQUFDO0lBQ2xDLElBQUksQ0FBQyxLQUFLLEVBQUUsQ0FBQztRQUNYLE1BQU0sSUFBSSxLQUFLLENBQUMsbUVBQW1FLE9BQU8sQ0FBQyxHQUFHLEVBQUUsRUFBRSxDQUFDLENBQUM7SUFDdEcsQ0FBQztJQUNELE9BQU8sSUFBSSxDQUFDLE9BQU8sQ0FBQyxLQUFLLENBQUMsQ0FBQztBQUM3QixDQUFDIiwic291cmNlc0NvbnRlbnQiOlsiaW1wb3J0ICogYXMgcGF0aCBmcm9tICdwYXRoJztcbmltcG9ydCB7IGZpbmRVcCB9IGZyb20gJy4uL2ZpbGVzJztcblxuLyoqXG4gKiBGaW5kIHRoZSByb290IGRpcmVjdG9yeSBvZiB0aGUgcmVwbyBmcm9tIHRoZSBjdXJyZW50IGRpcmVjdG9yeVxuICpcbiAqIFdlIGxvb2sgZm9yIGEgZmlsZSB0aGF0IGlzIHByZXNlbnQgb25seSBpbiB0aGUgcm9vdCBvZiBvdXIgQVdTIENESyBDTEkgcmVwb3NpdG9yeS5cbiAqL1xuZXhwb3J0IGFzeW5jIGZ1bmN0aW9uIGF1dG9GaW5kUmVwb1Jvb3QoKSB7XG4gIGNvbnN0IGZvdW5kID0gZmluZFVwKCd5YXJuLmxvY2snKTtcbiAgaWYgKCFmb3VuZCkge1xuICAgIHRocm93IG5ldyBFcnJvcihgQ291bGQgbm90IGRldGVybWluZSByZXBvc2l0b3J5IHJvb3Q6ICd5YXJuLmxvY2snIG5vdCBmb3VuZCBmcm9tICR7cHJvY2Vzcy5jd2QoKX1gKTtcbiAgfVxuICByZXR1cm4gcGF0aC5kaXJuYW1lKGZvdW5kKTtcbn1cblxuIl19

package/lib/package-sources/library-globalinstall-source.d.ts

@@ -0,0 +1,20 @@
+import type { IRunnerSource, IPreparedRunnerSource, ITestLibrarySource } from './source';
+/**
+ * A library dependency that cli-integ installs into its own `node_modules`.
+ */
+export declare class RunnerLibraryGlobalInstallSource implements IRunnerSource<ITestLibrarySource> {
+    private readonly packageName;
+    private readonly range;
+    readonly sourceDescription: string;
+    constructor(packageName: string, range: string);
+    runnerPrepare(): Promise<IPreparedRunnerSource<ITestLibrarySource>>;
+}
+export declare class TestLibraryGlobalInstallSource implements ITestLibrarySource {
+    readonly packageName: string;
+    private readonly version;
+    constructor(packageName: string, version: string);
+    requestedVersion(): string;
+    assertJsiiPackagesAvailable(): void;
+    initializeDotnetPackages(currentDir: string): Promise<void>;
+    requestedAlphaVersion(): string;
+}

package/lib/package-sources/library-globalinstall-source.js

@@ -0,0 +1,70 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.TestLibraryGlobalInstallSource = exports.RunnerLibraryGlobalInstallSource = void 0;
+const fs_1 = require("fs");
+const os = require("os");
+const path = require("path");
+const files_1 = require("../files");
+const npm_1 = require("../npm");
+const shell_1 = require("../shell");
+/**
+ * A library dependency that cli-integ installs into its own `node_modules`.
+ */
+class RunnerLibraryGlobalInstallSource {
+    packageName;
+    range;
+    sourceDescription;
+    constructor(packageName, range) {
+        this.packageName = packageName;
+        this.range = range;
+        this.sourceDescription = `${this.packageName}@${this.range}`;
+    }
+    async runnerPrepare() {
+        // Create a tempdir where we install the requested package, then symlink into our `node_modules`
+        const tempDir = await fs_1.promises.mkdtemp(path.join(os.tmpdir(), 'tmpcdk'));
+        await fs_1.promises.mkdir(tempDir, { recursive: true });
+        await (0, shell_1.shell)(['node', require.resolve('npm'), 'install', `${this.packageName}@${this.range}`], {
+            cwd: tempDir,
+        });
+        const symlinkPath = path.join(__dirname, '..', '..', 'node_modules', this.packageName);
+        await fs_1.promises.mkdir(path.dirname(symlinkPath), { recursive: true });
+        await fs_1.promises.symlink(path.join(tempDir, 'node_modules', this.packageName), symlinkPath, 'junction');
+        const version = await (0, npm_1.npmQueryInstalledVersion)(this.packageName, tempDir);
+        return {
+            version,
+            async dispose() {
+                // Remove the symlink again
+                await fs_1.promises.rm(symlinkPath);
+            },
+            serialize: () => {
+                return [TestLibraryGlobalInstallSource, [this.packageName, version]];
+            },
+        };
+    }
+}
+exports.RunnerLibraryGlobalInstallSource = RunnerLibraryGlobalInstallSource;
+class TestLibraryGlobalInstallSource {
+    packageName;
+    version;
+    constructor(packageName, version) {
+        this.packageName = packageName;
+        this.version = version;
+    }
+    requestedVersion() {
+        return this.version;
+    }
+    assertJsiiPackagesAvailable() {
+        // FIXME: Always a no-op.
+    }
+    async initializeDotnetPackages(currentDir) {
+        // FIXME: this code has nothing to do with the package source, really, so shouldn't be here.
+        if (process.env.CWD_FILES_DIR) {
+            await (0, files_1.copyDirectoryContents)(process.env.CWD_FILES_DIR, currentDir);
+        }
+    }
+    requestedAlphaVersion() {
+        return this.version;
+    }
+}
+exports.TestLibraryGlobalInstallSource = TestLibraryGlobalInstallSource;
+//# sourceMappingURL=data:application/json;base64,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

package/lib/package-sources/library-npm-source.d.ts

@@ -0,0 +1,17 @@
+import type { IRunnerSource, IPreparedRunnerSource, ITestLibrarySource } from './source';
+export declare class RunnerLibraryNpmSource implements IRunnerSource<ITestLibrarySource> {
+    private readonly packageName;
+    private readonly range;
+    readonly sourceDescription: string;
+    constructor(packageName: string, range: string);
+    runnerPrepare(): Promise<IPreparedRunnerSource<ITestLibrarySource>>;
+}
+export declare class TestLibraryNpmSource implements ITestLibrarySource {
+    readonly packageName: string;
+    readonly version: string;
+    constructor(packageName: string, version: string);
+    requestedVersion(): string;
+    assertJsiiPackagesAvailable(): void;
+    initializeDotnetPackages(currentDir: string): Promise<void>;
+    requestedAlphaVersion(): string;
+}

package/lib/package-sources/library-npm-source.js

@@ -0,0 +1,60 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.TestLibraryNpmSource = exports.RunnerLibraryNpmSource = void 0;
+const files_1 = require("../files");
+const npm_1 = require("../npm");
+class RunnerLibraryNpmSource {
+    packageName;
+    range;
+    sourceDescription;
+    constructor(packageName, range) {
+        this.packageName = packageName;
+        this.range = range;
+        this.sourceDescription = `${this.packageName}@${this.range}`;
+    }
+    async runnerPrepare() {
+        const version = await (0, npm_1.npmMostRecentMatching)(this.packageName, this.range);
+        return {
+            version: version,
+            async dispose() {
+            },
+            serialize: () => {
+                return [TestLibraryNpmSource, [this.packageName, version]];
+            },
+        };
+    }
+}
+exports.RunnerLibraryNpmSource = RunnerLibraryNpmSource;
+class TestLibraryNpmSource {
+    packageName;
+    version;
+    constructor(packageName, version) {
+        this.packageName = packageName;
+        this.version = version;
+    }
+    requestedVersion() {
+        return this.version;
+    }
+    assertJsiiPackagesAvailable() {
+        // FIXME: This probably shouldn't be here. Always a no-op.
+    }
+    async initializeDotnetPackages(currentDir) {
+        // FIXME: this code has nothing to do with the package source, really, so shouldn't be here.
+        if (process.env.CWD_FILES_DIR) {
+            await (0, files_1.copyDirectoryContents)(process.env.CWD_FILES_DIR, currentDir);
+        }
+    }
+    requestedAlphaVersion() {
+        const frameworkVersion = this.requestedVersion();
+        if (frameworkVersion.includes('-rc.')) {
+            // For a pipeline release
+            return frameworkVersion.replace(/-rc\.\d+$/, '-alpha.999');
+        }
+        else {
+            // For a stable release
+            return `${frameworkVersion}-alpha.0`;
+        }
+    }
+}
+exports.TestLibraryNpmSource = TestLibraryNpmSource;
+//# sourceMappingURL=data:application/json;base64,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

package/lib/package-sources/library-preinstalled-source.d.ts

@@ -0,0 +1,21 @@
+import type { IRunnerSource, IPreparedRunnerSource, ITestLibrarySource } from './source';
+/**
+ * A library dependency that should already be installed via `cli-integ`'s dependencies.
+ */
+export declare class RunnerLibraryPreinstalledSource implements IRunnerSource<ITestLibrarySource> {
+    private readonly packageName;
+    static preinstalledVersion(packageName: string): Promise<string>;
+    static isPreinstalled(packageName: string): Promise<boolean>;
+    readonly sourceDescription: string;
+    constructor(packageName: string);
+    runnerPrepare(): Promise<IPreparedRunnerSource<ITestLibrarySource>>;
+}
+export declare class TestLibraryPreinstalledSource implements ITestLibrarySource {
+    readonly packageName: string;
+    private readonly version;
+    constructor(packageName: string, version: string);
+    requestedVersion(): string;
+    assertJsiiPackagesAvailable(): void;
+    initializeDotnetPackages(currentDir: string): Promise<void>;
+    requestedAlphaVersion(): string;
+}

package/lib/package-sources/library-preinstalled-source.js

@@ -0,0 +1,78 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.TestLibraryPreinstalledSource = exports.RunnerLibraryPreinstalledSource = void 0;
+const promises_1 = require("fs/promises");
+const path = require("path");
+const files_1 = require("../files");
+/**
+ * A library dependency that should already be installed via `cli-integ`'s dependencies.
+ */
+class RunnerLibraryPreinstalledSource {
+    packageName;
+    static async preinstalledVersion(packageName) {
+        // Pretend to be in the test directory and resolve the package
+        const searchPath = path.resolve(__dirname, '../../tests');
+        let resolvedPjPath;
+        try {
+            resolvedPjPath = require.resolve(`${packageName}/package.json`, {
+                paths: [searchPath],
+            });
+        }
+        catch (e) {
+            throw new Error(`${packageName} not found preinstalled (searching from ${searchPath}): ${e}`);
+        }
+        const pj = JSON.parse(await (0, promises_1.readFile)(resolvedPjPath, 'utf-8'));
+        return pj.version;
+    }
+    static async isPreinstalled(packageName) {
+        try {
+            await RunnerLibraryPreinstalledSource.preinstalledVersion(packageName);
+            return true;
+        }
+        catch {
+            return false;
+        }
+    }
+    sourceDescription;
+    constructor(packageName) {
+        this.packageName = packageName;
+        this.sourceDescription = `${this.packageName} from preinstalled deps`;
+    }
+    async runnerPrepare() {
+        const version = await RunnerLibraryPreinstalledSource.preinstalledVersion(this.packageName);
+        return {
+            version,
+            async dispose() {
+            },
+            serialize: () => {
+                return [TestLibraryPreinstalledSource, [this.packageName, version]];
+            },
+        };
+    }
+}
+exports.RunnerLibraryPreinstalledSource = RunnerLibraryPreinstalledSource;
+class TestLibraryPreinstalledSource {
+    packageName;
+    version;
+    constructor(packageName, version) {
+        this.packageName = packageName;
+        this.version = version;
+    }
+    requestedVersion() {
+        return this.version;
+    }
+    assertJsiiPackagesAvailable() {
+        // FIXME: Always a no-op.
+    }
+    async initializeDotnetPackages(currentDir) {
+        // FIXME: this code has nothing to do with the package source, really, so shouldn't be here.
+        if (process.env.CWD_FILES_DIR) {
+            await (0, files_1.copyDirectoryContents)(process.env.CWD_FILES_DIR, currentDir);
+        }
+    }
+    requestedAlphaVersion() {
+        return this.version;
+    }
+}
+exports.TestLibraryPreinstalledSource = TestLibraryPreinstalledSource;
+//# sourceMappingURL=data:application/json;base64,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

package/lib/package-sources/source.d.ts

@@ -1,28 +1,46 @@
-export interface IPackageSourceSetup {
-    readonly name: string;
-    readonly description: string;
-    prepare(): Promise<void>;
-    cleanup(): Promise<void>;
+/**
+ * The part of a source that executes in the runner
+ *
+ * `SourceType` should be either `ITestLibrarySource` or `ITestCliSource`,
+ * and will be loaded in the test process.
+ */
+export interface IRunnerSource<SourceType> {
+    readonly sourceDescription: string;
+    runnerPrepare(): Promise<IPreparedRunnerSource<SourceType>>;
 }
-export interface IPackageSource {
+export interface IPreparedRunnerSource<SourceType> {
+    readonly version: string;
+    dispose(): Promise<void>;
+    /**
+     * Return the constructor and constructor arguments for the actual source
+     * class in the test process.
+     */
+    serialize(): SourceDescriptor<SourceType>;
+}
+export type Constructor<A> = new (...args: any[]) => A;
+export type SourceDescriptor<A> = [Constructor<A>, any[]];
+export interface ITestCliSource {
+    /**
+     * Adds the CLI to the $PATH
+     */
     makeCliAvailable(): Promise<void>;
-    assertJsiiPackagesAvailable(): void;
-    majorVersion(): string;
-    initializeDotnetPackages(targetDir: string): Promise<void>;
     /**
-     * CLI version
+     * The CLI version
      */
-    requestedCliVersion(): string;
+    requestedVersion(): string;
+}
+export interface ITestLibrarySource {
     /**
-     * Framework version if it's different than the CLI version
-     *
-     * Not all tests will respect this.
+     * Requested library version
      */
-    requestedFrameworkVersion(): string;
+    requestedVersion(): string;
     /**
-     * Versions of alpha packages if different than the CLI version
-     *
-     * Not all tests will respect this.
+     * Versions of alpha packages
      */
     requestedAlphaVersion(): string;
+    assertJsiiPackagesAvailable(): void;
+    /**
+     * Put the right files into the given directory to make .NET use the CodeArtifact repos (if configured)
+     */
+    initializeDotnetPackages(targetDir: string): Promise<void>;
 }

package/lib/package-sources/source.js

@@ -1,3 +1,3 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoic291cmNlLmpzIiwic291cmNlUm9vdCI6IiIsInNvdXJjZXMiOlsic291cmNlLnRzIl0sIm5hbWVzIjpbXSwibWFwcGluZ3MiOiIiLCJzb3VyY2VzQ29udGVudCI6WyJleHBvcnQgaW50ZXJmYWNlIElQYWNrYWdlU291cmNlU2V0dXAge1xuICByZWFkb25seSBuYW1lOiBzdHJpbmc7XG4gIHJlYWRvbmx5IGRlc2NyaXB0aW9uOiBzdHJpbmc7XG5cbiAgcHJlcGFyZSgpOiBQcm9taXNlPHZvaWQ+O1xuICBjbGVhbnVwKCk6IFByb21pc2U8dm9pZD47XG59XG5cbmV4cG9ydCBpbnRlcmZhY2UgSVBhY2thZ2VTb3VyY2Uge1xuICBtYWtlQ2xpQXZhaWxhYmxlKCk6IFByb21pc2U8dm9pZD47XG5cbiAgYXNzZXJ0SnNpaVBhY2thZ2VzQXZhaWxhYmxlKCk6IHZvaWQ7XG4gIG1ham9yVmVyc2lvbigpOiBzdHJpbmc7XG5cbiAgaW5pdGlhbGl6ZURvdG5ldFBhY2thZ2VzKHRhcmdldERpcjogc3RyaW5nKTogUHJvbWlzZTx2b2lkPjtcblxuICAvKipcbiAgICogQ0xJIHZlcnNpb25cbiAgICovXG4gIHJlcXVlc3RlZENsaVZlcnNpb24oKTogc3RyaW5nO1xuXG4gIC8qKlxuICAgKiBGcmFtZXdvcmsgdmVyc2lvbiBpZiBpdCdzIGRpZmZlcmVudCB0aGFuIHRoZSBDTEkgdmVyc2lvblxuICAgKlxuICAgKiBOb3QgYWxsIHRlc3RzIHdpbGwgcmVzcGVjdCB0aGlzLlxuICAgKi9cbiAgcmVxdWVzdGVkRnJhbWV3b3JrVmVyc2lvbigpOiBzdHJpbmc7XG5cbiAgLyoqXG4gICAqIFZlcnNpb25zIG9mIGFscGhhIHBhY2thZ2VzIGlmIGRpZmZlcmVudCB0aGFuIHRoZSBDTEkgdmVyc2lvblxuICAgKlxuICAgKiBOb3QgYWxsIHRlc3RzIHdpbGwgcmVzcGVjdCB0aGlzLlxuICAgKi9cbiAgcmVxdWVzdGVkQWxwaGFWZXJzaW9uKCk6IHN0cmluZztcbn1cbiJdfQ==
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoic291cmNlLmpzIiwic291cmNlUm9vdCI6IiIsInNvdXJjZXMiOlsic291cmNlLnRzIl0sIm5hbWVzIjpbXSwibWFwcGluZ3MiOiIiLCJzb3VyY2VzQ29udGVudCI6WyIvKipcbiAqIFRoZSBwYXJ0IG9mIGEgc291cmNlIHRoYXQgZXhlY3V0ZXMgaW4gdGhlIHJ1bm5lclxuICpcbiAqIGBTb3VyY2VUeXBlYCBzaG91bGQgYmUgZWl0aGVyIGBJVGVzdExpYnJhcnlTb3VyY2VgIG9yIGBJVGVzdENsaVNvdXJjZWAsXG4gKiBhbmQgd2lsbCBiZSBsb2FkZWQgaW4gdGhlIHRlc3QgcHJvY2Vzcy5cbiAqL1xuZXhwb3J0IGludGVyZmFjZSBJUnVubmVyU291cmNlPFNvdXJjZVR5cGU+IHtcbiAgcmVhZG9ubHkgc291cmNlRGVzY3JpcHRpb246IHN0cmluZztcblxuICBydW5uZXJQcmVwYXJlKCk6IFByb21pc2U8SVByZXBhcmVkUnVubmVyU291cmNlPFNvdXJjZVR5cGU+Pjtcbn1cblxuZXhwb3J0IGludGVyZmFjZSBJUHJlcGFyZWRSdW5uZXJTb3VyY2U8U291cmNlVHlwZT4ge1xuICByZWFkb25seSB2ZXJzaW9uOiBzdHJpbmc7XG5cbiAgZGlzcG9zZSgpOiBQcm9taXNlPHZvaWQ+O1xuXG4gIC8qKlxuICAgKiBSZXR1cm4gdGhlIGNvbnN0cnVjdG9yIGFuZCBjb25zdHJ1Y3RvciBhcmd1bWVudHMgZm9yIHRoZSBhY3R1YWwgc291cmNlXG4gICAqIGNsYXNzIGluIHRoZSB0ZXN0IHByb2Nlc3MuXG4gICAqL1xuICBzZXJpYWxpemUoKTogU291cmNlRGVzY3JpcHRvcjxTb3VyY2VUeXBlPjtcbn1cblxuZXhwb3J0IHR5cGUgQ29uc3RydWN0b3I8QT4gPSBuZXcgKC4uLmFyZ3M6IGFueVtdKSA9PiBBO1xuXG5leHBvcnQgdHlwZSBTb3VyY2VEZXNjcmlwdG9yPEE+ID0gW0NvbnN0cnVjdG9yPEE+LCBhbnlbXV07XG5cbmV4cG9ydCBpbnRlcmZhY2UgSVRlc3RDbGlTb3VyY2Uge1xuICAvKipcbiAgICogQWRkcyB0aGUgQ0xJIHRvIHRoZSAkUEFUSFxuICAgKi9cbiAgbWFrZUNsaUF2YWlsYWJsZSgpOiBQcm9taXNlPHZvaWQ+O1xuXG4gIC8qKlxuICAgKiBUaGUgQ0xJIHZlcnNpb25cbiAgICovXG4gIHJlcXVlc3RlZFZlcnNpb24oKTogc3RyaW5nO1xufVxuXG5leHBvcnQgaW50ZXJmYWNlIElUZXN0TGlicmFyeVNvdXJjZSB7XG4gIC8qKlxuICAgKiBSZXF1ZXN0ZWQgbGlicmFyeSB2ZXJzaW9uXG4gICAqL1xuICByZXF1ZXN0ZWRWZXJzaW9uKCk6IHN0cmluZztcblxuICAvKipcbiAgICogVmVyc2lvbnMgb2YgYWxwaGEgcGFja2FnZXNcbiAgICovXG4gIHJlcXVlc3RlZEFscGhhVmVyc2lvbigpOiBzdHJpbmc7XG5cbiAgYXNzZXJ0SnNpaVBhY2thZ2VzQXZhaWxhYmxlKCk6IHZvaWQ7XG5cbiAgLyoqXG4gICAqIFB1dCB0aGUgcmlnaHQgZmlsZXMgaW50byB0aGUgZ2l2ZW4gZGlyZWN0b3J5IHRvIG1ha2UgLk5FVCB1c2UgdGhlIENvZGVBcnRpZmFjdCByZXBvcyAoaWYgY29uZmlndXJlZClcbiAgICovXG4gIGluaXRpYWxpemVEb3RuZXRQYWNrYWdlcyh0YXJnZXREaXI6IHN0cmluZyk6IFByb21pc2U8dm9pZD47XG59XG4iXX0=

package/lib/package-sources/subprocess.d.ts

@@ -1,3 +1,10 @@
-import type { IPackageSourceSetup, IPackageSource } from './source';
-export declare function serializeForSubprocess(s: IPackageSourceSetup): void;
-export declare function packageSourceInSubprocess(): IPackageSource;
+import type { IPreparedRunnerSource, ITestCliSource, ITestLibrarySource } from './source';
+export interface PreparedSources {
+    readonly cli: IPreparedRunnerSource<ITestCliSource>;
+    readonly library: IPreparedRunnerSource<ITestLibrarySource>;
+    readonly toolkitLib: IPreparedRunnerSource<ITestLibrarySource>;
+}
+type SourceType<A> = A extends IPreparedRunnerSource<infer T> ? T : unknown;
+export declare function serializeSources(sources: PreparedSources): void;
+export declare function testSource<K extends keyof PreparedSources>(k: K): SourceType<PreparedSources[K]>;
+export {};