@sitecoreai-labs/sitecoreai-cli 0.0.4 → 0.1.0

package/dist/recipe/compile/page-template.d.ts

@@ -0,0 +1,30 @@
+import { type OperationIr } from "../ir/operations";
+import { type PageTemplateRecipe } from "../schema/recipe";
+import { type CompileContext } from "./shared";
+/**
+ * Compile a `PageTemplateRecipe` to an Operation IR.
+ *
+ * A page template is a Sitecore data template that pages conform to. It
+ * differs from a `ContentTemplateRecipe` in two ways:
+ *
+ *   1. It inherits the SXA Headless page base set
+ *      (`SXA_HEADLESS_PAGE_BASE_TEMPLATES`) on top of the Standard
+ *      template, so items conforming to it pick up the layout /
+ *      navigation / taxonomy / page-design / sitemap facets that make
+ *      them authorable pages in XM Cloud Pages.
+ *   2. Its `__Standard Values` carries a `__Renderings` layout shell —
+ *      `<r><d id="{device}" l="{jsonLayout}" /></r>` — so pages render
+ *      through the headless JSON-layout pipeline. When the recipe
+ *      declares a `layout`, its placements are seeded into that shell.
+ *
+ * Everything else (template item, sections, fields, standard values,
+ * insert options, default workflow) is the same datasource-template
+ * shape `compileContentTemplateRecipe` emits — reused via
+ * `emitDatasourceTemplate`.
+ *
+ * Path:
+ *   - `meta.tax.group` set → `<pageTemplatesRoot ?? templatesRoot>/<group>/<name>`
+ *     (the group folder is emitted once per set as a CreateOnly op).
+ *   - no group → flat at `<pageTemplatesRoot ?? templatesRoot>/<name>`.
+ */
+export declare function compilePageTemplateRecipe(input: PageTemplateRecipe, context: CompileContext, emittedFolders?: Set<string>): OperationIr;

package/dist/recipe/compile/page-template.js

