Files
clean-architecture-frontend…/scripts/test-sample-removal.ts
T
DongHyeonka 4ab35c4a05
frontend-quality-gates / merge / static checks (pull_request) Successful in 2m50s
frontend-quality-gates / merge / tests (pull_request) Failing after 14m15s
frontend-quality-gates / merge / browser tests (pull_request) Successful in 10m29s
frontend-quality-gates / FE-GATE-017 / diagram-review (pull_request) Skipped
frontend-quality-gates / FE-GATE-014 / config-compatibility (pull_request) Skipped
frontend-quality-gates / FE-GATE-028 / manual-accessibility-review (pull_request) Skipped
frontend-quality-gates / FE-GATE-026 / lab-performance (pull_request) Skipped
frontend-quality-gates / FE-GATE-015 / immutable-release-candidate (pull_request) Skipped
frontend-quality-gates / external-vulnerability-provider (pull_request) Skipped
frontend-quality-gates / external-provenance-provider (pull_request) Skipped
frontend-quality-gates / promote-verified-immutable-candidate (pull_request) Skipped
frontend-quality-gates / deploy-promoted-release (pull_request) Skipped
frontend-quality-gates / FE-GATE-019 / hosting-header (pull_request) Skipped
frontend-quality-gates / FE-GATE-021 / runbook-boot-config (pull_request) Skipped
frontend-quality-gates / FE-GATE-022 / runbook-chunk-mismatch (pull_request) Skipped
frontend-quality-gates / FE-GATE-023 / runbook-api-degradation (pull_request) Skipped
frontend-quality-gates / FE-GATE-024 / runbook-telemetry (pull_request) Skipped
frontend-quality-gates / FE-GATE-025 / runbook-release-rollback (pull_request) Skipped
frontend-quality-gates / FE-GATE-018 / field-web-vitals (pull_request) Skipped
frontend-quality-gates / main / checker self-tests (pull_request) Skipped
fix(test): 템플릿 시험이 사본에 만드는 기능 ID를 예약 접두어로 옮긴다
템플릿 시험과 드릴이 저장소 사본에 고정 ID로 기능을 만든다. 매뉴얼
코드 조각 시험은 매뉴얼 예시 invoice-feature를(FE-GATE-005), 생성 기능
e2e·청크 복구·부팅 실패 spec은 order-feature를(FE-GATE-008), scaffold
드릴은 scaffold-feature를(FE-GATE-020) 쓴다. 사본에는 제품 기능이 들어
있고 create:feature는 같은 ID나 같은 접두어를 거부한다. 그래서 매뉴얼
1단계 예시대로 invoice-feature를 만든 제품은 기능 코드와 상관없이 merge
게이트에서 막힌다.

고른 방법: 사본에 만드는 기능 ID를 모두 이미 정한 예약 접두어
typecheck-probe-로 옮기고 scripts/lib/template-probe-features.ts 한 곳에
둔다. 매뉴얼 조각은 invoice-feature 기준 그대로 두고, 시험이 조각과
검사 파일의 이름(INVOICE_, Invoice, invoice-, invoice)을 예약 기능의
이름으로 바꿔 넣는다(renameFeatureText). 생성 기능 e2e는 메시지 키와
계약 이름을 ID에서 만든다. 버린 대안: 사본에서 제품의 같은 이름
기능을 먼저 지우기(등록·조립 파일까지 지워야 해 사본이 제품과 달라진다),
create:feature가 흔한 이름을 거부하기(제품 이름을 막는다).

위험·한계: 이름 바꾸기는 낱말 단위 치환이라 조각의 영어 문장 속
invoice도 바뀐다(조각과 검사가 함께 바뀌어 결과는 같다). 제품이
typecheck-probe-로 시작하는 기능을 만들면 다시 부딪친다. 매뉴얼과
create-feature 참조에 쓰지 말라고 적었고 생성 명령이 막지는 않는다.
measure-feature-shape-growth의 s000-feature 꼴 ID는 그대로 뒀다.

검증: desktop에서 RED(이 커밋의 시험을 기준 커밋에 얹음)와 GREEN,
제품 상태(invoice-feature·order-feature를 만든 사본)의 FE-GATE-005·008
재현은 PR 본문에 적는다.

Refs: 1112/08-02
2026-11-12 22:32:09 +09:00

563 lines
22 KiB
TypeScript

