apify-test-tools 0.10.2-beta.3 → 0.10.2-beta.5

package/bin/git.ts

@@ -9,8 +9,8 @@ const GIT_LOG_FORMAT = ['%H', '%aN<%aE>', '%aD', '%s'].join(GIT_FORMAT_SEPARATOR
  * Gets the list of changed files between the given commits (inclusive), so it diffs from the parent of the oldest.
  */
 export const getChangedFiles = async (commits: Commit[]) => {
-    // getCommits never returns an empty list (the rerun check returns all commits when the base commit
-    // is the branch HEAD, and an empty git range throws when parsing), so this signals a programmer error
+    // getCommits never returns an empty list (it throws on an empty range, and the rerun check returns all
+    // commits when the base commit is the branch HEAD), so this signals a programmer error
     if (commits.length === 0) {
         throw new Error('Cannot get changed files: the commit list is empty. This should never happen.');
     }
@@ -35,59 +35,22 @@ export const getChangedFilesBetween = async (fromRef: string, toRef: string) =>
 };
 
 /**
- * Returns true if the branch contains a merge commit whose parent is reachable from targetBranch
- * (i.e. a genuine "merge from target" commit, not a merge of some unrelated branch).
- * Uses the full targetBranch..sourceBranch range, ignoring baseCommit.
+ * The commit `git diff base...head` compares against: where `head` forked from `base`, or the last commit of `base`
+ * that `head` merged in. The diff from it holds only what `head` itself changed, like GitHub's "Files changed" tab.
+ * With criss-cross merges there are several such commits and git picks one.
  */
-export const hasMergeFromTarget = async (sourceBranch: string, targetBranch: string): Promise<boolean> => {
-    const mergeShas = (
-        await runGitCommand(['log', '--merges', '--pretty=format:%H', `${targetBranch}..${sourceBranch}`], {
-            operation: 'find merge commits on the source branch that are absent from the target branch',
-        })
-    )
-        .split('\n')
-        .filter(Boolean);
+export const getMergeBase = async (base: string, head: string): Promise<string> =>
+    runGitCommand(['merge-base', base, head], { operation: `find where ${head} forked from ${base}` });
 
-    for (const sha of mergeShas) {
-        const parents = (
-            await runGitCommand(['log', '-1', '--pretty=format:%P', sha], {
-                operation: 'get parents of a merge commit',
-            })
-        ).split(' ');
-        for (const parent of parents) {
-            // git merge-base A B outputs the common ancestor.
-            // If that equals A, then A is an ancestor of B (i.e. parent is reachable from targetBranch).
-            let mergeBase: string;
-            try {
-                mergeBase = await runGitCommand(['merge-base', parent, targetBranch], {
-                    operation: 'check whether a merge parent is reachable from the target branch',
-                });
-            } catch (error) {
-                // Exit code 1 on merge-base means the histories have no common ancestor.
-                if (error instanceof GitCommandError && error.exitCode === 1) {
-                    continue;
-                }
-                throw error;
-            }
-            if (mergeBase === parent) {
-                return true;
-            }
-        }
-    }
-    return false;
-};
-
-/**
- * Returns all files touched by non-merge commits on the branch (full history, ignoring baseCommit).
- * Used to check whether the branch itself has any functional changes, independent of what master merged in.
- */
-export const getBranchOnlyChangedFiles = async (sourceBranch: string, targetBranch: string): Promise<string[]> => {
-    const output = await runGitCommand(
-        ['log', '--no-merges', '--name-only', '--pretty=format:', `${targetBranch}..${sourceBranch}`],
-        { operation: 'list files changed by non-merge commits on the source branch' },
-    );
-    return output.split('\n').filter(Boolean);
-};
+/** Resolves a ref to a commit, or undefined when it isn't in the local history (e.g. it was force-pushed away). */
+export const findCommitSha = async (ref: string): Promise<string | undefined> =>
+    runGitCommand(['rev-parse', '--verify', '--quiet', `${ref}^{commit}`], {
+        operation: `look up ${ref} in local Git history`,
+    }).catch((error: unknown) => {
+        // --quiet suppresses Git's error text for a missing commit, but Git still exits with code 1
+        if (error instanceof GitCommandError && error.exitCode === 1) return undefined;
+        throw error;
+    });
 
 const SHA_REGEX = /^[0-9a-f]{40}$/i;
 
@@ -120,8 +83,8 @@ export const getCommitsBetween = async (fromRef: string, toRef: string): Promise
     const output = await runGitCommand(['log', `--pretty=format:${GIT_LOG_FORMAT}`, `${fromRef}..${toRef}`], {
         operation: 'list commits reachable from the source ref but absent from the target ref',
     });
-    const commitsStrings = output.split('\n');
-    const commits = commitsStrings.map((commitString) => parseCommit(commitString));
+    // An empty range (e.g. `x..x`) prints nothing
+    const commits = output.split('\n').filter(Boolean).map(parseCommit);
     commits.reverse();
     return commits;
 };
