@sitecoreai-labs/sitecoreai-cli 0.0.4

package/dist/recipe/compile/shared.js

@@ -0,0 +1,843 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.ensureEnumerationTemplates = exports.ensureContentModelsGroupFolder = exports.ensureRenderingsSectionFolder = exports.ensurePresentationParametersBucket = exports.ensureComponentFoldersBucket = exports.ensureSectionFolder = exports.resolveRenderingParent = exports.resolvePresentationParametersBucketPath = exports.resolveComponentFoldersBucketPath = exports.resolveComponentTemplateParent = exports.resolveEnumFolderPath = exports.siteOf = exports.joinPath = exports.PRESENTATION_PARAMETERS_BUCKET = exports.COMPONENT_FOLDERS_BUCKET = exports.DEFAULT_FIELDS_SECTION = exports.PARAMS_SECTION_NAME = void 0;
+exports.sharedField = sharedField;
+exports.versionedField = versionedField;
+exports.emitDatasourceTemplate = emitDatasourceTemplate;
+exports.buildFieldOp = buildFieldOp;
+exports.buildStandardValuesFieldEntries = buildStandardValuesFieldEntries;
+const guids_1 = require("../guids");
+const errors_1 = require("../../shared/errors");
+const sitecore_templates_1 = require("../ir/sitecore-templates");
+const field_types_1 = require("../schema/field-types");
+const source_fields_1 = require("../schema/source-fields");
+exports.PARAMS_SECTION_NAME = "Parameters";
+exports.DEFAULT_FIELDS_SECTION = "Content";
+exports.COMPONENT_FOLDERS_BUCKET = "Component Folders";
+exports.PRESENTATION_PARAMETERS_BUCKET = "Presentation Parameters";
+const joinPath = (parent, name) => {
+    const trimmed = parent.endsWith("/") ? parent.slice(0, -1) : parent;
+    return `${trimmed}/${name}`;
+};
+exports.joinPath = joinPath;
+/** Site name for deterministic folder refKeys. */
+const siteOf = (context) => context.site ?? "default";
+exports.siteOf = siteOf;
+/**
+ * Resolve a `sitecore.enumHandle` reference to the tenant content path
+ * the enumeration's folder lives at. Used by `resolveFieldSource` to
+ * emit Droplink Source values as content paths (the form SXA Headless's
+ * rendering parameter dialog accepts) rather than `{GUID}` references.
+ *
+ * Path shape:
+ *   - With `location.folder` set →
+ *     `<enumerationsRoot>/<folder>/<enum.name>`.
+ *   - Without `location.folder` → `<enumerationsRoot>/<enum.name>` (flat).
+ *
+ * Throws INPUT_INVALID when the enum handle isn't in the recipe set
+ * (author error: `sitecore.enumHandle` references something that
+ * doesn't exist), or when `enumerationsRoot` is unset on the context.
+ */
+const resolveEnumFolderPath = (context, enumHandle, consumerHandle) => {
+    if (!context.enumerationsRoot) {
+        throw (0, errors_1.createCliError)(`Recipe '${consumerHandle}' references sitecore.enumHandle='${enumHandle}' but no enumerationsRoot is configured.`, "INPUT_INVALID", {
+            hint: "Set `enumerationsRoot` on the active envProfile in sitecoreai.cli.json.",
+        });
+    }
+    const enumRecipe = context.enumsByHandle?.get(enumHandle);
+    if (!enumRecipe) {
+        throw (0, errors_1.createCliError)(`Recipe '${consumerHandle}' references sitecore.enumHandle='${enumHandle}' but no EnumerationRecipe with that handle is in the set.`, "INPUT_INVALID", {
+            hint: "Add an `EnumerationRecipe` (kind: 'enumeration') with the matching handle to the recipe set, or change the field's `sitecore.enumHandle` to point at an existing one.",
+        });
+    }
+    const folder = enumRecipe.location?.folder;
+    return folder
+        ? (0, exports.joinPath)((0, exports.joinPath)(context.enumerationsRoot, folder), enumRecipe.name)
+        : (0, exports.joinPath)(context.enumerationsRoot, enumRecipe.name);
+};
+exports.resolveEnumFolderPath = resolveEnumFolderPath;
+function sharedField(fieldGuid, value) {
+    return { fieldId: fieldGuid, value };
+}
+function versionedField(fieldGuid, value) {
+    return {
+        fieldId: fieldGuid,
+        language: sitecore_templates_1.DEFAULT_LANGUAGE,
+        version: sitecore_templates_1.DEFAULT_VERSION,
+        value,
+    };
+}
+/**
+ * Resolve the parent path under which a `ComponentTemplateRecipe`'s
+ * template item lands.
+ *
+ *   - With section + componentsRoot → `<componentsRoot>/<section>` (new layout).
+ *   - With section only → `<templatesRoot>/<section>` (mid-migration fallback).
+ *   - Without section → `<templatesRoot>` (legacy flat layout).
+ */
+const resolveComponentTemplateParent = (context, section) => {
+    if (section) {
+        if (context.componentsRoot) {
+            return (0, exports.joinPath)(context.componentsRoot, section);
+        }
+        return (0, exports.joinPath)(context.templatesRoot, section);
+    }
+    return context.templatesRoot;
+};
+exports.resolveComponentTemplateParent = resolveComponentTemplateParent;
+/**
+ * Resolve the parent path for a Component Folder template — the
+ * `<Component> Folder` items emitted when a recipe declares
+ * `children:`. Always nested under
+ * `<sectionRoot>/Component Folders/`.
+ */
+const resolveComponentFoldersBucketPath = (context, section) => (0, exports.joinPath)((0, exports.resolveComponentTemplateParent)(context, section), exports.COMPONENT_FOLDERS_BUCKET);
+exports.resolveComponentFoldersBucketPath = resolveComponentFoldersBucketPath;
+/**
+ * Resolve the parent path for a Presentation Parameters template —
+ * `<sectionRoot>/Presentation Parameters/`. When the recipe lacks a
+ * section (legacy callers), parameters templates land directly under
+ * `templatesRoot` to match the old flat layout.
+ */
+const resolvePresentationParametersBucketPath = (context, section) => {
+    if (!section) {
+        return context.templatesRoot;
+    }
+    return (0, exports.joinPath)((0, exports.resolveComponentTemplateParent)(context, section), exports.PRESENTATION_PARAMETERS_BUCKET);
+};
+exports.resolvePresentationParametersBucketPath = resolvePresentationParametersBucketPath;
+/**
+ * Resolve the parent path for the rendering item.
+ *
+ *   - With section → `<renderingsRoot>/<section>/<Component>`.
+ *   - Without → legacy flat `<renderingsRoot>/<Component>`.
+ */
+const resolveRenderingParent = (context, section) => (section ? (0, exports.joinPath)(context.renderingsRoot, section) : context.renderingsRoot);
+exports.resolveRenderingParent = resolveRenderingParent;
+/**
+ * Ensure a section folder (under `componentsRoot/<section>`) exists.
+ * Idempotent: emits a CreateOnly CreateItem op the first time a given
+ * (site, section) pair is seen and records the refKey in the
+ * `emittedFolders` set so subsequent calls are no-ops.
+ *
+ * Returns the section folder's refKey for downstream callers that want
+ * to nest items under it.
+ */
+const ensureSectionFolder = (operations, context, section, emittedFolders) => {
+    const site = (0, exports.siteOf)(context);
+    const refKey = (0, guids_1.sectionFolderId)(site, section);
+    if (emittedFolders.has(refKey))
+        return refKey;
+    emittedFolders.add(refKey);
+    const parent = context.componentsRoot ?? context.templatesRoot;
+    const path = (0, exports.joinPath)(parent, section);
+    operations.push({
+        op: "CreateItem",
+        policy: "CreateOnly",
+        label: `section-folder:${site}:${section}`,
+        id: refKey,
+        path,
+        parent: { kind: "ref-path", value: parent },
+        templateOf: sitecore_templates_1.SITECORE_TEMPLATES.TEMPLATE_FOLDER,
+        name: section,
+        fields: [sharedField(sitecore_templates_1.SYSTEM_FIELDS.ICON, { kind: "string", value: sitecore_templates_1.FOLDER_ICON })],
+    });
+    return refKey;
+};
+exports.ensureSectionFolder = ensureSectionFolder;
+/**
+ * Ensure a "Component Folders" subfolder exists under the section
+ * folder. Idempotent.
+ */
+const ensureComponentFoldersBucket = (operations, context, section, emittedFolders) => {
+    const site = (0, exports.siteOf)(context);
+    const refKey = (0, guids_1.componentFoldersBucketId)(site, section);
+    if (emittedFolders.has(refKey))
+        return refKey;
+    emittedFolders.add(refKey);
+    const sectionRefKey = (0, exports.ensureSectionFolder)(operations, context, section, emittedFolders);
+    const parentPath = (0, exports.resolveComponentTemplateParent)(context, section);
+    operations.push({
+        op: "CreateItem",
+        policy: "CreateOnly",
+        label: `component-folders-bucket:${site}:${section}`,
+        id: refKey,
+        path: (0, exports.joinPath)(parentPath, exports.COMPONENT_FOLDERS_BUCKET),
+        parent: { kind: "ref-recipe", refKey: sectionRefKey },
+        templateOf: sitecore_templates_1.SITECORE_TEMPLATES.TEMPLATE_FOLDER,
+        name: exports.COMPONENT_FOLDERS_BUCKET,
+        fields: [sharedField(sitecore_templates_1.SYSTEM_FIELDS.ICON, { kind: "string", value: sitecore_templates_1.FOLDER_ICON })],
+    });
+    return refKey;
+};
+exports.ensureComponentFoldersBucket = ensureComponentFoldersBucket;
+/**
+ * Ensure a "Presentation Parameters" subfolder exists under the section
+ * folder. Idempotent.
+ */
+const ensurePresentationParametersBucket = (operations, context, section, emittedFolders) => {
+    const site = (0, exports.siteOf)(context);
+    const refKey = (0, guids_1.presentationParametersBucketId)(site, section);
+    if (emittedFolders.has(refKey))
+        return refKey;
+    emittedFolders.add(refKey);
+    const sectionRefKey = (0, exports.ensureSectionFolder)(operations, context, section, emittedFolders);
+    const parentPath = (0, exports.resolveComponentTemplateParent)(context, section);
+    operations.push({
+        op: "CreateItem",
+        policy: "CreateOnly",
+        label: `presentation-parameters-bucket:${site}:${section}`,
+        id: refKey,
+        path: (0, exports.joinPath)(parentPath, exports.PRESENTATION_PARAMETERS_BUCKET),
+        parent: { kind: "ref-recipe", refKey: sectionRefKey },
+        templateOf: sitecore_templates_1.SITECORE_TEMPLATES.TEMPLATE_FOLDER,
+        name: exports.PRESENTATION_PARAMETERS_BUCKET,
+        fields: [sharedField(sitecore_templates_1.SYSTEM_FIELDS.ICON, { kind: "string", value: sitecore_templates_1.FOLDER_ICON })],
+    });
+    return refKey;
+};
+exports.ensurePresentationParametersBucket = ensurePresentationParametersBucket;
+/**
+ * Ensure a section subfolder under the renderings tree exists —
+ * `<renderingsRoot>/<section>/`. Mirrors the templates side; the
+ * rendering tree shape mirrors the template tree per the layout plan.
+ */
+const ensureRenderingsSectionFolder = (operations, context, section, emittedFolders) => {
+    const site = (0, exports.siteOf)(context);
+    const refKey = (0, guids_1.renderingsSectionFolderId)(site, section);
+    if (emittedFolders.has(refKey))
+        return refKey;
+    emittedFolders.add(refKey);
+    const path = (0, exports.joinPath)(context.renderingsRoot, section);
+    operations.push({
+        op: "CreateItem",
+        policy: "CreateOnly",
+        label: `renderings-section-folder:${site}:${section}`,
+        id: refKey,
+        path,
+        parent: { kind: "ref-path", value: context.renderingsRoot },
+        // Real SXA renderings-tree section folders use `Rendering Folder`,
+        // not the generic `Folder` template. Verified against live tenant
+        // 2026-05-02 — every section under
+        // `/sitecore/layout/Renderings/Project/<site>/` conforms to this.
+        templateOf: sitecore_templates_1.SITECORE_TEMPLATES.RENDERING_FOLDER,
+        name: section,
+        fields: [sharedField(sitecore_templates_1.SYSTEM_FIELDS.ICON, { kind: "string", value: sitecore_templates_1.FOLDER_ICON })],
+    });
+    return refKey;
+};
+exports.ensureRenderingsSectionFolder = ensureRenderingsSectionFolder;
+/**
+ * Ensure a Content Models group folder exists. Returns the refKey for
+ * downstream `CreateItem.parent` references. Idempotent across
+ * repeated calls within one recipe-set compile.
+ */
+const ensureContentModelsGroupFolder = (operations, context, group, emittedFolders) => {
+    if (!context.contentModelsRoot)
+        return undefined;
+    const site = (0, exports.siteOf)(context);
+    const refKey = (0, guids_1.contentModelsGroupFolderId)(site, group);
+    if (emittedFolders.has(refKey))
+        return refKey;
+    emittedFolders.add(refKey);
+    const path = (0, exports.joinPath)(context.contentModelsRoot, group);
+    operations.push({
+        op: "CreateItem",
+        policy: "CreateOnly",
+        label: `content-models-group-folder:${site}:${group}`,
+        id: refKey,
+        path,
+        parent: { kind: "ref-path", value: context.contentModelsRoot },
+        templateOf: sitecore_templates_1.SITECORE_TEMPLATES.TEMPLATE_FOLDER,
+        name: group,
+        fields: [sharedField(sitecore_templates_1.SYSTEM_FIELDS.ICON, { kind: "string", value: sitecore_templates_1.FOLDER_ICON })],
+    });
+    return refKey;
+};
+exports.ensureContentModelsGroupFolder = ensureContentModelsGroupFolder;
+const ensureEnumerationTemplates = (operations, context, site, emittedFolders) => {
+    const folderTemplateRefKey = (0, guids_1.enumerationsFolderTemplateId)(site);
+    const enumerationTemplateRefKey = (0, guids_1.enumerationTemplateId)(site);
+    const containerValueFieldRefKey = (0, guids_1.enumerationContainerValueFieldId)(site);
+    const valueTemplateRefKey = (0, guids_1.enumerationValueTemplateId)(site);
+    const valueFieldRefKey = (0, guids_1.enumerationTemplateValueFieldId)(site);
+    const sentinel = `enumeration-templates:${site}`;
+    if (emittedFolders.has(sentinel)) {
+        return {
+            folderTemplateRefKey,
+            enumerationTemplateRefKey,
+            containerValueFieldRefKey,
+            valueTemplateRefKey,
+            valueFieldRefKey,
+        };
+    }
+    emittedFolders.add(sentinel);
+    // Enum templates live at the SITE templates root's `/Presentation`
+    // bucket (sibling of `/Components`), NOT nested under `/Components`.
+    // Orchestrators typically alias `templatesRoot` and `componentsRoot`
+    // to the same `<siteRoot>/Components` value; strip the trailing
+    // `/Components` segment from whichever is provided to land on the
+    // site templates root. When the input doesn't end in `/Components`
+    // (legacy flat layout), use it as-is.
+    const root = context.componentsRoot ?? context.templatesRoot;
+    const siteTemplatesRoot = root.replace(/\/Components$/, "");
+    const parentPath = (0, exports.joinPath)(siteTemplatesRoot, "Presentation");
+    const templateEntries = [
+        { refKey: folderTemplateRefKey, name: "Enumerations Folder" },
+        { refKey: enumerationTemplateRefKey, name: "Enumeration" },
+        { refKey: valueTemplateRefKey, name: "Enumeration Value" },
+    ];
+    for (const { refKey, name } of templateEntries) {
+        operations.push({
+            op: "CreateItem",
+            policy: "CreateOnly",
+            label: `enumeration-template:${site}:${name}`,
+            id: refKey,
+            path: (0, exports.joinPath)(parentPath, name),
+            parent: { kind: "ref-path", value: parentPath },
+            templateOf: sitecore_templates_1.SITECORE_TEMPLATES.TEMPLATE,
+            name,
+            fields: [sharedField(sitecore_templates_1.SYSTEM_FIELDS.ICON, { kind: "string", value: sitecore_templates_1.ENUMERATION_ICON })],
+        });
+        operations.push({
+            op: "SetBaseTemplates",
+            policy: "CreateOnly",
+            label: `enumeration-template-base:${site}:${name}`,
+            itemRefKey: refKey,
+            baseTemplates: [sitecore_templates_1.STANDARD_TEMPLATE_ID],
+        });
+    }
+    // Inner `Enumeration` Section + `Value` field — emitted on BOTH the
+    // Enumeration template (for the per-enum container's default value)
+    // and the Enumeration Value template (for each leaf value's payload).
+    // Same field name + shape on both so Edge consumers query the same
+    // way to read either the canonical default (off the container) or a
+    // leaf payload (off a value item):
+    //   `item.field("Value").value`.
+    const innerValueFieldEntries = [
+        {
+            templatePath: (0, exports.joinPath)(parentPath, "Enumeration"),
+            templateRefKey: enumerationTemplateRefKey,
+            sectionRefKey: (0, guids_1.enumerationContainerSectionId)(site),
+            fieldRefKey: containerValueFieldRefKey,
+            labelPrefix: "enumeration-template",
+        },
+        {
+            templatePath: (0, exports.joinPath)(parentPath, "Enumeration Value"),
+            templateRefKey: valueTemplateRefKey,
+            sectionRefKey: (0, guids_1.enumerationTemplateSectionId)(site),
+            fieldRefKey: valueFieldRefKey,
+            labelPrefix: "enumeration-value-template",
+        },
+    ];
+    for (const e of innerValueFieldEntries) {
+        const sectionPath = (0, exports.joinPath)(e.templatePath, "Enumeration");
+        operations.push({
+            op: "CreateItem",
+            policy: "CreateOnly",
+            label: `${e.labelPrefix}-section:${site}`,
+            id: e.sectionRefKey,
+            path: sectionPath,
+            parent: { kind: "ref-recipe", refKey: e.templateRefKey },
+            templateOf: sitecore_templates_1.SITECORE_TEMPLATES.TEMPLATE_SECTION,
+            name: "Enumeration",
+            fields: [],
+        });
+        operations.push({
+            op: "CreateItem",
+            policy: "CreateOnly",
+            label: `${e.labelPrefix}-value-field:${site}`,
+            id: e.fieldRefKey,
+            path: (0, exports.joinPath)(sectionPath, "Value"),
+            parent: { kind: "ref-recipe", refKey: e.sectionRefKey },
+            templateOf: sitecore_templates_1.SITECORE_TEMPLATES.TEMPLATE_FIELD,
+            name: "Value",
+            fields: [
+                sharedField(sitecore_templates_1.TEMPLATE_FIELD_FIELDS.TYPE, {
+                    kind: "string",
+                    value: (0, field_types_1.sitecoreFieldTypeLabel)("single-line-text"),
+                }),
+                sharedField(sitecore_templates_1.SYSTEM_FIELDS.SORT_ORDER, { kind: "number", value: 100 }),
+                sharedField(sitecore_templates_1.TEMPLATE_FIELD_FIELDS.SHARED, { kind: "string", value: "1" }),
+                versionedField(sitecore_templates_1.TEMPLATE_FIELD_FIELDS.TITLE, { kind: "string", value: "Value" }),
+                versionedField(sitecore_templates_1.SYSTEM_FIELDS.DISPLAY_NAME, { kind: "string", value: "Value" }),
+            ],
+        });
+    }
+    // Standard Values + Insert Options for each template that authors can
+    // insert into. Living at the template definition (not at every data
+    // folder) keeps Droplink picker results clean — only real value items
+    // appear, no stray __Standard Values siblings.
+    const standardValuesEntries = [
+        {
+            templateRefKey: folderTemplateRefKey,
+            templateName: "Enumerations Folder",
+            svRefKey: (0, guids_1.enumerationsFolderTemplateStandardValuesId)(site),
+            // Folders contain enums (typical) or sub-folders (nesting via
+            // multi-segment `folder: "Theme/Color"` recipes).
+            insertOptions: [enumerationTemplateRefKey, folderTemplateRefKey],
+        },
+        {
+            templateRefKey: enumerationTemplateRefKey,
+            templateName: "Enumeration",
+            svRefKey: (0, guids_1.enumerationTemplateStandardValuesId)(site),
+            // Per-enum items only contain values — never sub-enums or folders.
+            insertOptions: [valueTemplateRefKey],
+        },
+    ];
+    for (const entry of standardValuesEntries) {
+        const svPath = (0, exports.joinPath)((0, exports.joinPath)(parentPath, entry.templateName), "__Standard Values");
+        operations.push({
+            op: "CreateItem",
+            policy: "CreateOnly",
+            label: `enumeration-template-standard-values:${site}:${entry.templateName}`,
+            id: entry.svRefKey,
+            path: svPath,
+            parent: { kind: "ref-recipe", refKey: entry.templateRefKey },
+            templateOf: entry.templateRefKey,
+            name: "__Standard Values",
+            fields: [],
+        });
+        // SetStandardValues + Insert Options are recipe-controlled and
+        // CreateAndUpdate so re-pushes always reconcile the link + the
+        // Insert Options list — there's no "preserve CMS edit" case worth
+        // honouring (authors edit the recipe, not the SV's __Masters field
+        // directly), and CreateOnly was leaving stale values from earlier
+        // broken pushes in place.
+        operations.push({
+            op: "SetStandardValues",
+            policy: "CreateAndUpdate",
+            label: `enumeration-template-link-standard-values:${site}:${entry.templateName}`,
+            templateRefKey: entry.templateRefKey,
+            standardValuesRefKey: entry.svRefKey,
+        });
+        // `ref-recipe-list`, NOT `ref-guid-list` — the executor must
+        // resolve each template refKey against the captured-itemId map to
+        // the server-assigned itemId before rendering. `ref-guid-list`
+        // emits refKey GUIDs verbatim; those are deterministic compile-time
+        // values, not the actual tenant-side template IDs, so the resulting
+        // `__Masters` value points at items that don't exist and the
+        // editor's Insert menu silently has nothing to enumerate.
+        operations.push({
+            op: "SetField",
+            policy: "CreateAndUpdate",
+            label: `enumeration-template-insert-options:${site}:${entry.templateName}`,
+            itemRefKey: entry.svRefKey,
+            fieldId: sitecore_templates_1.SYSTEM_FIELDS.INSERT_OPTIONS,
+            value: {
+                kind: "ref-recipe-list",
+                refKeys: [...entry.insertOptions],
+            },
+        });
+    }
+    return {
+        folderTemplateRefKey,
+        enumerationTemplateRefKey,
+        containerValueFieldRefKey,
+        valueTemplateRefKey,
+        valueFieldRefKey,
+    };
+};
+exports.ensureEnumerationTemplates = ensureEnumerationTemplates;
+function emitDatasourceTemplate(operations, recipe, context, icon, policy) {
+    const site = (0, exports.siteOf)(context);
+    const tplRefKey = (0, guids_1.templateId)(site, recipe.handle);
+    const parentPath = recipe.parentPath ?? context.templatesRoot;
+    const tplPath = (0, exports.joinPath)(parentPath, recipe.name);
+    const parentRef = recipe.parentRefKey
+        ? { kind: "ref-recipe", refKey: recipe.parentRefKey }
+        : { kind: "ref-path", value: parentPath };
+    operations.push({
+        op: "CreateItem",
+        policy,
+        label: `template:${recipe.handle}`,
+        id: tplRefKey,
+        path: tplPath,
+        parent: parentRef,
+        templateOf: sitecore_templates_1.SITECORE_TEMPLATES.TEMPLATE,
+        name: recipe.name,
+        fields: [
+            sharedField(sitecore_templates_1.SYSTEM_FIELDS.ICON, { kind: "string", value: icon }),
+            versionedField(sitecore_templates_1.SYSTEM_FIELDS.DISPLAY_NAME, { kind: "string", value: recipe.displayName }),
+        ],
+    });
+    operations.push({
+        op: "SetBaseTemplates",
+        policy,
+        label: `base-templates:${recipe.handle}`,
+        itemRefKey: tplRefKey,
+        baseTemplates: [sitecore_templates_1.STANDARD_TEMPLATE_ID, ...(recipe.additionalBaseTemplates ?? [])],
+    });
+    for (const group of groupFieldsBySection(recipe.fields)) {
+        const secRefKey = (0, guids_1.sectionId)(site, recipe.handle, group.section);
+        const secPath = (0, exports.joinPath)(tplPath, group.section);
+        operations.push({
+            op: "CreateItem",
+            policy,
+            label: `section:${recipe.handle}/${group.section}`,
+            id: secRefKey,
+            path: secPath,
+            parent: { kind: "ref-recipe", refKey: tplRefKey },
+            templateOf: sitecore_templates_1.SITECORE_TEMPLATES.TEMPLATE_SECTION,
+            name: group.section,
+            fields: [],
+        });
+        group.fields.forEach((field, index) => {
+            operations.push(...buildFieldOp({
+                recipeHandle: recipe.handle,
+                fieldRefKey: (0, guids_1.fieldId)(site, recipe.handle, field.name),
+                fieldPath: (0, exports.joinPath)(secPath, field.name),
+                parentRefKey: secRefKey,
+                labelPrefix: `field:${recipe.handle}`,
+                field,
+                zeroBasedIndex: index,
+                policy,
+                site,
+                context,
+            }));
+        });
+    }
+    const svRefKey = (0, guids_1.standardValuesId)(site, recipe.handle);
+    const svPath = (0, exports.joinPath)(tplPath, "__Standard Values");
+    operations.push({
+        op: "CreateItem",
+        policy,
+        label: `standard-values:${recipe.handle}`,
+        id: svRefKey,
+        path: svPath,
+        parent: { kind: "ref-recipe", refKey: tplRefKey },
+        // The SV item conforms to the template we just created — runtime
+        // resolution turns this ref-recipe placeholder into the assigned id.
+        templateOf: tplRefKey,
+        name: "__Standard Values",
+        // Per-field defaults from `field.default` / `field.sitecore.defaultValue`.
+        // These pre-fill new datasource items so authors see meaningful
+        // initial content instead of an empty form. Reference-shape fields
+        // (link/image/etc.) are skipped — their defaults need encoded
+        // payloads outside the simple string-default surface.
+        fields: buildStandardValuesFieldEntries(site, recipe.handle, recipe.fields),
+    });
+    operations.push({
+        op: "SetStandardValues",
+        policy,
+        label: `link-standard-values:${recipe.handle}`,
+        templateRefKey: tplRefKey,
+        standardValuesRefKey: svRefKey,
+    });
+    if (recipe.insertOptions && recipe.insertOptions.length > 0) {
+        operations.push({
+            op: "SetField",
+            policy,
+            label: `insert-options:${recipe.handle}`,
+            itemRefKey: svRefKey,
+            fieldId: sitecore_templates_1.SYSTEM_FIELDS.INSERT_OPTIONS,
+            value: {
+                kind: "ref-recipe-list",
+                refKeys: recipe.insertOptions.map((handle) => (0, guids_1.templateId)(site, handle)),
+            },
+        });
+    }
+}
+/**
+ * Build the CreateItem op for a single field definition.
+ *
+ * Always returns exactly one op — the field-definition item itself.
+ * Backing storage for enum-shaped fields is decided by the field's
+ * `sitecore.type` / `sitecore.enumHandle` and resolved into the
+ * `Source` field via `resolveFieldSource`:
+ *   - `sitecore.type: "droplist"` + inline `values: [...]` → Source is
+ *     a pipe-separated literal; Sitecore enumerates the string directly,
+ *     no value items needed.
+ *   - `sitecore.enumHandle: "<handle>"` (Droplink default) → Source is
+ *     the EnumerationRecipe's folder path on the tenant; the picker
+ *     enumerates that path's children at editor time. The values live
+ *     under the `EnumerationRecipe`'s folder item, emitted by
+ *     `compileEnumerationRecipe`.
+ *
+ * Inline Droplink (`shape: "enum"` + inline `values` + no `enumHandle`
+ * + no `sitecore.type` override) is rejected by `resolveFieldSource`
+ * with INPUT_INVALID — it never reliably worked in SXA Headless's
+ * rendering parameters dialog (the picker couldn't enumerate the
+ * per-field folder), so authors must commit to one of the two
+ * supported shapes.
+ */
+function buildFieldOp(input) {
+    const { recipeHandle, fieldRefKey, fieldPath, parentRefKey, labelPrefix, field, zeroBasedIndex, policy, site, context, } = input;
+    const sortOrder = field.sitecore?.sortOrder ?? (zeroBasedIndex + 1) * 100;
+    const sitecoreType = resolveSitecoreType(field);
+    const fields = [
+        sharedField(sitecore_templates_1.TEMPLATE_FIELD_FIELDS.TYPE, {
+            kind: "string",
+            value: (0, field_types_1.sitecoreFieldTypeLabel)(sitecoreType),
+        }),
+        sharedField(sitecore_templates_1.SYSTEM_FIELDS.SORT_ORDER, { kind: "number", value: sortOrder }),
+        versionedField(sitecore_templates_1.TEMPLATE_FIELD_FIELDS.TITLE, { kind: "string", value: field.name }),
+        versionedField(sitecore_templates_1.SYSTEM_FIELDS.DISPLAY_NAME, { kind: "string", value: field.name }),
+    ];
+    const sourceValue = resolveFieldSource(field, sitecoreType, site, recipeHandle, context);
+    if (sourceValue !== undefined) {
+        fields.push(sharedField(sitecore_templates_1.TEMPLATE_FIELD_FIELDS.SOURCE, sourceValue));
+    }
+    return [
+        {
+            op: "CreateItem",
+            policy,
+            label: `${labelPrefix}/${field.name}`,
+            id: fieldRefKey,
+            path: fieldPath,
+            parent: { kind: "ref-recipe", refKey: parentRefKey },
+            templateOf: sitecore_templates_1.SITECORE_TEMPLATES.TEMPLATE_FIELD,
+            name: field.name,
+            fields,
+        },
+    ];
+}
+function resolveSitecoreType(field) {
+    if (field.sitecore?.type) {
+        return field.sitecore.type;
+    }
+    const multiple = "multiple" in field ? field.multiple : undefined;
+    return (0, field_types_1.defaultSitecoreFieldType)(field.shape, multiple);
+}
+/**
+ * Build the field-default entries for a template's `__Standard Values`
+ * item. Each entry carries the field's recipe-derived `fieldId` AND
+ * `fieldName` — Sitecore resolves recipe-created field GUIDs by name
+ * against the SV item's template (the recipe-derived id won't match the
+ * tenant's server-assigned field-definition id; the name lookup is what
+ * actually writes the value).
+ *
+ * Reference-shape defaults (link / image / treelist, plus
+ * non-enum-backed droplink) are skipped silently — those need encoded
+ * GUIDs or structured payloads that the simple `default: "string"`
+ * recipe surface can't express. Authors who need defaults for those
+ * can layer them in via a `ContentItemRecipe` that targets the SV
+ * path explicitly.
+ *
+ * Enum-shaped fields branch on the resolved Type:
+ *   - **Type=Droplist** (override): default is the raw string. Droplist
+ *     reads its options from a pipe-separated Source; SV default is a
+ *     name match against that list.
+ *   - **Type=Droplink + `sitecore.enumHandle`** (the canonical shared
+ *     enum shape): default is a `ref-recipe` GUID reference to the
+ *     value item under `enumerationFolderId(site, enumHandle)`.
+ *   - **Type=Droplink without `sitecore.enumHandle`** (inline Droplink):
+ *     unsupported — `resolveFieldSource` rejects it upstream and this
+ *     function throws defensively if it ever reaches here.
+ *
+ * If the declared default isn't actually one of the enum's values, the
+ * derived GUID won't exist on the tenant and the SV write fails at
+ * apply time — author error, not silently masked here.
+ */
+function buildStandardValuesFieldEntries(site, handle, fields, 
+// Resolver for the field-definition refKey. Defaults to `fieldId`
+// (component/content templates); pass `paramsFieldId` when emitting
+// SV defaults for a parameters template (which uses a different
+// GUID family scoped under `paramsTemplateId`).
+fieldIdResolver = guids_1.fieldId) {
+    const entries = [];
+    for (const field of fields) {
+        const raw = field.sitecore?.defaultValue ?? field.default;
+        if (raw === undefined)
+            continue;
+        const value = encodeStandardValueDefaultForField(raw, field, site, handle);
+        if (value === undefined)
+            continue;
+        entries.push({
+            fieldId: fieldIdResolver(site, handle, field.name),
+            fieldName: field.name,
+            language: sitecore_templates_1.DEFAULT_LANGUAGE,
+            version: sitecore_templates_1.DEFAULT_VERSION,
+            value,
+        });
+    }
+    return entries;
+}
+/**
+ * Encode an SV default value for a field. Wraps `encodeStandardValueDefault`
+ * with shape-aware handling for enum fields.
+ *
+ * Type decides the encoding shape:
+ *   - Type=Droplink + `sitecore.enumHandle`: default is a GUID reference
+ *     to the value item under the EnumerationRecipe's folder
+ *     (`enumerationFolderId(site, enumHandle)`).
+ *   - Type=Droplist (override): default is the raw string — Droplist's
+ *     own enumeration is a pipe-separated Source string, so a name match
+ *     in that list is the right encoding.
+ *   - Type=Droplink without `enumHandle`: throws INPUT_INVALID — inline
+ *     Droplink isn't supported; authors must commit to one of the two
+ *     shapes above.
+ */
+function encodeStandardValueDefaultForField(raw, field, site, handle) {
+    if (field.shape === "enum") {
+        const sitecoreType = resolveSitecoreType(field);
+        if (sitecoreType === "droplist") {
+            // Droplist enumerates from a pipe-list Source; the SV default is
+            // the raw value string, not a GUID.
+            return { kind: "string", value: raw };
+        }
+        const enumHandle = field.sitecore?.enumHandle;
+        if (!enumHandle) {
+            // Defensive — `resolveFieldSource` rejects inline Droplink at the
+            // upstream call site, so this branch only fires if an enum field
+            // somehow reached SV emission without going through field-op
+            // construction. Throw rather than emit a broken default.
+            throw (0, errors_1.createCliError)(`Field '${field.name}' on recipe '${handle}' is shape=enum + Type=Droplink but declares no sitecore.enumHandle; inline Droplink isn't supported.`, "INPUT_INVALID", {
+                hint: "Either set `sitecore.enumHandle` to a shared EnumerationRecipe's handle, or override `sitecore.type` to 'droplist' for an inline pipe-list dropdown.",
+            });
+        }
+        return {
+            kind: "ref-recipe",
+            refKey: (0, guids_1.enumValueId)((0, guids_1.enumerationFolderId)(site, enumHandle), raw),
+        };
+    }
+    return encodeStandardValueDefault(raw, resolveSitecoreType(field));
+}
+const BOOLEAN_TRUE_PATTERN = /^(1|true|yes|on|enabled)$/i;
+function encodeStandardValueDefault(raw, type) {
+    switch (type) {
+        case "checkbox":
+            // Sitecore stores checkboxes as "1" (true) / "" (false).
+            return { kind: "string", value: BOOLEAN_TRUE_PATTERN.test(raw.trim()) ? "1" : "" };
+        case "single-line-text":
+        case "multi-line-text":
+        case "rich-text":
+        case "droplist":
+        case "lookup":
+        case "tags":
+        case "number":
+        case "integer":
+        case "date":
+        case "datetime":
+            return { kind: "string", value: raw };
+        case "image":
+        case "file":
+        case "general-link":
+        case "droplink":
+        case "treelist":
+        case "treelist-with-search":
+            // Reference-shape defaults need encoded payloads; not expressible
+            // via the simple `default: string` recipe surface. Skip; the field
+            // still gets created without a default.
+            return undefined;
+    }
+}
+/**
+ * Resolve a recipe field's `Source` value to a Sitecore-encoded string.
+ *
+ * When `sourceTypes` references recipe handles, the wire string depends
+ * on the resolved Sitecore itemIds — we can't render at compile time, so
+ * we emit `ref-source-fields` and the executor finishes the job with the
+ * captured-itemId resolver.
+ *
+ * Sources without handle references (`sourceRaw`, or `sourceQuery` /
+ * `sourceScope` alone) render at compile time as a plain string.
+ *
+ * Enum fields (`shape: "enum"`) accept exactly two shapes — the
+ * compiler rejects anything else with INPUT_INVALID:
+ *   - **Type=Droplink + `sitecore.enumHandle`** (the canonical shared
+ *     shape): Source is the EnumerationRecipe's tenant content path
+ *     (resolved via `context.enumsByHandle`). SXA enumerates that
+ *     path's children as picker entries; the values live as content
+ *     items the EnumerationRecipe owns. Source is emitted as a path
+ *     string (not a `{GUID}`) — SXA Headless's rendering parameter
+ *     dialog only enumerates Droplink Source as a content path / query.
+ *   - **Type=Droplist (override) + inline `values: [...]`**: Source is
+ *     a pipe-separated literal of the values — Sitecore reads the
+ *     option list straight out of the Source string with no folder
+ *     lookup. No content items are emitted.
+ *
+ * Inline Droplink (shape=enum + `values` + neither override) is rejected
+ * here: SXA Headless's rendering parameters dialog never reliably picked
+ * up the per-field folder of values, so authors must commit to one of
+ * the two supported shapes.
+ *
+ * Shared-enum + Droplist isn't supported either — Droplist needs values
+ * at compile time, which we can't resolve from a sibling EnumerationRecipe
+ * without a lookup.
+ */
+function resolveFieldSource(field, type, site, recipeHandle, context) {
+    const sc = field.sitecore;
+    if (sc) {
+        const fields = {
+            sourceTypes: sc.sourceTypes,
+            sourceQuery: sc.sourceQuery,
+            sourceScope: sc.sourceScope,
+            sourceRaw: sc.sourceRaw,
+        };
+        if ((0, source_fields_1.sourceFieldsNeedHandleResolution)(fields)) {
+            return {
+                kind: "ref-source-fields",
+                site,
+                sourceTypes: sc.sourceTypes,
+                sourceQuery: sc.sourceQuery,
+                sourceScope: sc.sourceScope,
+            };
+        }
+        const rendered = (0, source_fields_1.renderSourceFields)(fields, () => {
+            throw (0, errors_1.createCliError)("compile-time render should not need handle resolution", "UNKNOWN");
+        });
+        if (rendered !== undefined) {
+            return { kind: "string", value: rendered };
+        }
+    }
+    if (field.shape === "enum") {
+        // Droplist override on an enum field needs the inline values
+        // baked into Source as a pipe-separated literal — SXA's Droplist
+        // enumerates the string directly and never reads a folder.
+        if (type === "droplist") {
+            if (!field.values || field.values.length === 0) {
+                throw (0, errors_1.createCliError)(`Field '${field.name}' on recipe '${recipeHandle}' overrides sitecore.type to 'droplist' but declares no inline values; Droplist needs an inline value list.`, "INPUT_INVALID", {
+                    hint: 'Either drop the `sitecore.type: "droplist"` override and add `sitecore.enumHandle: "<recipe>@<v>"` (shared Droplink), or add `values: [...]` to the field.',
+                });
+            }
+            return { kind: "string", value: field.values.join("|") };
+        }
+        if (sc?.enumHandle) {
+            // Shared enum + Droplink — Source is the enum folder's tenant
+            // content path (NOT a `{GUID}` reference). SXA Headless's
+            // rendering parameter dialog enumerates Droplink Source as a path
+            // / query; a bare GUID doesn't reliably surface picker options.
+            // Path is computable at compile time from the EnumerationRecipe
+            // looked up via `context.enumsByHandle`.
+            if (!context) {
+                throw (0, errors_1.createCliError)(`Field '${field.name}' on recipe '${recipeHandle}' uses sitecore.enumHandle='${sc.enumHandle}' but the field-op builder was invoked without a CompileContext.`, "INPUT_INVALID", {
+                    hint: "Pass `context` into `buildFieldOp` so the enum's tenant path can be resolved from `enumsByHandle` + `enumerationsRoot`.",
+                });
+            }
+            const enumPath = (0, exports.resolveEnumFolderPath)(context, sc.enumHandle, recipeHandle);
+            return { kind: "string", value: enumPath };
+        }
+        // Inline Droplink (shape=enum + values + no enumHandle + no Droplist
+        // override) is not a valid shape — SXA Headless's rendering parameter
+        // dialog never reliably picked up a per-field folder of values, so the
+        // dropdown stayed empty in Pages. Force the author to commit:
+        //   - Inline scale → `sitecore.type: "droplist"` + inline `values`.
+        //   - Shared scale → `sitecore.enumHandle: "<EnumerationRecipe>@<v>"`.
+        throw (0, errors_1.createCliError)(`Field '${field.name}' on recipe '${recipeHandle}' is shape=enum but declares neither sitecore.type='droplist' (with inline values) nor sitecore.enumHandle (pointing at a shared EnumerationRecipe); inline Droplink isn't supported.`, "INPUT_INVALID", {
+            hint: 'Pick one: add `sitecore.type: "droplist"` for an inline pipe-list dropdown, or `sitecore.enumHandle: "<recipe>@<v>"` to point at a shared EnumerationRecipe (which authors edit out-of-band as content items).',
+        });
+    }
+    if (type === "droplist" && field.values && field.values.length > 0) {
+        return { kind: "string", value: field.values.join("|") };
+    }
+    return undefined;
+}
+/**
+ * Group recipe fields by their `sitecore.section` (default "Content").
+ * Section emit order = order of first occurrence in the recipe — the
+ * compiler is purely stable; recipe authors control ordering.
+ */
+function groupFieldsBySection(fields) {
+    const order = [];
+    const bySection = new Map();
+    for (const field of fields) {
+        const section = field.sitecore?.section ?? exports.DEFAULT_FIELDS_SECTION;
+        if (!bySection.has(section)) {
+            bySection.set(section, []);
+            order.push(section);
+        }
+        bySection.get(section).push(field);
+    }
+    return order.map((section) => ({ section, fields: bySection.get(section) }));
+}