import {
access,
mkdir,
readdir,
readFile,
rm,
writeFile,
} from "node:fs/promises";
import { spawnSync } from "node:child_process";
import path from "node:path";
import { fileURLToPath } from "node:url";
import { ROUTE_FEATURE_OWNER } from "../src/features/installed-feature-contracts.ts";
import { loadCiGateContract } from "./contracts/ci-gates.ts";
import { createFileSystemDeclarationSource } from "./generate-product-feature-index.ts";
import { productFeatureResidue } from "./lib/feature-residue.ts";
import { isProductionModulePath } from "./lib/risk-coverage.ts";
import {
createRemovalFixtureRoot,
filesBelow,
prepareRemovalFixture,
pruneRemovalFixtureCiContract,
pruneScriptOrchestration,
regenerateRemovalFixtureWorkflow,
REMOVAL_FIXTURE_COPY_TARGETS,
REMOVAL_FIXTURE_DOCUMENT_TARGETS,
renderRemovalJunit,
requireRemovalFixtureEnvironment,
runRemovalFixtureCheck,
runRemovalFixturePnpm,
sealRemovalFixtureRepository,
type RemovalCheck,
} from "./lib/removal-fixture.ts";
import { REMOVABLE_TEMPLATE_FEATURES } from "./lib/removable-template-features.ts";
import { SCAFFOLD_PROBE_FEATURE_ID } from "./lib/template-probe-features.ts";
/**
* 09-07 (D-10). Removes one installed feature, `--feature=<id>`, from a copy
* of the repository and proves the rest still typechecks, tests, covers and
* builds. Every feature loses its directory, its tests/features directory,
* its context when no other feature is left in it, its runtime-profile
* override and its central policy rows. A sample that
* scripts/lib/removable-template-features.ts lists also loses its extra paths
* and package scripts, with the CI evidence only those scripts produce, and
* the copy then gets a feature from create:feature and runs the gates again.
*
* Without `--feature` (FE-GATE-020) each listed sample is removed in turn.
* The template lists none since its samples were deleted (2026-11-07): the
* run then reports the drill as skipped, not passed, and test:feature-scaffold
* removes a generated feature through `--feature`.
*/
const SAMPLE_REPORT = "artifacts/tests/sample-removal.xml";
const requestedFeature = process.argv
.find((argument) => argument.startsWith("--feature="))
?.slice("--feature=".length);
if (requestedFeature === undefined) {
const checks: RemovalCheck[] = REMOVABLE_TEMPLATE_FEATURES.map((sample) => {
const status = spawnSync(
process.execPath,
[fileURLToPath(import.meta.url), `--feature=${sample.featureId}`],
{ stdio: "inherit" },
).status;
return status === 0
? { name: sample.featureId, passed: true }
: {
name: sample.featureId,
passed: false,
failure: `test:sample-removal -- --feature=${sample.featureId} exited ${status ?? "on a signal"}`,
};
});
await mkdir("artifacts/tests", { recursive: true });
if (checks.length === 0) {
await writeFile(
SAMPLE_REPORT,
`<?xml version="1.0" encoding="UTF-8"?>\n` +
`<testsuite name="sample-removal" tests="1" failures="0" skipped="1">` +
`<testcase name="listed-samples"><skipped message="scripts/lib/removable-template-features.ts lists no sample" /></testcase>` +
`</testsuite>\n`,
);
process.stdout.write(
"sample removal: SKIP (scripts/lib/removable-template-features.ts lists no sample; " +
"test:feature-scaffold removes a generated feature with --feature)\n",
);
} else {
await writeFile(SAMPLE_REPORT, renderRemovalJunit("sample-removal", checks));
if (checks.some((check) => !check.passed)) process.exitCode = 1;
}
process.exit();
}
const featureId: string = requestedFeature;
type FeatureExtras = Readonly<{
paths: readonly string[];
ciScripts: readonly string[];
evidencePathFragments: readonly string[];
}>;
/** The CI evidence that only `scripts` produce: it goes with them. */
async function evidenceOnlyFrom(scripts: readonly string[]): Promise<string[]> {
if (scripts.length === 0) return [];
const contract = await loadCiGateContract(process.cwd());
const commandIds = new Set(
contract.commands.filter(({ script }) => scripts.includes(script)).map(({ id }) => id),
);
return contract.artifacts.flatMap((artifact) =>
artifact.production === "command-generated" &&
artifact.producerCommandIds.length > 0 &&
artifact.producerCommandIds.every((commandId) => commandIds.has(commandId))
? [artifact.path]
: [],
);
}
// The sample's own files and scripts outside its folders, which
// verify:documentation reads too.
const listedSample = REMOVABLE_TEMPLATE_FEATURES.find(
(feature) => feature.featureId === featureId,
);
const extras: FeatureExtras = Object.freeze({
paths: listedSample?.extraPaths ?? [],
ciScripts: listedSample?.scripts ?? [],
evidencePathFragments: await evidenceOnlyFrom(listedSample?.scripts ?? []),
});
function escapeRegExp(value: string): string {
return value.replace(/[.*+?^${}()|[\]\\]/gu, "\\$&");
}
async function locateFeature(id: string) {
const source = await createFileSystemDeclarationSource(process.cwd());
for (const appId of source.appIds()) {
for (const context of source.contextsOf(appId)) {
const features = source.featuresOf(context.id);
const feature = features.find((candidate) => candidate.id === id);
if (!feature) continue;
let contextDirectory: string | null = null;
for (const entry of await readdir("src/contexts", { withFileTypes: true })) {
if (!entry.isDirectory()) continue;
const declaration = await readFile(
path.join("src/contexts", entry.name, "context-module.ts"),
"utf8",
).catch(() => "");
if (
new RegExp(`CONTEXT_MODULE_ID\\s*=\\s*["']${escapeRegExp(context.id)}["']`, "u")
.test(declaration)
) {
contextDirectory = `src/contexts/${entry.name}`;
}
}
return Object.freeze({
directory: feature.directory,
// The context goes with its last feature.
contextDirectory: features.length === 1 ? contextDirectory : null,
});
}
}
throw new Error(`No installed feature declares FEATURE_MODULE_ID "${id}"`);
}
const located = await locateFeature(featureId);
// Captured from this repository before the copy loses them.
const featureRouteIds = Object.entries(ROUTE_FEATURE_OWNER)
.filter(([, owner]) => owner === featureId)
.map(([routeId]) => routeId);
const fixtureRoot = await createRemovalFixtureRoot(`${featureId}-removal`);
const pnpmCli = requireRemovalFixtureEnvironment("npm_execpath");
const featureSource = `src/features/${located.directory}`;
const featureTests = `tests/features/${located.directory}`;
const isSample = listedSample !== undefined;
/**
* Platform tests that must survive the sample feature's removal. Asserting they
* are still present is what stops the removal fixture from "passing" by having
* quietly deleted the platform's own coverage along with the feature.
*/
const commonTestPaths = [
"tests/unit/external-contract-runtime.test.ts",
"tests/unit/http-execution-v3.test.ts",
// 1105/10-01. MAX_RETRY_ATTEMPTS and REQUEST_TIMEOUT_MS reach the executor
// (`createRuntimeContractHttpExecutor`), and a session being recovered waits
// on a session-required route. Before, only sample tests held these rules.
"tests/unit/runtime-adapters.test.ts",
"tests/unit/session-route-access.test.ts",
"tests/integration/http-execution-v3-observability.test.ts",
// 0929/10-02. HTTP scenario evidence (FE-GATE-007) and the feature API
// negative type fixtures (FE-GATE-003) run on the test contracts.
"tests/integration/http-scenario-catalog.test.ts",
"tests/mocks/scenarios/catalog.ts",
"tests/mocks/handlers/test-entities.ts",
// 16-02. Feature tests answer their own operations with it.
"tests/mocks/handlers/http-scenarios.ts",
"tests/fixtures/typecheck/fixture-feature-contract.ts",
"tests/fixtures/typecheck/invalid-feature-input.ts",
"tests/fixtures/typecheck/invalid-reference-operation.ts",
"tests/fixtures/typecheck/invalid-http-operation-input.ts",
"tests/fixtures/typecheck/invalid-http-wire-mapper.ts",
"tests/fixtures/typecheck/invalid-http-operation-id.ts",
"tests/fixtures/typecheck/invalid-http-route-id.ts",
"tests/fixtures/typecheck/invalid-feature-contribution-input.ts",
"tests/fixtures/typecheck/invalid-feature-capability-selection.ts",
];
const featureOwnedPaths = [
featureSource,
featureTests,
// The feature's bounded-context declaration when it was the last feature in
// it; the template app stays.
...(located.contextDirectory === null ? [] : [located.contextDirectory]),
...extras.paths,
];
type CoveragePolicy = {
repositoryBaseline: number;
generatedPaths: string[];
criticalModules: Array<{
path?: string;
minimum?: Record<string, number>;
}>;
highRiskPaths: string[];
waivers: Array<{ path?: string }>;
};
type EvidenceContribution = Readonly<{ owner?: string }>;
type EvidencePolicy = Record<
"scenarioCatalogs" | "sourceContracts",
unknown
>;
type GovernanceConsumer = Readonly<{ path?: string }>;
type GovernanceRegistry = Record<string, unknown> & {
consumers?: unknown;
consumerDirectories?: unknown;
};
type RemovalGovernance = { registries: GovernanceRegistry[] };
function runPnpm(script: string, extra: string[] = []): boolean {
return runRemovalFixturePnpm(fixtureRoot, pnpmCli, script, extra);
}
function check(name: string, script: string, extra: string[] = []): RemovalCheck {
return runRemovalFixtureCheck(name, fixtureRoot, pnpmCli, script, extra);
}
/** 14-08. A non-command check fails with its own findings, nothing else's. */
function outcome(name: string, findings: readonly string[], label: string): RemovalCheck {
return findings.length === 0
? { name, passed: true }
: { name, passed: false, failure: `${label}: ${findings.join(", ")}` };
}
try {
// 1103/14-04. The documents come too: removing a feature must leave them
// valid, and the fixture used to leave them out with the tests that read
// them, so a manual naming the sample's files passed here and then failed
// FE-GATE-017 in the product that removed it.
await prepareRemovalFixture(fixtureRoot, [
...REMOVAL_FIXTURE_COPY_TARGETS,
...REMOVAL_FIXTURE_DOCUMENT_TARGETS,
]);
// Fixture-only deletions: a project that removes the sample keeps these.
// verify:documentation runs in this fixture, so a current contract document
// must not name them as backtick paths (docs/manual/reference/patterns.md).
for (const excludedFixtureTest of [
"tests/unit/ci-workflow-generation.test.ts",
"tests/unit/__snapshots__/ci-workflow-generation.test.ts.snap",
"tests/unit/removal-fixture.test.ts",
"tests/unit/http-scenario-evidence.test.ts",
]) {
await rm(path.join(fixtureRoot, excludedFixtureTest), { force: true });
}
const coveragePolicyFile = path.join(
fixtureRoot,
"config/testing/risk-coverage.json",
);
const coveragePolicy = JSON.parse(
await readFile(coveragePolicyFile, "utf8"),
) as CoveragePolicy;
const generatedProductionModules = new Set(coveragePolicy.generatedPaths);
const removedProductionModuleCount = (
await filesBelow(path.join(fixtureRoot, featureSource))
)
.map((file) => path.relative(fixtureRoot, file).split(path.sep).join("/"))
.filter(
(file) =>
isProductionModulePath(file) && !generatedProductionModules.has(file),
).length;
for (const ownedPath of featureOwnedPaths) {
await rm(path.join(fixtureRoot, ownedPath), {
recursive: true,
force: true,
});
}
if (!runPnpm("generate:feature-index")) {
throw new Error("Feature topology indexes failed to regenerate after sample removal");
}
// Runtime profiles are product configuration. Once the feature is physically
// removed, its override key must disappear too or the built config still
// advertises a source capability that no longer exists. public/config.json
// is the local profile `dev` serves and has to stay equal to it (F-5).
for (const configPath of [
"config/runtime/local.json",
"config/runtime/development.json",
"config/runtime/staging.json",
"config/runtime/production.json",
"public/config.json",
]) {
const profilePath = path.join(fixtureRoot, configPath);
const runtimeConfig = JSON.parse(
await readFile(profilePath, "utf8"),
) as {
FEATURE_OVERRIDES?: Record<string, string>;
};
if (runtimeConfig.FEATURE_OVERRIDES) {
delete runtimeConfig.FEATURE_OVERRIDES[featureId];
}
await writeFile(
profilePath,
`${JSON.stringify(runtimeConfig, null, 2)}\n`,
);
}
const retainedCriticalModules = coveragePolicy.criticalModules.filter(
(modulePolicy) => !modulePolicy.path?.startsWith(`${featureSource}/`),
);
coveragePolicy.criticalModules = retainedCriticalModules;
coveragePolicy.highRiskPaths = coveragePolicy.highRiskPaths.filter(
(modulePath) => !modulePath.startsWith(`${featureSource}/`),
);
coveragePolicy.waivers = coveragePolicy.waivers.filter(
(waiver) => !waiver.path?.startsWith(`${featureSource}/`),
);
coveragePolicy.generatedPaths = coveragePolicy.generatedPaths.filter(
(modulePath) => !modulePath.startsWith(`${featureSource}/`),
);
coveragePolicy.repositoryBaseline -= removedProductionModuleCount;
if (coveragePolicy.repositoryBaseline <= 0) {
throw new Error(`${featureId} removal produced an invalid coverage baseline`);
}
await writeFile(
coveragePolicyFile,
`${JSON.stringify(coveragePolicy, null, 2)}\n`,
);
const evidencePolicyFile = path.join(
fixtureRoot,
"config/testing/test-evidence.json",
);
const evidencePolicy = JSON.parse(
await readFile(evidencePolicyFile, "utf8"),
) as EvidencePolicy;
for (const policyKey of ["scenarioCatalogs", "sourceContracts"] as const) {
const contributions = evidencePolicy[policyKey];
if (!Array.isArray(contributions)) {
throw new Error(`Test evidence policy is missing ${policyKey}`);
}
// A feature's own evidence goes with it. The sample has none since
// 0929/10-02: the HTTP scenario catalog is owned by the platform.
evidencePolicy[policyKey] = contributions.filter(
(candidate: unknown) =>
(candidate as EvidenceContribution).owner !== featureId,
);
}
await writeFile(
evidencePolicyFile,
`${JSON.stringify(evidencePolicy, null, 2)}\n`,
);
const governanceFile = path.join(
fixtureRoot,
"config/contracts/registry-governance.json",
);
const removalGovernance = JSON.parse(
await readFile(governanceFile, "utf8"),
) as RemovalGovernance;
removalGovernance.registries = removalGovernance.registries.map(
(registry) => ({
...registry,
...(Array.isArray(registry.consumers)
? {
consumers: registry.consumers.filter(
(candidate: unknown) => {
const consumer = candidate as GovernanceConsumer;
return !consumer.path?.includes(featureSource);
},
),
}
: {}),
...(Array.isArray(registry.consumerDirectories)
? {
consumerDirectories: registry.consumerDirectories.filter(
(directory: unknown) =>
typeof directory !== "string" ||
!directory.includes(featureSource),
),
}
: {}),
}),
);
await writeFile(
governanceFile,
`${JSON.stringify(removalGovernance, null, 2)}\n`,
);
const removedCiScripts = new Set(extras.ciScripts);
const fixturePackagePath = path.join(fixtureRoot, "package.json");
const fixturePackage = JSON.parse(await readFile(fixturePackagePath, "utf8")) as {
scripts: Record<string, string>;
};
pruneScriptOrchestration(fixturePackage.scripts, "test:all", removedCiScripts);
await writeFile(fixturePackagePath, `${JSON.stringify(fixturePackage, null, 2)}\n`);
await pruneRemovalFixtureCiContract({
root: fixtureRoot,
removedScripts: removedCiScripts,
removedEvidencePathFragments: extras.evidencePathFragments,
});
// D-13: removing the sample is a breaking registry change. The fixture
// records the new registry baseline the way a downstream project does, and
// the canonical check:registries then runs against it.
if (!runRemovalFixturePnpm(fixtureRoot, pnpmCli, "update:registry-baseline", [], {
REGISTRY_BASELINE_OWNER: "removal-fixture",
REGISTRY_BASELINE_REASON: `${featureId} removed`,
})) {
throw new Error("Registry baseline failed to update after sample removal");
}
// 1103 X2 #3. The dev server's manifest names the installed contract
// packages; the removed feature's is gone.
const devManifest = spawnSync(process.execPath, ["scripts/write-dev-release-manifest.ts"], {
cwd: fixtureRoot,
stdio: "inherit",
});
if (devManifest.status !== 0) {
throw new Error("public/release-manifest.json failed to update after the removal");
}
// 1103 X2 #2. config/scale/feature-shape-ceilings.json records the initial
// JavaScript of the features installed now, and test:unit compares a build
// with it. A product re-records it when it adds a feature; removing that
// feature changes it again, so the fixture re-records it as the product
// would.
const measurement = path.join(fixtureRoot, "scripts/scale/measure-feature-shape-growth.ts");
if (await access(measurement).then(() => true, () => false)) {
const measured = spawnSync(
process.execPath,
[measurement, "--initial-baseline", "--write"],
{ cwd: fixtureRoot, stdio: "inherit" },
);
if (measured.status !== 0) {
throw new Error("Initial JavaScript record failed to update after the removal");
}
}
await regenerateRemovalFixtureWorkflow(fixtureRoot);
// 1105/16-04. Template tests use example feature IDs as data; only what
// still points at the removed feature counts (scripts/lib/feature-residue.ts).
const residue = await productFeatureResidue(fixtureRoot, featureId, located.directory);
const builtResiduePattern = new RegExp(
`${escapeRegExp(featureId)}|${escapeRegExp(located.directory)}`,
"i",
);
const missingCommonTests: string[] = [];
for (const testPath of commonTestPaths) {
await access(path.join(fixtureRoot, testPath)).catch(() => {
missingCommonTests.push(testPath);
});
}
const gateChecks = (prefix: string): RemovalCheck[] => [
check(`${prefix}typecheck`, "check:types"),
// 1103/14-04 (FOLLOW-UP 09-07). Merge and documentation gates the drill
// did not run: the documents, lint, screen text and design tokens can
// name or use what the removal deleted.
check(`${prefix}lint`, "lint"),
check(`${prefix}documentation`, "verify:documentation"),
check(`${prefix}i18n`, "check:i18n"),
check(`${prefix}design-system`, "check:design-system"),
check(`${prefix}architecture`, "check:architecture"),
check(`${prefix}registries`, "check:registries"),
check(`${prefix}unit-integration`, "test:all"),
check(`${prefix}coverage`, "test:coverage"),
check(`${prefix}test-evidence-source`, "check:test-evidence:source"),
check(`${prefix}ci-contract`, "check:ci"),
check(`${prefix}home-smoke`, "exec", [
"vitest",
"run",
"tests/component/router.test.tsx",
"--reporter=default",
]),
check(`${prefix}build`, "build"),
];
const checks: RemovalCheck[] = [
outcome("common-test-evidence", missingCommonTests, "platform tests missing"),
...gateChecks(""),
];
const builtResidue: string[] = [];
const buildSucceeded =
checks.find(({ name }) => name === "build")?.passed === true;
if (buildSucceeded) {
for (const file of await filesBelow(path.join(fixtureRoot, "dist"))) {
if (!/\.(?:js|css|html|json)$/.test(file)) continue;
const content = await readFile(file, "utf8");
if (builtResiduePattern.test(content)) {
builtResidue.push(path.relative(fixtureRoot, file));
}
}
}
const routeCatalog = await import(
`${new URL(
"../src/features/installed-feature-contracts.ts",
`file://${fixtureRoot}/scripts/`,
).href}?removed=${Date.now()}`
) as { ROUTE_REGISTRY: Readonly<Record<string, unknown>> };
const routeIds = new Set(Object.keys(routeCatalog.ROUTE_REGISTRY));
checks.push(
outcome(
"route-absent",
featureRouteIds.filter((routeId) => routeIds.has(routeId)),
"routes still registered",
),
outcome("fixture-id-residue", residue, "residue"),
outcome("built-fixture-id-residue", builtResidue, "built residue"),
);
// U7 (decision 4). The same copy, now without the listed sample, gets one
// feature from create:feature and runs the same gates again: the command
// and the feature it writes need nothing from the sample.
if (isSample) {
// 1103/09-06. With the write slice (NEVER), which needs nothing from
// the sample either.
const created = check("scaffold-create-feature", "create:feature", [
SCAFFOLD_PROBE_FEATURE_ID,
"--with-create",
]);
checks.push(created);
if (created.passed) {
sealRemovalFixtureRepository(fixtureRoot);
checks.push(...gateChecks("scaffold-"));
}
}
const failed = checks.filter((entry) => !entry.passed);
await mkdir("artifacts/tests", { recursive: true });
await writeFile(
`artifacts/tests/feature-removal-${featureId}.xml`,
renderRemovalJunit(`${featureId}-removal`, checks),
);
if (failed.length > 0) {
process.stderr.write(
`${featureId} removal failed:\n${failed
.map((entry) => ` ${entry.name}: ${entry.failure ?? "failed"}`)
.join("\n")}\n`,
);
process.exitCode = 1;
} else {
process.stdout.write(
`${featureId} removal: PASS (${checks.length} checks, no fixture IDs)\n`,
);
}
} finally {
await rm(fixtureRoot, { recursive: true, force: true });
}