act-test-runner 2.0.0

package/dist/index.js

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

package/dist/internal/ActCliParams.d.ts

@@ -0,0 +1,57 @@
+/**
+ * Copyright (c) 2026 original authors
+ *
+ * Permission is hereby granted, free of charge, to any person obtaining a copy
+ * of this software and associated documentation files (the "Software"), to deal
+ * in the Software without restriction, including without limitation the rights
+ * to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+ * copies of the Software, and to permit persons to whom the Software is
+ * furnished to do so, subject to the following conditions:
+ *
+ * The above copyright notice and this permission notice shall be included in
+ * all copies or substantial portions of the Software.
+ *
+ * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+ * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+ * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+ * AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+ * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+ * OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+ * SOFTWARE.
+ */
+import { WebhookEventName } from '@octokit/webhooks-types';
+import type { ActResourceServerSpec, ActValueSource } from '../ActRunnerOptions.js';
+import type { ActMatrixValues } from '../ActRunnerResult.js';
+export declare const MANAGED_ACT_PARAMS: Set<string>;
+export declare const INTERNAL_ACT_PARAMS: Set<string>;
+export type ActCliParamsInput<EventType extends WebhookEventName | undefined = undefined> = {
+    workflowsPath: string;
+    eventPayloadFilePath: string | undefined;
+    eventType: EventType | undefined;
+    envSource: ActValueSource | undefined;
+    inputsSource: ActValueSource | undefined;
+    secretsSource: ActValueSource | undefined;
+    variablesSource: ActValueSource | undefined;
+    matrixValues: ActMatrixValues | undefined;
+    cacheServer: ActResourceServerSpec | undefined;
+    artifactServer: ActResourceServerSpec | undefined;
+    additionalArgs: string[];
+};
+export declare class ActCliParams<EventType extends WebhookEventName | undefined = undefined> {
+    private readonly workflowsPath;
+    private readonly eventPayloadFilePath;
+    private readonly eventType;
+    private readonly envSource;
+    private readonly inputsSource;
+    private readonly secretsSource;
+    private readonly variablesSource;
+    private readonly matrixValues;
+    private readonly cacheServer;
+    private readonly artifactServer;
+    private readonly additionalArgs;
+    constructor(params: ActCliParamsInput<EventType>);
+    asCliArgs(): string[];
+    private addEvent;
+    private addInputs;
+    private addResource;
+}

package/dist/internal/ActCliParams.js