@@ -137,6 +100,9 @@ export const getCommits = async ({
 }: Pick<Config, 'sourceBranch' | 'targetBranch' | 'baseCommit'>): Promise<Commit[]> => {
     const baseCommitSha = parseBaseCommit(baseCommit);
     const commits = await getCommitsBetween(targetBranch, sourceBranch);
+    if (commits.length === 0) {
+        throw new Error(`${sourceBranch} has no commits that are not on ${targetBranch}.`);
+    }
 
     // The last validated (base) commit being the branch HEAD means nothing new was pushed since the last
     // validation — the dev reran the workflow (or force-pushed to the same state) to trigger a clean test
@@ -181,16 +147,16 @@ export const parseCommit = (commitString: string): Commit => {
 };
 
 /**
- * Returns the currently checked-out branch. Release builds point the Actor version at this branch,
+ * Returns the currently checked-out branch. Builds point the Actor version at this branch,
  * so a detached HEAD (no branch to point at) is an error rather than a guess.
  */
 export const getCurrentBranch = async (): Promise<string> => {
     const branch = await runGitCommand(['rev-parse', '--abbrev-ref', 'HEAD'], {
-        operation: 'determine the current branch for release',
+        operation: 'determine the checked-out branch',
     });
     if (branch === 'HEAD') {
         throw new Error(
-            'Cannot determine the branch to release: HEAD is detached. Check out the branch you want to release.',
+            'Cannot determine the branch to build from: HEAD is detached. Check out the branch you want to build.',
         );
     }
     return branch;
@@ -200,17 +166,6 @@ export const getCurrentBranch = async (): Promise<string> => {
 export const resolveCommitSha = async (ref: string): Promise<string> =>
     runGitCommand(['rev-parse', '--verify', `${ref}^{commit}`], { operation: `resolve ${ref} to a commit` });
 
-/**
- * Branch name a ref points to, without the remote: `origin/foo` and `foo` both give `foo`, and `HEAD`
- * gives the checked-out branch. Null when there is no branch to point at (a SHA, a tag, a detached HEAD).
- */
-export const resolveBranchName = async (ref: string): Promise<string | null> => {
-    const fullName = await runGitCommand(['rev-parse', '--symbolic-full-name', ref], {
-        operation: `resolve the branch name of ${ref}`,
-    });
-    return fullName.match(/^refs\/(?:heads|remotes\/[^/]+)\/(.+)$/)?.[1] ?? null;
-};
-
 /**
  * Reads the repository URL from the `origin` remote, rewritten to the SSH form the Apify platform
  * uses for Git repo sources, e.g. git@github.com:apify-store/google-maps

package/bin/main.ts

@@ -6,13 +6,14 @@ import yargs, { type Options } from 'yargs';
 // eslint-disable-next-line import/extensions --- With .js, it cannot find types
 import { hideBin } from 'yargs/helpers';
 
-import { getAffectedActors, toAffectedActorsDocument } from './affected-actors.js';
-import { deleteOldBuilds, runBuilds } from './build.js';
+import { getAffectedActors } from './affected-actors.js';
+import { buildActors, DEFAULT_VERSION_KEYWORD, deleteOldBuilds } from './build.js';
 import { runBuildsFromLocal } from './build-from-local.js';
-import { getChangedFiles, getCommits, getCurrentBranch, getRepoName, resolveRepoUrl } from './git.js';
+import { getChangedFiles, getCommits } from './git.js';
 import { logger, logLevels } from './logger.js';
 import { writeJson } from './output.js';
 import { notifyToSlack } from './slack.js';
+import { parseBuildInput, parseReleaseChanges, readStdin } from './stdin-input.js';
 import { reportTestResults } from './test-report.js';
 import { readConfigFile } from './utils/config/load-config.js';
 
@@ -83,9 +84,27 @@ const dryRunOptions = {
     },
 } as const satisfies Record<string, Options>;
 
-/** Flags for commands that trigger Apify builds. */
+/** Flags of `build`, which builds exactly the Actors it is given. */
 const buildOptions = {
-    'use-docker-cache': { type: 'boolean', default: false },
+    'version-number': {
+        type: 'string',
+        demandOption: true,
+        describe: `Version to build, like 0.1, or "${DEFAULT_VERSION_KEYWORD}" for each Actor's default version`,
+        coerce: (value: string) => {
+            if (value !== DEFAULT_VERSION_KEYWORD && !/^\d+\.\d+$/.test(value)) {
+                throw new Error(
+                    `--version-number must look like 0.1 or be "${DEFAULT_VERSION_KEYWORD}", got "${value}"`,
+                );
+            }
+            return value;
+        },
+    },
+} as const satisfies Record<string, Options>;
+
+/** Where `notify-release` posts the release. */
+const releaseSlackOptions = {
+    'report-slack-channel': { type: 'string', describe: 'Channel for the full report: commits and changed files' },
+    'release-slack-channel': { type: 'string', describe: 'Channel for the changelog additions only' },
 } as const satisfies Record<string, Options>;
 
 /** Global flags, available to every command. */
@@ -146,7 +165,7 @@ await yargs()
         'Find the Actors whose context changed in a commit range ending at the checked-out HEAD',
         (y) => y.options(affectedRangeOptions).options(actorSelectionOptions),
         async (args) => {
-            writeJson(toAffectedActorsDocument(await getAffectedActors({ ...args, head: 'HEAD' })));
+            writeJson(await getAffectedActors(args));
         },
     )
     .command(
@@ -165,89 +184,36 @@ await yargs()
     )
     .command(
         'build',
-        '',
-        (y) =>
-            y
-                .options(gitRangeOptions)
-                .options(actorSelectionOptions)
-                .options(buildOptions)
-                .options(repoUrlOptions)
-                .options(dryRunOptions)
-                .option('test-files-glob', { type: 'string' }),
-        async (config) => {
-            // Cosmetic-only changes don't need testing, so they don't need a build either
-            const { functionallyChangedActors: actorsChanged } = await getAffectedActors({
-                head: config.sourceBranch,
-                base: config.targetBranch,
-                since: config.baseCommit,
-                testFilesGlob: config.testFilesGlob,
-                actors: config.actors,
-                ignore: config.ignore,
-            });
-            const builds = await runBuilds({
-                ...(await resolveRepoUrl(config.repoUrl)),
-                actorConfigs: actorsChanged,
-                branch: config.sourceBranch.replace('origin/', ''),
-                dryRun: config.dryRun,
-                useDockerCache: config.useDockerCache,
+        'Build the Actors listed on stdin, as {"actors": [{"actorFullName": ...}]}, from the checked-out branch',
+        (y) => y.options(buildOptions).options(repoUrlOptions).options(dryRunOptions),
+        async (args) => {
+            const input = parseBuildInput(await readStdin());
+            const names = input.actors.map(({ actorFullName }) => actorFullName);
+            // An empty --actors selects every Actor, but an empty list here means there is nothing to build
+            const actorConfigs = names.length > 0 ? await readConfigFile({ actors: names, ignore: [] }) : [];
+            const builds = await buildActors({
+                actorConfigs,
+                versionNumber: args.versionNumber,
+                repoUrl: args.repoUrl,
+                dryRun: args.dryRun,
             });
             writeJson(builds);
         },
     )
     .command(
-        'release',
-        '',
-        (y) =>
-            y
-                .options(actorSelectionOptions)
-                .options(buildOptions)
-                .options(repoUrlOptions)
-                .options(dryRunOptions)
-                // The last commit that is already released, everything after it up to HEAD gets released.
-                // Required, see the README section "Releasing Actors" for how to set it for each merge strategy.
-                .option('base-commit', { type: 'string', demandOption: true })
-                .option('report-slack-channel', { type: 'string' })
-                .option('release-slack-channel', { type: 'string' }),
+        'notify-release',
+        'Announce a release on Slack, from the get-affected-actors output on stdin',
+        (y) => y.options(releaseSlackOptions).options(repoUrlOptions).options(dryRunOptions),
         async (args) => {
-            const branch = await getCurrentBranch();
-            const { commits, changedFiles, changelog, functionallyChangedActors, cosmeticallyChangedActors } =
-                await getAffectedActors({
-                    head: 'HEAD',
-                    since: args.baseCommit,
-                    actors: args.actors,
-                    ignore: args.ignore,
-                });
-            // A release ships cosmetic changes (README, input schema descriptions, ...) too
-            const actorsChanged = [...functionallyChangedActors, ...cosmeticallyChangedActors];
-            if (commits.length === 0) {
-                logger.info(`HEAD is the base commit ${args.baseCommit}, there is nothing new to release`);
-                return;
-            }
-            const { repoUrl, shouldVerifyRepoUrl } = await resolveRepoUrl(args.repoUrl);
-
-            const isLatest = true;
-            const { dryRun, reportSlackChannel, releaseSlackChannel } = args;
-            const builds = await runBuilds({
-                isLatest,
-                repoUrl,
-                shouldVerifyRepoUrl,
-                actorConfigs: actorsChanged,
-                branch,
-                dryRun,
-                useDockerCache: args.useDockerCache,
-            });
-            logger.info(JSON.stringify(builds));
-
+            const { commits, changedFiles, changelog } = parseReleaseChanges(await readStdin());
             await notifyToSlack({
-                changedFiles,
                 commits,
+                changedFiles,
                 changelog,
-                repository: getRepoName(repoUrl),
-                dryRun,
-                // The newest commit, same as the pushed head commit
-                author: commits[commits.length - 1].author,
-                reportSlackChannel,
-                releaseSlackChannel,
+                repoUrl: args.repoUrl,
+                dryRun: args.dryRun,
+                reportSlackChannel: args.reportSlackChannel,
+                releaseSlackChannel: args.releaseSlackChannel,
             });
         },
     )

package/bin/slack.ts

@@ -1,16 +1,17 @@
 import { WebClient } from '@slack/web-api';
 
+import { getRepoName, resolveRepoUrl } from './git.js';
 import { logger } from './logger.js';
 import type { Commit } from './types.js';
 import { getEnvVar } from './utils.js';
 
 type NotifyToSlackOptions = {
-    repository: string;
     changedFiles: string[];
     changelog: string | null;
     commits: Commit[];
+    // Defaults to the `origin` remote, see resolveRepoUrl
+    repoUrl?: string;
     dryRun: boolean;
-    author: string;
     releaseSlackChannel?: string;
     reportSlackChannel?: string;
 };
@@ -37,16 +38,23 @@ export const sendingLabel = (dryRun: boolean) => (dryRun ? '[DRY RUN] Would send
 // Git authors come as "Name<email>", Slack only needs the name
 const displayName = (author: string) => author.replace(/\s*<[^>]*>$/, '');
 
+/**
+ * Posts what a release changed: its commits, changed files and changelog, as get-affected-actors reports them.
+ * Posts nothing when there are no commits, which means there is nothing new to release.
+ */
 export const notifyToSlack = async ({
     changedFiles,
     commits,
     changelog,
-    repository,
+    repoUrl,
     dryRun,
-    author,
     releaseSlackChannel,
     reportSlackChannel,
 }: NotifyToSlackOptions) => {
+    if (commits.length === 0) {
+        logger.info('No new commits, so there is no release to announce');
+        return;
+    }
     if (!changelog) {
         logger.warn('No new changelog entries found, did you forget to update it?');
     }
@@ -57,6 +65,9 @@ export const notifyToSlack = async ({
     }
     const slack = await getSlackClient('SLACK_TOKEN_RELEASES_BOT', dryRun);
 
+    const repository = getRepoName((await resolveRepoUrl(repoUrl)).repoUrl);
+    // The newest commit, same as the pushed head commit
+    const { author } = commits[commits.length - 1];
     let shortMessage = `*${repository}* – New release (by ${displayName(author)}):\n\n`;
 
     // This one is just for broader public that only cares about public facing changes

package/bin/stdin-input.ts

@@ -0,0 +1,65 @@
+import process from 'node:process';
+
+import z, { prettifyError, type ZodType } from 'zod';
+
+export const readStdin = async (): Promise<string> => {
+    // Nothing piped in: fail right away instead of waiting for someone to type
+    if (process.stdin.isTTY) {
+        throw new Error('Expected JSON on stdin, but nothing was piped in.');
+    }
+    let raw = '';
+    for await (const chunk of process.stdin) {
+        raw += chunk;
+    }
+    return raw;
+};
+
+const parseStdinJson = <T>(
+    raw: string,
+    schema: ZodType<T>,
+    { expected, example }: { expected: string; example: string },
+) => {
+    // Empty input is an error, not "nothing to do": it is what a failed command earlier in the pipe leaves behind
+    if (!raw.trim()) {
+        throw new Error(`Expected ${expected} as JSON on stdin, got nothing (${example}).`);
+    }
+    let json: unknown;
+    try {
+        json = JSON.parse(raw);
+    } catch (error) {
+        throw new Error(`The input on stdin is not valid JSON: ${(error as Error).message}`);
+    }
+    const result = schema.safeParse(json);
+    if (!result.success) {
+        throw new Error(`The input on stdin is not ${expected} (${example}):\n${prettifyError(result.error)}`);
+    }
+    return result.data;
+};
+
+/**
+ * What `build` reads: the Actors to build. Only their names are read, the config file stays the source of truth
+ * for everything else about them. Other fields are ignored, so a get-affected-actors document only needs its Actor
+ * list picked, e.g. `jq '{ actors: .functionallyChangedActors }'`.
+ */
+const buildInputSchema = z.object({
+    actors: z.array(z.object({ actorFullName: z.string() })),
+});
+
+export const parseBuildInput = (raw: string) =>
+    parseStdinJson(raw, buildInputSchema, {
+        expected: 'the Actors to build',
+        example: `e.g. echo '{"actors":[{"actorFullName":"owner/name"}]}' | apify-test-tools build --version-number 0.1`,
+    });
+
+/** What `notify-release` reads: the parts of a get-affected-actors document that describe what changed. */
+const releaseChangesSchema = z.object({
+    commits: z.array(z.object({ sha: z.string(), author: z.string(), date: z.string(), message: z.string() })),
+    changedFiles: z.array(z.string()),
+    changelog: z.string().nullable(),
+});
+
+export const parseReleaseChanges = (raw: string) =>
+    parseStdinJson(raw, releaseChangesSchema, {
+        expected: 'the output of get-affected-actors',
+        example: 'e.g. apify-test-tools get-affected-actors --since <sha> | apify-test-tools notify-release',
+    });

package/bin/types.ts

@@ -10,6 +10,12 @@ export interface Config {
     testFilesGlob?: string;
 }
 
+/** The changes from `fromRef` (excluded) to `toRef`, compared as trees like `git diff fromRef toRef`. */
+export interface GitRange {
+    fromRef: string;
+    toRef: string;
+}
+
 export type Commit = {
     sha: string;
     author: string;

package/dist/bin/affected-actors.d.ts

@@ -1,12 +1,15 @@
-import type { ActorConfig, Commit } from './types.js';
+import type { Commit } from './types.js';
 interface AffectedActorsOptions {
-    /** End of the range. */
-    head: string;
-    /** Only the commits on head that are not on base count, i.e. the branch's own changes. */
+    /**
+     * Base usually points to the master branch
+     * Only what HEAD changes compared to base counts, like `git diff base...HEAD` or GitHub's "Files changed" tab:
+     * the branch's own changes, not what it merged in from base.
+     */
     base?: string;
     /**
-     * Only changes after this commit count. With `base` it's the last validated commit of the branch and is
-     * ignored when it isn't on the branch. Without `base` it must be an ancestor of head (e.g. the last release).
+     * With `base` it's the last validated commit of the branch: Actors that didn't change after it are left out.
+     * It's ignored when it is HEAD (a rerun) or isn't in the local history. Without `base` everything after it
+     * counts, and it must be an ancestor of HEAD (e.g. the last release).
      */
     since?: string;
     /** Glob relative to the repo root. Matching files count as changes even when .dockerignore lists them. */
@@ -14,37 +17,30 @@ interface AffectedActorsOptions {
     actors: string[];
     ignore: string[];
 }
-interface AffectedActors {
-    headSha: string;
-    /** Branch head points to, which is what git builds are made from. Null for a SHA or a detached HEAD. */
-    ref: string | null;
-    commits: Commit[];
-    changedFiles: string[];
-    changelog: string | null;
-    /** Actors with at least one functional change. They need a new build and tests. */
-    functionallyChangedActors: ActorConfig[];
-    /** Actors whose changes are all cosmetic (README, CHANGELOG, cosmetic .actor JSON). They only need a release build. */
-    cosmeticallyChangedActors: ActorConfig[];
-}
-/**
- * Finds the Actors whose context changed in the given range. `base` selects the branch's own commits
- * (a PR), `since` the commits after a known one (a release, or the last validated commit of a PR).
- */
-export declare const getAffectedActors: ({ head, base, since: sinceOption, testFilesGlob, actors, ignore, }: AffectedActorsOptions) => Promise<AffectedActors>;
 /** The JSON document `get-affected-actors` prints. Versioned, since other commands and workflows consume it. */
-export declare const toAffectedActorsDocument: ({ headSha, ref, commits, changedFiles, changelog, functionallyChangedActors, cosmeticallyChangedActors, }: AffectedActors) => {
-    version: number;
-    ref: string | null;
+interface AffectedActors {
+    version: 1;
     head: string;
+    /** The commits, changed files and changelog describe the whole range, `--since` with `--base` only narrows the Actors. */
     commits: Commit[];
     changedFiles: string[];
     changelog: string | null;
+    /**
+     * Actors with at least one functional change. They need a new build and tests. Only the names: the config file
+     * stays the source of truth for the rest.
+     */
     functionallyChangedActors: {
         actorFullName: string;
     }[];
+    /** Actors whose changes are all cosmetic (README, CHANGELOG, cosmetic .actor JSON). They only need a release build. */
     cosmeticallyChangedActors: {
         actorFullName: string;
     }[];
-};
+}
+/**
+ * Finds the Actors whose context changed in the given range. `base` selects the branch's own changes
+ * (a PR), `since` the changes after a known commit (a release, or the last validated commit of a PR).
+ */
+export declare const getAffectedActors: ({ base, since: sinceOption, testFilesGlob, actors, ignore, }: AffectedActorsOptions) => Promise<AffectedActors>;
 export {};
 //# sourceMappingURL=affected-actors.d.ts.map

package/dist/bin/affected-actors.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"affected-actors.d.ts","sourceRoot":"","sources":["../../bin/affected-actors.ts"],"names":[],"mappings":"AAaA,OAAO,KAAK,EAAE,WAAW,EAAE,MAAM,EAAE,MAAM,YAAY,CAAC;AAGtD,UAAU,qBAAqB;IAC3B,wBAAwB;IACxB,IAAI,EAAE,MAAM,CAAC;IACb,0FAA0F;IAC1F,IAAI,CAAC,EAAE,MAAM,CAAC;IACd;;;OAGG;IACH,KAAK,CAAC,EAAE,MAAM,CAAC;IACf,0GAA0G;IAC1G,aAAa,CAAC,EAAE,MAAM,CAAC;IACvB,MAAM,EAAE,MAAM,EAAE,CAAC;IACjB,MAAM,EAAE,MAAM,EAAE,CAAC;CACpB;AAED,UAAU,cAAc;IACpB,OAAO,EAAE,MAAM,CAAC;IAChB,wGAAwG;IACxG,GAAG,EAAE,MAAM,GAAG,IAAI,CAAC;IACnB,OAAO,EAAE,MAAM,EAAE,CAAC;IAClB,YAAY,EAAE,MAAM,EAAE,CAAC;IACvB,SAAS,EAAE,MAAM,GAAG,IAAI,CAAC;IACzB,mFAAmF;IACnF,yBAAyB,EAAE,WAAW,EAAE,CAAC;IACzC,uHAAuH;IACvH,yBAAyB,EAAE,WAAW,EAAE,CAAC;CAC5C;AA4DD;;;GAGG;AACH,eAAO,MAAM,iBAAiB,GAAU,oEAOrC,qBAAqB,KAAG,OAAO,CAAC,cAAc,CA4BhD,CAAC;AAEF,gHAAgH;AAChH,eAAO,MAAM,wBAAwB,GAAI,2GAQtC,cAAc;;;;;;;;;;;;;CAYhB,CAAC"}
+{"version":3,"file":"affected-actors.d.ts","sourceRoot":"","sources":["../../bin/affected-actors.ts"],"names":[],"mappings":"AAWA,OAAO,KAAK,EAAe,MAAM,EAAY,MAAM,YAAY,CAAC;AAMhE,UAAU,qBAAqB;IAC3B;;;;OAIG;IACH,IAAI,CAAC,EAAE,MAAM,CAAC;IACd;;;;OAIG;IACH,KAAK,CAAC,EAAE,MAAM,CAAC;IACf,0GAA0G;IAC1G,aAAa,CAAC,EAAE,MAAM,CAAC;IACvB,MAAM,EAAE,MAAM,EAAE,CAAC;IACjB,MAAM,EAAE,MAAM,EAAE,CAAC;CACpB;AAED,gHAAgH;AAChH,UAAU,cAAc;IACpB,OAAO,EAAE,CAAC,CAAC;IACX,IAAI,EAAE,MAAM,CAAC;IACb,0HAA0H;IAC1H,OAAO,EAAE,MAAM,EAAE,CAAC;IAClB,YAAY,EAAE,MAAM,EAAE,CAAC;IACvB,SAAS,EAAE,MAAM,GAAG,IAAI,CAAC;IACzB;;;OAGG;IACH,yBAAyB,EAAE;QAAE,aAAa,EAAE,MAAM,CAAA;KAAE,EAAE,CAAC;IACvD,uHAAuH;IACvH,yBAAyB,EAAE;QAAE,aAAa,EAAE,MAAM,CAAA;KAAE,EAAE,CAAC;CAC1D;AAyFD;;;GAGG;AACH,eAAO,MAAM,iBAAiB,GAAU,8DAMrC,qBAAqB,KAAG,OAAO,CAAC,cAAc,CA+ChD,CAAC"}