@@ -0,0 +1,121 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.compilePageTemplateRecipe = compilePageTemplateRecipe;
+const uuid_1 = require("uuid");
+const guids_1 = require("../guids");
+const operations_1 = require("../ir/operations");
+const policy_1 = require("../policy");
+const sitecore_templates_1 = require("../ir/sitecore-templates");
+const recipe_1 = require("../schema/recipe");
+const emit_1 = require("../layout/emit");
+const shared_1 = require("./shared");
+/**
+ * Compile a `PageTemplateRecipe` to an Operation IR.
+ *
+ * A page template is a Sitecore data template that pages conform to. It
+ * differs from a `ContentTemplateRecipe` in two ways:
+ *
+ *   1. It inherits the SXA Headless page base set
+ *      (`SXA_HEADLESS_PAGE_BASE_TEMPLATES`) on top of the Standard
+ *      template, so items conforming to it pick up the layout /
+ *      navigation / taxonomy / page-design / sitemap facets that make
+ *      them authorable pages in XM Cloud Pages.
+ *   2. Its `__Standard Values` carries a `__Renderings` layout shell —
+ *      `<r><d id="{device}" l="{jsonLayout}" /></r>` — so pages render
+ *      through the headless JSON-layout pipeline. When the recipe
+ *      declares a `layout`, its placements are seeded into that shell.
+ *
+ * Everything else (template item, sections, fields, standard values,
+ * insert options, default workflow) is the same datasource-template
+ * shape `compileContentTemplateRecipe` emits — reused via
+ * `emitDatasourceTemplate`.
+ *
+ * Path:
+ *   - `meta.tax.group` set → `<pageTemplatesRoot ?? templatesRoot>/<group>/<name>`
+ *     (the group folder is emitted once per set as a CreateOnly op).
+ *   - no group → flat at `<pageTemplatesRoot ?? templatesRoot>/<name>`.
+ */
+function compilePageTemplateRecipe(input, context, emittedFolders = new Set()) {
+    const recipe = recipe_1.PageTemplateRecipeSchema.parse(input);
+    const operations = [];
+    const policy = (0, policy_1.defaultPolicyForRecipe)(recipe.kind);
+    const site = (0, shared_1.siteOf)(context);
+    const root = context.pageTemplatesRoot ?? context.templatesRoot;
+    // `meta.tax.group` nests the template one folder level deep; the
+    // group folder is materialised once per (site, group) via the
+    // `emittedFolders` dedup set.
+    const group = recipe.meta?.tax?.group;
+    let parentPath = root;
+    let parentRefKey;
+    if (group) {
+        const groupRefKey = (0, shared_1.ensurePageTemplatesGroupFolder)(operations, context, group, emittedFolders);
+        parentPath = (0, shared_1.joinPath)(root, group);
+        parentRefKey = groupRefKey;
+    }
+    // Template item + base templates + sections + fields + standard
+    // values + insert options. `additionalBaseTemplates` wires in the SXA
+    // page base set so the result is a real page template, not a plain
+    // data shape.
+    (0, shared_1.emitDatasourceTemplate)(operations, {
+        handle: recipe.handle,
+        name: recipe.name,
+        displayName: recipe.displayName,
+        fields: recipe.fields,
+        ...(recipe.insertOptions !== undefined && { insertOptions: recipe.insertOptions }),
+        parentPath,
+        ...(parentRefKey !== undefined && { parentRefKey }),
+        additionalBaseTemplates: sitecore_templates_1.SXA_HEADLESS_PAGE_BASE_TEMPLATES,
+    }, context, recipe.icon ?? sitecore_templates_1.PAGE_TEMPLATE_ICON, policy);
+    // Stamp the standard-values layout shell. `emitLayoutXml` with
+    // `layoutId` set emits `<r><d id l />…</r>` even when the recipe
+    // declares no placements — device + JSON-layout pointer is the
+    // minimum a page's `__Renderings` needs.
+    const svRefKey = (0, guids_1.standardValuesId)(site, recipe.handle);
+    const layoutXml = (0, emit_1.emitLayoutXml)(recipe.layout ?? { placeholders: {} }, {
+        parentItemId: svRefKey,
+        deviceId: sitecore_templates_1.DEFAULT_DEVICE_ID,
+        layoutId: sitecore_templates_1.SXA_JSON_LAYOUT_ID,
+        renderingIdFor: (handle) => (0, guids_1.renderingId)(site, handle),
+        contentItemIdFor: (handle) => (0, guids_1.contentItemId)(site, handle),
+        // Page templates' standard-values layout never carries scoped
+        // datasource refs — those resolve against a host page, which a
+        // template doesn't have.
+        allowScoped: false,
+        mode: "canonical",
+    });
+    operations.push({
+        op: "SetField",
+        policy,
+        label: `page-template-layout:${recipe.handle}`,
+        itemRefKey: svRefKey,
+        fieldId: sitecore_templates_1.LAYOUT_FIELDS.RENDERINGS,
+        value: { kind: "string", value: layoutXml },
+    });
+    // Optional workflow binding on the standard-values item — new pages
+    // of this template enter the workflow at its initial state. Mirrors
+    // `compileContentTemplateRecipe`.
+    if (recipe.defaultWorkflow) {
+        operations.push({
+            op: "SetField",
+            policy,
+            label: `page-template-default-workflow:${recipe.handle}`,
+            itemRefKey: svRefKey,
+            fieldId: deriveStandardFieldId(svRefKey, "__Default workflow"),
+            fieldName: "__Default workflow",
+            value: { kind: "ref-recipe", refKey: (0, guids_1.workflowId)(recipe.defaultWorkflow) },
+        });
+    }
+    return operations_1.OperationIrSchema.parse({
+        schemaVersion: "1",
+        recipeHandle: recipe.handle,
+        operations,
+    });
+}
+/**
+ * Stable refKey for a Sitecore standard field on `itemRefKey`. Same
+ * derivation as `compile/content-template.ts` — declared separately to
+ * keep the modules independent (see that file's note).
+ */
+const STANDARD_FIELD_REFKEY_NAMESPACE = (0, uuid_1.v5)("standard-field", "d6c28e9f-21f3-56ee-ada3-f2a947c3d475" // NAMESPACE_ROOT
+);
+const deriveStandardFieldId = (parentRefKey, fieldName) => (0, uuid_1.v5)(`${parentRefKey}:${fieldName}`, STANDARD_FIELD_REFKEY_NAMESPACE);

