cdk-preflight 0.0.121 → 0.0.122

package/.claude/skills/add-preflight-rule/SKILL.md

@@ -25,7 +25,7 @@ cdk-preflight のルール追加パイプライン。AGENTS.md の設計原則
    - `walk` ビルトインは無い。`to_number`/`object.get`/`flatten_list`/`resolve` で明示的に書く
    - fail テンプレートはこのルール**だけ**に違反、pass テンプレートは完全クリーン
    - **数値・長さ・個数の制約は境界ちょうどで書く**。fail は「違反する値のうち限界に最も近いもの」、pass は「限界そのもの」— 20 文字下限なら fail=19 文字 / pass=20 文字であって、fail=5 文字 / pass=26 文字ではない。緩いペアはルールの向きしか証明しない（`count(v) < 20` は fail が 5 文字なら定数が `< 10` でも鳴り、pass が 26 文字なら `< 25` でも黙る）ので、定数も比較演算子も固定できないし、実機ゲートの証拠も弱くなる（19 文字が CREATE に失敗して初めて下限 20 が実証される）。ルールが両端を見ているレンジは fail に両端を置く（fail の判定は「自分のルールの診断が 1 件以上」なので、違反リソースを 2 つ並べてよい）。エンジンのスキーマが既に持っている側の端は入れない — ルールもそこは見ていない（原則 1）し、重複ガードが赤くなる。順序の無い制約（プロパティ欠落、enum の値違い、リソース間の不整合）には境界が無いので対象外
-4. **ローカルゲート**: まず `npx ts-node --transpile-only --project test/tsconfig.json scripts/rule-check.ts check <service|rule-id>...` を回す。`rules/` を直接読んで 1 エンジンに全ルールを載せ、fail が自分のルールで鳴るか / pass が全ルール無音か / どちらも組み込みエンジンに止められないかを返す（`bundle-rules` も meta.yaml の evidence も要らないので、実機ゲート前の直しはここで回す。80 本で数秒）。全部 `ok` になってから `npx projen bundle-rules && npx jest test/rules.test.ts test/structure.test.ts`（`bundle-rules` は `src/rules.generated.ts` / `docs/rules.md` に加えて **README のルール数バッジと対応リソースタイプ一覧も書き換える**。手で直さない。古いままなら `structure.test.ts` が落ちる）。**`rules/<service>/` を新設したときは `npx projen` も回す** — `.github/workflows/monthly-verify.yml` のサービス行列はそこから生成されるので、`bundle-rules` だけでは更新されず PR の self-mutation チェックが赤くなる（2026-09-13、Athena 追加で踏んだ）。`structure.test.ts` は手順 3 の境界値を機械で見る（rego のしきい値ごとに fail へ「限界に最も近い違反値」、pass へ「限界そのもの」が現れるか）。しきい値の検出が意味を持たないルールだけ `rules/_boundary-exceptions.txt` に理由付きで逃がす。**jest は `-t` で対象を絞る**。フルスイートは PR 直前の 1 回だけでよく、実測では 401 回中 73 回がフル実行で合計 5.8 時間を溶かしている。
+4. **ローカルゲート**: まず `npx ts-node --transpile-only --project test/tsconfig.json scripts/rule-check.ts check <service|rule-id>...` を回す。`rules/` を直接読んで 1 エンジンに全ルールを載せ、fail が自分のルールで鳴るか / pass が全ルール無音か / どちらも組み込みエンジンに止められないかを返す（`bundle-rules` も meta.yaml の evidence も要らないので、実機ゲート前の直しはここで回す。80 本で数秒）。全部 `ok` になってから `npx projen bundle-rules && npx jest test/rules test/structure.test.ts`（`test/rules` は `rules.test.ts` と、ルール表を回す `rules.shard*.test.ts` の両方に当たる）（`bundle-rules` は `src/rules.generated.ts` / `docs/rules.md` に加えて **README のルール数バッジと対応リソースタイプ一覧も書き換える**。手で直さない。古いままなら `structure.test.ts` が落ちる）。**`rules/<service>/` を新設したときは `npx projen` も回す** — `.github/workflows/monthly-verify.yml` のサービス行列はそこから生成されるので、`bundle-rules` だけでは更新されず PR の self-mutation チェックが赤くなる（2026-09-13、Athena 追加で踏んだ）。`structure.test.ts` は手順 3 の境界値を機械で見る（rego のしきい値ごとに fail へ「限界に最も近い違反値」、pass へ「限界そのもの」が現れるか）。しきい値の検出が意味を持たないルールだけ `rules/_boundary-exceptions.txt` に理由付きで逃がす。**jest は `-t` で対象を絞る**。フルスイートは PR 直前の 1 回だけでよく、実測では 401 回中 73 回がフル実行で合計 5.8 時間を溶かしている。
 5. **実機再現ゲート**: `bash bench/verify-rule.sh <rule-id>`（要 AWS 認証）。観測したエラーメッセージと日付を `meta.yaml#repro.evidence` に記録。
    - **evidence には実際にデプロイした値を書く**（`bench 2026-09-13 us-east-1: 19-char Value -> "...at least 20 characters" (ROLLBACK_COMPLETE); pass 20-char -> CREATE_COMPLETE`）。境界ちょうどのフィクスチャと組で、限界の位置そのものが meta.yaml から読める
    - fail テンプレートがデプロイに**成功**したら、それはドキュメント側の誤り（BROKEN-EXPECTATION）。ルールを削除し、証拠を issue に残して終了する。CloudFront では明文化された制約 9 件中 3 件がこれだった（2026-09-02）

package/.claude/skills/run-preflight-issue/SKILL.md

@@ -112,7 +112,10 @@ B の後は課金物の実在確認も回す（例 `aws athena list-capacity-res
 ## 関門
 
 **自動でやってよい**: issue コメントの投稿（着手・調査結果・API 結果）、実機再現ゲート（無料〜数円のスタックを多数作る）、
-ブランチへのコミット。
+ブランチへのコミット。**PR がマージされた後の後片付けも全部**（2026-09-14 のユーザー指示「勝手にやっておk　今後も」）:
+結果コメントを残して issue を close / #91 のチェックを付けて 1 行サマリを書く / ルールにできなかった分を #91 の「積み残し」に移す。
+#91 の本文を書き換えるときは `gh issue view 91 --json body -q .body` で**その場で取り直して**から編集し、
+`[ -s <file> ]` で非空を確かめてから `gh issue edit`、最後に `grep` で反映を確認する（古い／空の `--body-file` は本文を丸ごと上書きする）。
 
 **止まって人間に聞く**:
 
@@ -120,8 +123,7 @@ B の後は課金物の実在確認も回す（例 `aws athena list-capacity-res
 - 課金リソースが必要だと判明したとき（作らずに報告して止まる）
 - `.claude/settings*.json` の permission を足したくなったとき（**自分で書き換えない**）
 
-**絶対にしない**: 課金リソースの作成、issue の close、#91 のチェックボックス操作（PR マージが人間の手なので、
-その先は全部人間の仕事）、既存の無料下敷き（`pfdb` / `pfwg` / `cdkpf-*-probe` ロールやバケット）の削除。
+**絶対にしない**: 課金リソースの作成、既存の無料下敷き（`pfdb` / `pfwg` / `cdkpf-*-probe` ロールやバケット）の削除。
 
 ## やらないこと
 

package/.jsii

@@ -9482,7 +9482,7 @@
           },
           "locationInModule": {
             "filename": "src/index.ts",
-            "line": 98
+            "line": 93
           },
           "name": "ruleIds",
           "returns": {
@@ -9600,6 +9600,6 @@
       "symbolId": "src/index:PreflightOptions"
     }
   },
-  "version": "0.0.121",
-  "fingerprint": "2XAAXc7viB/4ogTsfHceUynSzFJNAs7aMANuaSuZ8F8="
+  "version": "0.0.122",
+  "fingerprint": "CXf4WHV95yWFjsMKp4xBg1usqS8JMPdQz72DaTgvZ2I="
 }

package/AGENTS.md

@@ -14,7 +14,7 @@ Growth is the normal state. The upstream engine ships slowly and carefully by de
 
 ## Design principles (do not violate)
 
-1. **No duplication of the engine.** If the bundled engine already reports a constraint as ERROR/FATAL (schema check or built-in rule), we must not re-implement it. `test/rules.test.ts` enforces this mechanically ("does not duplicate a built-in blocker"). If that test fails for a new rule, the rule is unnecessary — delete it and record why in the PR.
+1. **No duplication of the engine.** If the bundled engine already reports a constraint as ERROR/FATAL (schema check or built-in rule), we must not re-implement it. `test/rule-table.ts`, run through the `test/rules.shard*.test.ts` files, enforces this mechanically ("does not duplicate a built-in blocker"). If that test fails for a new rule, the rule is unnecessary — delete it and record why in the PR.
 2. **Every rule ships with proof.** `templates/fail.template.json` must violate exactly this rule; `templates/pass.template.json` must be clean. `meta.yaml#repro` records how the deploy-time failure was verified (`real-deploy` / `research-case` / `doc-only` — the last one requires an explanation in `evidence`).
 
    **Both fixtures sit on the boundary.** For an ordered constraint (a number, a length, a count) the fail template carries the *tightest violating* value and the pass template the *exact limit* — a 20-character minimum gets a 19-character fail and a 20-character pass, not 5 and 26. A slack pair proves only the direction of the rule: `count(v) < 20` still fires on a 5-character fail template when the constant is wrong (`< 10`), and a 26-character pass template stays silent even at `< 25`, so neither the constant nor the comparison operator is pinned by the fixtures. It also weakens the real-deploy gate, which is the only thing that establishes where AWS's limit actually is — a 19-character key that fails CREATE proves the documented 20, a 5-character one proves "somewhere above 5". A range the rule checks at both ends gets a resource at each end (the fixture assertion is "at least one diagnostic for this rule", so several violating resources in one fail template are fine, and a branch a single fixture cannot reach gets a targeted case in `test/rules.test.ts`). An end the engine's schema already enforces stays out of the fail template — the rule does not check it (principle 1) and the duplication guard would flag it. Constraints with no ordering — a missing property, a wrong enum member, a cross-resource mismatch — have no boundary to sit on. The evidence line records the values that were actually deployed, so it pins the boundary too: `bench 2026-09-13 us-east-1: 19-char Value -> "API Key value should be at least 20 characters" (ROLLBACK_COMPLETE); pass 20-char -> CREATE_COMPLETE`.
@@ -68,7 +68,7 @@ The ordering is by **how easily the L2 guard is bypassed in normal use**, not by
 
 The two failure modes are watched separately: **staleness** (the constraint disappeared at AWS — the fail template now deploys clean) is caught by the monthly real-deploy run and reported as BROKEN; **obsolescence** (the engine caught up — the rule is now a duplicate) is caught by the duplication guard and the redundancy scan and reported as REDUNDANT. Both land in the monthly issue.
 
