@sitecoreai-labs/sitecoreai-cli 0.0.4 → 0.1.0

package/dist/recipe/compile/content-item.d.ts

@@ -1,31 +1,51 @@
-import { type OperationIr } from "../ir/operations";
-import { type ContentItemRecipe } from "../schema/recipe";
+import { type OperationIr, type RefValue } from "../ir/operations";
+import { type ContentFieldValue, type ContentItemRecipe } from "../schema/recipe";
 import { type CompileContext } from "./shared";
 /**
  * Compile a `ContentItemRecipe` to an Operation IR.
  *
- * Emits one `CreateItem` for the content item plus one `SetField` per
- * field value. The item's `templateOf` resolves via `templateId(templateType)`
- * — the corresponding `ContentTemplateRecipe` (or `ComponentTemplateRecipe`)
- * must ship in the same set so the executor's captured-itemId map carries
- * its server-assigned GUID at apply time. The cross-recipe validator
- * (`validateRecipeSet`) catches missing template references before push.
+ * Emits a `CreateItem` for the item, then — by the recipe's mode:
  *
- * Field values dispatch on `shape` to one of the encoders below. Most
- * shapes encode at compile time to a `kind: "string"` value (Sitecore's
- * stored representation is always a string); `reference` shapes emit
- * `kind: "ref-recipe-list"` so the executor substitutes captured itemIds
- * at apply time.
+ *  - **simple** (`fields` [+ `translations`]) — `SetField`s for the primary
+ *    language at version 1; per translation language, an `AddItemVersion`
+ *    that materialises the language version, plus its `SetField`s.
+ *  - **story** (`versions`) — per (language, numbered version): an
+ *    `AddItemVersion` (except the default-language v1 the `CreateItem`
+ *    already made) and that version's `SetField`s.
+ *
+ * `storage: shared` fields are emitted as `SetField`s with no
+ * language/version. The two modes are mutually exclusive — `versions`
+ * alongside `fields`/`translations` is rejected (`INPUT_INVALID`); Zod
+ * can't express the XOR on a `discriminatedUnion` member, so the compiler
+ * enforces it.
+ *
+ * Op order is `CreateItem → AddItemVersion…s → SetField…s` so every
+ * per-version `SetField` lands on a version that already exists.
+ *
+ * The item's `templateOf` resolves via `templateId(templateType)` — the
+ * corresponding template recipe must ship in the same set; the cross-recipe
+ * validator (`validateRecipeSet`) catches a missing reference before push.
+ * Field values dispatch on `shape` (see `encodeContentFieldValue`).
+ *
+ * Per-version `workflowState` resolves to a `__Workflow state` SetField
+ * (against the item's `workflow`), `date` to a `__Created` SetField, and
+ * `layout` to a `__Final Renderings` SetField.
  *
  * Phase 4 v1 limitations:
- *  - `link-internal` is deferred — the wire format is XML wrapping a
- *    refKey-resolved GUID, which requires a new RefValue kind. Authors
- *    should use `reference` (with a single-element `refs` array) for
- *    Droplink/Reference fields, or `link-external` for external URLs.
- *  - `image.mediaPath` is treated as an opaque path — no media-item
- *    upload. Sitecore renders the field if a media library item exists
- *    at that path; otherwise the field is empty until media seeding
- *    lands in Phase 5+.
+ *  - per-version personalization `variants` are not yet compiled — a story
+ *    recipe that sets them is rejected with a clear error rather than
+ *    silently dropped.
+ *  - `link-internal` is deferred — authors use `reference` (single-element
+ *    `refs`) for Droplink/Reference fields, or `link-external` for URLs.
+ *  - `image.mediaPath` is an opaque path — no media-item upload.
  */
 export declare function compileContentItemRecipe(input: ContentItemRecipe, context: CompileContext): OperationIr;