@@ -0,0 +1,119 @@
+/**
+ * Copyright (c) 2026 original authors
+ *
+ * Permission is hereby granted, free of charge, to any person obtaining a copy
+ * of this software and associated documentation files (the "Software"), to deal
+ * in the Software without restriction, including without limitation the rights
+ * to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+ * copies of the Software, and to permit persons to whom the Software is
+ * furnished to do so, subject to the following conditions:
+ *
+ * The above copyright notice and this permission notice shall be included in
+ * all copies or substantial portions of the Software.
+ *
+ * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+ * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+ * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+ * AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+ * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+ * OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+ * SOFTWARE.
+ */
+import { checkExists } from '../utils/checks.js';
+import { firstDefined } from '../utils/objects.js';
+export const MANAGED_ACT_PARAMS = new Set([
+    '--workflows',
+    '-W',
+    '--env-file',
+    '--env',
+    '--input-file',
+    '--input',
+    '--secret-file',
+    '--secret',
+    '-s',
+    '--var-file',
+    '--var',
+    '--matrix',
+    '--cache-server-path',
+    '--cache-server-addr',
+    '--cache-server-port',
+    '--artifact-server-path',
+    '--artifact-server-addr',
+    '--artifact-server-port',
+    '--detect-event',
+    '--eventpath',
+    '-e',
+]);
+export const INTERNAL_ACT_PARAMS = new Set(['--rm', '--json']);
+export class ActCliParams {
+    workflowsPath;
+    eventPayloadFilePath;
+    eventType;
+    envSource;
+    inputsSource;
+    secretsSource;
+    variablesSource;
+    matrixValues;
+    cacheServer;
+    artifactServer;
+    additionalArgs;
+    constructor(params) {
+        this.workflowsPath = params.workflowsPath;
+        this.eventType = params.eventType;
+        this.eventPayloadFilePath = params.eventPayloadFilePath;
+        this.envSource = params.envSource;
+        this.inputsSource = params.inputsSource;
+        this.secretsSource = params.secretsSource;
+        this.variablesSource = params.variablesSource;
+        this.matrixValues = params.matrixValues;
+        this.cacheServer = params.cacheServer;
+        this.artifactServer = params.artifactServer;
+        this.additionalArgs = params.additionalArgs;
+    }
+    asCliArgs() {
+        const args = ['--workflows', this.workflowsPath];
+        this.addEvent(args, this.eventType, this.eventPayloadFilePath);
+        this.addInputs(args, '--env-file', 'env values file', '--env', this.envSource);
+        this.addInputs(args, '--input-file', 'input values file', '--input', this.inputsSource);
+        this.addInputs(args, '--secret-file', 'secrets values file', '--secret', this.secretsSource);
+        this.addInputs(args, '--var-file', 'variables values file', '--var', this.variablesSource);
+        Object.entries(this.matrixValues ?? {}).forEach(([key, value]) => {
+            args.push('--matrix');
+            args.push(`${key}:${value}`);
+        });
+        this.addResource(args, this.cacheServer, '--cache-server-path', '--cache-server-addr', '--cache-server-port');
+        this.addResource(args, this.artifactServer, '--artifact-server-path', '--artifact-server-addr', '--artifact-server-port');
+        this.additionalArgs.forEach((arg) => args.push(arg));
+        return args;
+    }
+    addEvent(args, eventType, eventPayloadFilePath) {
+        args.push(firstDefined(() => eventType, () => '--detect-event'));
+        if (eventPayloadFilePath !== undefined) {
+            checkExists('event payload file', eventPayloadFilePath);
+            args.push('--eventpath', eventPayloadFilePath);
+        }
+    }
+    addInputs(args, fileArg, fileLabel, valuesArg, source) {
+        if (source?.file !== undefined) {
+            checkExists(fileLabel, source.file);
+            args.push(fileArg, source.file);
+        }
+        Object.entries(source?.values ?? {}).forEach(([key, value]) => {
+            args.push(valuesArg, `${key}=${value}`);
+        });
+    }
+    addResource(args, resource, storageParam, addressParam, portParam) {
+        if (resource !== undefined) {
+            args.push(storageParam);
+            args.push(resource.path);
+            if (resource.host !== undefined) {
+                args.push(addressParam);
+                args.push(resource.host);
+            }
+            if (resource.port !== undefined) {
+                args.push(portParam);
+                args.push(resource.port.toString());
+            }
+        }
+    }
+}

package/dist/internal/ActExecListener.d.ts

@@ -0,0 +1,37 @@
+/**
+ * Copyright (c) 2026 original authors
+ *
+ * Permission is hereby granted, free of charge, to any person obtaining a copy
+ * of this software and associated documentation files (the "Software"), to deal
+ * in the Software without restriction, including without limitation the rights
+ * to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+ * copies of the Software, and to permit persons to whom the Software is
+ * furnished to do so, subject to the following conditions:
+ *
+ * The above copyright notice and this permission notice shall be included in
+ * all copies or substantial portions of the Software.
+ *
+ * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+ * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+ * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+ * AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+ * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+ * OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+ * SOFTWARE.
+ */
+import type { ActJobExecResult } from '../ActRunnerResult.js';
+import { ActOutputListener } from '../ActOutputListener.js';
+export declare class ActExecListener {
+    private readonly execOutput;
+    private readonly jobsByName;
+    private readonly jobIterationTrackers;
+    private readonly outputListener;
+    constructor(outputListener?: ActOutputListener);
+    onRawOutput(output: string): void;
+    getOutput(): string;
+    getJobs(): Record<string, ActJobExecResult>;
+    private toActOutput;
+    private processOutput;
+    private getJobOutputProcessor;
+    private getJobIterationIdx;
+}

package/dist/internal/ActExecListener.js