-**Adding.** Two gates, both mechanical, and nothing else can reject a candidate: the duplication guard (`test/rules.test.ts`) and the real-deploy gate (`bench/verify-rule.sh`). The real-deploy gate is the one thing that did *not* get looser with the widened scope, and deliberately so — `enforce` is the default mode, so a false positive is a hard synth failure in someone's CI. The CloudFront survey is the standing evidence: 3 of 9 documented constraints deployed clean (see "A doc sentence is a hypothesis" above). Volume comes from running the bench over more services, never from lowering that bar.
+**Adding.** Two gates, both mechanical, and nothing else can reject a candidate: the duplication guard (`test/rules.shard*.test.ts`) and the real-deploy gate (`bench/verify-rule.sh`). The real-deploy gate is the one thing that did *not* get looser with the widened scope, and deliberately so — `enforce` is the default mode, so a false positive is a hard synth failure in someone's CI. The CloudFront survey is the standing evidence: 3 of 9 documented constraints deployed clean (see "A doc sentence is a hypothesis" above). Volume comes from running the bench over more services, never from lowering that bar.
 
 **Retiring.** The trigger is the bundled engine (or CloudFormation's server-side validation) starting to block the constraint — never an L2 construct, never cfn-lint. You do not have to watch for it; two mechanisms report it:
 
@@ -146,10 +146,10 @@ If you are a subagent running one of these phases, do not spawn further agents.
    - **Dynamic reference strings are markerized too** (measured 2026-09-03): a literal `{{resolve:ssm:/path}}` property value surfaces as `{"__dynamic": "dynamic reference: {{resolve:ssm:/path}}", "__param_type": "String"}` and `resolve()` is undefined for it. A rule that judges the reference text itself (e.g. the SSM parameter path) must read the raw property with `object.get` and extract the `__dynamic` string. Reference implementation: `pf-ec2-instance-ami-arch`.
    - **Deploy-region rules**: the enforce plugin injects a generated module defining `deploy_region` (and `deploy_account` when the account id is concrete) whenever the app-level region is concrete (`deployEnvironmentModule` in `src/private/enforce.ts`; the test harness injects `us-east-1` for fixtures). Rules must read it as `data.cdk_preflight.deploy_region` — the data reference is undefined when not injected, so the rule skips; a bare `deploy_region` variable would be a compile error. `data.cdk_preflight.deploy_account` works the same way (`pf-kms-key-policy-lockout` treats any account as ours when it is absent, `pf-kms-alias-target` skips its account check). Consequences: region-dependent rules are silent in warn mode (`enforce: false` hands rules to the CDK built-in plugin, which we cannot inject into) and in region-agnostic apps; say so in `meta.yaml#repro.evidence`. Reference implementations: `pf-dynamodb-global-table-replica-region`, `pf-dynamodb-kinesis-stream-region`.
    - Helper rules must use a unique `_pf_<rule>_...` prefix (all rules share one package, and the enforce plugin loads a service's rules as a single module). `bundle-rules` fails the build when two modules define the same top-level name — without the check, the second definition merges into the first as an incremental rule and both rules quietly change meaning. A name two rules genuinely need belongs in `rules/_lib/`.
-   - **`meta.resourceTypes` is load-bearing, not documentation.** The enforce plugin compiles only the rules whose declared types appear in the synthesized templates — rule compilation is the dominant fixed cost (~4.6s for the whole pack, ~0.8s for the ~100 rules a typical app keeps), so this is what keeps `cdk synth` usable as the pack grows. A type a rule *reads* but does not *declare* makes the rule silently stop firing on real apps. Declare every type the rule touches, including the counterpart of a cross-resource rule; `test/rules.test.ts` checks every rule survives pruning against its own fail template.
+   - **`meta.resourceTypes` is load-bearing, not documentation.** The enforce plugin compiles only the rules whose declared types appear in the synthesized templates — rule compilation is the dominant fixed cost (~4.6s for the whole pack, ~0.8s for the ~100 rules a typical app keeps), so this is what keeps `cdk synth` usable as the pack grows. A type a rule *reads* but does not *declare* makes the rule silently stop firing on real apps. Declare every type the rule touches, including the counterpart of a cross-resource rule; `test/rules.shard*.test.ts` checks every rule survives pruning against its own fail template.
    - A helper several rules of one service need (parsing an opaque DSL, enumerating nested scopes) goes in `rules/_lib/<service>.rego` with a `_pf_<service>lib_` prefix (`rules/_lib/sfn.rego` is the reference: ASL from `DefinitionString` *or* the L1 `Definition` object, nested Parallel/Map scopes to depth 3, effective QueryLanguage). Rules never reference another rule's helpers — `exclude` can unload any rule, a lib is always loaded.
    - **Cheap screen for definition-level constraints**: some services expose their create-time validator as a free API (`aws stepfunctions validate-state-machine-definition --type STANDARD|EXPRESS` is the same validator CreateStateMachine runs). Use it to triage doc hypotheses before spending a CloudFormation deploy on each — 100 Step Functions hypotheses took minutes (2026-09-05). The real-deploy gate stays.
-3. `npx ts-node --transpile-only --project test/tsconfig.json scripts/rule-check.ts check <service|rule-id>` while iterating: it reads `rules/` straight from disk into a single engine (no bundle, no meta validation, no jest) and reports, per rule, whether the fail template fires its own rule, the pass template is silent for every rule, and neither trips a built-in ERROR/FATAL. Then `npx projen bundle-rules` and `npx jest test/rules.test.ts test/structure.test.ts` — the duplication guard and fixture checks run there for real. Prefer `jest -t` while iterating; the full suite is 3,228 tests / ~2 min (measured 2026-09-08), so keep it for the pre-PR run.
+3. `npx ts-node --transpile-only --project test/tsconfig.json scripts/rule-check.ts check <service|rule-id>` while iterating: it reads `rules/` straight from disk into a single engine (no bundle, no meta validation, no jest) and reports, per rule, whether the fail template fires its own rule, the pass template is silent for every rule, and neither trips a built-in ERROR/FATAL. Then `npx projen bundle-rules` and `npx jest test/rules test/structure.test.ts` (the `test/rules` pattern picks up both `rules.test.ts` and the `rules.shard*.test.ts` files that carry the per-rule table) — the duplication guard and fixture checks run there for real. Prefer `jest -t` while iterating; the full suite is ~11,400 tests / ~2.5 min on 8 cores (measured 2026-09-14), so keep it for the pre-PR run.
 4. **Real-deploy gate**: `bash bench/verify-rule.sh <rule-id>` deploys the fail template (expects CREATE to fail; records the service error message) and, where cheap, the pass template (expects success, then deletes). Paste the observed error into `meta.yaml#repro.evidence` with the date. Only `doc-only` rules may skip this, with justification.
 5. Update nothing else by hand — `docs/rules.md`, `src/rules.generated.ts`, and the parts of `README.md` between the
    `<!-- supported-resources:start -->` markers (plus the rule-count badge) are all written by `npx projen bundle-rules`.

package/lib/index.js

@@ -17,7 +17,7 @@ const rules_generated_1 = require("./rules.generated");
  * Preflight.apply(app);
  */
 class Preflight {
-    static [JSII_RTTI_SYMBOL_1] = { fqn: "cdk-preflight.Preflight", version: "0.0.121" };
+    static [JSII_RTTI_SYMBOL_1] = { fqn: "cdk-preflight.Preflight", version: "0.0.122" };
     /**
      * Register the cdk-preflight rules on an App or Stage.
      */
@@ -38,12 +38,7 @@ class Preflight {
             (0, enforce_1.installEnforceGate)(scope);
         }
         else {
-            aws_cdk_lib_1.Validations.of(scope).addPlugins(new aws_cdk_lib_1.CloudFormationValidatePlugin({
-                regoRules: [
-                    ...rules_generated_1.BUNDLED_LIBS.map((l) => ({ name: l.name, content: l.rego })),
-                    ...selected.map((r) => ({ name: r.id, content: r.rego })),
-                ],
-            }));
+            aws_cdk_lib_1.Validations.of(scope).addPlugins((0, enforce_1.observePluginCached)(selected));
         }
     }
     /**
@@ -55,4 +50,4 @@ class Preflight {
     constructor() { }
 }
 exports.Preflight = Preflight;
-//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiaW5kZXguanMiLCJzb3VyY2VSb290IjoiIiwic291cmNlcyI6WyIuLi9zcmMvaW5kZXgudHMiXSwibmFtZXMiOltdLCJtYXBwaW5ncyI6Ijs7OztBQUFBLDZDQUErRTtBQUUvRSwrQ0FBK0U7QUFDL0UsdURBQWdFO0FBa0RoRTs7Ozs7Ozs7OztHQVVHO0FBQ0gsTUFBYSxTQUFTOztJQUNwQjs7T0FFRztJQUNJLE1BQU0sQ0FBQyxLQUFLLENBQUMsS0FBaUIsRUFBRSxVQUE0QixFQUFFO1FBQ25FLElBQUksQ0FBQyxtQkFBSyxDQUFDLE9BQU8sQ0FBQyxLQUFLLENBQUMsRUFBRSxDQUFDO1lBQzFCLE1BQU0sSUFBSSxLQUFLLENBQUMsc0VBQXNFLENBQUMsQ0FBQztRQUMxRixDQUFDO1FBQ0QsTUFBTSxPQUFPLEdBQUcsT0FBTyxDQUFDLE9BQU8sSUFBSSxFQUFFLENBQUM7UUFDdEMsTUFBTSxPQUFPLEdBQUcsT0FBTyxDQUFDLE1BQU0sQ0FBQyxDQUFDLEVBQUUsRUFBRSxFQUFFLENBQUMsQ0FBQywrQkFBYSxDQUFDLElBQUksQ0FBQyxDQUFDLENBQUMsRUFBRSxFQUFFLENBQUMsQ0FBQyxDQUFDLEVBQUUsS0FBSyxFQUFFLENBQUMsQ0FBQyxDQUFDO1FBQ2hGLElBQUksT0FBTyxDQUFDLE1BQU0sR0FBRyxDQUFDLEVBQUUsQ0FBQztZQUN2QixNQUFNLElBQUksS0FBSyxDQUFDLGlEQUFpRCxPQUFPLENBQUMsSUFBSSxDQUFDLElBQUksQ0FBQyxFQUFFLENBQUMsQ0FBQztRQUN6RixDQUFDO1FBQ0QsTUFBTSxRQUFRLEdBQUcsK0JBQWE7YUFDM0IsTUFBTSxDQUFDLENBQUMsQ0FBQyxFQUFFLEVBQUUsQ0FBQyxDQUFDLE9BQU8sQ0FBQyxzQkFBc0IsSUFBSSxJQUFJLENBQUMsSUFBSSxDQUFDLENBQUMsUUFBUSxLQUFLLGdCQUFnQixDQUFDO2FBQzFGLE1BQU0sQ0FBQyxDQUFDLENBQUMsRUFBRSxFQUFFLENBQUMsQ0FBQyxPQUFPLENBQUMsUUFBUSxDQUFDLENBQUMsQ0FBQyxFQUFFLENBQUMsQ0FBQyxDQUFDO1FBRTFDLElBQUksT0FBTyxDQUFDLE9BQU8sSUFBSSxJQUFJLEVBQUUsQ0FBQztZQUM1Qix5QkFBVyxDQUFDLEVBQUUsQ0FBQyxLQUFLLENBQUMsQ0FBQyxVQUFVLENBQUMsSUFBSSxnQ0FBc0IsQ0FBQyxRQUFRLEVBQUUsT0FBTyxDQUFDLE1BQU0sSUFBSSxLQUFLLENBQUMsQ0FBQyxDQUFDO1lBQ2hHLElBQUEsNEJBQWtCLEVBQUMsS0FBSyxDQUFDLENBQUM7UUFDNUIsQ0FBQzthQUFNLENBQUM7WUFDTix5QkFBVyxDQUFDLEVBQUUsQ0FBQyxLQUFLLENBQUMsQ0FBQyxVQUFVLENBQUMsSUFBSSwwQ0FBNEIsQ0FBQztnQkFDaEUsU0FBUyxFQUFFO29CQUNULEdBQUcsOEJBQVksQ0FBQyxHQUFHLENBQUMsQ0FBQyxDQUFDLEVBQUUsRUFBRSxDQUFDLENBQUMsRUFBRSxJQUFJLEVBQUUsQ0FBQyxDQUFDLElBQUksRUFBRSxPQUFPLEVBQUUsQ0FBQyxDQUFDLElBQUksRUFBRSxDQUFDLENBQUM7b0JBQy9ELEdBQUcsUUFBUSxDQUFDLEdBQUcsQ0FBQyxDQUFDLENBQUMsRUFBRSxFQUFFLENBQUMsQ0FBQyxFQUFFLElBQUksRUFBRSxDQUFDLENBQUMsRUFBRSxFQUFFLE9BQU8sRUFBRSxDQUFDLENBQUMsSUFBSSxFQUFFLENBQUMsQ0FBQztpQkFDMUQ7YUFDRixDQUFDLENBQUMsQ0FBQztRQUNOLENBQUM7SUFDSCxDQUFDO0lBRUQ7O09BRUc7SUFDSSxNQUFNLENBQUMsT0FBTztRQUNuQixPQUFPLCtCQUFhLENBQUMsR0FBRyxDQUFDLENBQUMsQ0FBQyxFQUFFLEVBQUUsQ0FBQyxDQUFDLENBQUMsRUFBRSxDQUFDLENBQUM7SUFDeEMsQ0FBQztJQUVELGdCQUF1QixDQUFDOztBQXJDMUIsOEJBc0NDIiwic291cmNlc0NvbnRlbnQiOlsiaW1wb3J0IHsgQ2xvdWRGb3JtYXRpb25WYWxpZGF0ZVBsdWdpbiwgU3RhZ2UsIFZhbGlkYXRpb25zIH0gZnJvbSAnYXdzLWNkay1saWInO1xuaW1wb3J0IHsgSUNvbnN0cnVjdCB9IGZyb20gJ2NvbnN0cnVjdHMnO1xuaW1wb3J0IHsgaW5zdGFsbEVuZm9yY2VHYXRlLCBQcmVmbGlnaHRFbmZvcmNlUGx1Z2luIH0gZnJvbSAnLi9wcml2YXRlL2VuZm9yY2UnO1xuaW1wb3J0IHsgQlVORExFRF9MSUJTLCBCVU5ETEVEX1JVTEVTIH0gZnJvbSAnLi9ydWxlcy5nZW5lcmF0ZWQnO1xuXG4vKipcbiAqIE9wdGlvbnMgZm9yIHtAbGluayBQcmVmbGlnaHQuYXBwbHl9LlxuICovXG5leHBvcnQgaW50ZXJmYWNlIFByZWZsaWdodE9wdGlvbnMge1xuICAvKipcbiAgICogUnVsZSBpZHMgdG8gZGlzYWJsZSAoc2VlIGBQcmVmbGlnaHQucnVsZUlkcygpYCBvciBkb2NzL3J1bGVzLm1kKS5cbiAgICpcbiAgICogQGRlZmF1bHQgLSBhbGwgYnVuZGxlZCBydWxlcyBhcmUgZW5hYmxlZFxuICAgKi9cbiAgcmVhZG9ubHkgZXhjbHVkZT86IHN0cmluZ1tdO1xuXG4gIC8qKlxuICAgKiBGYWlsIHN5bnRoZXNpcyB3aGVuIGEgYnVuZGxlZCBydWxlIGlzIHZpb2xhdGVkLlxuICAgKlxuICAgKiBJbiB0aGUgZGVmYXVsdCAoZW5mb3JjZSkgbW9kZSwgY2RrLXByZWZsaWdodCBldmFsdWF0ZXMgaXRzIHJ1bGVzIHdpdGggaXRzXG4gICAqIG93biB2YWxpZGF0aW9uIHBsdWdpbiBhbmQgYSB2aW9sYXRpb24gbWFrZXMgYGNkayBzeW50aGAgZmFpbCDigJQgdGhlIHdob2xlXG4gICAqIHBvaW50IG9mIHByZWZsaWdodCBjaGVja3MgaXMgdGhhdCBhIHRlbXBsYXRlIGtub3duIHRvIGZhaWwgYXQgZGVwbG95IHRpbWVcbiAgICogbmV2ZXIgbGVhdmVzIHlvdXIgbWFjaGluZS4gU2V0IGBlbmZvcmNlOiBmYWxzZWAgdG8gb2JzZXJ2ZSBmaXJzdDogZmluZGluZ3NcbiAgICogYXJlIHRoZW4gcmVwb3J0ZWQgdGhyb3VnaCB0aGUgQ0RLIGJ1aWx0LWluIENsb3VkRm9ybWF0aW9uIHZhbGlkYXRvciBhbmRcbiAgICogc3VyZmFjZSBhcyBzeW50aCB3YXJuaW5ncyB3aXRoIGNvbnN0cnVjdCB0cmFjZXMsIHdoaWNoIGNhbiBiZSBtdXRlZCBwZXJcbiAgICogZmluZGluZyB2aWEgYEFja25vd2xlZGdlIHdpdGggJ0Nsb3VkRm9ybWF0aW9uLVZhbGlkYXRlOjo8cnVsZS1pZD4nYC5cbiAgICpcbiAgICogQGRlZmF1bHQgdHJ1ZVxuICAgKi9cbiAgcmVhZG9ubHkgZW5mb3JjZT86IGJvb2xlYW47XG5cbiAgLyoqXG4gICAqIEluIGVuZm9yY2UgbW9kZSwgYWRkaXRpb25hbGx5IGZhaWwgc3ludGhlc2lzIG9uIGVycm9yLWNsYXNzIGZpbmRpbmdzXG4gICAqIChzZXZlcml0eSBFUlJPUi9GQVRBTCkgb2YgdGhlIGJ1aWx0LWluIHZhbGlkYXRpb24gZW5naW5lIGl0c2VsZiwgZS5nLlxuICAgKiBzY2hlbWEgdmlvbGF0aW9ucyBsaWtlIGBGMzAzNGAuIFRoaXMgaXMgdGhlIHdvcmthcm91bmQgZm9yIHRoZSBDREtcbiAgICogYmVoYXZpb3Igd2hlcmUgYWxsIGJ1aWx0LWluIGZpbmRpbmdzIGFyZSBkb3duZ3JhZGVkIHRvIHdhcm5pbmdzLlxuICAgKlxuICAgKiBPbmx5IGVmZmVjdGl2ZSBpbiBlbmZvcmNlIG1vZGUgKHRoZSBkZWZhdWx0KS5cbiAgICpcbiAgICogQGRlZmF1bHQgZmFsc2VcbiAgICovXG4gIHJlYWRvbmx5IHN0cmljdD86IGJvb2xlYW47XG5cbiAgLyoqXG4gICAqIEluY2x1ZGUgcnVsZXMgdGhhdCBhcmUgbWFya2VkIGBwZW5kaW5nLWVuZ2luZWAgKGNhbmRpZGF0ZXMgdGhhdCBoYXZlIGJlZW5cbiAgICogcHJvcG9zZWQgdG8gdGhlIHVwc3RyZWFtIGNsb3VkZm9ybWF0aW9uLXZhbGlkYXRlIGVuZ2luZSBidXQgYXJlIG5vdCBtZXJnZWRcbiAgICogeWV0KS4gRGlzYWJsZSB0aGlzIGlmIHlvdSBydW4gYSBuZXdlciBlbmdpbmUgdGhhdCBhbHJlYWR5IGNvdmVycyB0aGVtLlxuICAgKlxuICAgKiBAZGVmYXVsdCB0cnVlXG4gICAqL1xuICByZWFkb25seSBpbmNsdWRlVXBzdHJlYW1QZW5kaW5nPzogYm9vbGVhbjtcbn1cblxuLyoqXG4gKiBjZGstcHJlZmxpZ2h0OiBjYXRjaCBkZXBsb3ktdGltZSBDbG91ZEZvcm1hdGlvbiBmYWlsdXJlcyBhdCBzeW50aCB0aW1lLlxuICpcbiAqIEluamVjdHMgYSBjdXJhdGVkIFJlZ28gcnVsZSBwYWNrIChjb25zdHJhaW50cyB0aGF0IHJlc291cmNlIHByb3ZpZGVyIHNjaGVtYXNcbiAqIGRvIG5vdCBleHByZXNzOiBkb2Mtb25seSB2YWx1ZSBsaW1pdHMsIGNyb3NzLXByb3BlcnR5IGFuZCBjcm9zcy1yZXNvdXJjZVxuICogcnVsZXMpIGludG8gdGhlIEFXUyBDREsgYnVpbHQtaW4gQ2xvdWRGb3JtYXRpb24gdmFsaWRhdG9yLlxuICpcbiAqIEBleGFtcGxlXG4gKiBkZWNsYXJlIGNvbnN0IGFwcDogQXBwO1xuICogUHJlZmxpZ2h0LmFwcGx5KGFwcCk7XG4gKi9cbmV4cG9ydCBjbGFzcyBQcmVmbGlnaHQge1xuICAvKipcbiAgICogUmVnaXN0ZXIgdGhlIGNkay1wcmVmbGlnaHQgcnVsZXMgb24gYW4gQXBwIG9yIFN0YWdlLlxuICAgKi9cbiAgcHVibGljIHN0YXRpYyBhcHBseShzY29wZTogSUNvbnN0cnVjdCwgb3B0aW9uczogUHJlZmxpZ2h0T3B0aW9ucyA9IHt9KTogdm9pZCB7XG4gICAgaWYgKCFTdGFnZS5pc1N0YWdlKHNjb3BlKSkge1xuICAgICAgdGhyb3cgbmV3IEVycm9yKCdjZGstcHJlZmxpZ2h0OiBQcmVmbGlnaHQuYXBwbHkoKSBtdXN0IGJlIGNhbGxlZCBvbiBhbiBBcHAgb3IgYSBTdGFnZScpO1xuICAgIH1cbiAgICBjb25zdCBleGNsdWRlID0gb3B0aW9ucy5leGNsdWRlID8/IFtdO1xuICAgIGNvbnN0IHVua25vd24gPSBleGNsdWRlLmZpbHRlcigoaWQpID0+ICFCVU5ETEVEX1JVTEVTLnNvbWUoKHIpID0+IHIuaWQgPT09IGlkKSk7XG4gICAgaWYgKHVua25vd24ubGVuZ3RoID4gMCkge1xuICAgICAgdGhyb3cgbmV3IEVycm9yKGBjZGstcHJlZmxpZ2h0OiB1bmtub3duIHJ1bGUgaWQocykgaW4gZXhjbHVkZTogJHt1bmtub3duLmpvaW4oJywgJyl9YCk7XG4gICAgfVxuICAgIGNvbnN0IHNlbGVjdGVkID0gQlVORExFRF9SVUxFU1xuICAgICAgLmZpbHRlcigocikgPT4gKG9wdGlvbnMuaW5jbHVkZVVwc3RyZWFtUGVuZGluZyA/PyB0cnVlKSB8fCByLnVwc3RyZWFtICE9PSAncGVuZGluZy1lbmdpbmUnKVxuICAgICAgLmZpbHRlcigocikgPT4gIWV4Y2x1ZGUuaW5jbHVkZXMoci5pZCkpO1xuXG4gICAgaWYgKG9wdGlvbnMuZW5mb3JjZSA/PyB0cnVlKSB7XG4gICAgICBWYWxpZGF0aW9ucy5vZihzY29wZSkuYWRkUGx1Z2lucyhuZXcgUHJlZmxpZ2h0RW5mb3JjZVBsdWdpbihzZWxlY3RlZCwgb3B0aW9ucy5zdHJpY3QgPz8gZmFsc2UpKTtcbiAgICAgIGluc3RhbGxFbmZvcmNlR2F0ZShzY29wZSk7XG4gICAgfSBlbHNlIHtcbiAgICAgIFZhbGlkYXRpb25zLm9mKHNjb3BlKS5hZGRQbHVnaW5zKG5ldyBDbG91ZEZvcm1hdGlvblZhbGlkYXRlUGx1Z2luKHtcbiAgICAgICAgcmVnb1J1bGVzOiBbXG4gICAgICAgICAgLi4uQlVORExFRF9MSUJTLm1hcCgobCkgPT4gKHsgbmFtZTogbC5uYW1lLCBjb250ZW50OiBsLnJlZ28gfSkpLFxuICAgICAgICAgIC4uLnNlbGVjdGVkLm1hcCgocikgPT4gKHsgbmFtZTogci5pZCwgY29udGVudDogci5yZWdvIH0pKSxcbiAgICAgICAgXSxcbiAgICAgIH0pKTtcbiAgICB9XG4gIH1cblxuICAvKipcbiAgICogVGhlIGlkcyBvZiBhbGwgYnVuZGxlZCBydWxlcy5cbiAgICovXG4gIHB1YmxpYyBzdGF0aWMgcnVsZUlkcygpOiBzdHJpbmdbXSB7XG4gICAgcmV0dXJuIEJVTkRMRURfUlVMRVMubWFwKChyKSA9PiByLmlkKTtcbiAgfVxuXG4gIHByaXZhdGUgY29uc3RydWN0b3IoKSB7fVxufVxuIl19
+//# sourceMappingURL=data:application/json;base64,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

package/lib/private/enforce.d.ts

@@ -1,4 +1,4 @@
-import { type IPolicyValidationContext, type IPolicyValidationPlugin, type PolicyValidationPluginReport } from 'aws-cdk-lib';
+import { CloudFormationValidatePlugin, type IPolicyValidationContext, type IPolicyValidationPlugin, type PolicyValidationPluginReport } from 'aws-cdk-lib';
 import type { IConstruct } from 'constructs';
 import { type BundledRuleData } from '../rules.generated';
 /**
@@ -72,6 +72,7 @@ export declare function installEnforceGate(scope: IConstruct): void;
 export declare function fallbackFormat(pluginReports: any[]): string;
 /** （テストからも利用するため export している） */
 export declare function loadFormatter(): any | undefined;
+export declare function observePluginCached(rules: BundledRuleData[]): CloudFormationValidatePlugin;
 /**
  * ルールを service ごとに 1 モジュールへまとめる。
  *

package/lib/private/enforce.js

@@ -40,6 +40,7 @@ exports.isConcreteRegion = isConcreteRegion;
 exports.installEnforceGate = installEnforceGate;
 exports.fallbackFormat = fallbackFormat;
 exports.loadFormatter = loadFormatter;
+exports.observePluginCached = observePluginCached;
 exports.mergeRuleModules = mergeRuleModules;
 exports.templateResourceTypes = templateResourceTypes;
 exports.prune = prune;
@@ -380,6 +381,31 @@ function regoEngineCached(engineModule, rules, region, account) {
     }
     return cachedRegoEngine.engine;
 }
+// 観測モード（enforce: false）は CDK 組み込みの CloudFormationValidatePlugin に相乗りする。
+// あちらはコンストラクタでエンジンを 1 つ作って free() しないので、同じプロセスで App を
+// 作り直すたびにインスタンスが積み上がり、regoEngineCached と同じ超線形の悪化を起こす
+// （実測 2026-09-13: 同じルールセットで 4 回 synth して 36s -> 95s -> 131s -> 178s）。
+// ルールセットが変わらない限りプラグインごと使い回す。
+// ponytail: キーが変わったときに古いエンジンは free() しない（エンジンは CDK 側の
+// private フィールドで、触るには内部実装に手を入れることになる）。設定違いの Stage が
+// N 個あれば N 個積むが、実アプリでは 1〜2 個。積み上がりが問題になるなら、そのときに
+// アップストリームへ free/dispose を入れてもらう。
+let cachedObservePlugin;
+function observePluginCached(rules) {
+    const key = rules.map((r) => r.id).join(',');
+    if (cachedObservePlugin?.key !== key) {
+        cachedObservePlugin = {
+            key,
+            plugin: new aws_cdk_lib_1.CloudFormationValidatePlugin({
+                regoRules: [
+                    ...rules_generated_1.BUNDLED_LIBS.map((l) => ({ name: l.name, content: l.rego })),
+                    ...mergeRuleModules(rules),
+                ],
+            }),
+        };
+    }
+    return cachedObservePlugin.plugin;
+}
 /** 全ルールに共通の rego ヘッダ。bundle-rules が package 名と import を 1 種類に強制している。 */
 const REGO_HEADER = 'package cdk_preflight\n\nimport rego.v1\n';
 /**
@@ -477,4 +503,4 @@ function loadEngine() {
         return undefined;
     }
 }
-//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"enforce.js","sourceRoot":"","sources":["../../src/private/enforce.ts"],"names":[],"mappings":"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","sourcesContent":["import * as fs from 'fs';\nimport * as path from 'path';\nimport {\n  App,\n  type IPolicyValidationContext,\n  type IPolicyValidationPlugin,\n  type PolicyValidationPluginReport,\n  type PolicyViolation,\n} from 'aws-cdk-lib';\nimport type { IConstruct } from 'constructs';\nimport { BUNDLED_LIBS, type BundledRuleData } from '../rules.generated';\n\n/* eslint-disable @typescript-eslint/no-require-imports */\n/* eslint-disable import/no-extraneous-dependencies -- @aws/cloudformation-validate は\n   aws-cdk-lib 同梱コピーを動的解決する設計（依存には載せない）。README/AGENTS.md 参照 */\n\n/**\n * The name of the generated Rego module that carries the deployment\n * environment into rule evaluation.\n */\nexport const DEPLOY_ENV_MODULE_NAME = '_pf_deploy_environment';\n\n/**\n * Build the generated module defining `deploy_region` for the rule package.\n *\n * Rules must read it as `data.cdk_preflight.deploy_region` (never as a bare\n * variable): the data reference is simply undefined when the module is not\n * injected — the rule body fails and the rule skips — while a bare variable\n * would be a compile error. Injected by the enforce plugin when the app-level\n * region is concrete; the warn mode (CDK built-in plugin) never injects it,\n * so region-dependent rules only fire in enforce mode.\n */\nexport function deployEnvironmentModule(region: string, accountId?: string): { name: string; content: string } {\n  const account = isConcreteAccount(accountId) ? `deploy_account := ${JSON.stringify(accountId)}\\n` : '';\n  return {\n    name: DEPLOY_ENV_MODULE_NAME,\n    content: `package cdk_preflight\\n\\nimport rego.v1\\n\\ndeploy_region := ${JSON.stringify(region)}\\n${account}`,\n  };\n}\n\n/** Whether the account from the validation context is a concrete 12-digit account id. */\nexport function isConcreteAccount(accountId: string | undefined): accountId is string {\n  return typeof accountId === 'string' && /^\\d{12}$/.test(accountId);\n}\n\n/**\n * Whether the region from the validation context is a concrete region name\n * (as opposed to undefined, an unresolved token, or a placeholder).\n */\nexport function isConcreteRegion(region: string | undefined): region is string {\n  return typeof region === 'string' && /^[a-z]{2}(-[a-z]+)+-\\d+$/.test(region);\n}\n\ninterface EngineDiagnostic {\n  readonly ruleId: string;\n  readonly severity: string;\n  readonly message: string;\n  readonly source?: string;\n  readonly entity?: { readonly logicalId?: string };\n  readonly propertyPath?: string;\n  readonly documentationUrl?: string;\n}\n\n/**\n * enforce モード用の内部プラグイン。\n *\n * CDK 組み込みの CloudFormationValidatePlugin は全 finding を warning に丸めるため\n * （aws-cdk-lib 2.267.0 実測、昇格フラグも無効）、同じエンジンを直接呼び、\n * cdk-preflight のルール違反（および strict 時はエンジンのエラークラス）を\n * policy validation の失敗として報告して synth を止める。\n */\nexport class PreflightEnforcePlugin implements IPolicyValidationPlugin {\n  public readonly name = PLUGIN_NAME;\n\n  constructor(\n    private readonly rules: BundledRuleData[],\n    private readonly strict: boolean,\n  ) {}\n\n  public validate(context: IPolicyValidationContext): PolicyValidationPluginReport {\n    const engine = loadEngineCached();\n    if (!engine) {\n      // eslint-disable-next-line no-console\n      console.error(\n        'cdk-preflight: could not resolve @aws/cloudformation-validate; ' +\n        'enforce mode is unavailable and no preflight checks were run. ' +\n        'Install it as a devDependency or use the default (warn) mode.',\n      );\n      return { success: true, violations: [] };\n    }\n\n    const region = isConcreteRegion(context.region) ? context.region : undefined;\n    const account = isConcreteAccount(context.accountId) ? context.accountId : undefined;\n    const ours = new Set(this.rules.map((r) => r.id));\n    const violations: PolicyViolation[] = [];\n\n    // 全テンプレートの和集合で刈り込む。テンプレートごとに刈るとエンジンを何度も\n    // 作り直すことになり、そちらのコストの方が高くつく（regoEngineCached のコメント参照）。\n    const rules = prune(this.rules, templateResourceTypes(context.stackTemplates.map((st) => st.templatePath)));\n\n    // 1 本も残らない = このアプリのリソースに関係するルールが無い。エンジンを組む必要も無い\n    // （libs だけを載せたエンジンは violation ルールを持たず、評価時に落ちる）。\n    // strict のときは組み込みエンジンの findings を拾う仕事が残るので通常どおり進む。\n    if (rules.length === 0 && !this.strict) {\n      return { success: true, violations: [] };\n    }\n\n    let eng: any;\n    try {\n      eng = regoEngineCached(engine, rules, region, account);\n    } catch (e) {\n      // ルールパックがコンパイルできない = どのテンプレートも検査できないので、\n      // 全スタックぶん violation を立てる（1 枚ずつの catch には到達しない）。\n      return { success: false, violations: context.stackTemplates.map((st) => engineErrorViolation(st, e)) };\n    }\n\n    for (const st of context.stackTemplates) {\n      let report: any;\n      try {\n        report = eng.validateDetailed(new engine.TemplateFile(st.templatePath), {\n          pseudoParameterOverrides: {\n            accountId: context.accountId,\n            region: context.region,\n          },\n          // 組み込みルールは CDK 組み込みの CloudFormationValidatePlugin が同じテンプレートに\n          // 対して既に走らせている。strict でなければ結果も使わず捨てているので、丸ごと切る\n          // （実測 70 リソース 1 枚で初回 3.27s -> 0.22s）。strict のときだけ必要になる。\n          disableBuiltinRules: !this.strict,\n        });\n      } catch (e) {\n        // throw を外に出すと CDK はこの呼び出しを plugin failure（violation ゼロ）として\n        // 記録するだけになり、ここまでに集めた違反も後続テンプレートの違反も丸ごと消え、\n        // 残るのは `failed: undefined` だけになる（issue #151）。\n        // synth を止めるのは installEnforceGate の役目。ここは「どのスタックで何が\n        // 起きたか」をレポートに残し、他スタックのルールを走らせ続けるためのもの。\n        violations.push(engineErrorViolation(st, e));\n        continue;\n      }\n      for (const d of (report.diagnostics ?? []) as EngineDiagnostic[]) {\n        const isOurs = d.source === 'CUSTOM' && ours.has(d.ruleId);\n        const isStrictHit = this.strict\n          && d.source !== 'CUSTOM'\n          && (d.severity === 'ERROR' || d.severity === 'FATAL');\n        if (!isOurs && !isStrictHit) continue;\n        violations.push({\n          ruleName: d.ruleId,\n          description: d.message,\n          severity: mapSeverity(d.severity),\n          violatingResources: [{\n            resourceLogicalId: d.entity?.logicalId ?? '(unknown)',\n            templatePath: st.templatePath,\n            locations: [d.propertyPath ?? '(template)'],\n          }],\n          ...(d.documentationUrl ? { ruleMetadata: { DocumentationUrl: d.documentationUrl } } : {}),\n        });\n      }\n    }\n\n    // CDK 組み込みの CloudFormationValidatePlugin と同じ判定。warning だけなら\n    // レポートには載るが合成は通る（CLI 側は success/failure に関わらず必ず出力する）。\n    return { success: violations.every((v) => !BLOCKS_SYNTH.has(String(v.severity))), violations };\n  }\n}\n\n/** 合成を止める violation severity。 */\nconst BLOCKS_SYNTH = new Set(['error', 'fatal']);\n\n/**\n * エンジンの severity を policy validation の severity に写す。表は aws-cdk-lib 2.267.0 の\n * CloudFormationValidatePlugin と同一。`repro.method: doc-only` のルールは WARN を出すので\n * warning になり、報告はされるが synth は止めない（証拠が実機のデプロイ失敗ではないため）。\n */\nfunction mapSeverity(severity: string | undefined): string {\n  switch (severity) {\n    case 'FATAL':\n    case 'ERROR':\n      return 'error';\n    case 'WARN':\n      return 'warning';\n    case 'INFO':\n      return 'informational';\n    case 'DEBUG':\n      return 'debug';\n    default:\n      return 'warning';\n  }\n}\n\n/**\n * ルール評価そのものが失敗したことを表す violation の ruleName。\n * バンドル済みルールの id ではないので `exclude` では消せない（消してよい状態ではない）。\n */\nexport const ENGINE_ERROR_RULE = 'pf-engine-error';\n\n/** エンジンが投げた値をメッセージに落とす。エンジンは Error ではなく素の文字列を投げることがある。 */\nfunction engineErrorText(e: unknown): string {\n  const message = (e as { message?: unknown } | undefined)?.message;\n  return typeof message === 'string' && message.length > 0 ? message : String(e);\n}\n\n/** 1 枚のテンプレートを検査できなかったことを violation として報告する。 */\nfunction engineErrorViolation(st: { stackConstructPath: string; templatePath: string }, e: unknown): PolicyViolation {\n  return {\n    ruleName: ENGINE_ERROR_RULE,\n    description:\n      'cdk-preflight could not evaluate its rules for this template, so no preflight rule ran for it: '\n      + engineErrorText(e),\n    severity: 'error',\n    fix: 'Report this at https://github.com/badmintoncryer/cdk-preflight/issues; '\n      + 'to unblock the build meanwhile, use Preflight.apply(app, { enforce: false }).',\n    violatingResources: [{\n      constructPath: st.stackConstructPath,\n      templatePath: st.templatePath,\n      locations: ['(template)'],\n    }],\n  };\n}\n\n/** The plugin name recorded in `validation-report.json` for our findings. */\nexport const PLUGIN_NAME = 'cdk-preflight';\n\n/** The cloud assembly file the CDK writes its validation report to. */\nconst VALIDATION_REPORT_FILE = 'validation-report.json';\n\nconst GATE_INSTALLED = Symbol.for('cdk-preflight.enforceGate');\n\n/**\n * enforce モードの取りこぼしを塞ぐゲートを App に仕込む。\n *\n * CDK CLI 2.1128.1 以降は app に「レポートは CLI が処理する」と伝えたうえで\n * `validation-report.json` を自分で読むが、その絞り込み（toolkit-lib の\n * `filterReportsByStacks`）が violation の constructPath 先頭セグメントを\n * 選択スタックの hierarchicalId と突き合わせるため、`Stage/Stack` 形式になる\n * Stage 内スタックの違反がすべて捨てられ、synth が黙って成功する（issue #113）。\n *\n * そこで synth 完了後にレポートを読み直し、cdk-preflight の違反が残っていれば\n * 自分で報告して synth を止める。ライブラリが自力で報告する経路（素の node 実行、\n * jest、CLI 2.1128.1 未満）では synth が例外を投げるためここには到達せず、\n * 二重報告は起きない。\n */\nexport function installEnforceGate(scope: IConstruct): void {\n  const root = scope.node.root;\n  if (!App.isApp(root)) return;\n  const app = root as App & { [GATE_INSTALLED]?: boolean };\n  if (app[GATE_INSTALLED]) return;\n  Object.defineProperty(app, GATE_INSTALLED, { value: true, enumerable: false });\n\n  const synth = app.synth.bind(app);\n  let checked = false;\n  app.synth = (options?: Parameters<App['synth']>[0]) => {\n    const assembly = synth(options);\n    if (!checked) {\n      checked = true;\n      failIfReportUnhandled(assembly.directory);\n    }\n    return assembly;\n  };\n}\n\n/**\n * レポートに cdk-preflight の失敗が残っていれば、findings を出力して synth を止める。\n *\n * 判定は cdk-preflight のレポートだけを見る。組み込みエンジンや construct annotation\n * だけが失敗している場合は CLI が正しく扱えるので、こちらは黙って CLI に任せる。\n * 逆に発火するときはレポート全体を出す。ここで synth を止めると CLI 側の出力が\n * 一切走らないため、同時に出ていたはずの他プラグインの finding が消えてしまう。\n */\nfunction failIfReportUnhandled(directory: string): void {\n  let pluginReports: any[];\n  try {\n    const report = JSON.parse(fs.readFileSync(path.join(directory, VALIDATION_REPORT_FILE), 'utf8'));\n    pluginReports = report?.pluginReports ?? [];\n  } catch {\n    // レポートが無い（プラグイン未実行）または壊れている場合は何もしない\n    return;\n  }\n  const failed = pluginReports.some(\n    (r) => r?.pluginName === PLUGIN_NAME && r?.conclusion === 'failure',\n  );\n  if (!failed) return;\n\n  // eslint-disable-next-line no-console\n  console.error(formatReports(pluginReports));\n  throw new Error(\n    'cdk-preflight: validation failed. Fix the findings above, ' +\n    \"acknowledge them with Validations.of(scope).acknowledge({ id: 'cdk-preflight::<rule-id>' }), \" +\n    'or exclude the rule via Preflight.apply(app, { exclude: [...] }).',\n  );\n}\n\n/**\n * CDK 本体のフォーマッタで整形し、CLI と同一の見た目にする。\n * 私有パスなので解決できないことがあり、その場合は最小限の自前整形に落とす\n * （見た目より「落とす」ことを優先する）。\n */\nfunction formatReports(pluginReports: any[]): string {\n  const formatter = loadFormatterCached();\n  if (formatter) {\n    try {\n      return formatter.formatValidationReports(process.cwd(), pluginReports).join('\\n\\n');\n    } catch {\n      // fall through\n    }\n  }\n  return fallbackFormat(pluginReports);\n}\n\n/**\n * CDK 本体のフォーマッタを解決できないときの最小限の整形。\n * 見た目は劣るが、findings を必ず読める形で出すための最後の砦。\n * （テストからも利用するため export している）\n */\nexport function fallbackFormat(pluginReports: any[]): string {\n  const blocks: string[] = [];\n  for (const report of pluginReports) {\n    for (const violation of report?.violations ?? []) {\n      const ackId = String(violation.ruleName).includes('::')\n        ? violation.ruleName\n        : `${report.pluginName}::${violation.ruleName}`;\n      for (const c of violation.violatingConstructs ?? []) {\n        blocks.push(\n          `${String(violation.severity ?? 'ERROR').toUpperCase()} ${violation.description} (${report.pluginName})\\n` +\n          `   ${c.constructPath} (${c.cloudFormationResource?.logicalId}) ${c.constructFqn}\\n` +\n          `   Acknowledge with '${String(ackId).replace(/ /g, '-')}'`,\n        );\n      }\n    }\n  }\n  return blocks.join('\\n\\n');\n}\n\n// フォーマッタは aws-cdk-lib の私有パスにあり `exports` から見えないため、\n// エンジン解決（loadEngine）と同じくパッケージルートからの絶対パスで読み込む。\nlet cachedFormatter: any | false | undefined;\nfunction loadFormatterCached(): any | undefined {\n  if (cachedFormatter === undefined) {\n    cachedFormatter = loadFormatter() ?? false;\n  }\n  return cachedFormatter === false ? undefined : cachedFormatter;\n}\n\n/** （テストからも利用するため export している） */\nexport function loadFormatter(): any | undefined {\n  try {\n    const libRoot = path.dirname(require.resolve('aws-cdk-lib/package.json'));\n    const mod = require(path.join(libRoot, 'core/lib/validation/private/modern-formatter.js'));\n    return typeof mod?.formatValidationReports === 'function' ? mod : undefined;\n  } catch {\n    return undefined;\n  }\n}\n\n// エンジン（WASM）の初期化は重いため、モジュールレベルでキャッシュする\nlet cachedEngineModule: any | false | undefined;\nfunction loadEngineCached(): any | undefined {\n  if (cachedEngineModule === undefined) {\n    cachedEngineModule = loadEngine() ?? false;\n  }\n  return cachedEngineModule === false ? undefined : cachedEngineModule;\n}\n\n// エンジン（WASM）は 1 プロセスに 1 つだけ生かす。作り直す前に free() しないとインスタンスが\n// 積み上がり、2 個目以降の構築が超線形に遅くなる（実測: free 無しで 3.8s -> 11.2s -> 22.1s、\n// 構築前に free すると 3.5s -> 0.4s）。ルールセットが変わる（Stage ごとに exclude が違う、\n// テストで複数アプリを合成する）たびに作り直すので、キャッシュは 1 スロットで足りる。\nlet cachedRegoEngine: { key: string; engine: any } | undefined;\nfunction regoEngineCached(engineModule: any, rules: BundledRuleData[], region?: string, account?: string): any {\n  const key = `${region ?? ''}|${account ?? ''}|${rules.map((r) => r.id).join(',')}`;\n  if (cachedRegoEngine?.key !== key) {\n    cachedRegoEngine?.engine?.free?.();\n    cachedRegoEngine = undefined;\n    const customRules = [\n      ...BUNDLED_LIBS.map((l) => ({ name: l.name, content: l.rego })),\n      ...mergeRuleModules(rules),\n    ];\n    if (region !== undefined) {\n      customRules.push(deployEnvironmentModule(region, account));\n    }\n    cachedRegoEngine = { key, engine: new engineModule.RegoEngine({ customRules }) };\n  }\n  return cachedRegoEngine.engine;\n}\n\n/** 全ルールに共通の rego ヘッダ。bundle-rules が package 名と import を 1 種類に強制している。 */\nconst REGO_HEADER = 'package cdk_preflight\\n\\nimport rego.v1\\n';\n\n/**\n * ルールを service ごとに 1 モジュールへまとめる。\n *\n * コンパイル時間はルール本体の量よりモジュール数で効いてくる（実測 1844 ルールを\n * 1 ルール 1 モジュールで載せると約 6.2s、service 単位の 39 モジュールに畳むと約 1.0s）。\n * ルールはもともと全部 `package cdk_preflight` なので、Rego から見れば結合しても\n * しなくても同じ 1 パッケージ——モジュール境界に意味論は無い。したがって畳めるのだが、\n * 裏を返せば「別ルールが同じ名前のヘルパーを定義すると黙って 1 つの規則に合流する」\n * という危険も結合前から存在する。bundle-rules がルール間のトップレベル名衝突を\n * 弾いているのはそのため（共有したい定義は rules/_lib/ に置く）。\n * （テストからも利用するため export している）\n */\nexport function mergeRuleModules(rules: BundledRuleData[]): { name: string; content: string }[] {\n  const byService = new Map<string, string[]>();\n  for (const r of rules) {\n    const body = r.rego.replace(/^(?:package|import)\\s.*\\n/gm, '');\n    byService.set(r.service, [...byService.get(r.service) ?? [], body]);\n  }\n  return [...byService].map(([service, bodies]) => ({\n    name: `_pf_service_${service}`,\n    content: REGO_HEADER + bodies.join('\\n'),\n  }));\n}\n\n/**\n * テンプレート群に出てくるリソースタイプ。刈り込みに使えないテンプレートが 1 枚でもあれば\n * undefined を返し、刈り込みそのものを諦める（何が載っているか分からないまま落とすと、\n * ルールが黙って発火しなくなる = enforce にとって最悪の壊れ方になるため）。\n * （テストからも利用するため export している）\n */\nexport function templateResourceTypes(templatePaths: string[]): Set<string> | undefined {\n  const types = new Set<string>();\n  for (const templatePath of templatePaths) {\n    let template: any;\n    try {\n      template = JSON.parse(fs.readFileSync(templatePath, 'utf8'));\n    } catch {\n      return undefined;\n    }\n    // Transform（SAM 等）はマクロ展開で別のリソースに化けるので、生のテンプレートから\n    // 読めるリソースタイプは当てにならない。\n    if (template?.Transform !== undefined) return undefined;\n    for (const resource of Object.values(template?.Resources ?? {}) as any[]) {\n      // Fn::ForEach などで Type が静的に読めないエントリがあれば諦める。\n      if (typeof resource?.Type !== 'string') return undefined;\n      types.add(resource.Type);\n    }\n  }\n  return types;\n}\n\n/**\n * テンプレートに出てくるリソースタイプに関係するルールだけを選ぶ。\n *\n * エンジンのコンパイル時間はルール数でほぼ決まるので（実測 1844 ルールで約 4.6s、\n * 典型的なアプリに残る 100 ルール前後なら 0.8s 前後）、これが固定費の主な削りどころ。\n * 安全性は meta.resourceTypes の宣言に乗っている: ルールが見るリソースタイプが\n * 宣言から漏れていると刈られて発火しなくなるため、test/rules.test.ts が全ルールについて\n * 「自分の fail テンプレートで刈り残ること」を検査している。\n * （テストからも利用するため export している）\n */\nexport function prune(rules: BundledRuleData[], types: Set<string> | undefined): BundledRuleData[] {\n  if (types === undefined) return rules;\n  // 刈る根拠が無いルールは残す: \"*\"（全リソース型に効くタグ系ルール）と、\n  // resourceTypes が空のもの（バンドル済みルールは非空が保証されているので、該当するのは\n  // 手で組み立てたルール = テストや将来のテンプレート層ルールだけ）。\n  return rules.filter((r) => r.resourceTypes.length === 0\n    || r.resourceTypes.includes('*')\n    || r.resourceTypes.some((t) => types.has(t)));\n}\n\n/**\n * @aws/cloudformation-validate を解決する。\n * 通常は aws-cdk-lib が bundledDependencies として同梱しているコピーに乗る。\n * （テストからも利用するため export している）\n */\nexport function loadEngine(): any | undefined {\n  try {\n    return require('@aws/cloudformation-validate');\n  } catch {\n    // fall through\n  }\n  try {\n    const libPkg = require.resolve('aws-cdk-lib/package.json');\n    const engPkg = require.resolve('@aws/cloudformation-validate/package.json', {\n      paths: [path.dirname(libPkg)],\n    });\n    return require(path.dirname(engPkg));\n  } catch {\n    return undefined;\n  }\n}\n"]}
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"enforce.js","sourceRoot":"","sources":["../../src/private/enforce.ts"],"names":[],"mappings":"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","sourcesContent":["import * as fs from 'fs';\nimport * as path from 'path';\nimport {\n  App,\n  CloudFormationValidatePlugin,\n  type IPolicyValidationContext,\n  type IPolicyValidationPlugin,\n  type PolicyValidationPluginReport,\n  type PolicyViolation,\n} from 'aws-cdk-lib';\nimport type { IConstruct } from 'constructs';\nimport { BUNDLED_LIBS, type BundledRuleData } from '../rules.generated';\n\n/* eslint-disable @typescript-eslint/no-require-imports */\n/* eslint-disable import/no-extraneous-dependencies -- @aws/cloudformation-validate は\n   aws-cdk-lib 同梱コピーを動的解決する設計（依存には載せない）。README/AGENTS.md 参照 */\n\n/**\n * The name of the generated Rego module that carries the deployment\n * environment into rule evaluation.\n */\nexport const DEPLOY_ENV_MODULE_NAME = '_pf_deploy_environment';\n\n/**\n * Build the generated module defining `deploy_region` for the rule package.\n *\n * Rules must read it as `data.cdk_preflight.deploy_region` (never as a bare\n * variable): the data reference is simply undefined when the module is not\n * injected — the rule body fails and the rule skips — while a bare variable\n * would be a compile error. Injected by the enforce plugin when the app-level\n * region is concrete; the warn mode (CDK built-in plugin) never injects it,\n * so region-dependent rules only fire in enforce mode.\n */\nexport function deployEnvironmentModule(region: string, accountId?: string): { name: string; content: string } {\n  const account = isConcreteAccount(accountId) ? `deploy_account := ${JSON.stringify(accountId)}\\n` : '';\n  return {\n    name: DEPLOY_ENV_MODULE_NAME,\n    content: `package cdk_preflight\\n\\nimport rego.v1\\n\\ndeploy_region := ${JSON.stringify(region)}\\n${account}`,\n  };\n}\n\n/** Whether the account from the validation context is a concrete 12-digit account id. */\nexport function isConcreteAccount(accountId: string | undefined): accountId is string {\n  return typeof accountId === 'string' && /^\\d{12}$/.test(accountId);\n}\n\n/**\n * Whether the region from the validation context is a concrete region name\n * (as opposed to undefined, an unresolved token, or a placeholder).\n */\nexport function isConcreteRegion(region: string | undefined): region is string {\n  return typeof region === 'string' && /^[a-z]{2}(-[a-z]+)+-\\d+$/.test(region);\n}\n\ninterface EngineDiagnostic {\n  readonly ruleId: string;\n  readonly severity: string;\n  readonly message: string;\n  readonly source?: string;\n  readonly entity?: { readonly logicalId?: string };\n  readonly propertyPath?: string;\n  readonly documentationUrl?: string;\n}\n\n/**\n * enforce モード用の内部プラグイン。\n *\n * CDK 組み込みの CloudFormationValidatePlugin は全 finding を warning に丸めるため\n * （aws-cdk-lib 2.267.0 実測、昇格フラグも無効）、同じエンジンを直接呼び、\n * cdk-preflight のルール違反（および strict 時はエンジンのエラークラス）を\n * policy validation の失敗として報告して synth を止める。\n */\nexport class PreflightEnforcePlugin implements IPolicyValidationPlugin {\n  public readonly name = PLUGIN_NAME;\n\n  constructor(\n    private readonly rules: BundledRuleData[],\n    private readonly strict: boolean,\n  ) {}\n\n  public validate(context: IPolicyValidationContext): PolicyValidationPluginReport {\n    const engine = loadEngineCached();\n    if (!engine) {\n      // eslint-disable-next-line no-console\n      console.error(\n        'cdk-preflight: could not resolve @aws/cloudformation-validate; ' +\n        'enforce mode is unavailable and no preflight checks were run. ' +\n        'Install it as a devDependency or use the default (warn) mode.',\n      );\n      return { success: true, violations: [] };\n    }\n\n    const region = isConcreteRegion(context.region) ? context.region : undefined;\n    const account = isConcreteAccount(context.accountId) ? context.accountId : undefined;\n    const ours = new Set(this.rules.map((r) => r.id));\n    const violations: PolicyViolation[] = [];\n\n    // 全テンプレートの和集合で刈り込む。テンプレートごとに刈るとエンジンを何度も\n    // 作り直すことになり、そちらのコストの方が高くつく（regoEngineCached のコメント参照）。\n    const rules = prune(this.rules, templateResourceTypes(context.stackTemplates.map((st) => st.templatePath)));\n\n    // 1 本も残らない = このアプリのリソースに関係するルールが無い。エンジンを組む必要も無い\n    // （libs だけを載せたエンジンは violation ルールを持たず、評価時に落ちる）。\n    // strict のときは組み込みエンジンの findings を拾う仕事が残るので通常どおり進む。\n    if (rules.length === 0 && !this.strict) {\n      return { success: true, violations: [] };\n    }\n\n    let eng: any;\n    try {\n      eng = regoEngineCached(engine, rules, region, account);\n    } catch (e) {\n      // ルールパックがコンパイルできない = どのテンプレートも検査できないので、\n      // 全スタックぶん violation を立てる（1 枚ずつの catch には到達しない）。\n      return { success: false, violations: context.stackTemplates.map((st) => engineErrorViolation(st, e)) };\n    }\n\n    for (const st of context.stackTemplates) {\n      let report: any;\n      try {\n        report = eng.validateDetailed(new engine.TemplateFile(st.templatePath), {\n          pseudoParameterOverrides: {\n            accountId: context.accountId,\n            region: context.region,\n          },\n          // 組み込みルールは CDK 組み込みの CloudFormationValidatePlugin が同じテンプレートに\n          // 対して既に走らせている。strict でなければ結果も使わず捨てているので、丸ごと切る\n          // （実測 70 リソース 1 枚で初回 3.27s -> 0.22s）。strict のときだけ必要になる。\n          disableBuiltinRules: !this.strict,\n        });\n      } catch (e) {\n        // throw を外に出すと CDK はこの呼び出しを plugin failure（violation ゼロ）として\n        // 記録するだけになり、ここまでに集めた違反も後続テンプレートの違反も丸ごと消え、\n        // 残るのは `failed: undefined` だけになる（issue #151）。\n        // synth を止めるのは installEnforceGate の役目。ここは「どのスタックで何が\n        // 起きたか」をレポートに残し、他スタックのルールを走らせ続けるためのもの。\n        violations.push(engineErrorViolation(st, e));\n        continue;\n      }\n      for (const d of (report.diagnostics ?? []) as EngineDiagnostic[]) {\n        const isOurs = d.source === 'CUSTOM' && ours.has(d.ruleId);\n        const isStrictHit = this.strict\n          && d.source !== 'CUSTOM'\n          && (d.severity === 'ERROR' || d.severity === 'FATAL');\n        if (!isOurs && !isStrictHit) continue;\n        violations.push({\n          ruleName: d.ruleId,\n          description: d.message,\n          severity: mapSeverity(d.severity),\n          violatingResources: [{\n            resourceLogicalId: d.entity?.logicalId ?? '(unknown)',\n            templatePath: st.templatePath,\n            locations: [d.propertyPath ?? '(template)'],\n          }],\n          ...(d.documentationUrl ? { ruleMetadata: { DocumentationUrl: d.documentationUrl } } : {}),\n        });\n      }\n    }\n\n    // CDK 組み込みの CloudFormationValidatePlugin と同じ判定。warning だけなら\n    // レポートには載るが合成は通る（CLI 側は success/failure に関わらず必ず出力する）。\n    return { success: violations.every((v) => !BLOCKS_SYNTH.has(String(v.severity))), violations };\n  }\n}\n\n/** 合成を止める violation severity。 */\nconst BLOCKS_SYNTH = new Set(['error', 'fatal']);\n\n/**\n * エンジンの severity を policy validation の severity に写す。表は aws-cdk-lib 2.267.0 の\n * CloudFormationValidatePlugin と同一。`repro.method: doc-only` のルールは WARN を出すので\n * warning になり、報告はされるが synth は止めない（証拠が実機のデプロイ失敗ではないため）。\n */\nfunction mapSeverity(severity: string | undefined): string {\n  switch (severity) {\n    case 'FATAL':\n    case 'ERROR':\n      return 'error';\n    case 'WARN':\n      return 'warning';\n    case 'INFO':\n      return 'informational';\n    case 'DEBUG':\n      return 'debug';\n    default:\n      return 'warning';\n  }\n}\n\n/**\n * ルール評価そのものが失敗したことを表す violation の ruleName。\n * バンドル済みルールの id ではないので `exclude` では消せない（消してよい状態ではない）。\n */\nexport const ENGINE_ERROR_RULE = 'pf-engine-error';\n\n/** エンジンが投げた値をメッセージに落とす。エンジンは Error ではなく素の文字列を投げることがある。 */\nfunction engineErrorText(e: unknown): string {\n  const message = (e as { message?: unknown } | undefined)?.message;\n  return typeof message === 'string' && message.length > 0 ? message : String(e);\n}\n\n/** 1 枚のテンプレートを検査できなかったことを violation として報告する。 */\nfunction engineErrorViolation(st: { stackConstructPath: string; templatePath: string }, e: unknown): PolicyViolation {\n  return {\n    ruleName: ENGINE_ERROR_RULE,\n    description:\n      'cdk-preflight could not evaluate its rules for this template, so no preflight rule ran for it: '\n      + engineErrorText(e),\n    severity: 'error',\n    fix: 'Report this at https://github.com/badmintoncryer/cdk-preflight/issues; '\n      + 'to unblock the build meanwhile, use Preflight.apply(app, { enforce: false }).',\n    violatingResources: [{\n      constructPath: st.stackConstructPath,\n      templatePath: st.templatePath,\n      locations: ['(template)'],\n    }],\n  };\n}\n\n/** The plugin name recorded in `validation-report.json` for our findings. */\nexport const PLUGIN_NAME = 'cdk-preflight';\n\n/** The cloud assembly file the CDK writes its validation report to. */\nconst VALIDATION_REPORT_FILE = 'validation-report.json';\n\nconst GATE_INSTALLED = Symbol.for('cdk-preflight.enforceGate');\n\n/**\n * enforce モードの取りこぼしを塞ぐゲートを App に仕込む。\n *\n * CDK CLI 2.1128.1 以降は app に「レポートは CLI が処理する」と伝えたうえで\n * `validation-report.json` を自分で読むが、その絞り込み（toolkit-lib の\n * `filterReportsByStacks`）が violation の constructPath 先頭セグメントを\n * 選択スタックの hierarchicalId と突き合わせるため、`Stage/Stack` 形式になる\n * Stage 内スタックの違反がすべて捨てられ、synth が黙って成功する（issue #113）。\n *\n * そこで synth 完了後にレポートを読み直し、cdk-preflight の違反が残っていれば\n * 自分で報告して synth を止める。ライブラリが自力で報告する経路（素の node 実行、\n * jest、CLI 2.1128.1 未満）では synth が例外を投げるためここには到達せず、\n * 二重報告は起きない。\n */\nexport function installEnforceGate(scope: IConstruct): void {\n  const root = scope.node.root;\n  if (!App.isApp(root)) return;\n  const app = root as App & { [GATE_INSTALLED]?: boolean };\n  if (app[GATE_INSTALLED]) return;\n  Object.defineProperty(app, GATE_INSTALLED, { value: true, enumerable: false });\n\n  const synth = app.synth.bind(app);\n  let checked = false;\n  app.synth = (options?: Parameters<App['synth']>[0]) => {\n    const assembly = synth(options);\n    if (!checked) {\n      checked = true;\n      failIfReportUnhandled(assembly.directory);\n    }\n    return assembly;\n  };\n}\n\n/**\n * レポートに cdk-preflight の失敗が残っていれば、findings を出力して synth を止める。\n *\n * 判定は cdk-preflight のレポートだけを見る。組み込みエンジンや construct annotation\n * だけが失敗している場合は CLI が正しく扱えるので、こちらは黙って CLI に任せる。\n * 逆に発火するときはレポート全体を出す。ここで synth を止めると CLI 側の出力が\n * 一切走らないため、同時に出ていたはずの他プラグインの finding が消えてしまう。\n */\nfunction failIfReportUnhandled(directory: string): void {\n  let pluginReports: any[];\n  try {\n    const report = JSON.parse(fs.readFileSync(path.join(directory, VALIDATION_REPORT_FILE), 'utf8'));\n    pluginReports = report?.pluginReports ?? [];\n  } catch {\n    // レポートが無い（プラグイン未実行）または壊れている場合は何もしない\n    return;\n  }\n  const failed = pluginReports.some(\n    (r) => r?.pluginName === PLUGIN_NAME && r?.conclusion === 'failure',\n  );\n  if (!failed) return;\n\n  // eslint-disable-next-line no-console\n  console.error(formatReports(pluginReports));\n  throw new Error(\n    'cdk-preflight: validation failed. Fix the findings above, ' +\n    \"acknowledge them with Validations.of(scope).acknowledge({ id: 'cdk-preflight::<rule-id>' }), \" +\n    'or exclude the rule via Preflight.apply(app, { exclude: [...] }).',\n  );\n}\n\n/**\n * CDK 本体のフォーマッタで整形し、CLI と同一の見た目にする。\n * 私有パスなので解決できないことがあり、その場合は最小限の自前整形に落とす\n * （見た目より「落とす」ことを優先する）。\n */\nfunction formatReports(pluginReports: any[]): string {\n  const formatter = loadFormatterCached();\n  if (formatter) {\n    try {\n      return formatter.formatValidationReports(process.cwd(), pluginReports).join('\\n\\n');\n    } catch {\n      // fall through\n    }\n  }\n  return fallbackFormat(pluginReports);\n}\n\n/**\n * CDK 本体のフォーマッタを解決できないときの最小限の整形。\n * 見た目は劣るが、findings を必ず読める形で出すための最後の砦。\n * （テストからも利用するため export している）\n */\nexport function fallbackFormat(pluginReports: any[]): string {\n  const blocks: string[] = [];\n  for (const report of pluginReports) {\n    for (const violation of report?.violations ?? []) {\n      const ackId = String(violation.ruleName).includes('::')\n        ? violation.ruleName\n        : `${report.pluginName}::${violation.ruleName}`;\n      for (const c of violation.violatingConstructs ?? []) {\n        blocks.push(\n          `${String(violation.severity ?? 'ERROR').toUpperCase()} ${violation.description} (${report.pluginName})\\n` +\n          `   ${c.constructPath} (${c.cloudFormationResource?.logicalId}) ${c.constructFqn}\\n` +\n          `   Acknowledge with '${String(ackId).replace(/ /g, '-')}'`,\n        );\n      }\n    }\n  }\n  return blocks.join('\\n\\n');\n}\n\n// フォーマッタは aws-cdk-lib の私有パスにあり `exports` から見えないため、\n// エンジン解決（loadEngine）と同じくパッケージルートからの絶対パスで読み込む。\nlet cachedFormatter: any | false | undefined;\nfunction loadFormatterCached(): any | undefined {\n  if (cachedFormatter === undefined) {\n    cachedFormatter = loadFormatter() ?? false;\n  }\n  return cachedFormatter === false ? undefined : cachedFormatter;\n}\n\n/** （テストからも利用するため export している） */\nexport function loadFormatter(): any | undefined {\n  try {\n    const libRoot = path.dirname(require.resolve('aws-cdk-lib/package.json'));\n    const mod = require(path.join(libRoot, 'core/lib/validation/private/modern-formatter.js'));\n    return typeof mod?.formatValidationReports === 'function' ? mod : undefined;\n  } catch {\n    return undefined;\n  }\n}\n\n// エンジン（WASM）の初期化は重いため、モジュールレベルでキャッシュする\nlet cachedEngineModule: any | false | undefined;\nfunction loadEngineCached(): any | undefined {\n  if (cachedEngineModule === undefined) {\n    cachedEngineModule = loadEngine() ?? false;\n  }\n  return cachedEngineModule === false ? undefined : cachedEngineModule;\n}\n\n// エンジン（WASM）は 1 プロセスに 1 つだけ生かす。作り直す前に free() しないとインスタンスが\n// 積み上がり、2 個目以降の構築が超線形に遅くなる（実測: free 無しで 3.8s -> 11.2s -> 22.1s、\n// 構築前に free すると 3.5s -> 0.4s）。ルールセットが変わる（Stage ごとに exclude が違う、\n// テストで複数アプリを合成する）たびに作り直すので、キャッシュは 1 スロットで足りる。\nlet cachedRegoEngine: { key: string; engine: any } | undefined;\nfunction regoEngineCached(engineModule: any, rules: BundledRuleData[], region?: string, account?: string): any {\n  const key = `${region ?? ''}|${account ?? ''}|${rules.map((r) => r.id).join(',')}`;\n  if (cachedRegoEngine?.key !== key) {\n    cachedRegoEngine?.engine?.free?.();\n    cachedRegoEngine = undefined;\n    const customRules = [\n      ...BUNDLED_LIBS.map((l) => ({ name: l.name, content: l.rego })),\n      ...mergeRuleModules(rules),\n    ];\n    if (region !== undefined) {\n      customRules.push(deployEnvironmentModule(region, account));\n    }\n    cachedRegoEngine = { key, engine: new engineModule.RegoEngine({ customRules }) };\n  }\n  return cachedRegoEngine.engine;\n}\n\n// 観測モード（enforce: false）は CDK 組み込みの CloudFormationValidatePlugin に相乗りする。\n// あちらはコンストラクタでエンジンを 1 つ作って free() しないので、同じプロセスで App を\n// 作り直すたびにインスタンスが積み上がり、regoEngineCached と同じ超線形の悪化を起こす\n// （実測 2026-09-13: 同じルールセットで 4 回 synth して 36s -> 95s -> 131s -> 178s）。\n// ルールセットが変わらない限りプラグインごと使い回す。\n// ponytail: キーが変わったときに古いエンジンは free() しない（エンジンは CDK 側の\n// private フィールドで、触るには内部実装に手を入れることになる）。設定違いの Stage が\n// N 個あれば N 個積むが、実アプリでは 1〜2 個。積み上がりが問題になるなら、そのときに\n// アップストリームへ free/dispose を入れてもらう。\nlet cachedObservePlugin: { key: string; plugin: CloudFormationValidatePlugin } | undefined;\nexport function observePluginCached(rules: BundledRuleData[]): CloudFormationValidatePlugin {\n  const key = rules.map((r) => r.id).join(',');\n  if (cachedObservePlugin?.key !== key) {\n    cachedObservePlugin = {\n      key,\n      plugin: new CloudFormationValidatePlugin({\n        regoRules: [\n          ...BUNDLED_LIBS.map((l) => ({ name: l.name, content: l.rego })),\n          ...mergeRuleModules(rules),\n        ],\n      }),\n    };\n  }\n  return cachedObservePlugin.plugin;\n}\n\n/** 全ルールに共通の rego ヘッダ。bundle-rules が package 名と import を 1 種類に強制している。 */\nconst REGO_HEADER = 'package cdk_preflight\\n\\nimport rego.v1\\n';\n\n/**\n * ルールを service ごとに 1 モジュールへまとめる。\n *\n * コンパイル時間はルール本体の量よりモジュール数で効いてくる（実測 1844 ルールを\n * 1 ルール 1 モジュールで載せると約 6.2s、service 単位の 39 モジュールに畳むと約 1.0s）。\n * ルールはもともと全部 `package cdk_preflight` なので、Rego から見れば結合しても\n * しなくても同じ 1 パッケージ——モジュール境界に意味論は無い。したがって畳めるのだが、\n * 裏を返せば「別ルールが同じ名前のヘルパーを定義すると黙って 1 つの規則に合流する」\n * という危険も結合前から存在する。bundle-rules がルール間のトップレベル名衝突を\n * 弾いているのはそのため（共有したい定義は rules/_lib/ に置く）。\n * （テストからも利用するため export している）\n */\nexport function mergeRuleModules(rules: BundledRuleData[]): { name: string; content: string }[] {\n  const byService = new Map<string, string[]>();\n  for (const r of rules) {\n    const body = r.rego.replace(/^(?:package|import)\\s.*\\n/gm, '');\n    byService.set(r.service, [...byService.get(r.service) ?? [], body]);\n  }\n  return [...byService].map(([service, bodies]) => ({\n    name: `_pf_service_${service}`,\n    content: REGO_HEADER + bodies.join('\\n'),\n  }));\n}\n\n/**\n * テンプレート群に出てくるリソースタイプ。刈り込みに使えないテンプレートが 1 枚でもあれば\n * undefined を返し、刈り込みそのものを諦める（何が載っているか分からないまま落とすと、\n * ルールが黙って発火しなくなる = enforce にとって最悪の壊れ方になるため）。\n * （テストからも利用するため export している）\n */\nexport function templateResourceTypes(templatePaths: string[]): Set<string> | undefined {\n  const types = new Set<string>();\n  for (const templatePath of templatePaths) {\n    let template: any;\n    try {\n      template = JSON.parse(fs.readFileSync(templatePath, 'utf8'));\n    } catch {\n      return undefined;\n    }\n    // Transform（SAM 等）はマクロ展開で別のリソースに化けるので、生のテンプレートから\n    // 読めるリソースタイプは当てにならない。\n    if (template?.Transform !== undefined) return undefined;\n    for (const resource of Object.values(template?.Resources ?? {}) as any[]) {\n      // Fn::ForEach などで Type が静的に読めないエントリがあれば諦める。\n      if (typeof resource?.Type !== 'string') return undefined;\n      types.add(resource.Type);\n    }\n  }\n  return types;\n}\n\n/**\n * テンプレートに出てくるリソースタイプに関係するルールだけを選ぶ。\n *\n * エンジンのコンパイル時間はルール数でほぼ決まるので（実測 1844 ルールで約 4.6s、\n * 典型的なアプリに残る 100 ルール前後なら 0.8s 前後）、これが固定費の主な削りどころ。\n * 安全性は meta.resourceTypes の宣言に乗っている: ルールが見るリソースタイプが\n * 宣言から漏れていると刈られて発火しなくなるため、test/rules.test.ts が全ルールについて\n * 「自分の fail テンプレートで刈り残ること」を検査している。\n * （テストからも利用するため export している）\n */\nexport function prune(rules: BundledRuleData[], types: Set<string> | undefined): BundledRuleData[] {\n  if (types === undefined) return rules;\n  // 刈る根拠が無いルールは残す: \"*\"（全リソース型に効くタグ系ルール）と、\n  // resourceTypes が空のもの（バンドル済みルールは非空が保証されているので、該当するのは\n  // 手で組み立てたルール = テストや将来のテンプレート層ルールだけ）。\n  return rules.filter((r) => r.resourceTypes.length === 0\n    || r.resourceTypes.includes('*')\n    || r.resourceTypes.some((t) => types.has(t)));\n}\n\n/**\n * @aws/cloudformation-validate を解決する。\n * 通常は aws-cdk-lib が bundledDependencies として同梱しているコピーに乗る。\n * （テストからも利用するため export している）\n */\nexport function loadEngine(): any | undefined {\n  try {\n    return require('@aws/cloudformation-validate');\n  } catch {\n    // fall through\n  }\n  try {\n    const libPkg = require.resolve('aws-cdk-lib/package.json');\n    const engPkg = require.resolve('@aws/cloudformation-validate/package.json', {\n      paths: [path.dirname(libPkg)],\n    });\n    return require(path.dirname(engPkg));\n  } catch {\n    return undefined;\n  }\n}\n"]}

package/package.json

@@ -88,9 +88,13 @@
   "publishConfig": {
     "access": "public"
   },
-  "version": "0.0.121",
+  "version": "0.0.122",
   "jest": {
     "coverageProvider": "v8",
+    "coveragePathIgnorePatterns": [
+      "/node_modules/",
+      "/src/rules.generated.ts"
+    ],
     "testMatch": [
       "<rootDir>/@(src|test)/**/*(*.)@(spec|test).ts?(x)",
       "<rootDir>/@(src|test)/**/__tests__/**/*.ts?(x)",
@@ -107,9 +111,6 @@
       "text"
     ],
     "coverageDirectory": "coverage",
-    "coveragePathIgnorePatterns": [
-      "/node_modules/"
-    ],
     "testPathIgnorePatterns": [
       "/node_modules/"
     ],