-//# sourceMappingURL=content-item.d.ts.map
+/**
+ * Encode one ContentFieldValue to a RefValue. Returns null when the
+ * shape is deferred (e.g. `link-internal` in Phase 4 v1) — the caller
+ * skips emitting a SetField op for it. Throws on truly invalid input.
+ *
+ * Exported so `compilePageRecipe` reuses the exact same field-value
+ * encoding for page-item fields.
+ */
+export declare const encodeContentFieldValue: (value: ContentFieldValue, recipeHandle: string, site: string) => RefValue | null;

package/dist/recipe/compile/content-item.js

@@ -1,51 +1,70 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
+exports.encodeContentFieldValue = void 0;
 exports.compileContentItemRecipe = compileContentItemRecipe;
+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 emit_1 = require("../layout/emit");
 const recipe_1 = require("../schema/recipe");
 const shared_1 = require("./shared");
 /**
  * Compile a `ContentItemRecipe` to an Operation IR.
  *
- * Emits one `CreateItem` for the content item plus one `SetField` per
- * field value. The item's `templateOf` resolves via `templateId(templateType)`
- * — the corresponding `ContentTemplateRecipe` (or `ComponentTemplateRecipe`)
- * must ship in the same set so the executor's captured-itemId map carries
- * its server-assigned GUID at apply time. The cross-recipe validator
- * (`validateRecipeSet`) catches missing template references before push.
+ * Emits a `CreateItem` for the item, then — by the recipe's mode:
  *
- * Field values dispatch on `shape` to one of the encoders below. Most
- * shapes encode at compile time to a `kind: "string"` value (Sitecore's
- * stored representation is always a string); `reference` shapes emit
- * `kind: "ref-recipe-list"` so the executor substitutes captured itemIds
- * at apply time.
+ *  - **simple** (`fields` [+ `translations`]) — `SetField`s for the primary
+ *    language at version 1; per translation language, an `AddItemVersion`
+ *    that materialises the language version, plus its `SetField`s.
+ *  - **story** (`versions`) — per (language, numbered version): an
+ *    `AddItemVersion` (except the default-language v1 the `CreateItem`
+ *    already made) and that version's `SetField`s.
+ *
+ * `storage: shared` fields are emitted as `SetField`s with no
+ * language/version. The two modes are mutually exclusive — `versions`
+ * alongside `fields`/`translations` is rejected (`INPUT_INVALID`); Zod
+ * can't express the XOR on a `discriminatedUnion` member, so the compiler
+ * enforces it.
+ *
+ * Op order is `CreateItem → AddItemVersion…s → SetField…s` so every
+ * per-version `SetField` lands on a version that already exists.
+ *
+ * The item's `templateOf` resolves via `templateId(templateType)` — the
+ * corresponding template recipe must ship in the same set; the cross-recipe
+ * validator (`validateRecipeSet`) catches a missing reference before push.
+ * Field values dispatch on `shape` (see `encodeContentFieldValue`).
+ *
+ * Per-version `workflowState` resolves to a `__Workflow state` SetField
+ * (against the item's `workflow`), `date` to a `__Created` SetField, and
+ * `layout` to a `__Final Renderings` SetField.
  *
  * Phase 4 v1 limitations:
- *  - `link-internal` is deferred — the wire format is XML wrapping a
- *    refKey-resolved GUID, which requires a new RefValue kind. Authors
- *    should use `reference` (with a single-element `refs` array) for
- *    Droplink/Reference fields, or `link-external` for external URLs.
- *  - `image.mediaPath` is treated as an opaque path — no media-item
- *    upload. Sitecore renders the field if a media library item exists
- *    at that path; otherwise the field is empty until media seeding
- *    lands in Phase 5+.
+ *  - per-version personalization `variants` are not yet compiled — a story
+ *    recipe that sets them is rejected with a clear error rather than
+ *    silently dropped.
+ *  - `link-internal` is deferred — authors use `reference` (single-element
+ *    `refs`) for Droplink/Reference fields, or `link-external` for URLs.
+ *  - `image.mediaPath` is an opaque path — no media-item upload.
  */
 function compileContentItemRecipe(input, context) {
     const recipe = recipe_1.ContentItemRecipeSchema.parse(input);
     if (!context.contentItemsRoot) {
-        throw (0, errors_1.createCliError)(`compileContentItemRecipe requires context.contentItemsRoot; tenant-side path missing for recipe ${recipe.handle}`, "INPUT_INVALID");
+        throw (0, errors_1.createScaiError)(`compileContentItemRecipe requires context.contentItemsRoot; tenant-side path missing for recipe ${recipe.handle}`, "INPUT_INVALID");
+    }
+    // Simple (fields/translations) XOR story (versions) — never both.
+    const isStory = recipe.versions !== undefined;
+    if (isStory && (recipe.translations !== undefined || Object.keys(recipe.fields).length > 0)) {
+        throw (0, errors_1.createScaiError)(`ContentItemRecipe '${recipe.handle}': a recipe is either simple (fields/translations) or a story (versions), not both.`, "INPUT_INVALID");
     }
-    const operations = [];
     const policy = (0, policy_1.defaultPolicyForRecipe)(recipe.kind);
     const site = (0, shared_1.siteOf)(context);
     const itemRefKey = (0, guids_1.contentItemId)(site, recipe.handle);
     const itemPath = (0, shared_1.joinPath)(context.contentItemsRoot, recipe.name);
     const templateRefKey = (0, guids_1.templateId)(site, recipe.templateType);
-    operations.push({
+    const createItem = {
         op: "CreateItem",
         policy,
         label: `content-item:${recipe.handle}`,
@@ -53,38 +72,158 @@ function compileContentItemRecipe(input, context) {
         path: itemPath,
         parent: { kind: "ref-path", value: context.contentItemsRoot },
         // String GUID — the executor treats this as a refKey when it matches a
-        // captured-itemId entry (the ContentTemplateRecipe / ComponentTemplateRecipe
-        // for `recipe.templateType` registers `templateId(handle)` at apply
-        // time), else as a literal Sitecore template GUID.
+        // captured-itemId entry (the template recipe registers `templateId(handle)`),
+        // else as a literal Sitecore template GUID.
         templateOf: templateRefKey,
         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 }),
         ],
-    });
-    for (const [fieldName, fieldValue] of Object.entries(recipe.fields)) {
-        const value = encodeContentFieldValue(fieldValue, recipe.handle, site);
-        if (value === null)
-            continue;
-        const fieldGuid = (0, guids_1.fieldId)(site, recipe.templateType, fieldName);
+    };
+    // AddItemVersion ops are emitted before SetFields so every per-version
+    // SetField lands on a version that already exists.
+    const versionOps = [];
+    const fieldOps = [];
+    /** Emit one SetField per field value at the given (language, version). */
+    const emitFields = (fields, language, version, labelTag) => {
+        for (const [fieldName, fieldValue] of Object.entries(fields)) {
+            const value = (0, exports.encodeContentFieldValue)(fieldValue, recipe.handle, site);
+            if (value === null)
+                continue;
+            fieldOps.push({
+                op: "SetField",
+                policy,
+                label: `content-item-field:${recipe.handle}:${labelTag}:${fieldName}`,
+                itemRefKey,
+                // Recipe-created field — Sitecore assigns the Template Field its own
+                // GUID, so `fieldId` is only an IR-internal refKey; the mutation and
+                // the planner's drift check resolve by `fieldName`.
+                fieldId: (0, guids_1.fieldId)(site, recipe.templateType, fieldName),
+                fieldName,
+                ...(language !== undefined && { language }),
+                ...(version !== undefined && { version }),
+                value,
+            });
+        }
+    };
+    // Item-level `storage: shared` fields — one value, no language/version.
+    emitFields(recipe.shared ?? {}, undefined, undefined, "shared");
+    if (isStory) {
+        for (const [language, entries] of Object.entries(recipe.versions ?? {})) {
+            for (const entry of [...entries].sort((a, b) => a.version - b.version)) {
+                if ((entry.variants?.length ?? 0) > 0) {
+                    throw (0, errors_1.createScaiError)(`ContentItemRecipe '${recipe.handle}': per-version personalization variants are not yet compiled.`, "INPUT_INVALID", {
+                        hint: 'Author per-version fields, workflowState, date and layout for now — see docs/recipe-sync-architecture.md, "Content versioning — seeding a story".',
+                    });
+                }
+                // `CreateItem` already made the default-language version 1; every
+                // other (language, version) cell needs an explicit AddItemVersion.
+                if (!(language === sitecore_templates_1.DEFAULT_LANGUAGE && entry.version === sitecore_templates_1.DEFAULT_VERSION)) {
+                    versionOps.push({
+                        op: "AddItemVersion",
+                        policy,
+                        label: `content-item-version:${recipe.handle}:${language}:${entry.version}`,
+                        itemRefKey,
+                        language,
+                        version: entry.version,
+                    });
+                }
+                const versionTag = `${language}.v${entry.version}`;
+                emitFields(entry.fields, language, entry.version, versionTag);
+                // The version's `__Workflow state` — resolved against the item's
+                // workflow (a workflow state can't exist without a workflow).
+                if (entry.workflowState !== undefined) {
+                    if (!recipe.workflow) {
+                        throw (0, errors_1.createScaiError)(`ContentItemRecipe '${recipe.handle}': version ${versionTag} sets workflowState ` +
+                            `'${entry.workflowState}' but the recipe has no \`workflow\`.`, "INPUT_INVALID", {
+                            hint: "Set the item-level `workflow` (a WorkflowRecipe handle) so the state resolves.",
+                        });
+                    }
+                    fieldOps.push({
+                        op: "SetField",
+                        policy,
+                        label: `content-item-workflow-state:${recipe.handle}:${versionTag}`,
+                        itemRefKey,
+                        fieldId: deriveStandardFieldId(itemRefKey, "__Workflow state"),
+                        fieldName: "__Workflow state",
+                        language,
+                        version: entry.version,
+                        value: {
+                            kind: "ref-recipe",
+                            refKey: (0, guids_1.workflowStateId)(recipe.workflow, entry.workflowState),
+                        },
+                    });
+                }
+                // The version's narrative date → `__Created`, backdating the
+                // version so a seeded story's history reads true.
+                if (entry.date !== undefined) {
+                    fieldOps.push({
+                        op: "SetField",
+                        policy,
+                        label: `content-item-version-date:${recipe.handle}:${versionTag}`,
+                        itemRefKey,
+                        fieldId: deriveStandardFieldId(itemRefKey, "__Created"),
+                        fieldName: "__Created",
+                        language,
+                        version: entry.version,
+                        value: { kind: "string", value: toSitecoreDate(entry.date, "datetime") },
+                    });
+                }
+                // The version's `__Final Renderings` (per-version layout). A content
+                // item has no `Data` home, so scoped datasources are disallowed — a
+                // version layout references shared datasources by handle.
+                if (entry.layout !== undefined) {
+                    const layoutXml = (0, emit_1.emitLayoutXml)(entry.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),
+                        allowScoped: false,
+                        mode: "canonical",
+                    });
+                    if (layoutXml.length > 0) {
+                        fieldOps.push({
+                            op: "SetField",
+                            policy,
+                            label: `content-item-layout:${recipe.handle}:${versionTag}`,
+                            itemRefKey,
+                            fieldId: sitecore_templates_1.LAYOUT_FIELDS.FINAL_RENDERINGS,
+                            language,
+                            version: entry.version,
+                            value: { kind: "string", value: layoutXml },
+                        });
+                    }
+                }
+            }
+        }
+    }
+    else {
+        // Simple mode — primary language at version 1, then a version per
+        // translation language.
+        emitFields(recipe.fields, sitecore_templates_1.DEFAULT_LANGUAGE, sitecore_templates_1.DEFAULT_VERSION, sitecore_templates_1.DEFAULT_LANGUAGE);
+        for (const [language, translation] of Object.entries(recipe.translations ?? {})) {
+            versionOps.push({
+                op: "AddItemVersion",
+                policy,
+                label: `content-item-version:${recipe.handle}:${language}:${sitecore_templates_1.DEFAULT_VERSION}`,
+                itemRefKey,
+                language,
+                version: sitecore_templates_1.DEFAULT_VERSION,
+            });
+            emitFields(translation.fields, language, sitecore_templates_1.DEFAULT_VERSION, language);
+        }
+    }
+    const operations = [createItem, ...versionOps, ...fieldOps];
+    if (recipe.workflow) {
         operations.push({
             op: "SetField",
             policy,
-            label: `content-item-field:${recipe.handle}:${fieldName}`,
+            label: `content-item-workflow:${recipe.handle}`,
             itemRefKey,
-            fieldId: fieldGuid,
-            // Recipe-created field — Sitecore assigns its own GUID to the
-            // Template Field item, so fieldGuid is only an IR-internal refKey.
-            // The mutation needs the human-readable name; planner uses it for
-            // diff matching against the remote item's field-by-name.
-            fieldName,
-            // Versioned: content-item field values are language/version-scoped.
-            // Default language/version are filled in by versionedField helper —
-            // duplicating its shape here so the SetField op carries them.
-            language: sitecore_templates_1.DEFAULT_LANGUAGE,
-            version: sitecore_templates_1.DEFAULT_VERSION,
-            value,
+            fieldId: deriveStandardFieldId(itemRefKey, "__Workflow"),
+            fieldName: "__Workflow",
+            value: { kind: "ref-recipe", refKey: (0, guids_1.workflowId)(recipe.workflow) },
         });
     }
     return operations_1.OperationIrSchema.parse({
@@ -93,6 +232,15 @@ function compileContentItemRecipe(input, context) {
         operations,
     });
 }