@@ -0,0 +1,98 @@
+/**
+ * Copyright (c) 2026 original authors
+ *
+ * Permission is hereby granted, free of charge, to any person obtaining a copy
+ * of this software and associated documentation files (the "Software"), to deal
+ * in the Software without restriction, including without limitation the rights
+ * to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+ * copies of the Software, and to permit persons to whom the Software is
+ * furnished to do so, subject to the following conditions:
+ *
+ * The above copyright notice and this permission notice shall be included in
+ * all copies or substantial portions of the Software.
+ *
+ * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+ * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+ * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+ * AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+ * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+ * OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+ * SOFTWARE.
+ */
+import { ActJobOutputProcessor } from './ActJobOutputProcessor.js';
+import { jobDescriptor, formattedMessage, stepDescriptor, } from './ActJsonOutput.js';
+import { JobIterationTracker } from './JobIterationTracker.js';
+export class ActExecListener {
+    execOutput = [];
+    jobsByName = new Map();
+    jobIterationTrackers = new Map();
+    outputListener;
+    constructor(outputListener) {
+        this.outputListener = outputListener;
+    }
+    onRawOutput(output) {
+        const lines = output.toString().split('\n');
+        lines.forEach((line) => {
+            try {
+                const jsonOutput = JSON.parse(line);
+                const actOutput = this.toActOutput(jsonOutput);
+                this.outputListener?.onOutput(actOutput);
+                this.processOutput(jsonOutput);
+            }
+            catch (err) {
+                if (err instanceof SyntaxError) {
+                    // persist unparseable output as-is
+                    this.execOutput.push(line);
+                }
+                else {
+                    throw err;
+                }
+            }
+        });
+    }
+    getOutput() {
+        return this.execOutput.join('\n');
+    }
+    getJobs() {
+        return Object.fromEntries(Array.from(this.jobsByName).map(([name, jobProcessor]) => [
+            name,
+            jobProcessor.buildResult(),
+        ]));
+    }
+    toActOutput(jsonOutput) {
+        return {
+            time: jsonOutput.time,
+            level: jsonOutput.level,
+            message: jsonOutput.msg,
+            job: jobDescriptor(jsonOutput),
+            step: stepDescriptor(jsonOutput),
+        };
+    }
+    processOutput(output) {
+        const msg = formattedMessage(output.msg, output.job);
+        this.execOutput.push(msg);
+        const job = jobDescriptor(output);
+        if (job !== undefined) {
+            const jobProcessor = this.getJobOutputProcessor(job, output.matrix);
+            jobProcessor.processOutput(output);
+        }
+    }
+    getJobOutputProcessor(job, matrix) {
+        const iterationNumber = this.getJobIterationIdx(job.id, matrix);
+        const jobName = iterationNumber === undefined ? job.id : `${job.id}_${iterationNumber}`;
+        if (!this.jobsByName.has(jobName)) {
+            this.jobsByName.set(jobName, new ActJobOutputProcessor(jobName, matrix));
+        }
+        return this.jobsByName.get(jobName);
+    }
+    getJobIterationIdx(jobName, matrix) {
+        if (Object.keys(matrix).length == 0) {
+            return undefined;
+        }
+        if (!this.jobIterationTrackers.has(jobName)) {
+            this.jobIterationTrackers.set(jobName, new JobIterationTracker());
+        }
+        const iterationTracker = this.jobIterationTrackers.get(jobName);
+        return iterationTracker.iterationIndex(matrix);
+    }
+}

package/dist/internal/ActJobExecResultBuilder.d.ts

@@ -0,0 +1,33 @@
+/**
+ * Copyright (c) 2025 original authors
+ *
+ * Permission is hereby granted, free of charge, to any person obtaining a copy of
+ * this software and associated documentation files (the "Software"), to deal in
+ * the Software without restriction, including without limitation the rights to
+ * use, copy, modify, merge, publish, distribute, sublicense, and/or sell copies of
+ * the Software, and to permit persons to whom the Software is furnished to do so,
+ * subject to the following conditions:
+ *
+ * The above copyright notice and this permission notice shall be included in all
+ * copies or substantial portions of the Software.
+ *
+ * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+ * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, FITNESS
+ * FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR
+ * COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER
+ * IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN
+ * CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
+ */
+import { ActJobExecResult } from '../ActJobExecResult.js';
+export declare class ActJobExecResultBuilder {
+    private readonly name;
+    private hasExecutedSteps;
+    private status;
+    private readonly outputLines;
+    constructor(name: string);
+    output(line: string): ActJobExecResultBuilder;
+    stepCompleted(): ActJobExecResultBuilder;
+    completed(): ActJobExecResultBuilder;
+    failed(): ActJobExecResultBuilder;
+    build(): ActJobExecResult;
+}

package/dist/internal/ActJobExecResultBuilder.js

