@intentius/chant-lexicon-aws 0.124.31 → 0.124.33

package/dist/import/live-export.js

@@ -0,0 +1,34 @@
+import { hasOwnershipMarker, tagArrayToMap } from "@intentius/chant/ownership";
+import { AWS_TAG_OWNERSHIP_KEYS } from "../ownership.js";
+import { CFParser } from "./parser.js";
+/**
+ * Map a live CloudFormation template body to full-fidelity export IR.
+ *
+ * `aws cloudformation get-template` returns the template body as a JSON object
+ * (for JSON templates) or a string (for YAML). `CFParser` already turns either
+ * into `TemplateIR` — the same IR the import path uses — so the result feeds
+ * `templateGenerator()` (CFGenerator) unchanged. Pure: all I/O stays in the
+ * caller.
+ */
+export function parseStackTemplate(templateBody, selector, owned) {
+    const content = typeof templateBody === "string" ? templateBody : JSON.stringify(templateBody);
+    const ir = new CFParser().parse(content);
+    const hasSelector = selector && (selector.type !== undefined || selector.name !== undefined);
+    if (!hasSelector && !owned)
+        return ir;
+    return {
+        ...ir,
+        resources: ir.resources.filter((r) => {
+            if (selector?.type !== undefined && r.type !== selector.type)
+                return false;
+            if (selector?.name !== undefined && r.logicalId !== selector.name)
+                return false;
+            if (owned) {
+                const tags = r.properties.Tags;
+                if (!hasOwnershipMarker(tagArrayToMap(tags), AWS_TAG_OWNERSHIP_KEYS))
+                    return false;
+            }
+            return true;
+        }),
+    };
+}

package/dist/import/parser.js