+/**
+ * Stable refKey for a Sitecore standard field on `itemRefKey`. Mirrors
+ * the pattern in `compile/workflow.ts` — the canonical `fieldName` is
+ * what the apply path uses for resolution, so `fieldId` only needs to
+ * be a deterministic per-(item, field) refKey.
+ */
+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);
 /**
  * Format a recipe `date` (ISO `YYYY-MM-DD`) or `datetime` (ISO 8601 with
  * timezone) into Sitecore's stored format `yyyyMMddTHHmmssZ`.
@@ -100,7 +248,7 @@ function compileContentItemRecipe(input, context) {
 const toSitecoreDate = (iso, kind) => {
     const parsed = new Date(iso);
     if (Number.isNaN(parsed.getTime())) {
-        throw (0, errors_1.createCliError)(`ContentFieldValue ${kind}: '${iso}' is not a valid ISO date`, "INPUT_INVALID");
+        throw (0, errors_1.createScaiError)(`ContentFieldValue ${kind}: '${iso}' is not a valid ISO date`, "INPUT_INVALID");
     }
     if (kind === "date") {
         // Date-only — pin to UTC midnight to keep the output deterministic
@@ -154,6 +302,9 @@ const escapeXmlAttr = (s) => s
  * Encode one ContentFieldValue to a RefValue. Returns null when the
  * shape is deferred (e.g. `link-internal` in Phase 4 v1) — the caller
  * skips emitting a SetField op for it. Throws on truly invalid input.
+ *
+ * Exported so `compilePageRecipe` reuses the exact same field-value
+ * encoding for page-item fields.
  */
 const encodeContentFieldValue = (value, recipeHandle, site) => {
     switch (value.shape) {
@@ -177,7 +328,7 @@ const encodeContentFieldValue = (value, recipeHandle, site) => {
             // Deferred: General Link XML wrapping a refKey-resolved GUID needs
             // a new RefValue kind. Recipe authors targeting Phase 4 should use
             // `reference` (single-element refs[]) for Droplink-shaped fields.
-            throw (0, errors_1.createCliError)(`ContentItemRecipe '${recipeHandle}': link-internal is deferred to Phase 5. ` +
+            throw (0, errors_1.createScaiError)(`ContentItemRecipe '${recipeHandle}': link-internal is deferred to Phase 5. ` +
                 `Use 'reference' shape with a single-element refs[] for Droplink/Reference fields, ` +
                 `or 'link-external' with an absolute URL for now.`, "INPUT_INVALID");
         case "reference":
@@ -187,3 +338,4 @@ const encodeContentFieldValue = (value, recipeHandle, site) => {
             };
     }
 };
+exports.encodeContentFieldValue = encodeContentFieldValue;

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

@@ -15,4 +15,3 @@ import { type CompileContext } from "./shared";
  *   - Without `contentModelsRoot` → legacy `<templatesRoot>/<name>`.
  */
 export declare function compileContentTemplateRecipe(input: ContentTemplateRecipe, context: CompileContext, emittedFolders?: Set<string>): OperationIr;
-//# sourceMappingURL=content-template.d.ts.map

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

@@ -1,6 +1,8 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.compileContentTemplateRecipe = compileContentTemplateRecipe;
+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");
@@ -35,6 +37,7 @@ function compileContentTemplateRecipe(input, context, emittedFolders = new Set()
             parentPath = context.contentModelsRoot;
         }
     }
+    const policy = (0, policy_1.defaultPolicyForRecipe)(recipe.kind);
     (0, shared_1.emitDatasourceTemplate)(operations, {
         handle: recipe.handle,
         name: recipe.name,
@@ -43,10 +46,31 @@ function compileContentTemplateRecipe(input, context, emittedFolders = new Set()
         insertOptions: recipe.insertOptions,
         ...(parentPath !== undefined && { parentPath }),
         ...(parentRefKey !== undefined && { parentRefKey }),
-    }, context, sitecore_templates_1.DEFAULT_ICON, (0, policy_1.defaultPolicyForRecipe)(recipe.kind));
+    }, context, sitecore_templates_1.DEFAULT_ICON, policy);
+    if (recipe.defaultWorkflow) {
+        const site = (0, shared_1.siteOf)(context);
+        const svRefKey = (0, guids_1.standardValuesId)(site, recipe.handle);
+        operations.push({
+            op: "SetField",
+            policy,
+            label: `content-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`. See
+ * `compile/content-item.ts` for the rationale — same shape, separate
+ * declaration 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/design-parameters-template.d.ts

@@ -0,0 +1,13 @@
+import { type OperationIr } from "../ir/operations";
+import { type DesignParametersTemplateRecipe } from "../schema/recipe";
+import { type CompileContext } from "./shared";
+/**
+ * Compile a standalone `DesignParametersTemplateRecipe` to an Operation IR.
+ *
+ * Lands at
+ * `<componentsRoot>/<section>/Presentation Parameters/<name>` —
+ * mirrors the layout that the synthesised inline parameters template
+ * uses, so a standalone recipe and an inline-hoisted one occupy the
+ * same Sitecore path.
+ */
+export declare function compileDesignParametersTemplateRecipe(input: DesignParametersTemplateRecipe, context: CompileContext, emittedFolders?: Set<string>): OperationIr;

package/dist/recipe/compile/design-parameters-template.js

@@ -0,0 +1,92 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.compileDesignParametersTemplateRecipe = compileDesignParametersTemplateRecipe;
+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 shared_1 = require("./shared");
+/**
+ * Compile a standalone `DesignParametersTemplateRecipe` to an Operation IR.
+ *
+ * Lands at
+ * `<componentsRoot>/<section>/Presentation Parameters/<name>` —
+ * mirrors the layout that the synthesised inline parameters template
+ * uses, so a standalone recipe and an inline-hoisted one occupy the
+ * same Sitecore path.
+ */
+function compileDesignParametersTemplateRecipe(input, context, emittedFolders = new Set()) {
+    const recipe = recipe_1.DesignParametersTemplateRecipeSchema.parse(input);
+    const operations = [];
+    const policy = (0, policy_1.defaultPolicyForRecipe)(recipe.kind);
+    const icon = recipe.icon ?? sitecore_templates_1.DEFAULT_ICON;
+    const site = (0, shared_1.siteOf)(context);
+    (0, shared_1.ensureSectionFolder)(operations, context, recipe.section, emittedFolders);
+    const bucketRefKey = (0, shared_1.ensurePresentationDesignParametersBucket)(operations, context, recipe.section, emittedFolders);
+    const parentPath = (0, shared_1.resolvePresentationDesignParametersBucketPath)(context, recipe.section);
+    // The standalone parameters template lands at the same identity
+    // (designParametersTemplateId) as inline-hoisted ones — keeps re-pushes
+    // idempotent if a recipe migrates from inline to standalone.
+    const tplRefKey = (0, guids_1.designParametersTemplateId)(site, recipe.handle);
+    const tplPath = (0, shared_1.joinPath)(parentPath, recipe.name);
+    operations.push({
+        op: "CreateItem",
+        policy,
+        label: `parameters-template:${recipe.handle}`,
+        id: tplRefKey,
+        path: tplPath,
+        parent: { kind: "ref-recipe", refKey: bucketRefKey },
+        templateOf: sitecore_templates_1.SITECORE_TEMPLATES.TEMPLATE,
+        name: recipe.name,
+        fields: [
+            (0, shared_1.sharedField)(sitecore_templates_1.SYSTEM_FIELDS.ICON, { kind: "string", value: icon }),
+            (0, shared_1.versionedField)(sitecore_templates_1.SYSTEM_FIELDS.DISPLAY_NAME, { kind: "string", value: recipe.displayName }),
+        ],
+    });
+    operations.push({
+        op: "SetBaseTemplates",
+        policy,
+        label: `parameters-base-templates:${recipe.handle}`,
+        itemRefKey: tplRefKey,
+        // The SXA Headless params bases (BaseRenderingParameters +
+        // _PerSiteStandardValues + the other SXA Headless marker) are what
+        // make the Pages editor recognise this as a parameters shape and
+        // surface its fields in the rendering parameters dialog. Vanilla
+        // Sitecore's "Standard Rendering Parameters" doesn't work here —
+        // verified empirically on tenant introspection.
+        baseTemplates: [...sitecore_templates_1.SXA_HEADLESS_PARAMS_BASE_TEMPLATES],
+    });
+    const secRefKey = (0, guids_1.designParametersSectionId)(site, recipe.handle, shared_1.PARAMS_SECTION_NAME);
+    const secPath = (0, shared_1.joinPath)(tplPath, shared_1.PARAMS_SECTION_NAME);
+    operations.push({
+        op: "CreateItem",
+        policy,
+        label: `parameters-section:${recipe.handle}/${shared_1.PARAMS_SECTION_NAME}`,
+        id: secRefKey,
+        path: secPath,
+        parent: { kind: "ref-recipe", refKey: tplRefKey },
+        templateOf: sitecore_templates_1.SITECORE_TEMPLATES.TEMPLATE_SECTION,
+        name: shared_1.PARAMS_SECTION_NAME,
+        fields: [],
+    });
+    recipe.params.forEach((param, index) => {
+        operations.push(...(0, shared_1.buildFieldOp)({
+            recipeHandle: recipe.handle,
+            fieldRefKey: (0, guids_1.designParameterFieldId)(site, recipe.handle, param.name),
+            fieldPath: (0, shared_1.joinPath)(secPath, param.name),
+            parentRefKey: secRefKey,
+            labelPrefix: `parameters-field:${recipe.handle}`,
+            field: param,
+            zeroBasedIndex: index,
+            policy,
+            site,
+            context,
+        }));
+    });
+    return operations_1.OperationIrSchema.parse({
+        schemaVersion: "1",
+        recipeHandle: recipe.handle,
+        operations,
+    });
+}

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

@@ -56,4 +56,3 @@ import { type CompileContext } from "./shared";
  * shared-vocabulary use; not yet implemented).
  */
 export declare function compileEnumerationRecipe(input: EnumerationRecipe, context: CompileContext, emittedFolders?: Set<string>): OperationIr;
-//# sourceMappingURL=enumeration.d.ts.map

package/dist/recipe/compile/enumeration.js

@@ -65,7 +65,7 @@ const shared_1 = require("./shared");
 function compileEnumerationRecipe(input, context, emittedFolders = new Set()) {
     const recipe = recipe_1.EnumerationRecipeSchema.parse(input);
     if (!context.enumerationsRoot) {
-        throw (0, errors_1.createCliError)(`Recipe '${recipe.handle}' is an enumeration but no enumerationsRoot is configured.`, "INPUT_INVALID", {
+        throw (0, errors_1.createScaiError)(`Recipe '${recipe.handle}' is an enumeration but no enumerationsRoot is configured.`, "INPUT_INVALID", {
             hint: "Set `enumerationsRoot` on the active envProfile in sitecoreai.cli.json (e.g. `/sitecore/content/<siteCollection>/<site>/Settings/Enumerations`).",
         });
     }
@@ -80,7 +80,7 @@ function compileEnumerationRecipe(input, context, emittedFolders = new Set()) {
     if (recipe.default !== undefined) {
         const valueNames = new Set(recipe.values.map((v) => v.name));
         if (!valueNames.has(recipe.default)) {
-            throw (0, errors_1.createCliError)(`Recipe '${recipe.handle}' declares default='${recipe.default}' but no matching value.name.`, "INPUT_INVALID", {
+            throw (0, errors_1.createScaiError)(`Recipe '${recipe.handle}' declares default='${recipe.default}' but no matching value.name.`, "INPUT_INVALID", {
                 hint: `default must match one of values[].name (got: ${[...valueNames].join(", ") || "<none>"}).`,
             });
         }
@@ -91,7 +91,7 @@ function compileEnumerationRecipe(input, context, emittedFolders = new Set()) {
     // that doesn't exist yet. Reject explicitly so authors don't get a
     // surprise misplacement.
     if (recipe.location?.scope === "siteCollection") {
-        throw (0, errors_1.createCliError)(`Recipe '${recipe.handle}' declares location.scope='siteCollection' but the siteCollection enumerations root isn't wired up yet.`, "INPUT_INVALID", {
+        throw (0, errors_1.createScaiError)(`Recipe '${recipe.handle}' declares location.scope='siteCollection' but the siteCollection enumerations root isn't wired up yet.`, "INPUT_INVALID", {
             hint: 'Use `location.scope: "site"` for now (or omit `location`). Site-collection scope will land when the orchestrator threads a siteCollectionEnumerationsRoot through CompileContext.',
         });
     }
@@ -125,7 +125,7 @@ function compileEnumerationRecipe(input, context, emittedFolders = new Set()) {
             .map((s) => s.trim())
             .filter(Boolean);
         if (folderSegments.length === 0) {
-            throw (0, errors_1.createCliError)(`Recipe '${recipe.handle}' declares location.folder that is empty after trimming.`, "INPUT_INVALID", {
+            throw (0, errors_1.createScaiError)(`Recipe '${recipe.handle}' declares location.folder that is empty after trimming.`, "INPUT_INVALID", {
                 hint: "Use a non-empty folder string like 'Theme' or 'Components/Card'.",
             });
         }

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

@@ -19,4 +19,3 @@ import { type CompileContext } from "./shared";
  * recipe in the set into one combined IR.
  */
 export declare function compilePageDesignRecipe(input: PageDesignRecipe, context: CompileContext): OperationIr;
-//# sourceMappingURL=page-design.d.ts.map

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

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