package/dist/recipe/compile/page.d.ts

@@ -0,0 +1,26 @@
+import { type OperationIr } from "../ir/operations";
+import { type PageRecipe } from "../schema/recipe";
+import { type CompileContext } from "./shared";
+/**
+ * Compile a `PageRecipe` to an Operation IR.
+ *
+ * A page is a concrete content-tree item conforming to a page template.
+ * Emits:
+ *   1. `CreateItem` for the page item under `pagesRoot`, with
+ *      `templateOf` pointing at the `PageTemplateRecipe`'s template.
+ *   2. One `SetField` per `fields` entry — page-template field values,
+ *      encoded the same way `compileContentItemRecipe` encodes them.
+ *   3. A `CreateItem` for `<page>/Data` and one per `scoped` placement —
+ *      page-local datasource items conforming to the placed component's
+ *      datasource template (see the layout block).
+ *   4. `SetField(__Final Renderings)` — the page's own layout (when
+ *      `layout` is declared), in canonical wire form. `scoped`
+ *      placements resolve to the `<page>/Data/<slot>` GUIDs; `shared`
+ *      points at a `ContentItemRecipe`; `none` is config-driven.
+ *   5. `SetField(__Workflow)` — when `workflow` is set.
+ *
+ * Policy is `CreateOnly` (the `page-item` purpose): the registry seeds
+ * the page, authors own it thereafter, and a re-push never overwrites
+ * their edits.
+ */
+export declare function compilePageRecipe(input: PageRecipe, context: CompileContext): OperationIr;

package/dist/recipe/compile/page.js

