@smoothbricks/cli 0.10.8 → 0.10.10

package/dist/wrangler/{environment.js → stage.js}

@@ -3,40 +3,40 @@ import { getStaticTOMLValue, parseTOML } from 'toml-eslint-parser';
 import typia from 'typia';
 import { cloneEnvBlock } from './prepare-env.js';
 const MAX_PULL_REQUEST_NUMBER = 999999999;
-const ENVIRONMENT_PATTERN = /^(?:staging|production|pr[1-9][0-9]{0,8})$/;
-export function pullRequestEnvironment(prNumber) {
+const STAGE_PATTERN = /^(?:staging|production|pr[1-9][0-9]{0,8})$/;
+export function pullRequestStage(prNumber) {
     if (!Number.isInteger(prNumber) || prNumber < 1 || prNumber > MAX_PULL_REQUEST_NUMBER) {
         throw new Error(`Pull request number must be an integer from 1 through ${MAX_PULL_REQUEST_NUMBER}.`);
     }
     return `pr${prNumber}`;
 }
-export function parseEnvironmentToken(value) {
-    if (!ENVIRONMENT_PATTERN.test(value)) {
-        throw new Error('Environment must be exactly staging, production, or pr followed by an integer from 1 through 999999999.');
+export function parseDeploymentStage(value) {
+    if (!STAGE_PATTERN.test(value)) {
+        throw new Error('Deployment stage must be exactly staging, production, or pr followed by an integer from 1 through 999999999.');
     }
     if (value === 'staging' || value === 'production')
         return value;
-    return pullRequestEnvironment(Number(value.slice(2)));
+    return pullRequestStage(Number(value.slice(2)));
 }
-export function isPullRequestEnvironment(environment) {
-    return environment.startsWith('pr');
+export function isPullRequestStage(stage) {
+    return stage.startsWith('pr');
 }
-export function environmentDomain(environment, zone) {
-    const token = parseEnvironmentToken(environment);
+export function stageDomain(stage, zone) {
+    const token = parseDeploymentStage(stage);
     if (!zone || zone.startsWith('.') || zone.endsWith('.')) {
         throw new Error('Zone must be a non-empty DNS name without leading or trailing dots.');
     }
     return token === 'production' ? zone : `${token}.${zone}`;
 }
-export function environmentResourceName(base, environment) {
-    const token = parseEnvironmentToken(environment);
+export function stageResourceName(base, stage) {
+    const token = parseDeploymentStage(stage);
     if (!base) {
         throw new Error('Resource base name must not be empty.');
     }
     return token === 'production' ? base : `${base}-${token}`;
 }
-export function hasExactEnvironmentSegment(value, environment) {
-    const escaped = environment.replace(/[.*+?^${}()|[\]\\]/g, '\\$&');
+export function hasExactStageSegment(value, stage) {
+    const escaped = stage.replace(/[.*+?^${}()|[\]\\]/g, '\\$&');
     return new RegExp(`(?:^|[-.])${escaped}(?=$|[-.])`).test(value);
 }
 const isWranglerRoot = (() => {
@@ -86,14 +86,14 @@ const isUnknownRows = (() => {
     });
     return input => Array.isArray(input) && input.every(elem => "object" === typeof elem && null !== elem && false === Array.isArray(elem) && _io0(elem));
 })();
-export function planConfiguredEnvironmentResources(toml, environment) {
-    const block = parseRoot(toml).env?.[environment];
+export function planConfiguredStageResources(toml, stage) {
+    const block = parseRoot(toml).env?.[stage];
     if (!isWranglerEnvironment(block)) {
-        throw new Error(`Wrangler configuration must declare [env.${environment}].`);
+        throw new Error(`Wrangler configuration must declare [env.${stage}].`);
     }
-    const workerName = requiredString(block, 'name', `[env.${environment}]`);
+    const workerName = requiredString(block, 'name', `[env.${stage}]`);
     return {
-        environment,
+        stage,
         workerName,
         kvNamespaces: readKvBindings(block.kv_namespaces),
         r2Buckets: readRows(block.r2_buckets).map((row) => {
@@ -127,8 +127,8 @@ function stagingWorkerName(staging) {
     }
     return { workerName: staging.name, workerBaseName: staging.name.slice(0, -'-staging'.length) };
 }
-export function planPullRequestResources(toml, environment, liveNamespaces) {
-    parseEnvironmentToken(environment);
+export function planPullRequestResources(toml, stage, liveNamespaces) {
+    parseDeploymentStage(stage);
     const staging = stagingEnvironment(toml);
     const { workerBaseName } = stagingWorkerName(staging);
     const namespaceById = new Map(liveNamespaces.map((namespace) => [namespace.id, namespace]));
@@ -137,7 +137,7 @@ export function planPullRequestResources(toml, environment, liveNamespaces) {
         if (!stagingNamespace) {
             throw new Error(`Staging KV binding ${binding} references namespace ${id}, which is absent from the account listing.`);
         }
-        const title = replaceExactToken(stagingNamespace.title, 'staging', environment);
+        const title = replaceExactToken(stagingNamespace.title, 'staging', stage);
         if (title === stagingNamespace.title) {
             throw new Error(`Staging KV namespace title ${stagingNamespace.title} has no exact staging segment.`);
         }
@@ -146,20 +146,20 @@ export function planPullRequestResources(toml, environment, liveNamespaces) {
     const r2Buckets = readRows(staging.r2_buckets).map((row) => {
         const binding = requiredString(row, 'binding', 'R2 binding');
         const stagingBucket = requiredString(row, 'bucket_name', `R2 binding ${binding}`);
-        const bucketName = replaceExactToken(stagingBucket, 'staging', environment);
+        const bucketName = replaceExactToken(stagingBucket, 'staging', stage);
         if (bucketName === stagingBucket) {
             throw new Error(`Staging R2 bucket ${stagingBucket} has no exact staging segment.`);
         }
         return { binding, bucketName };
     });
     const routes = readRows(staging.routes).map((row) => ({
-        pattern: replaceHostnameLabel(requiredString(row, 'pattern', 'route'), environment),
+        pattern: replaceHostnameLabel(requiredString(row, 'pattern', 'route'), stage),
         ...(typeof row.zone_name === 'string' ? { zoneName: row.zone_name } : {}),
         customDomain: row.custom_domain === true,
     }));
     return {
-        environment,
-        workerName: environmentResourceName(workerBaseName, environment),
+        stage,
+        workerName: stageResourceName(workerBaseName, stage),
         workerBaseName,
         kvNamespaces,
         r2Buckets,
@@ -167,14 +167,14 @@ export function planPullRequestResources(toml, environment, liveNamespaces) {
     };
 }
 export function derivePullRequestWranglerConfig(toml, options) {
-    const environment = options.environment;
-    parseEnvironmentToken(environment);
+    const stage = options.stage;
+    parseDeploymentStage(stage);
     if (!options.accountId) {
         throw new Error('Cloudflare account id is required to derive rate-limit namespaces.');
     }
     const staging = stagingEnvironment(toml);
     const { workerBaseName } = stagingWorkerName(staging);
-    const cloned = cloneEnvBlock(toml, 'staging', environment);
+    const cloned = cloneEnvBlock(toml, 'staging', stage);
     const program = parseTOML(cloned);
     const rootValue = getStaticTOMLValue(program);
     if (!isWranglerRoot(rootValue)) {
@@ -183,7 +183,7 @@ export function derivePullRequestWranglerConfig(toml, options) {
     const root = rootValue;
     const edits = [];
     for (const table of program.body[0].body) {
-        if (table.type !== 'TOMLTable' || table.resolvedKey[0] !== 'env' || table.resolvedKey[1] !== environment) {
+        if (table.type !== 'TOMLTable' || table.resolvedKey[0] !== 'env' || table.resolvedKey[1] !== stage) {
             continue;
         }
         const tableValue = valueAtPath(root, table.resolvedKey);
@@ -193,7 +193,7 @@ export function derivePullRequestWranglerConfig(toml, options) {
         for (const keyValue of table.body) {
             const key = cloned.slice(keyValue.key.range[0], keyValue.key.range[1]).trim();
             const current = tableValue[key];
-            const next = deriveFieldValue(table.resolvedKey.slice(2), tableValue, key, current, environment, workerBaseName, options.accountId, options.kvNamespaceIds);
+            const next = deriveFieldValue(table.resolvedKey.slice(2), tableValue, key, current, stage, workerBaseName, options.accountId, options.kvNamespaceIds);
             if (next !== current) {
                 edits.push({ start: keyValue.value.range[0], end: keyValue.value.range[1], value: tomlLiteral(next) });
             }
@@ -206,25 +206,25 @@ export function derivePullRequestWranglerConfig(toml, options) {
     parseTOML(derived);
     return derived;
 }
-function deriveFieldValue(path, table, key, current, environment, workerBaseName, accountId, kvNamespaceIds) {
+function deriveFieldValue(path, table, key, current, stage, workerBaseName, accountId, kvNamespaceIds) {
     const section = path[0];
     if (path.length === 0 && key === 'name') {
-        return environmentResourceName(workerBaseName, environment);
+        return stageResourceName(workerBaseName, stage);
     }
     if (section === 'routes' && key === 'pattern' && typeof current === 'string') {
-        return replaceHostnameLabel(current, environment);
+        return replaceHostnameLabel(current, stage);
     }
     if (section === 'vars' && typeof current === 'string') {
         if (key === 'ENVIRONMENT') {
-            return environment;
+            return stage;
         }
         if (key === 'AUTH_KEYS_INSTANCE_NAME') {
-            return replaceExactToken(current, 'staging', environment);
+            return replaceExactToken(current, 'staging', stage);
         }
-        return replaceHostnameLabel(current, environment);
+        return replaceHostnameLabel(current, stage);
     }
     if (section === 'send_email' && key === 'allowed_sender_addresses' && Array.isArray(current)) {
-        return current.map((value) => (typeof value === 'string' ? replaceHostnameLabel(value, environment) : value));
+        return current.map((value) => (typeof value === 'string' ? replaceHostnameLabel(value, stage) : value));
     }
     if (section === 'kv_namespaces' && key === 'id' && typeof current === 'string') {
         const derived = kvNamespaceIds.get(current);
@@ -234,22 +234,22 @@ function deriveFieldValue(path, table, key, current, environment, workerBaseName
         return derived;
     }
     if (section === 'r2_buckets' && key === 'bucket_name' && typeof current === 'string') {
-        return replaceExactToken(current, 'staging', environment);
+        return replaceExactToken(current, 'staging', stage);
     }
     if (section === 'ratelimits' && key === 'namespace_id') {
         const bindingName = requiredString(table, 'name', 'Rate-limit binding');
-        return rateLimitNamespaceId(accountId, workerBaseName, environment, bindingName);
+        return rateLimitNamespaceId(accountId, workerBaseName, stage, bindingName);
     }
     return current;
 }
-export function rateLimitNamespaceId(accountId, workerBaseName, environment, bindingName) {
-    const token = parseEnvironmentToken(environment);
+export function rateLimitNamespaceId(accountId, workerBaseName, stage, bindingName) {
+    const token = parseDeploymentStage(stage);
     const digest = createHash('sha256').update(`${accountId}:${workerBaseName}:${token}:${bindingName}`).digest();
     const value = digest.readUInt32BE(0) & 2147483647;
     return String(value === 0 ? 1 : value);
 }
-function replaceHostnameLabel(value, environment) {
-    return value.replace(/(^|[.@/])staging(?=\.)/g, `$1${environment}`);
+function replaceHostnameLabel(value, stage) {
+    return value.replace(/(^|[.@/])staging(?=\.)/g, `$1${stage}`);
 }
 function replaceExactToken(value, from, to) {
     const escaped = from.replace(/[.*+?^${}()|[\]\\]/g, '\\$&');

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@smoothbricks/cli",
-  "version": "0.10.8",
+  "version": "0.10.10",
   "type": "module",
   "description": "SmoothBricks monorepo automation CLI",
   "bin": {
@@ -48,12 +48,12 @@
       "import": "./dist/wrangler/prepare-env.js",
       "default": "./dist/wrangler/prepare-env.js"
     },
-    "./wrangler/environment": {
-      "types": "./dist/wrangler/environment.d.ts",
-      "bun": "./src/wrangler/environment.ts",
-      "development": "./src/wrangler/environment.ts",
-      "import": "./dist/wrangler/environment.js",
-      "default": "./dist/wrangler/environment.js"
+    "./wrangler/stage": {
+      "types": "./dist/wrangler/stage.d.ts",
+      "bun": "./src/wrangler/stage.ts",
+      "development": "./src/wrangler/stage.ts",
+      "import": "./dist/wrangler/stage.js",
+      "default": "./dist/wrangler/stage.js"
     }
   },
   "sideEffects": [
@@ -71,7 +71,7 @@
   "dependencies": {
     "@arethetypeswrong/core": "^0.18.2",
     "@prettier/sync": "^0.6.1",
-    "@smoothbricks/nx-plugin": "0.3.5",
+    "@smoothbricks/nx-plugin": "0.3.6",
     "@smoothbricks/validation": "0.1.5",
     "commander": "^14.0.3",
     "prettier": "^3.6.1",

package/src/cli.ts

@@ -4,7 +4,7 @@ import { cliPackageVersion } from './lib/cli-package.js';
 import { findRepoRoot } from './lib/run.js';
 import { ensureChromium } from './playwright/index.js';
 import { resolvePrConflicts } from './pr/index.js';
-import { cleanupPullRequest, deployEnvironment } from './wrangler/deploy-environment.js';
+import { cleanupPullRequest, deployStage } from './wrangler/deploy-stage.js';
 import { scaffold } from './wrangler/scaffold.js';
 
 export async function runCli(argv = process.argv.slice(2)): Promise<void> {
@@ -175,7 +175,8 @@ function buildProgram(): Command {
     .requiredOption('--targets <targets>', 'comma-separated Nx platform target names or globs')
     .requiredOption('--output <path>', 'output directory for current and repair artifacts')
     .option('--ref <ref>', 'fixed release graph ref to inspect')
-    .action(async (options: { bump: string; output: string; ref?: string; targets: string }) => {
+    .option('--github-output <path>', 'append selected current platform projects to a GitHub Actions output file')
+    .action(async (options: { bump: string; githubOutput?: string; output: string; ref?: string; targets: string }) => {
       // The source self-hosting shim has no Typia transform; release commands import transformed output validators.
       const { releaseCollectPlatformOutputs } = await import('./release/index.js');
       await releaseCollectPlatformOutputs(await findRepoRoot(), options);
@@ -334,6 +335,7 @@ function buildProgram(): Command {
     .option('--step <step>')
     .option('--mode <mode>', 'auto, affected, or run-many', 'auto')
     .option('--configuration <configuration>')
+    .option('--stage <stage>')
     .action(
       async (options: {
         target: string;
@@ -341,6 +343,7 @@ function buildProgram(): Command {
         step?: string;
         mode?: 'auto' | 'affected' | 'run-many';
         configuration?: string;
+        stage?: string;
       }) => {
         const { githubCiNxSmart } = await import('./github-ci/index.js');
         await githubCiNxSmart(await findRepoRoot(), options);
@@ -375,14 +378,14 @@ function buildProgram(): Command {
     });
   githubCi
     .command('nx-deploy')
-    .option('--environment <environment>', 'explicit staging, production, or prN override')
+    .option('--stage <stage>', 'explicit staging, production, or prN override')
     .option('--mode <mode>', 'auto, affected, or run-many', 'run-many')
     .option('--name <name>')
     .option('--step <step>')
     .option('--verify', 'run build, lint, and test before deploy')
     .action(
       async (options: {
-        environment?: string;
+        stage?: string;
         mode?: 'auto' | 'affected' | 'run-many';
         name?: string;
         step?: string;
@@ -423,10 +426,10 @@ function buildProgram(): Command {
       scaffold(await findRepoRoot(), project, { force: options.force });
     });
   wrangler
-    .command('deploy-environment')
-    .requiredOption('--environment <environment>', 'staging, production, or prN')
-    .action(async (options: { environment: string }) => {
-      await deployEnvironment(process.cwd(), options.environment);
+    .command('deploy-stage')
+    .requiredOption('--stage <stage>', 'staging, production, or prN')
+    .action(async (options: { stage: string }) => {
+      await deployStage(process.cwd(), options.stage);
     });
   wrangler
     .command('cleanup-pr')

package/src/github-ci/index.test.ts

@@ -14,8 +14,8 @@ import {
   nxSmartArgs,
   publishGithubDeployment,
   readGitHeadSha,
-  resolveDeploymentEnvironment,
-  selectEnvironmentDeployProjects,
+  resolveDeploymentStage,
+  selectStageDeployProjects,
 } from './index.js';
 import {
   applyCollectedOutputs,
@@ -134,12 +134,13 @@ describe('GitHub CI Nx target expansion', () => {
     ).toEqual(['native:package-linux', 'native:compile-linux', 'native:build']);
   });
 
-  it('adds the generic target skip tag only to nx-smart', () => {
-    expect(nxSmartArgs('test', 'affected')).toEqual([
-      'affected',
+  it('adds optional stage before the generic target skip tag only to nx-smart', () => {
+    expect(nxSmartArgs('e2e-deployment', 'run-many', undefined, 'pr123')).toEqual([
+      'run-many',
       '-t',
-      'test',
-      '--exclude=tag:ci:skip:test',
+      'e2e-deployment',
+      '--stage=pr123',
+      '--exclude=tag:ci:skip:e2e-deployment',
       '--parallel=100%',
     ]);
     expect(nxRunManyArgs({ target: 'test', projects: projects.slice(0, 1) })).not.toContain(
@@ -166,11 +167,12 @@ describe('collected Nx outputs', () => {
 
   it('collects an empty artifact when selected projects have no matching target', async () => {
     await withNxRunManyFixture(async ({ root, artifact }) => {
-      await githubCiNxRunMany(root, {
+      const expanded = await githubCiNxRunMany(root, {
         targets: '*-linux',
         projects: 'app',
         collectOutputs: artifact,
       });
+      expect(expanded.runs).toEqual([]);
 
       const sourceSha = await readGitHeadSha(root);
       expect(JSON.parse(await readFile(join(artifact, 'manifest.json'), 'utf8'))).toEqual({
@@ -186,10 +188,11 @@ describe('collected Nx outputs', () => {
       await writeFile(join(root, 'packages/app/test-target.ts'), "await Bun.write('test-ran.txt', 'tested');\n");
       await writeFile(join(root, 'packages/app/build-target.ts'), "throw new Error('build must not run here');\n");
 
-      await githubCiNxRunMany(root, {
+      const expanded = await githubCiNxRunMany(root, {
         targets: 'test',
         projectsWithTargets: '*-macos,*-ios',
       });
+      expect(expanded.runs.map((run) => run.projects.map((project) => project.project))).toEqual([['app']]);
 
       await expect(readFile(join(root, 'test-ran.txt'), 'utf8')).resolves.toBe('tested');
       await expect(readFile(join(root, 'build-ran.txt'), 'utf8')).rejects.toThrow();
@@ -538,10 +541,10 @@ async function withNxRunManyFixture(
   }
 }
 
-describe('event-aware environment deployment', () => {
-  it('resolves same-repository PR, private push, release, and explicit production environments', () => {
+describe('event-aware stage deployment', () => {
+  it('resolves same-repository PR, private push, release, and explicit production stages', () => {
     expect(
-      resolveDeploymentEnvironment(
+      resolveDeploymentStage(
         undefined,
         { GITHUB_EVENT_NAME: 'pull_request' },
         {
@@ -552,12 +555,12 @@ describe('event-aware environment deployment', () => {
       ),
     ).toBe('pr123');
     expect(
-      resolveDeploymentEnvironment(undefined, { GITHUB_EVENT_NAME: 'push', GITHUB_REF_NAME: 'private' }, undefined),
+      resolveDeploymentStage(undefined, { GITHUB_EVENT_NAME: 'push', GITHUB_REF_NAME: 'private' }, undefined),
     ).toBe('staging');
-    expect(resolveDeploymentEnvironment(undefined, { GITHUB_EVENT_NAME: 'release' }, undefined)).toBe('production');
-    expect(resolveDeploymentEnvironment('production', {}, undefined)).toBe('production');
+    expect(resolveDeploymentStage(undefined, { GITHUB_EVENT_NAME: 'release' }, undefined)).toBe('production');
+    expect(resolveDeploymentStage('production', {}, undefined)).toBe('production');
     expect(() =>
-      resolveDeploymentEnvironment(
+      resolveDeploymentStage(
         undefined,
         { GITHUB_EVENT_NAME: 'pull_request' },
         {
@@ -569,15 +572,15 @@ describe('event-aware environment deployment', () => {
     ).toThrow(/same-repository/);
   });
 
-  it('selects only deploy targets owned by the environment convention', async () => {
+  it('selects only deploy targets owned by the stage convention', async () => {
     const definitions: Record<string, unknown> = {
       'conloca-app': {
         targets: {
-          deploy: { options: { command: 'smoo wrangler deploy-environment --environment {args.environment}' } },
+          deploy: { options: { command: 'smoo wrangler deploy-stage --stage {args.stage}' } },
         },
       },
       'conloca-app-backend': {
-        targets: { deploy: { command: 'smoo wrangler deploy-environment --environment {args.environment}' } },
+        targets: { deploy: { command: 'smoo wrangler deploy-stage --stage {args.stage}' } },
       },
       'conloca-oauth-redirect': {
         targets: { deploy: { options: { command: 'wrangler deploy --config wrangler.toml' } } },
@@ -588,7 +591,7 @@ describe('event-aware environment deployment', () => {
     };
 
     await expect(
-      selectEnvironmentDeployProjects(Object.keys(definitions), async (project) => definitions[project]),
+      selectStageDeployProjects(Object.keys(definitions), async (project) => definitions[project]),
     ).resolves.toEqual(['conloca-app', 'conloca-app-backend']);
   });
 
@@ -652,19 +655,21 @@ describe('event-aware environment deployment', () => {
     ]);
   });
 
-  it('deploys app/backend, follows with e2e-deployed, and publishes PR metadata', async () => {
+  it('deploys app/backend, publishes PR metadata, and emits the resolved stage', async () => {
     const nxCalls: string[][] = [];
     const listCalls: Array<[string, string]> = [];
     const summaries: string[] = [];
     const deployments: Array<[string, string]> = [];
+    const outputs: string[] = [];
 
     await githubCiNxDeploy(
       '/repo',
-      { mode: 'run-many', name: 'Deploy Environment' },
+      { mode: 'run-many', name: 'Deploy Stage' },
       {
         processEnv: {
           GITHUB_EVENT_NAME: 'pull_request',
           GITHUB_STEP_SUMMARY: '/summary',
+          GITHUB_OUTPUT: '/output',
         },
         setStatus: async () => {},
         eventPayload: {
@@ -674,7 +679,7 @@ describe('event-aware environment deployment', () => {
         },
         listProjects: async (_root, target, mode) => {
           listCalls.push([target, mode]);
-          return target === 'deploy' ? ['conloca-app', 'conloca-app-backend'] : ['conloca-e2e'];
+          return ['conloca-app', 'conloca-app-backend'];
         },
         runNx: async (args) => {
           nxCalls.push(args);
@@ -683,24 +688,90 @@ describe('event-aware environment deployment', () => {
         appendSummary: async (_path, content) => {
           summaries.push(content);
         },
-        publishDeployment: async (environment, url) => {
-          deployments.push([environment, url]);
+        appendOutput: async (_path, content) => {
+          outputs.push(content);
+        },
+        publishDeployment: async (stage, url) => {
+          deployments.push([stage, url]);
         },
       },
     );
 
-    expect(listCalls).toEqual([
-      ['deploy', 'run-many'],
-      ['e2e-deployed', 'run-many'],
-    ]);
-    expect(nxCalls).toHaveLength(2);
+    expect(listCalls).toEqual([['deploy', 'run-many']]);
+    expect(nxCalls).toHaveLength(1);
     expect(nxCalls[0]).toContain('--projects=conloca-app,conloca-app-backend');
     expect(nxCalls[0]).toContain('--exclude=tag:permanent-deploy-target');
-    expect(nxCalls[0]).toContain('--environment=pr123');
-    expect(nxCalls[1]).toContain('-t');
-    expect(nxCalls[1]).toContain('e2e-deployed');
-    expect(nxCalls[1]).toContain('--environment=pr123');
+    expect(nxCalls[0]).toContain('--stage=pr123');
+    expect(nxCalls[0]).not.toContain('e2e-deployment');
     expect(summaries).toEqual(['## pr123 deployment\n\n[View deployment](https://app.pr123.conloca.com)\n']);
     expect(deployments).toEqual([['pr123', 'https://app.pr123.conloca.com']]);
+    expect(outputs).toEqual(['stage=pr123\n']);
+  });
+
+  it('emits no stage when no deploy project exists', async () => {
+    const outputs: string[] = [];
+    const statuses: string[] = [];
+
+    await githubCiNxDeploy(
+      '/repo',
+      { stage: 'staging' },
+      {
+        processEnv: { GITHUB_OUTPUT: '/output' },
+        listProjects: async () => [],
+        appendOutput: async (_path, content) => {
+          outputs.push(content);
+        },
+        setStatus: async (status) => {
+          statuses.push(status);
+        },
+      },
+    );
+
+    expect(outputs).toEqual([]);
+    expect(statuses).toEqual(['pending', 'success']);
+  });
+
+  it('emits no stage after deployment or output failure', async () => {
+    const deploymentOutputs: string[] = [];
+    const deploymentStatuses: string[] = [];
+    await expect(
+      githubCiNxDeploy(
+        '/repo',
+        { stage: 'staging' },
+        {
+          processEnv: { GITHUB_OUTPUT: '/output' },
+          listProjects: async () => ['app'],
+          runNx: async () => 1,
+          appendOutput: async (_path, content) => {
+            deploymentOutputs.push(content);
+          },
+          setStatus: async (status) => {
+            deploymentStatuses.push(status);
+          },
+        },
+      ),
+    ).rejects.toThrow(/failed with exit code 1/);
+    expect(deploymentOutputs).toEqual([]);
+    expect(deploymentStatuses).toEqual(['pending', 'failure']);
+
+    const outputStatuses: string[] = [];
+    await expect(
+      githubCiNxDeploy(
+        '/repo',
+        { stage: 'staging' },
+        {
+          processEnv: { GITHUB_OUTPUT: '/output' },
+          listProjects: async () => ['app'],
+          runNx: async () => 0,
+          appendOutput: async () => {
+            throw new Error('output unavailable');
+          },
+          setStatus: async (status) => {
+            outputStatuses.push(status);
+          },
+        },
+      ),
+    ).rejects.toThrow('output unavailable');
+    expect(outputStatuses).toEqual(['pending', 'failure']);
   });
 });