@@ -0,0 +1,52 @@
+/**
+ * Copyright (c) 2025 original authors
+ *
+ * Permission is hereby granted, free of charge, to any person obtaining a copy of
+ * this software and associated documentation files (the "Software"), to deal in
+ * the Software without restriction, including without limitation the rights to
+ * use, copy, modify, merge, publish, distribute, sublicense, and/or sell copies of
+ * the Software, and to permit persons to whom the Software is furnished to do so,
+ * subject to the following conditions:
+ *
+ * The above copyright notice and this permission notice shall be included in all
+ * copies or substantial portions of the Software.
+ *
+ * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+ * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, FITNESS
+ * FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR
+ * COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER
+ * IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN
+ * CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
+ */
+import { ActJobExecResult } from '../ActJobExecResult.js';
+import { ActExecStatus } from '../ActExecStatus.js';
+export class ActJobExecResultBuilder {
+    name;
+    hasExecutedSteps = false;
+    status;
+    outputLines = [];
+    constructor(name) {
+        this.name = name;
+    }
+    output(line) {
+        this.outputLines.push(line);
+        return this;
+    }
+    stepCompleted() {
+        this.hasExecutedSteps = true;
+        return this;
+    }
+    completed() {
+        this.status = this.hasExecutedSteps
+            ? ActExecStatus.SUCCESS
+            : ActExecStatus.SKIPPED;
+        return this;
+    }
+    failed() {
+        this.status = ActExecStatus.FAILED;
+        return this;
+    }
+    build() {
+        return new ActJobExecResult(this.name, this.status, this.outputLines.join('\n'));
+    }
+}

package/dist/internal/ActJobOutputProcessor.d.ts

@@ -0,0 +1,40 @@
+/**
+ * Copyright (c) 2026 original authors
+ *
+ * Permission is hereby granted, free of charge, to any person obtaining a copy
+ * of this software and associated documentation files (the "Software"), to deal
+ * in the Software without restriction, including without limitation the rights
+ * to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+ * copies of the Software, and to permit persons to whom the Software is
+ * furnished to do so, subject to the following conditions:
+ *
+ * The above copyright notice and this permission notice shall be included in
+ * all copies or substantial portions of the Software.
+ *
+ * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+ * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+ * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+ * AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+ * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+ * OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+ * SOFTWARE.
+ */
+import type { ActJobExecResult, ActMatrixValues } from '../ActRunnerResult.js';
+import { JsonOutput } from './ActJsonOutput.js';
+export declare class ActJobOutputProcessor {
+    private readonly name;
+    private readonly matrix;
+    private hasExecutedSteps;
+    private status;
+    private readonly outputLines;
+    private readonly steps;
+    private currentStepProcessor;
+    constructor(name: string, matrix: ActMatrixValues);
+    processOutput(output: JsonOutput): void;
+    private isNonLifecycleStep;
+    private isExecutedStep;
+    private getOrInitializeStepProcessor;
+    private isNewStep;
+    private completed;
+    buildResult(): ActJobExecResult;
+}

package/dist/internal/ActJobOutputProcessor.js

@@ -0,0 +1,101 @@
+/**
+ * Copyright (c) 2026 original authors
+ *
+ * Permission is hereby granted, free of charge, to any person obtaining a copy
+ * of this software and associated documentation files (the "Software"), to deal
+ * in the Software without restriction, including without limitation the rights
+ * to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+ * copies of the Software, and to permit persons to whom the Software is
+ * furnished to do so, subject to the following conditions:
+ *
+ * The above copyright notice and this permission notice shall be included in
+ * all copies or substantial portions of the Software.
+ *
+ * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+ * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+ * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+ * AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+ * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+ * OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+ * SOFTWARE.
+ */
+import { ActExecStatus } from '../ActRunnerResult.js';
+import { formattedMessage, stepDescriptor, } from './ActJsonOutput.js';
+import { ActStepExecResultBuilder as ActStepOutputProcessor } from './ActStepOutputProcessor.js';
+const JOB_LIFECYCLE_STEPS = new Set(['Set up job', 'Complete job']);
+export class ActJobOutputProcessor {
+    name;
+    matrix;
+    hasExecutedSteps = false;
+    status;
+    outputLines = [];
+    steps = [];
+    currentStepProcessor;
+    constructor(name, matrix) {
+        this.name = name;
+        this.matrix = matrix;
+    }
+    processOutput(output) {
+        const msg = formattedMessage(output.msg, output.job);
+        this.outputLines.push(msg);
+        const step = stepDescriptor(output);
+        if (step !== undefined) {
+            // mark job as run only if it executed meaningful steps
+            if (this.isExecutedStep(output)) {
+                this.hasExecutedSteps = true;
+            }
+            const stepProcessor = this.getOrInitializeStepProcessor(step);
+            stepProcessor.processOutput(output);
+        }
+        if (output.jobResult !== undefined) {
+            this.completed(output.jobResult);
+        }
+    }
+    isNonLifecycleStep(output) {
+        return output.step !== undefined && !JOB_LIFECYCLE_STEPS.has(output.step);
+    }
+    isExecutedStep(output) {
+        return (this.isNonLifecycleStep(output) &&
+            output.stepResult !== undefined &&
+            output.stepResult !== 'skipped');
+    }
+    getOrInitializeStepProcessor(descriptor) {
+        if (this.currentStepProcessor === undefined) {
+            // first step
+            this.currentStepProcessor = new ActStepOutputProcessor(descriptor);
+        }
+        else if (this.isNewStep(this.currentStepProcessor.descriptor, descriptor)) {
+            // new step started
+            this.steps.push(this.currentStepProcessor.buildResult());
+            this.currentStepProcessor = new ActStepOutputProcessor(descriptor);
+        }
+        return this.currentStepProcessor;
+    }
+    isNewStep(currentDescriptor, newDescriptor) {
+        return (currentDescriptor.id != newDescriptor.id ||
+            currentDescriptor.name != newDescriptor.name);
+    }
+    completed(result) {
+        if (this.currentStepProcessor !== undefined) {
+            this.steps.push(this.currentStepProcessor.buildResult());
+            this.currentStepProcessor = undefined;
+        }
+        if (result === 'failure') {
+            this.status = ActExecStatus.FAILED;
+        }
+        else {
+            this.status = this.hasExecutedSteps
+                ? ActExecStatus.SUCCESS
+                : ActExecStatus.SKIPPED;
+        }
+    }
+    buildResult() {
+        return {
+            name: this.name,
+            status: this.status,
+            output: this.outputLines.join('\n'),
+            matrix: this.matrix,
+            steps: this.steps,
+        };
+    }
+}