@@ -0,0 +1,184 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.compilePageRecipe = compilePageRecipe;
+const uuid_1 = require("uuid");
+const errors_1 = require("../../shared/errors");
+const guids_1 = require("../guids");
+const operations_1 = require("../ir/operations");
+const policy_1 = require("../policy");
+const sitecore_templates_1 = require("../ir/sitecore-templates");
+const recipe_1 = require("../schema/recipe");
+const emit_1 = require("../layout/emit");
+const content_item_1 = require("./content-item");
+const shared_1 = require("./shared");
+/**
+ * Compile a `PageRecipe` to an Operation IR.
+ *
+ * A page is a concrete content-tree item conforming to a page template.
+ * Emits:
+ *   1. `CreateItem` for the page item under `pagesRoot`, with
+ *      `templateOf` pointing at the `PageTemplateRecipe`'s template.
+ *   2. One `SetField` per `fields` entry — page-template field values,
+ *      encoded the same way `compileContentItemRecipe` encodes them.
+ *   3. A `CreateItem` for `<page>/Data` and one per `scoped` placement —
+ *      page-local datasource items conforming to the placed component's
+ *      datasource template (see the layout block).
+ *   4. `SetField(__Final Renderings)` — the page's own layout (when
+ *      `layout` is declared), in canonical wire form. `scoped`
+ *      placements resolve to the `<page>/Data/<slot>` GUIDs; `shared`
+ *      points at a `ContentItemRecipe`; `none` is config-driven.
+ *   5. `SetField(__Workflow)` — when `workflow` is set.
+ *
+ * Policy is `CreateOnly` (the `page-item` purpose): the registry seeds
+ * the page, authors own it thereafter, and a re-push never overwrites
+ * their edits.
+ */
+function compilePageRecipe(input, context) {
+    const recipe = recipe_1.PageRecipeSchema.parse(input);
+    if (!context.pagesRoot) {
+        throw (0, errors_1.createScaiError)(`compilePageRecipe requires context.pagesRoot; tenant-side path missing for recipe ${recipe.handle}`, "INPUT_INVALID", {
+            hint: "Set `pagesRoot` on the active envProfile in sitecoreai.cli.json — e.g. `/sitecore/content/<tenant>/<site>/Home`.",
+        });
+    }
+    const operations = [];
+    const policy = (0, policy_1.defaultPolicyForRecipe)(recipe.kind);
+    const site = (0, shared_1.siteOf)(context);
+    const itemRefKey = (0, guids_1.pageItemId)(site, recipe.handle);
+    const itemPath = (0, shared_1.joinPath)(context.pagesRoot, recipe.name);
+    operations.push({
+        op: "CreateItem",
+        policy,
+        label: `page:${recipe.handle}`,
+        id: itemRefKey,
+        path: itemPath,
+        parent: { kind: "ref-path", value: context.pagesRoot },
+        // String GUID — resolves as a refKey when the page template ships in
+        // the same set (`templateId(template)` is captured at apply time),
+        // else as a literal Sitecore template GUID.
+        templateOf: (0, guids_1.templateId)(site, recipe.template),
+        name: recipe.name,
+        fields: [
+            (0, shared_1.sharedField)(sitecore_templates_1.SYSTEM_FIELDS.ICON, { kind: "string", value: sitecore_templates_1.DEFAULT_ICON }),
+            (0, shared_1.versionedField)(sitecore_templates_1.SYSTEM_FIELDS.DISPLAY_NAME, { kind: "string", value: recipe.displayName }),
+        ],
+    });
+    // Page field values — keyed by field name on the page template.
+    for (const [fieldName, fieldValue] of Object.entries(recipe.fields)) {
+        const value = (0, content_item_1.encodeContentFieldValue)(fieldValue, recipe.handle, site);
+        if (value === null)
+            continue;
+        operations.push({
+            op: "SetField",
+            policy,
+            label: `page-field:${recipe.handle}:${fieldName}`,
+            itemRefKey,
+            // Recipe-created field — Sitecore assigns its own GUID, so this
+            // is an IR-internal refKey; the mutation resolves via `fieldName`.
+            fieldId: (0, guids_1.fieldId)(site, recipe.template, fieldName),
+            fieldName,
+            language: sitecore_templates_1.DEFAULT_LANGUAGE,
+            version: sitecore_templates_1.DEFAULT_VERSION,
+            value,
+        });
+    }
+    // Page-local layout → `__Final Renderings` (versioned — per-language
+    // final layout).
+    if (recipe.layout && Object.keys(recipe.layout.placeholders).length > 0) {
+        // Scoped placements materialise page-local datasource items under
+        // `<page>/Data`. Each conforms to the placed component's datasource
+        // template — a separate `ContentTemplateRecipe` when the component
+        // declares one, else the component template itself.
+        const scopedSlots = new Map();
+        for (const placements of Object.values(recipe.layout.placeholders)) {
+            for (const placement of placements) {
+                if (placement.datasourceRef?.kind === "scoped") {
+                    scopedSlots.set(placement.datasourceRef.slot, placement.componentHandle);
+                }
+            }
+        }
+        if (scopedSlots.size > 0) {
+            // The `<page>/Data` folder — materialised once, CreateOnly.
+            const dataFolderRefKey = (0, guids_1.datasourceId)(itemRefKey, "Data");
+            const dataFolderPath = (0, shared_1.joinPath)(itemPath, "Data");
+            operations.push({
+                op: "CreateItem",
+                policy: "CreateOnly",
+                label: `page-data-folder:${recipe.handle}`,
+                id: dataFolderRefKey,
+                path: dataFolderPath,
+                parent: { kind: "ref-recipe", refKey: itemRefKey },
+                templateOf: sitecore_templates_1.SITECORE_TEMPLATES.FOLDER,
+                name: "Data",
+                fields: [],
+            });
+            for (const [slot, componentHandle] of scopedSlots) {
+                // Resolve the component's datasource template; fall back to the
+                // component template itself (the inline-`fields:` pattern, and
+                // the only option for a standalone single-recipe compile).
+                const component = context.componentsByHandle?.get(componentHandle);
+                const datasourceTemplateHandle = component?.datasource?.template?.handle ?? componentHandle;
+                operations.push({
+                    op: "CreateItem",
+                    policy,
+                    label: `page-datasource:${recipe.handle}:${slot}`,
+                    id: (0, guids_1.datasourceId)(itemRefKey, slot),
+                    path: (0, shared_1.joinPath)(dataFolderPath, slot),
+                    parent: { kind: "ref-recipe", refKey: dataFolderRefKey },
+                    templateOf: (0, guids_1.templateId)(site, datasourceTemplateHandle),
+                    name: slot,
+                    fields: [
+                        (0, shared_1.sharedField)(sitecore_templates_1.SYSTEM_FIELDS.ICON, { kind: "string", value: sitecore_templates_1.DEFAULT_ICON }),
+                        (0, shared_1.versionedField)(sitecore_templates_1.SYSTEM_FIELDS.DISPLAY_NAME, { kind: "string", value: slot }),
+                    ],
+                });
+            }
+        }
+        const layoutXml = (0, emit_1.emitLayoutXml)(recipe.layout, {
+            parentItemId: itemRefKey,
+            deviceId: sitecore_templates_1.DEFAULT_DEVICE_ID,
+            renderingIdFor: (handle) => (0, guids_1.renderingId)(site, handle),
+            contentItemIdFor: (handle) => (0, guids_1.contentItemId)(site, handle),
+            // A page has a content home — scoped placements resolve against
+            // the `<page>/Data/<slot>` items materialised just above.
+            allowScoped: true,
+            scopedDatasourceIdFor: (slot) => (0, guids_1.datasourceId)(itemRefKey, slot),
+            mode: "canonical",
+        });
+        if (layoutXml.length > 0) {
+            operations.push({
+                op: "SetField",
+                policy,
+                label: `page-layout:${recipe.handle}`,
+                itemRefKey,
+                fieldId: sitecore_templates_1.LAYOUT_FIELDS.FINAL_RENDERINGS,
+                language: sitecore_templates_1.DEFAULT_LANGUAGE,
+                version: sitecore_templates_1.DEFAULT_VERSION,
+                value: { kind: "string", value: layoutXml },
+            });
+        }
+    }
+    if (recipe.workflow) {
+        operations.push({
+            op: "SetField",
+            policy,
+            label: `page-workflow:${recipe.handle}`,
+            itemRefKey,
+            fieldId: deriveStandardFieldId(itemRefKey, "__Workflow"),
+            fieldName: "__Workflow",
+            value: { kind: "ref-recipe", refKey: (0, guids_1.workflowId)(recipe.workflow) },
+        });
+    }
+    return operations_1.OperationIrSchema.parse({
+        schemaVersion: "1",
+        recipeHandle: recipe.handle,
+        operations,
+    });
+}
+/**
+ * Stable refKey for a Sitecore standard field on `itemRefKey`. Same
+ * derivation as `compile/content-item.ts` — declared separately to keep
+ * the modules independent.
+ */
+const STANDARD_FIELD_REFKEY_NAMESPACE = (0, uuid_1.v5)("standard-field", "d6c28e9f-21f3-56ee-ada3-f2a947c3d475" // NAMESPACE_ROOT
+);
+const deriveStandardFieldId = (parentRefKey, fieldName) => (0, uuid_1.v5)(`${parentRefKey}:${fieldName}`, STANDARD_FIELD_REFKEY_NAMESPACE);