@@ -0,0 +1,394 @@
+import { BaseValueParser } from "@intentius/chant/import/base-parser";
+import yaml from "js-yaml";
+/**
+ * Custom YAML schema for CloudFormation shorthand tags (!Ref, !Sub, !GetAtt, etc.)
+ */
+const cfnYamlTypes = [
+    new yaml.Type("!Ref", {
+        kind: "scalar",
+        construct: (data) => ({ Ref: data }),
+    }),
+    new yaml.Type("!Sub", {
+        kind: "scalar",
+        construct: (data) => ({ "Fn::Sub": data }),
+    }),
+    new yaml.Type("!Sub", {
+        kind: "sequence",
+        construct: (data) => ({ "Fn::Sub": data }),
+    }),
+    new yaml.Type("!GetAtt", {
+        kind: "scalar",
+        // `!GetAtt Db.Endpoint.Address` names the attribute `Endpoint.Address`:
+        // the logical id ends at the first dot.
+        construct: (data) => {
+            const dot = data.indexOf(".");
+            return { "Fn::GetAtt": dot < 0 ? [data] : [data.slice(0, dot), data.slice(dot + 1)] };
+        },
+    }),
+    new yaml.Type("!GetAtt", {
+        kind: "sequence",
+        construct: (data) => ({ "Fn::GetAtt": data }),
+    }),
+    new yaml.Type("!Join", {
+        kind: "sequence",
+        construct: (data) => ({ "Fn::Join": data }),
+    }),
+    new yaml.Type("!Select", {
+        kind: "sequence",
+        construct: (data) => ({ "Fn::Select": data }),
+    }),
+    new yaml.Type("!Split", {
+        kind: "sequence",
+        construct: (data) => ({ "Fn::Split": data }),
+    }),
+    new yaml.Type("!If", {
+        kind: "sequence",
+        construct: (data) => ({ "Fn::If": data }),
+    }),
+    new yaml.Type("!Equals", {
+        kind: "sequence",
+        construct: (data) => ({ "Fn::Equals": data }),
+    }),
+    new yaml.Type("!Not", {
+        kind: "sequence",
+        construct: (data) => ({ "Fn::Not": data }),
+    }),
+    new yaml.Type("!And", {
+        kind: "sequence",
+        construct: (data) => ({ "Fn::And": data }),
+    }),
+    new yaml.Type("!Or", {
+        kind: "sequence",
+        construct: (data) => ({ "Fn::Or": data }),
+    }),
+    new yaml.Type("!FindInMap", {
+        kind: "sequence",
+        construct: (data) => ({ "Fn::FindInMap": data }),
+    }),
+    new yaml.Type("!Base64", {
+        kind: "scalar",
+        construct: (data) => ({ "Fn::Base64": data }),
+    }),
+    new yaml.Type("!Base64", {
+        kind: "mapping",
+        construct: (data) => ({ "Fn::Base64": data }),
+    }),
+    new yaml.Type("!Cidr", {
+        kind: "sequence",
+        construct: (data) => ({ "Fn::Cidr": data }),
+    }),
+    new yaml.Type("!ImportValue", {
+        kind: "scalar",
+        construct: (data) => ({ "Fn::ImportValue": data }),
+    }),
+    new yaml.Type("!ImportValue", {
+        kind: "mapping",
+        construct: (data) => ({ "Fn::ImportValue": data }),
+    }),
+    new yaml.Type("!GetAZs", {
+        kind: "scalar",
+        construct: (data) => ({ "Fn::GetAZs": data }),
+    }),
+    new yaml.Type("!GetAZs", {
+        kind: "mapping",
+        construct: (data) => ({ "Fn::GetAZs": data }),
+    }),
+    new yaml.Type("!Transform", {
+        kind: "mapping",
+        construct: (data) => ({ "Fn::Transform": data }),
+    }),
+    new yaml.Type("!Condition", {
+        kind: "scalar",
+        construct: (data) => ({ Condition: data }),
+    }),
+];
+const CF_SCHEMA = yaml.DEFAULT_SCHEMA.extend(cfnYamlTypes);
+/** Parameter keys import carries besides Type, Description and Default. */
+const PARAMETER_CONSTRAINT_KEYS = [
+    "AllowedValues",
+    "AllowedPattern",
+    "ConstraintDescription",
+    "MinLength",
+    "MaxLength",
+    "MinValue",
+    "MaxValue",
+    "NoEcho",
+];
+/** Resource attributes import carries besides Type, Properties, Metadata and Condition. */
+const RESOURCE_ATTRIBUTE_KEYS = ["DependsOn", "DeletionPolicy", "UpdateReplacePolicy", "UpdatePolicy", "CreationPolicy"];
+/**
+ * Parser for CloudFormation JSON templates.
+ * Extends BaseValueParser for generic recursive value walking;
+ * overrides dispatchIntrinsic with the CFN-specific dispatch table.
+ */
+export class CFParser extends BaseValueParser {
+    constructor() {
+        super(...arguments);
+        /**
+         * Parse the Conditions section (#2069). Inside a condition expression the
+         * single-key `{ "Condition": "<name>" }` form references another declared
+         * condition; `inConditionExpression` scopes that dispatch to this section
+         * so a resource property that happens to hold a single-key `Condition`
+         * object is left alone.
+         */
+        this.inConditionExpression = false;
+    }
+    /**
+     * Parse CF JSON content into intermediate representation
+     */
+    parse(content) {
+        let parsed;
+        try {
+            parsed = JSON.parse(content);
+        }
+        catch {
+            parsed = yaml.load(content, { schema: CF_SCHEMA });
+        }
+        const template = parsed;
+        const parameters = this.parseParameters(template.Parameters ?? {});
+        const conditions = this.parseConditions(template.Conditions ?? {});
+        const resources = this.parseResources(template.Resources ?? {});
+        const outputs = this.parseOutputs(template.Outputs ?? {});
+        const warnings = this.collectDroppedSectionWarnings(template);
+        return {
+            parameters,
+            conditions: conditions.length > 0 ? conditions : undefined,
+            resources,
+            outputs: outputs.length > 0 ? outputs : undefined,
+            warnings: warnings.length > 0 ? warnings : undefined,
+            metadata: {
+                version: template.AWSTemplateFormatVersion ?? "2010-09-09",
+                description: template.Description,
+                ...(template.Metadata !== undefined ? { templateMetadata: this.parseValue(template.Metadata) } : {}),
+                ...(template.Mappings !== undefined ? { mappings: template.Mappings } : {}),
+            },
+        };
+    }
+    collectDroppedSectionWarnings(template) {
+        const warnings = [];
+        for (const key of Object.keys(template)) {
+            if (!CFParser.CARRIED_SECTIONS.has(key)) {
+                warnings.push(`Template section "${key}" is not carried by import — it is dropped from the generated source`);
+            }
+        }
+        return warnings;
+    }
+    parseConditions(conditions) {
+        return Object.entries(conditions).map(([name, expression]) => {
+            this.inConditionExpression = true;
+            try {
+                return { name, expression: this.parseValue(expression) };
+            }
+            finally {
+                this.inConditionExpression = false;
+            }
+        });
+    }
+    /**
+     * Parse the Outputs section (#2069).
+     */
+    parseOutputs(outputs) {
+        return Object.entries(outputs)
+            .filter(([_, output]) => typeof output === "object" && output !== null)
+            .map(([name, output]) => ({
+            name,
+            value: this.parseValue(output.Value),
+            description: output.Description,
+            exportName: output.Export?.Name !== undefined ? this.parseValue(output.Export.Name) : undefined,
+            condition: typeof output.Condition === "string" ? output.Condition : undefined,
+        }));
+    }
+    /**
+     * Parse parameters section
+     */
+    parseParameters(params) {
+        return Object.entries(params).map(([name, param]) => {
+            const constraints = Object.fromEntries(PARAMETER_CONSTRAINT_KEYS.filter((k) => param[k] !== undefined).map((k) => [k, param[k]]));
+            return {
+                name,
+                type: param.Type,
+                description: param.Description,
+                defaultValue: param.Default,
+                required: param.Default === undefined,
+                ...(Object.keys(constraints).length > 0 ? { constraints } : {}),
+            };
+        });
+    }
+    /**
+     * Parse resources section
+     */
+    parseResources(resources) {
+        return Object.entries(resources)
+            .filter(([_, resource]) => typeof resource?.Type === "string")
+            .map(([logicalId, resource]) => {
+            const attributes = Object.fromEntries(RESOURCE_ATTRIBUTE_KEYS.filter((k) => resource[k] !== undefined).map((k) => [k, this.parseValue(resource[k])]));
+            return {
+                logicalId,
+                type: resource.Type,
+                properties: this.parseProperties(resource.Properties ?? {}),
+                metadata: resource.Metadata !== undefined ? this.parseValue(resource.Metadata) : undefined,
+                condition: typeof resource.Condition === "string" ? resource.Condition : undefined,
+                ...(Object.keys(attributes).length > 0 ? { attributes } : {}),
+            };
+        });
+    }
+    /**
+     * Parse resource properties, handling intrinsic functions
+     */
+    parseProperties(props) {
+        const result = {};
+        for (const [key, value] of Object.entries(props)) {
+            result[key] = this.parseValue(value);
+        }
+        return result;
+    }
+    /**
+     * CFN-specific intrinsic dispatch table.
+     */
+    dispatchIntrinsic(key, value, _obj) {
+        // `{ "Condition": "<name>" }` — only valid inside the Conditions section
+        // (#2069); see parseConditions for the scoping.
+        if (key === "Condition" && this.inConditionExpression && typeof value === "string") {
+            return { __intrinsic: "ConditionRef", name: value };
+        }
+        if (key === "Ref") {
+            return { __intrinsic: "Ref", name: value };
+        }
+        if (key === "Fn::GetAtt") {
+            if (Array.isArray(value) && value.length === 2) {
+                return { __intrinsic: "GetAtt", logicalId: value[0], attribute: value[1] };
+            }
+            if (typeof value === "string" && value.indexOf(".") > 0) {
+                const dot = value.indexOf(".");
+                return { __intrinsic: "GetAtt", logicalId: value.slice(0, dot), attribute: value.slice(dot + 1) };
+            }
+        }
+        if (key === "Fn::Sub") {
+            if (typeof value === "string") {
+                return { __intrinsic: "Sub", template: value };
+            }
+            if (Array.isArray(value) && value.length >= 1) {
+                return { __intrinsic: "Sub", template: value[0], variables: value[1] };
+            }
+        }
+        if (key === "Fn::If") {
+            const ifValue = value;
+            return {
+                __intrinsic: "If",
+                condition: ifValue[0],
+                valueIfTrue: this.parseValue(ifValue[1]),
+                valueIfFalse: this.parseValue(ifValue[2]),
+            };
+        }
+        if (key === "Fn::Join") {
+            const joinValue = value;
+            const delimiter = joinValue[0];
+            const source = joinValue[1];
+            return {
+                __intrinsic: "Join",
+                delimiter,
+                values: Array.isArray(source)
+                    ? source.map((v) => this.parseValue(v))
+                    : [this.parseValue(source)],
+            };
+        }
+        if (key === "Fn::Select") {
+            // The index is kept as written (0 or "0"). A list source is `values`;
+            // anything else (a Ref to a list parameter, Fn::GetAZs, Fn::Split) is
+            // `source`, the list itself. Wrapping it in a list would select the
+            // list rather than an item of it.
+            const selectValue = value;
+            const index = selectValue[0];
+            const source = selectValue[1];
+            if (Array.isArray(source)) {
+                return {
+                    __intrinsic: "Select",
+                    index,
+                    values: source.map((v) => this.parseValue(v)),
+                };
+            }
+            return {
+                __intrinsic: "Select",
+                index,
+                source: this.parseValue(source),
+            };
+        }
+        if (key === "Fn::Split") {
+            const splitValue = value;
+            return {
+                __intrinsic: "Split",
+                delimiter: splitValue[0],
+                source: this.parseValue(splitValue[1]),
+            };
+        }
+        if (key === "Fn::Base64") {
+            return { __intrinsic: "Base64", value: this.parseValue(value) };
+        }
+        if (key === "Fn::FindInMap") {
+            const mapValue = value;
+            if (!Array.isArray(mapValue) || mapValue.length !== 3) {
+                throw new Error(`Fn::FindInMap takes [MapName, TopLevelKey, SecondLevelKey]; this one has ${JSON.stringify(value)} ` +
+                    "(a fourth DefaultValue argument needs AWS::LanguageExtensions, which import does not carry)");
+            }
+            return {
+                __intrinsic: "FindInMap",
+                mapName: this.parseValue(mapValue[0]),
+                firstKey: this.parseValue(mapValue[1]),
+                secondKey: this.parseValue(mapValue[2]),
+            };
+        }
+        if (key === "Fn::GetAZs") {
+            return { __intrinsic: "GetAZs", region: this.parseValue(value) };
+        }
+        if (key === "Fn::ImportValue") {
+            return { __intrinsic: "ImportValue", value: this.parseValue(value) };
+        }
+        if (key === "Fn::Cidr") {
+            const cidrValue = value;
+            return {
+                __intrinsic: "Cidr",
+                ipBlock: this.parseValue(cidrValue[0]),
+                count: this.parseValue(cidrValue[1]),
+                cidrBits: this.parseValue(cidrValue[2]),
+            };
+        }
+        if (key === "Fn::Transform") {
+            return { __intrinsic: "Transform", value };
+        }
+        if (key === "Fn::Equals") {
+            const eqValue = value;
+            return {
+                __intrinsic: "Equals",
+                left: this.parseValue(eqValue[0]),
+                right: this.parseValue(eqValue[1]),
+            };
+        }
+        if (key === "Fn::Not") {
+            const notValue = value;
+            return { __intrinsic: "Not", condition: this.parseValue(notValue[0]) };
+        }
+        if (key === "Fn::And") {
+            const andValue = value;
+            return { __intrinsic: "And", conditions: andValue.map((v) => this.parseValue(v)) };
+        }
+        if (key === "Fn::Or") {
+            const orValue = value;
+            return { __intrinsic: "Or", conditions: orValue.map((v) => this.parseValue(v)) };
+        }
+        return null;
+    }
+}
+/**
+ * Template sections import carries. Anything else is named in a warning
+ * rather than dropped silently (#2069).
+ */
+CFParser.CARRIED_SECTIONS = new Set([
+    "AWSTemplateFormatVersion",
+    "Description",
+    "Metadata",
+    "Mappings",
+    "Parameters",
+    "Conditions",
+    "Resources",
+    "Outputs",
+]);

