@intentius/chant-lexicon-azure 0.124.31 → 0.124.33

package/dist/serializer.d.ts

@@ -9,6 +9,7 @@
  * - ARM bracket expression references
  * - parameters, outputs sections
  */
+import type { Declarable } from "@intentius/chant/declarable";
 import type { Serializer } from "@intentius/chant/serializer";
 export declare function apiVersionRegistryCandidates(dir?: string): string[];
 export declare function loadApiVersions(candidates?: string[]): Map<string, string>;
@@ -24,6 +25,12 @@ export declare function resetApiVersionCache(): void;
  */
 export declare function lookupApiVersion(resourceType: string): string | undefined;
 export declare function getApiVersion(resourceType: string): string;
+/**
+ * An attribute of an export. `id` is `resourceId()`, since `reference()`
+ * returns the resource's properties and they have no `id`; anything else
+ * reads `reference()` by the ARM name.
+ */
+export declare function armAttrExpression(entityNames: Map<Declarable, string>, name: string, attr: string): string;
 /**
  * Azure ARM template serializer implementation.
  */

package/dist/serializer.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"serializer.d.ts","sourceRoot":"","sources":["../src/serializer.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;GAUG;AAIH,OAAO,KAAK,EAAE,UAAU,EAAsC,MAAM,6BAA6B,CAAC;AA8ElG,wBAAgB,4BAA4B,CAAC,GAAG,GAAE,MAAqB,GAAG,MAAM,EAAE,CAKjF;AAED,wBAAgB,eAAe,CAAC,UAAU,GAAE,MAAM,EAAmC,GAAG,GAAG,CAAC,MAAM,EAAE,MAAM,CAAC,CAwB1G;AAcD,yEAAyE;AACzE,wBAAgB,oBAAoB,IAAI,IAAI,CAE3C;AAED;;;;;;;GAOG;AACH,wBAAgB,gBAAgB,CAAC,YAAY,EAAE,MAAM,GAAG,MAAM,GAAG,SAAS,CAWzE;AAED,wBAAgB,aAAa,CAAC,YAAY,EAAE,MAAM,GAAG,MAAM,CAO1D;AA2TD;;GAEG;AACH,eAAO,MAAM,eAAe,EAAE,UA0C7B,CAAC"}
+{"version":3,"file":"serializer.d.ts","sourceRoot":"","sources":["../src/serializer.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;GAUG;AAEH,OAAO,KAAK,EAAE,UAAU,EAAiB,MAAM,6BAA6B,CAAC;AAE7E,OAAO,KAAK,EAAE,UAAU,EAAsC,MAAM,6BAA6B,CAAC;AA8ElG,wBAAgB,4BAA4B,CAAC,GAAG,GAAE,MAAqB,GAAG,MAAM,EAAE,CAKjF;AAED,wBAAgB,eAAe,CAAC,UAAU,GAAE,MAAM,EAAmC,GAAG,GAAG,CAAC,MAAM,EAAE,MAAM,CAAC,CAwB1G;AAcD,yEAAyE;AACzE,wBAAgB,oBAAoB,IAAI,IAAI,CAE3C;AAED;;;;;;;GAOG;AACH,wBAAgB,gBAAgB,CAAC,YAAY,EAAE,MAAM,GAAG,MAAM,GAAG,SAAS,CAWzE;AAED,wBAAgB,aAAa,CAAC,YAAY,EAAE,MAAM,GAAG,MAAM,CAO1D;AA6BD;;;;GAIG;AACH,wBAAgB,iBAAiB,CAAC,WAAW,EAAE,GAAG,CAAC,UAAU,EAAE,MAAM,CAAC,EAAE,IAAI,EAAE,MAAM,EAAE,IAAI,EAAE,MAAM,GAAG,MAAM,CAK1G;AAiWD;;GAEG;AACH,eAAO,MAAM,eAAe,EAAE,UA+C7B,CAAC"}

package/dist/serializer.js

@@ -0,0 +1,543 @@
+/**
+ * Azure Resource Manager template serializer.
+ *
+ * Converts Declarable entities into ARM template JSON with:
+ * - resources[] array (not keyed by logical name like CloudFormation)
+ * - apiVersion per resource (from lexicon registry)
+ * - Resource-level fields (sku, kind, identity, tags, zones, plan, location)
+ *   hoisted from properties
+ * - ARM bracket expression references
+ * - parameters, outputs sections
+ */
+import { isPropertyDeclarable, isResourceDeclarable } from "@intentius/chant/declarable";
+import { ownershipEntries } from "@intentius/chant/ownership";
+import { AZURE_TAG_OWNERSHIP_KEYS } from "./ownership.js";
+import { walkValue } from "@intentius/chant/serializer-walker";
+import { isChildProject } from "@intentius/chant/child-project";
+import { existsSync, readFileSync } from "fs";
+import { join } from "path";
+import { moduleSourceDir } from "@intentius/chant/module-source";
+import { isStackOutput } from "@intentius/chant/stack-output";
+import { isAttrRefLike } from "@intentius/chant/utils";
+import { resolveDependsOn } from "@intentius/chant/resource-attributes";
+import { isDefaultTags } from "./default-tags.js";
+import { loadTaggableResources } from "./taggable.js";
+import { findArmResourceRefs } from "./lint/post-synth/arm-refs.js";
+import { isDeploymentScope, resolveTemplateScope, TEMPLATE_SCHEMAS } from "./deploy-scopes.js";
+/** Check if a declarable is a CoreParameter */
+function isCoreParameter(entity) {
+    return "parameterType" in entity;
+}
+/** Resource-level fields that get hoisted from properties to resource level. */
+const RESOURCE_LEVEL_FIELDS = new Set([
+    "location", "tags", "sku", "kind", "identity", "zones", "plan",
+]);
+/**
+ * Load apiVersion for a resource type from the lexicon registry.
+ *
+ * Reads the generated registry (src/generated/lexicon-azure.json in a dev
+ * checkout, dist/meta.json in the installed package). Resolves the package
+ * directory from import.meta.url so it works under pure ESM as well as
+ * tsx/vitest — the old `require()`-based resolver threw under ESM and the
+ * throw was swallowed, so every resource emitted the fallback apiVersion
+ * (#1581). A missing registry is now an error: a uniform fallback apiVersion
+ * silently bypasses the per-provider pins in spec/api-versions.ts.
+ */
+function resolveDir() {
+    return moduleSourceDir(import.meta.url);
+}
+export function apiVersionRegistryCandidates(dir = resolveDir()) {
+    return [
+        join(dir, "generated", "lexicon-azure.json"),
+        join(dir, "..", "dist", "meta.json"),
+    ];
+}
+export function loadApiVersions(candidates = apiVersionRegistryCandidates()) {
+    const map = new Map();
+    let content;
+    for (const candidate of candidates) {
+        if (!existsSync(candidate))
+            continue;
+        content = readFileSync(candidate, "utf-8");
+        break;
+    }
+    if (content === undefined) {
+        throw new Error(`azure: apiVersion registry not found (tried ${candidates.join(", ")}). ` +
+            "Run `npm run generate` (dev) or reinstall the package (dist/meta.json).");
+    }
+    const data = JSON.parse(content);
+    for (const entry of Object.values(data)) {
+        if (entry.apiVersion && entry.resourceType) {
+            map.set(entry.resourceType, entry.apiVersion);
+        }
+    }
+    if (map.size === 0) {
+        throw new Error("azure: apiVersion registry is empty — regenerate with `npm run generate`");
+    }
+    return map;
+}
+/**
+ * Override stale apiVersions from the generated registry.
+ * These are resource types where the registry apiVersion is known to be
+ * too old for modern ARM features (e.g. DataActions on role assignments).
+ */
+const API_VERSION_OVERRIDES = new Map([
+    ["Microsoft.Authorization/roleAssignments", "2022-04-01"],
+    ["Microsoft.Authorization/roleDefinitions", "2022-04-01"],
+]);
+let _apiVersions;
+/** Test hook: drop the cached registry so the next lookup reloads it. */
+export function resetApiVersionCache() {
+    _apiVersions = undefined;
+}
+/**
+ * Registry lookup without the serializer's fallback: the pinned apiVersion for
+ * `resourceType`, or `undefined` when neither the overrides nor the generated
+ * registry know the type. ARM resource types are case-insensitive and the live
+ * listing does not always echo the casing the registry uses, so the match is
+ * case-insensitive too. Used by prune (#1472), which needs an apiVersion for a
+ * type the current template no longer declares.
+ */
+export function lookupApiVersion(resourceType) {
+    const override = API_VERSION_OVERRIDES.get(resourceType);
+    if (override)
+        return override;
+    if (!_apiVersions)
+        _apiVersions = loadApiVersions();
+    const exact = _apiVersions.get(resourceType);
+    if (exact)
+        return exact;
+    const wanted = resourceType.toLowerCase();
+    for (const [type, version] of _apiVersions) {
+        if (type.toLowerCase() === wanted)
+            return version;
+    }
+    return undefined;
+}
+export function getApiVersion(resourceType) {
+    const version = lookupApiVersion(resourceType);
+    if (version)
+        return version;
+    console.warn(`azure: no pinned apiVersion for ${resourceType} in the lexicon registry; falling back to 2023-01-01`);
+    return "2023-01-01";
+}
+/**
+ * The ARM name of a chant export, as the arguments an ARM function takes
+ * (#4183). A resource's `name` prop is its ARM name, and the export name is
+ * used only when it has none. A literal name is quoted, one argument per
+ * segment of a child's `parent/child` name; a bracket expression such as
+ * `[parameters('n')]` is passed unwrapped.
+ */
+function armNameArgs(entity, exportName) {
+    const props = entity && isResourceDeclarable(entity) && typeof entity.props === "object" && entity.props !== null
+        ? entity.props
+        : undefined;
+    const name = typeof props?.name === "string" ? props.name : exportName;
+    if (name.startsWith("[") && name.endsWith("]"))
+        return { args: name.slice(1, -1), literal: null };
+    return { args: name.split("/").map((seg) => `'${seg}'`).join(", "), literal: name };
+}
+function entityNamed(entityNames, name) {
+    return [...entityNames.entries()].find(([, n]) => n === name)?.[0];
+}
+/** `resourceId(...)` for an export: the type and its ARM name. */
+function armResourceId(entityNames, name) {
+    const entity = entityNamed(entityNames, name);
+    const { args } = armNameArgs(entity, name);
+    return entity ? `resourceId('${entity.entityType}', ${args})` : `resourceId(${args})`;
+}
+/**
+ * An attribute of an export. `id` is `resourceId()`, since `reference()`
+ * returns the resource's properties and they have no `id`; anything else
+ * reads `reference()` by the ARM name.
+ */
+export function armAttrExpression(entityNames, name, attr) {
+    if (attr === "id")
+        return `[${armResourceId(entityNames, name)}]`;
+    const { args, literal } = armNameArgs(entityNamed(entityNames, name), name);
+    const target = literal !== null && !literal.includes("/") ? args : armResourceId(entityNames, name);
+    return `[reference(${target}).${attr}]`;
+}
+/**
+ * ARM-specific visitor for the generic serializer walker.
+ */
+function armVisitor(entityNames) {
+    return {
+        attrRef: (name, attr) => armAttrExpression(entityNames, name, attr),
+        resourceRef: (name) => `[${armResourceId(entityNames, name)}]`,
+        propertyDeclarable: (entity, walk) => {
+            if (!isResourceDeclarable(entity) || typeof entity.props !== "object" || entity.props === null) {
+                return undefined;
+            }
+            const props = entity.props;
+            const armProps = {};
+            for (const [key, value] of Object.entries(props)) {
+                if (value !== undefined) {
+                    armProps[key] = walk(value);
+                }
+            }
+            return Object.keys(armProps).length > 0 ? armProps : undefined;
+        },
+    };
+}
+/**
+ * Convert a value to ARM-compatible JSON using the generic walker.
+ */
+/** An ARM output for a literal, or for an azure intrinsic's `[...]` expression. */
+function armOutputValue(value) {
+    if (typeof value === "string")
+        return { type: "string", value };
+    if (typeof value === "number" && Number.isInteger(value))
+        return { type: "int", value };
+    if (typeof value === "boolean")
+        return { type: "bool", value };
+    return undefined;
+}
+function isIntrinsicLike(value) {
+    return typeof value === "object" && value !== null && typeof value.toJSON === "function";
+}
+function isCloudFormationShaped(value) {
+    if (typeof value !== "object" || value === null || Array.isArray(value))
+        return false;
+    const keys = Object.keys(value);
+    return keys.length === 1 && (keys[0] === "Ref" || keys[0].startsWith("Fn::"));
+}
+function isPlainObject(value) {
+    if (value === null || typeof value !== "object" || Array.isArray(value))
+        return false;
+    const proto = Object.getPrototypeOf(value);
+    return proto === Object.prototype || proto === null;
+}
+function toArmValue(value, entityNames) {
+    return walkValue(value, entityNames, armVisitor(entityNames));
+}
+/**
+ * Serialize entities into an ARM template object.
+ */
+function serializeToTemplate(entities, outputs, ownership, warnings = []) {
+    // Resolve the deployment scope from the resource types being emitted
+    // (#1545): a template of tenant-only resources (management groups, policy
+    // definitions at management-group scope, ...) must carry the matching
+    // $schema and must not lean on resourceGroup() expressions. Mixed sets
+    // with no common scope fall back to resource-group scope and AZR030
+    // reports the resources that cannot deploy there. A deploymentScope()
+    // pin overrides the inference — policy definitions and assignments
+    // deploy at several scopes, so a management-group guardrail project
+    // cannot be told from a subscription one by its resource set alone
+    //; AZR030 still flags resources the pinned scope cannot hold.
+    let pinnedScope;
+    const emittedTypes = [];
+    for (const [, entity] of entities) {
+        if (isStackOutput(entity) || isDefaultTags(entity) || isCoreParameter(entity))
+            continue;
+        if (isDeploymentScope(entity)) {
+            pinnedScope ?? (pinnedScope = entity.scope);
+        }
+        else if (isChildProject(entity)) {
+            emittedTypes.push("Microsoft.Resources/deployments");
+        }
+        else if (!isPropertyDeclarable(entity)) {
+            emittedTypes.push(entity.entityType);
+        }
+    }
+    const templateScope = pinnedScope ?? resolveTemplateScope(emittedTypes);
+    const template = {
+        $schema: TEMPLATE_SCHEMAS[templateScope],
+        contentVersion: "1.0.0.0",
+        resources: [],
+    };
+    // Build reverse map: entity -> name
+    const entityNames = new Map();
+    for (const [name, entity] of entities) {
+        entityNames.set(entity, name);
+    }
+    // Collect default tags. The ownership marker is stamped as tags, seeded
+    // first so user default tags (and explicit per-resource tags) win.
+    const defaultTagEntries = [];
+    if (ownership) {
+        for (const [key, value] of Object.entries(ownershipEntries(AZURE_TAG_OWNERSHIP_KEYS, ownership))) {
+            defaultTagEntries.push({ key, value });
+        }
+    }
+    for (const [, entity] of entities) {
+        if (isDefaultTags(entity)) {
+            defaultTagEntries.push(...entity.tags);
+        }
+    }
+    // Process entities
+    for (const [name, entity] of entities) {
+        // Skip non-resource types
+        if (isStackOutput(entity) || isDefaultTags(entity) || isDeploymentScope(entity))
+            continue;
+        if (isCoreParameter(entity)) {
+            if (!template.parameters)
+                template.parameters = {};
+            const param = {
+                type: mapParameterType(entity.parameterType),
+            };
+            if ("description" in entity && typeof entity.description === "string") {
+                param.metadata = { description: entity.description };
+            }
+            if ("defaultValue" in entity && entity.defaultValue !== undefined) {
+                param.defaultValue = entity.defaultValue;
+            }
+            template.parameters[name] = param;
+        }
+        else if (isChildProject(entity)) {
+            // ChildProjectInstance → linked deployment
+            const childProject = entity;
+            const childName = childProject.logicalName;
+            const filename = `${childName}.template.json`;
+            const resource = {
+                type: "Microsoft.Resources/deployments",
+                apiVersion: "2021-04-01",
+                name: childName,
+                properties: {
+                    mode: "Incremental",
+                    templateLink: { uri: filename },
+                },
+            };
+            template.resources.push(resource);
+        }
+        else if (!isPropertyDeclarable(entity)) {
+            const resourceType = entity.entityType;
+            // Prefer apiVersion from entity attributes (set by composites) over registry lookup
+            const attrs0 = (isResourceDeclarable(entity) && typeof entity.attributes === "object" && entity.attributes !== null)
+                ? entity.attributes
+                : undefined;
+            const apiVersion = (typeof attrs0?.apiVersion === "string") ? attrs0.apiVersion : getApiVersion(resourceType);
+            const resource = {
+                type: resourceType,
+                apiVersion,
+                name: name,
+            };
+            // Extract all props
+            if (isResourceDeclarable(entity) && typeof entity.props === "object" && entity.props !== null) {
+                const props = entity.props;
+                const armProperties = {};
+                for (const [key, value] of Object.entries(props)) {
+                    if (value === undefined)
+                        continue;
+                    if (RESOURCE_LEVEL_FIELDS.has(key)) {
+                        // Hoist to resource level
+                        resource[key] = toArmValue(value, entityNames);
+                    }
+                    else if (key === "name") {
+                        resource.name = toArmValue(value, entityNames);
+                    }
+                    else if (key === "properties" && isPlainObject(value)) {
+                        // The generated types take ARM's own `properties` object, so
+                        // merge it, not nest it (#4183).
+                        for (const [inner, innerValue] of Object.entries(value)) {
+                            if (innerValue !== undefined)
+                                armProperties[inner] = toArmValue(innerValue, entityNames);
+                        }
+                    }
+                    else {
+                        armProperties[key] = toArmValue(value, entityNames);
+                    }
+                }
+                if (Object.keys(armProperties).length > 0) {
+                    resource.properties = armProperties;
+                }
+            }
+            // Default location to resource group location if not specified.
+            // Above resource-group scope there is no resource group to read a
+            // location from, and the scoped resources (management groups, policy
+            // definitions, ...) have no location field at all (#1545).
+            if (!resource.location && templateScope === "resourceGroup") {
+                resource.location = "[resourceGroup().location]";
+            }
+            // Handle DependsOn
+            const attrs = (isResourceDeclarable(entity) && typeof entity.attributes === "object" && entity.attributes !== null)
+                ? entity.attributes
+                : undefined;
+            if (attrs?.DependsOn !== undefined) {
+                const resolved = resolveDependsOn(attrs.DependsOn, entityNames, name);
+                if (resolved.length > 0) {
+                    resource.dependsOn = resolved.map((dep) => entityNamed(entityNames, dep) ? `[${armResourceId(entityNames, dep)}]` : dep);
+                }
+            }
+            template.resources.push(resource);
+        }
+    }
+    // Inject default tags into taggable resources
+    if (defaultTagEntries.length > 0) {
+        const taggable = loadTaggableResources();
+        for (const resource of template.resources) {
+            if (!taggable.has(resource.type))
+                continue;
+            const resolved = {};
+            for (const t of defaultTagEntries) {
+                resolved[t.key] = toArmValue(t.value, entityNames);
+            }
+            const existing = resource.tags ?? {};
+            // Explicit tags take precedence
+            resource.tags = { ...resolved, ...existing };
+        }
+    }
+    // Auto-infer dependsOn from resourceId()/reference() expressions in properties.
+    // ARM only auto-infers dependencies from reference(), not resourceId().
+    const resourceNameSet = new Set(template.resources.map((r) => r.name));
+    for (const resource of template.resources) {
+        const refs = findArmResourceRefs(resource.properties);
+        // Also scan resource-level fields (location, tags, identity, etc.)
+        for (const field of RESOURCE_LEVEL_FIELDS) {
+            const val = resource[field];
+            if (val !== undefined) {
+                for (const ref of findArmResourceRefs(val)) {
+                    refs.add(ref);
+                }
+            }
+        }
+        // Also scan the name field for parent references (e.g. "vnet/subnet")
+        if (typeof resource.name === "string") {
+            for (const ref of findArmResourceRefs(resource.name)) {
+                refs.add(ref);
+            }
+        }
+        // Infer parent dependency for child resources (e.g. "vnet/subnet" depends on "vnet")
+        if (typeof resource.name === "string" && resource.name.includes("/")) {
+            const parentName = resource.name.split("/")[0];
+            if (resourceNameSet.has(parentName)) {
+                refs.add(parentName);
+            }
+        }
+        if (refs.size > 0) {
+            const existing = new Set(resource.dependsOn ?? []);
+            for (const refName of refs) {
+                // Only add if the referenced resource exists in this template and isn't self
+                if (refName === resource.name)
+                    continue;
+                if (!resourceNameSet.has(refName))
+                    continue;
+                // Find the resource to build the resourceId expression
+                const depResource = template.resources.find((r) => r.name === refName);
+                if (depResource) {
+                    const depExpr = `[resourceId('${depResource.type}', ${refName.split("/").map((seg) => `'${seg}'`).join(", ")})]`;
+                    if (!existing.has(depExpr)) {
+                        existing.add(depExpr);
+                    }
+                }
+            }
+            if (existing.size > 0) {
+                resource.dependsOn = [...existing];
+            }
+        }
+    }
+    // Emit StackOutput entities as ARM outputs
+    for (const [name, entity] of entities) {
+        if (isStackOutput(entity)) {
+            if (!template.outputs)
+                template.outputs = {};
+            const stackOutput = entity;
+            // `unknown` so isAttrRefLike narrows cleanly across the workspace/published
+            // type boundary.
+            const ref = stackOutput.sourceRef;
+            if (isAttrRefLike(ref)) {
+                const logicalName = ref.getLogicalName();
+                if (logicalName) {
+                    template.outputs[name] = {
+                        type: "string",
+                        value: armAttrExpression(entityNames, logicalName, ref.attribute),
+                    };
+                }
+            }
+            else {
+                const value = armOutputValue(isIntrinsicLike(ref) ? ref.toJSON() : ref);
+                if (value)
+                    template.outputs[name] = value;
+                else
+                    warnings.push(`azure: stack output "${name}" is not written: its value has no ARM form.`);
+            }
+        }
+    }
+    // Add LexiconOutputs
+    if (outputs && outputs.length > 0) {
+        template.outputs = template.outputs ?? {};
+        for (const output of outputs) {
+            if (output.sourceAttribute !== null) {
+                if (output.sourceEntity) {
+                    template.outputs[output.outputName] = {
+                        type: "string",
+                        value: armAttrExpression(entityNames, output.sourceEntity, output.sourceAttribute),
+                    };
+                }
+                else {
+                    warnings.push(`azure: output "${output.outputName}" is not written: its resource has no name in this build.`);
+                }
+                continue;
+            }
+            // A literal or an intrinsic (#4181). It has no source lexicon, so every
+            // lexicon receives it; a CloudFormation-shaped value is aws's to write.
+            const raw = output.getOutputValue();
+            const value = armOutputValue(raw);
+            if (value)
+                template.outputs[output.outputName] = value;
+            else if (!isCloudFormationShaped(raw)) {
+                warnings.push(`azure: output "${output.outputName}" is not written: its value has no ARM form.`);
+            }
+        }
+        if (Object.keys(template.outputs).length === 0)
+            delete template.outputs;
+    }
+    return template;
+}
+/**
+ * Map chant parameter types to ARM parameter types.
+ */
+function mapParameterType(paramType) {
+    switch (paramType) {
+        case "String": return "string";
+        case "Number": return "int";
+        case "CommaDelimitedList": return "array";
+        default: return "string";
+    }
+}
+/**
+ * Azure ARM template serializer implementation.
+ */
+export const azureSerializer = {
+    name: "azure",
+    rulePrefix: "AZR",
+    serialize(entities, outputs, context) {
+        // Check for child projects (linked templates)
+        let hasChildProjects = false;
+        const allFiles = {};
+        for (const [, entity] of entities) {
+            if (isChildProject(entity)) {
+                hasChildProjects = true;
+                const childProject = entity;
+                if (childProject.buildResult) {
+                    const childOutput = childProject.buildResult.outputs.get("azure");
+                    if (childOutput) {
+                        const childName = childProject.logicalName;
+                        const filename = `${childName}.template.json`;
+                        if (typeof childOutput === "string") {
+                            allFiles[filename] = childOutput;
+                        }
+                        else {
+                            allFiles[filename] = childOutput.primary;
+                            if (childOutput.files) {
+                                for (const [f, c] of Object.entries(childOutput.files)) {
+                                    allFiles[f] = c;
+                                }
+                            }
+                        }
+                    }
+                }
+            }
+        }
+        const warnings = [];
+        const template = serializeToTemplate(entities, outputs, context?.ownership, warnings);
+        const primary = JSON.stringify(template, null, 2);
+        if (!hasChildProjects && warnings.length === 0) {
+            return primary;
+        }
+        return {
+            primary,
+            ...(hasChildProjects ? { files: allFiles } : {}),
+            ...(warnings.length > 0 ? { warnings } : {}),
+        };
+    },
+};