package/dist/internal/ActJsonOutput.d.ts

@@ -0,0 +1,39 @@
+/**
+ * Copyright (c) 2026 original authors
+ *
+ * Permission is hereby granted, free of charge, to any person obtaining a copy
+ * of this software and associated documentation files (the "Software"), to deal
+ * in the Software without restriction, including without limitation the rights
+ * to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+ * copies of the Software, and to permit persons to whom the Software is
+ * furnished to do so, subject to the following conditions:
+ *
+ * The above copyright notice and this permission notice shall be included in
+ * all copies or substantial portions of the Software.
+ *
+ * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+ * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+ * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+ * AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+ * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+ * OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+ * SOFTWARE.
+ */
+import { ActOutputLevel, ActJobOrStepDescriptor } from '../ActOutputListener.js';
+import { ActMatrixValues } from '../ActRunnerResult.js';
+export type JobOrStepResult = 'success' | 'failure' | 'skipped';
+export type JsonOutput = {
+    time: Date;
+    level: ActOutputLevel;
+    msg: string;
+    job?: string;
+    jobID?: string;
+    jobResult?: JobOrStepResult;
+    step?: string;
+    stepID?: string[];
+    stepResult?: JobOrStepResult;
+    matrix: ActMatrixValues;
+};
+export declare function formattedMessage(message: string, jobName: string | undefined): string;
+export declare function jobDescriptor(output: JsonOutput): ActJobOrStepDescriptor | undefined;
+export declare function stepDescriptor(output: JsonOutput): ActJobOrStepDescriptor | undefined;

package/dist/internal/ActJsonOutput.js

@@ -0,0 +1,53 @@
+/**
+ * Copyright (c) 2026 original authors
+ *
+ * Permission is hereby granted, free of charge, to any person obtaining a copy
+ * of this software and associated documentation files (the "Software"), to deal
+ * in the Software without restriction, including without limitation the rights
+ * to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+ * copies of the Software, and to permit persons to whom the Software is
+ * furnished to do so, subject to the following conditions:
+ *
+ * The above copyright notice and this permission notice shall be included in
+ * all copies or substantial portions of the Software.
+ *
+ * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+ * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+ * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+ * AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+ * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+ * OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+ * SOFTWARE.
+ */
+export function formattedMessage(message, jobName) {
+    if (jobName !== undefined) {
+        return `[${jobName}] ${message}`.trim();
+    }
+    else {
+        return message.trim();
+    }
+}
+export function jobDescriptor(output) {
+    if (output.job !== undefined && output.jobID !== undefined) {
+        return {
+            id: output.jobID,
+            name: output.job,
+        };
+    }
+    return undefined;
+}
+export function stepDescriptor(output) {
+    // act reports step ids as a path (outermost to innermost, e.g. for
+    // composite action steps); the innermost entry identifies the step
+    // currently reporting output.
+    if (output.step !== undefined &&
+        output.stepID !== undefined &&
+        output.stepID.length > 0) {
+        const lastStepIdSegment = output.stepID[output.stepID.length - 1];
+        return {
+            id: lastStepIdSegment,
+            name: output.step,
+        };
+    }
+    return undefined;
+}