package/dist/index.js

@@ -0,0 +1,69 @@
+// Parameter
+export { Parameter } from "./parameter.js";
+// Condition (#2068) — the Conditions-section declarable
+export { Condition, isCondition, CONDITION_ENTITY_TYPE } from "./condition.js";
+// Mapping — the Mappings-section declarable, read with FindInMap
+export { Mapping, isMapping, MAPPING_ENTITY_TYPE } from "./mapping.js";
+// Default Tags
+export { defaultTags, isDefaultTags, DEFAULT_TAGS_MARKER } from "./default-tags.js";
+export { templateTransform, isTemplateTransform, TEMPLATE_TRANSFORM_MARKER } from "./template-transform.js";
+export { templateDescription, templateMetadata, isTemplateSection, TEMPLATE_SECTION_MARKER } from "./template-sections.js";
+// Effect receipts (#1835, epic #1703): the aws materialization row
+// (`AWS::SSM::Parameter`, plain String, path derived from the ownership
+// marker) and the SSM-backed receipt store behind the `effect()` op step.
+export { EffectReceipt, receiptParameterName, AWS_EFFECT_RECEIPT_ENTITY_TYPE, EFFECT_RECEIPTS_METADATA_KEY, RECEIPT_PATH_PREFIX, RECEIPT_UNRESOLVED_VALUE_NOTE, } from "./effect-receipt-row.js";
+export { awsReceiptStore, observeReceiptRows, ssmGetParameter, ssmPutParameter } from "./receipt-store.js";
+// Typed Op step-builder wrappers (chant #1288 Stage 2) — awsApply/awsDelete/
+// flociUp/flociDown with authoring-time types derived from this lexicon's
+// own *Args interfaces (see ./op/builders.ts's module doc for why these live
+// here rather than in core). Opt-in: `@intentius/chant/op`'s same-named
+// exports are core's original untyped builders, unchanged, for
+// cloud-agnostic authoring.
+export { awsApply, awsDelete, flociUp, flociDown } from "./op/builders.js";
+// Serializer
+export { awsSerializer } from "./serializer.js";
+// Nested Stacks
+export { nestedStack, isNestedStackInstance, NestedStackOutputRef, isNestedStackOutputRef, NESTED_STACK_MARKER } from "./nested-stack.js";
+// Re-export core child project, stack output, and lexicon output primitives
+export { isChildProject, CHILD_PROJECT_MARKER } from "@intentius/chant/child-project";
+export { stackOutput, isStackOutput, STACK_OUTPUT_MARKER } from "@intentius/chant/stack-output";
+export { output, isLexiconOutput } from "@intentius/chant/lexicon-output";
+// Plugin
+export { awsPlugin } from "./plugin.js";
+// Deep observation (#1015): the Cloud Control reader and the noise rules it
+// shares with core's normalization pass.
+export { observeResourcesDeepAws, awsDeepNormalizationHooks, hasOwnershipMarker, DEEP_READABLE_TYPES, AWS_READ_ONLY_NAMES, AWS_SERVICE_DEFAULTS, } from "./deep-observe.js";
+// The native read transport (#1206) — the applier's own transport, pointed at
+// CloudFormation Query and Cloud Control. `parseCloudControlResource` used to
+// live in ./deep-observe and parsed AWS CLI stdout; the reader no longer speaks
+// that wire format, so `parseResourceDescription` (which takes the API's own
+// `ResourceDescription` object) replaces it.
+export { describeStackResources, describeStackOutputs, describeStackDetail, getResource, listResources, parseResourceDescription, resolveEndpointOverride, serviceEndpointEnvVar, AwsReadError, } from "./api/read-client.js";
+// SigV4 (#1686). Exported as its own surface because it is deliberately not
+// specific to this transport: cedar's AVP client is the next caller, and the
+// point of the module is that there is one signer rather than one per lexicon.
+export { signRequest, resolveCredentials, EMPTY_PAYLOAD_SHA256, } from "./api/sigv4.js";
+// Intrinsics
+export { Sub, Ref, GetAtt, If, Join, Select, Split, Base64, GetAZs, Equals, And, Or, Not, SubIntrinsic, RefIntrinsic, GetAttIntrinsic, IfIntrinsic, JoinIntrinsic, SelectIntrinsic, SplitIntrinsic, Base64Intrinsic, GetAZsIntrinsic, EqualsIntrinsic, AndIntrinsic, OrIntrinsic, NotIntrinsic, FindInMap, FindInMapIntrinsic, ImportValue, ImportValueIntrinsic, Cidr, CidrIntrinsic, } from "./intrinsics.js";
+// Pseudo-parameters
+export { AWS, StackName, Region, AccountId, StackId, URLSuffix, NoValue, NotificationARNs, Partition, } from "./pseudo.js";
+// Generated resources — export everything from generated index
+// After running `chant generate`, this re-exports all 1000+ resource classes
+export * from "./generated/index.js";
+// Spec utilities (for tooling)
+export { fetchSchemaZip } from "./spec/fetch.js";
+export { parseCFNSchema, cfnShortName, cfnServiceName } from "./spec/parse.js";
+// Action constants
+export { S3Actions, LambdaActions, DynamoDBActions, SQSActions, SNSActions, IAMActions, ECRActions, LogsActions, ECSActions } from "./actions/index.js";
+// Built-in composites
+export { LambdaFunction, LambdaNode, LambdaPython, NodeLambda, PythonLambda, LambdaApi, LambdaScheduled, ScheduledLambda, LambdaSqs, LambdaEventBridge, LambdaDynamoDB, DynamoDBTable, EcrRepository, LambdaS3, LambdaSns, VpcDefault, FargateAlb, AlbShared, FargateService, FARGATE_SERVICE_LIMITS, NlbService, RdsInstance, RdsPostgres, EfsWithAccessPoint, Ec2InstanceRole, Ec2InstanceBundle, MinimalVpc, EksCluster, SolrFargateService, MicrovmApp, MICROVM_LIMITS, AgentCoreAgent, agentCoreDefaultEndpointArn, AGENTCORE_LIMITS, OrganizationRoot, GovernanceFoundation, RegionRestriction, OrganizationTrail, StepFunctionsWorkflow, MonitoringStack, BucketDeployment, } from "./composites/index.js";
+// Code generation pipeline
+export { generate, writeGeneratedFiles } from "./codegen/generate.js";
+export { packageLexicon } from "./codegen/package.js";
+// Component/release capabilities — the AWS operational leaves (cfn-deploy,
+// emr-*, code-deploy, …) contributed to core's capability-plugin seam. Core
+// loads `awsCapabilityPlugin` when a project's chant.config lists this lexicon.
+export { awsCapabilityPlugin } from "./components/capability-plugin.js";
+// AWS governance authoring: the desired-state config the AWS cloud
+// external governance reconciler applies, and the typed landing-zone authoring layer.
+export { landingZoneConfig, regionRestriction, DENY_AUDIT_TAMPER, DENY_LEAVE_ORGANIZATION, FOUNDATION_OUS } from "./governance.js";