package/dist/recipe/compile/partial-design.d.ts

@@ -15,4 +15,3 @@ import { type CompileContext } from "./shared";
  * resolve the same way.)
  */
 export declare function compilePartialDesignRecipe(input: PartialDesignRecipe, context: CompileContext): OperationIr;
-//# sourceMappingURL=partial-design.d.ts.map

package/dist/recipe/compile/partial-design.js

@@ -25,7 +25,7 @@ const shared_1 = require("./shared");
 function compilePartialDesignRecipe(input, context) {
     const recipe = recipe_1.PartialDesignRecipeSchema.parse(input);
     if (!context.partialDesignsRoot) {
-        throw (0, errors_1.createCliError)(`compilePartialDesignRecipe requires context.partialDesignsRoot; tenant-side path missing for recipe ${recipe.handle}`, "INPUT_INVALID");
+        throw (0, errors_1.createScaiError)(`compilePartialDesignRecipe requires context.partialDesignsRoot; tenant-side path missing for recipe ${recipe.handle}`, "INPUT_INVALID");
     }
     const operations = [];
     const policy = (0, policy_1.defaultPolicyForRecipe)(recipe.kind);

package/dist/recipe/compile/placeholder.d.ts

@@ -0,0 +1,23 @@
+import { type OperationIr } from "../ir/operations";
+import { type PlaceholderRecipe } from "../schema/recipe";
+import { type CompileContext } from "./shared";
+/**
+ * Compile a `PlaceholderRecipe` to an Operation IR.
+ *
+ * A standalone placeholder emits no ops on its own — a Placeholder
+ * Settings item's `Allowed Controls` whitelist is cross-recipe by
+ * nature (it unions this recipe's `allowedComponents` with every
+ * component that names the same `key` in `placedIn`). A per-recipe
+ * `SetField` would full-replace and clobber those contributions.
+ *
+ * So both halves of the hybrid model — standalone `PlaceholderRecipe`
+ * and inline `ComponentTemplateRecipe.placeholders` — are materialised
+ * by one cross-recipe aggregate, `buildPlaceholderSettingsAggregate` in
+ * `compile.ts`, which emits one `CreateItem` + one `SetField(Allowed
+ * Controls)` per unique placeholder key. This per-recipe compiler
+ * returns an empty IR; use `compileRecipeSet`.
+ *
+ * Same pattern as `compileSectionDefinitionRecipe`. The recipe is still
+ * parsed here so authors get schema feedback on a single-recipe compile.
+ */
+export declare function compilePlaceholderRecipe(input: PlaceholderRecipe, _context: CompileContext): OperationIr;

package/dist/recipe/compile/placeholder.js

@@ -0,0 +1,32 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.compilePlaceholderRecipe = compilePlaceholderRecipe;
+const operations_1 = require("../ir/operations");
+const recipe_1 = require("../schema/recipe");
+/**
+ * Compile a `PlaceholderRecipe` to an Operation IR.
+ *
+ * A standalone placeholder emits no ops on its own — a Placeholder
+ * Settings item's `Allowed Controls` whitelist is cross-recipe by
+ * nature (it unions this recipe's `allowedComponents` with every
+ * component that names the same `key` in `placedIn`). A per-recipe
+ * `SetField` would full-replace and clobber those contributions.
+ *
+ * So both halves of the hybrid model — standalone `PlaceholderRecipe`
+ * and inline `ComponentTemplateRecipe.placeholders` — are materialised
+ * by one cross-recipe aggregate, `buildPlaceholderSettingsAggregate` in
+ * `compile.ts`, which emits one `CreateItem` + one `SetField(Allowed
+ * Controls)` per unique placeholder key. This per-recipe compiler
+ * returns an empty IR; use `compileRecipeSet`.
+ *
+ * Same pattern as `compileSectionDefinitionRecipe`. The recipe is still
+ * parsed here so authors get schema feedback on a single-recipe compile.
+ */
+function compilePlaceholderRecipe(input, _context) {
+    const recipe = recipe_1.PlaceholderRecipeSchema.parse(input);
+    return operations_1.OperationIrSchema.parse({
+        schemaVersion: "1",
+        recipeHandle: recipe.handle,
+        operations: [],
+    });
+}

package/dist/recipe/compile/section-definition.d.ts

@@ -15,4 +15,3 @@ import { type CompileContext } from "./shared";
  * The recipe is still validated here so authors get schema feedback.
  */
 export declare function compileSectionDefinitionRecipe(input: SectionDefinitionRecipe, _context: CompileContext): OperationIr;
-//# sourceMappingURL=section-definition.d.ts.map

package/dist/recipe/compile/shared.d.ts

@@ -1,5 +1,5 @@
 import { type FieldValue, type Operation, type PushPolicy } from "../ir/operations";
-import { type FieldDefinition, type ParamDefinition } from "../schema/recipe";
+import { type FieldDefinition, type DesignParameter } from "../schema/recipe";
 /**
  * Where a recipe's items land in the Sitecore content tree. Tenant-side
  * config — recipes themselves are tenant-agnostic. The compiler emits
@@ -110,7 +110,7 @@ export interface CompileContext {
      * Each `EnumerationRecipe` lands at `<enumerationsRoot>/<EnumName>`
      * with one child item per value. Required for `EnumerationRecipe`
      * compilation; required for `ComponentTemplateRecipe`/
-     * `ParametersTemplateRecipe` compilation when any field carries
+     * `DesignParametersTemplateRecipe` compilation when any field carries
      * `sitecore.enumHandle`. Compiler throws INPUT_INVALID with a clear
      * message when needed but missing.
      */
@@ -157,6 +157,16 @@ export interface CompileContext {
      * no way to resolve the folder path.
      */
     enumsByHandle?: ReadonlyMap<string, import("../schema/recipe").EnumerationRecipe>;
+    /**
+     * Cross-recipe map of component handles → `ComponentTemplateRecipe`,
+     * populated by `compileRecipeSet`. `compilePageRecipe` uses it to
+     * resolve a scoped placement's component to its datasource template:
+     * `datasource.template.handle` when the component declares a separate
+     * content template, else the component template itself. Absent for
+     * standalone single-recipe compiles — the page compiler then assumes
+     * the component template is its own datasource template.
+     */
+    componentsByHandle?: ReadonlyMap<string, import("../schema/recipe").ComponentTemplateRecipe>;
     /**
      * SXA Available Renderings root, e.g.
      * `/sitecore/content/<siteCollection>/<site>/Presentation/Available Renderings`.
@@ -173,6 +183,33 @@ export interface CompileContext {
      * skipped — there's no section to bucket them under.
      */
     availableRenderingsRoot?: string;
+    /**
+     * SXA Placeholder Settings root, e.g.
+     * `/sitecore/content/<site>/Presentation/Placeholder Settings`. Where
+     * `buildPlaceholderSettingsAggregate` creates the Placeholder Settings
+     * items for every recipe-defined placeholder key (standalone
+     * `PlaceholderRecipe` + inline `ComponentTemplateRecipe.placeholders`).
+     *
+     * Required when the recipe set contains any `PlaceholderRecipe` or any
+     * component with inline `placeholders`; the aggregate throws
+     * INPUT_INVALID with a clear hint when needed but missing.
+     */
+    placeholderSettingsRoot?: string;
+    /**
+     * Templates root for `PageTemplateRecipe` items, e.g.
+     * `/sitecore/templates/Project/<site>`. Page templates land at
+     * `<pageTemplatesRoot>/[<group>/]<name>`. Optional — falls back to
+     * `templatesRoot` when unset.
+     */
+    pageTemplatesRoot?: string;
+    /**
+     * Site content-tree root under which `PageRecipe` items land —
+     * typically `/sitecore/content/<tenant>/<site>` or its `Home`
+     * subtree. Required for `PageRecipe` compilation; the compiler
+     * throws INPUT_INVALID with a clear hint when a page recipe is in
+     * the set but this is unset.
+     */
+    pagesRoot?: string;
 }
 export declare const PARAMS_SECTION_NAME = "Parameters";
 export declare const DEFAULT_FIELDS_SECTION = "Content";
@@ -221,7 +258,7 @@ export declare const resolveComponentFoldersBucketPath: (context: CompileContext
  * section (legacy callers), parameters templates land directly under
  * `templatesRoot` to match the old flat layout.
  */
-export declare const resolvePresentationParametersBucketPath: (context: CompileContext, section: string | undefined) => string;
+export declare const resolvePresentationDesignParametersBucketPath: (context: CompileContext, section: string | undefined) => string;
 /**
  * Resolve the parent path for the rendering item.
  *
@@ -248,7 +285,7 @@ export declare const ensureComponentFoldersBucket: (operations: Operation[], con
  * Ensure a "Presentation Parameters" subfolder exists under the section
  * folder. Idempotent.
  */
-export declare const ensurePresentationParametersBucket: (operations: Operation[], context: CompileContext, section: string, emittedFolders: Set<string>) => string;
+export declare const ensurePresentationDesignParametersBucket: (operations: Operation[], context: CompileContext, section: string, emittedFolders: Set<string>) => string;
 /**
  * Ensure a section subfolder under the renderings tree exists —
  * `<renderingsRoot>/<section>/`. Mirrors the templates side; the
@@ -261,6 +298,15 @@ export declare const ensureRenderingsSectionFolder: (operations: Operation[], co
  * repeated calls within one recipe-set compile.
  */
 export declare const ensureContentModelsGroupFolder: (operations: Operation[], context: CompileContext, group: string, emittedFolders: Set<string>) => string | undefined;
+/**
+ * Ensure a page-templates group folder exists under `<root>/<group>`,
+ * where `<root>` is `pageTemplatesRoot` (falling back to `templatesRoot`).
+ * Returns the refKey for `CreateItem.parent`, or `undefined` when no
+ * root resolves. Idempotent across one recipe-set compile via
+ * `emittedFolders`. Mirror of `ensureContentModelsGroupFolder` for the
+ * page-template tree.
+ */
+export declare const ensurePageTemplatesGroupFolder: (operations: Operation[], context: CompileContext, group: string, emittedFolders: Set<string>) => string | undefined;
 /**
  * Per-site SXA-style enumeration template trio. Three templates with
  * distinct roles — emitted as siblings under the site's
@@ -364,7 +410,7 @@ export interface BuildFieldOpInput {
     fieldPath: string;
     parentRefKey: string;
     labelPrefix: string;
-    field: FieldDefinition | ParamDefinition;
+    field: FieldDefinition | DesignParameter;
     zeroBasedIndex: number;
     policy: PushPolicy;
     /**
@@ -438,5 +484,4 @@ export declare function buildFieldOp(input: BuildFieldOpInput): Operation[];
  * derived GUID won't exist on the tenant and the SV write fails at
  * apply time — author error, not silently masked here.
  */
-export declare function buildStandardValuesFieldEntries(site: string, handle: string, fields: ReadonlyArray<FieldDefinition | ParamDefinition>, fieldIdResolver?: (site: string, handle: string, fieldName: string) => string): FieldValue[];
-//# sourceMappingURL=shared.d.ts.map
+export declare function buildStandardValuesFieldEntries(site: string, handle: string, fields: ReadonlyArray<FieldDefinition | DesignParameter>, fieldIdResolver?: (site: string, handle: string, fieldName: string) => string): FieldValue[];