package/dist/integrity.json

@@ -1,21 +1,21 @@
 {
   "algorithm": "sha256",
   "artifacts": {
-    "manifest.json": "502f22cebb774a0c8040aca0704aa28c48ae9cfabf7db99ba28e4c28e56b691e",
-    "meta.json": "435429f998bf94568544f01780e35c28b73e7d030520d59d4025867d272cdb75",
-    "types/index.d.ts": "9e99bb26113f101eb7073759e1b02b8d06aac73379254a64a5e492d52506156c",
+    "manifest.json": "0ee5d3480fac8e9a938968dd5ddcc859a7e84cafa9bea700cedfa550dd4ef346",
+    "meta.json": "3e18663eb9eb09920882f8014020432330a74ccd480689e7384c2022cbb10f39",
+    "types/index.d.ts": "8651f9ae166668f4311eea1fe61c3fe235f345947951c1d23d1df24a4fd3384f",
     "rules/hardcoded-region.ts": "957eadcaa9f39cc17d21437565d7a94607d9b082cf28918b178fa067f07498a9",
     "rules/iam-wildcard.ts": "10f5065fa2bbf2c8ce23dfb475a56df33f280df87784e44fec641b2584cbf333",
     "rules/s3-encryption.ts": "6611f3977d40314c31e6d4af99829a25ea71a529a6dfcaff425549c8aa54c29a",
     "rules/cf-refs.ts": "3fa8d144e430ae00204b159f1c8c5bf78576c52f984cc4f656eb366d7423f819",
     "rules/cor020.ts": "915bbb4c083c7b3b84b93e8e891b5ffffe5a138fdccda32ecfdda91b8685798c",
-    "rules/ext001.ts": "f8703f37a50ab23d0ecaef539c0215a71269d420fa5e09a3d0454b18b7350b34",
+    "rules/ext001.ts": "0d2ae9710dc5fc47478e38387764a7c6b4c7e79fa5e695d6282d5fc27d47aaa4",
     "rules/waw010.ts": "41c58aaedb8f9fe266f4b40f1a076f762796427fdf9b317b8a4a50c713e45571",
     "rules/waw011.ts": "fda06d63b71c37324dd23d519c2430c25d5fcb39a71eeed69caa76665dcae50d",
     "rules/waw013.ts": "f9b37b955917415a2eb5f4aed7f28b76aff0a6abdb05228dcbb8bc77bc67672a",
     "rules/waw014.ts": "889f1b06899b50f98941d05b029954cf375ac8a130933b98c9586079096216aa",
     "rules/waw015.ts": "071c940fb6432cd8b42a44d083921e9491d5063417839109c10b2bd13dd2032e",
-    "rules/waw016.ts": "b9538a9c44a58b687a08f74328caecba4236ad3c24c97759e6d69a3b9ce487c0",
+    "rules/waw016.ts": "2c4e230c98056a03ecdbfa0e408e36a31733e83cc96419910ae3ec9fd4b7fd9e",
     "rules/waw017.ts": "658554008954f71036e23b514dece7063142198fbdca125f11d09026f1d21ab2",
     "rules/waw018.ts": "a4aa83a25104f039a6c5e0f3e1f5b8b65e493b0ba162c985988190a726b90d2f",
     "rules/waw019.ts": "f14ebf024a3cce7005d54c762e4e0979537d6a854fb123344107d40d92a94b5c",
@@ -73,5 +73,5 @@
     "skills/chant-aws-eks.md": "8789255709ff004ad0a875fd5999edcdc66fc6e33d710db058d9f42703bcfdfe",
     "skills/chant-aws-carve-terraform.md": "8780b94ce60aded935938d5ef20ea667738354051da1bf9ca6d70d9886f65d21"
   },
-  "composite": "fb5b3c087f041ae538219ec50c7e0fcac77f1cf7e962b6ae9f110805cef39305"
+  "composite": "183d8f9b49de872c352a4daa986b8710ef256e152f04bea4d3b805515c53f657"
 }