@case-framework/survey-assistant 0.6.0 → 0.8.0

package/dist/{index-D6nqkz0O.d.mts → index-Ciq7vHIs.d.mts}

@@ -1,9 +1,10 @@
-import { i as AssistantItemTypeManifest, o as SurveyAssistantCapabilityManifest } from "./capabilities-DVTfogjv.mjs";
-import { p as SurveyAssistantTaskContext } from "./index-DvTqML-0.mjs";
-import { Ct as SurveyDocumentSnapshot, F as SurveyValidationIssue, I as SurveyValidationResult, N as SurveyOperation, Pt as JsonValue$1, f as SurveyAssistantTurnFinal, h as SurveyChangeSet, wt as SurveyDocumentVersion } from "./lifecycle-BmGAIUlv.mjs";
+import { i as AssistantItemTypeManifest, o as SurveyAssistantCapabilityManifest } from "./capabilities-CmeeAjEc.mjs";
+import "./digest-C39WyAWG.mjs";
+import { h as SurveyAssistantTaskContext } from "./index-D7wT6P3t.mjs";
+import { F as SurveyValidationIssue, I as SurveyValidationResult, Mt as JsonValue$1, N as SurveyOperation, St as SurveyDocumentVersion, f as SurveyAssistantTurnFinal, h as SurveyChangeSet, xt as SurveyDocumentSnapshot } from "./lifecycle-Dm8u7QFh.mjs";
 import { z } from "zod";
-import { JsonExpression, JsonPatchOperation, RawSurvey, RawSurveyItem, ResponseValue, SurveyExpressionReferenceDiagnostic, SurveyExpressionResponseSlot, SurveyTranslations, ValueType } from "@case-framework/survey-core";
-
+import { Content, ItemTypeRegistry, JsonExpression, JsonPatchOperation, RawSurvey, RawSurveyItem, ResponseSlotDefinition, ResponseValue, SurveyExpressionReferenceDiagnostic, SurveyExpressionResponseSlot, SurveyTranslations, ValueType } from "@case-framework/survey-core";
+import { FormAuthoringMode, getFormAuthoringMode as getFormAuthoringMode$1, hasSingleFormField, isCompatibleSimpleFieldUpsert as isCompatibleSimpleFieldUpsert$1, isValidSimpleFormConfig as isValidSimpleFormConfig$1, normalizeFormAuthoringConfig as normalizeFormAuthoringConfig$1, transitionFormAuthoringMode as transitionFormAuthoringMode$1 } from "@case-framework/survey-items/form";
 //#region src/engine/capabilities.d.ts
 interface AssistantCapabilityReference {
   topic: string;
@@ -16,10 +17,23 @@ interface AssistantItemInspection {
 }
 interface AssistantItemCapabilityAdapter {
   manifest: AssistantItemTypeManifest;
+  /** Trusted server-safe core shared with the player, including response activation dependencies. */
+  itemCore?: ItemTypeRegistry[string];
   references?: AssistantCapabilityReference[];
+  configurationSchema?: z.ZodType;
+  materializePreset?: (presetId: string, locale: string) => {
+    config: RawSurveyItem["config"];
+    translations: NonNullable<Extract<SurveyOperation, {
+      kind: "create-item";
+    }>["translations"]>;
+  };
+  validContentKeys?: (item: RawSurveyItem) => string[];
   normalizeCreate?: (item: RawSurveyItem) => RawSurveyItem;
+  requiredCreateContentKeys?: (item: RawSurveyItem) => string[];
   validateItem?: (item: RawSurveyItem) => SurveyValidationIssue[];
   supportsOperation?: (operation: SurveyOperation) => boolean;
+  deriveResponseSlotDefinitions?: (item: RawSurveyItem) => ResponseSlotDefinition[];
+  /** Type-only inspection adapter. Creatable response items require full definitions. */
   deriveResponseSlots?: (item: RawSurveyItem) => Record<string, ValueType>;
   inspectItem?: (item: RawSurveyItem) => AssistantItemInspection;
 }
@@ -27,50 +41,18 @@ interface SurveyAssistantCapabilitySet {
   manifest: SurveyAssistantCapabilityManifest;
   byItemType: ReadonlyMap<string, AssistantItemCapabilityAdapter>;
 }
-declare const resolveAssistantCapabilityReference: ({
-  capabilities,
-  itemType,
-  topic
-}: {
+declare const resolveAssistantCapabilityReference: ({ capabilities, itemType, topic }: {
   capabilities: SurveyAssistantCapabilitySet | undefined;
   itemType: string;
   topic: string;
 }) => AssistantCapabilityReference | undefined;
-declare const inspectAssistantItem: ({
-  capabilities,
-  item
-}: {
+declare const inspectAssistantItem: ({ capabilities, item }: {
   capabilities: SurveyAssistantCapabilitySet | undefined;
   item: RawSurveyItem;
 }) => AssistantItemInspection | undefined;
-type AssistantItemCreationResolution = {
-  kind: "deterministic";
-} | {
-  kind: "ui-intent";
-  intent: {
-    kind: "open-create-item";
-    itemType: string;
-    parentItemId?: string;
-  };
-} | {
-  kind: "unsupported";
-  reason: string;
-};
 declare const createSurveyAssistantCapabilities: (capabilities: readonly AssistantItemCapabilityAdapter[]) => SurveyAssistantCapabilitySet;
 declare const getDeterministicCreateItemTypes: (manifest: SurveyAssistantCapabilityManifest) => string[];
-declare const resolveAssistantItemCreation: ({
-  itemType,
-  manifest,
-  parentItemId
-}: {
-  itemType: string;
-  manifest: SurveyAssistantCapabilityManifest;
-  parentItemId?: string;
-}) => AssistantItemCreationResolution;
-declare const createUnsupportedItemCapability: ({
-  displayName,
-  itemType
-}: {
+declare const createUnsupportedItemCapability: ({ displayName, itemType }: {
   displayName: string;
   itemType: string;
 }) => AssistantItemCapabilityAdapter;
@@ -78,11 +60,7 @@ declare class SurveyAssistantCapabilityMismatchError extends Error {
   readonly code = "survey-assistant-capability-mismatch";
   constructor(message?: string);
 }
-declare const assertSurveyAssistantCapabilities: ({
-  manifest,
-  trustedCapabilities,
-  versionDigest
-}: {
+declare const assertSurveyAssistantCapabilities: ({ manifest, trustedCapabilities, versionDigest }: {
   manifest: SurveyAssistantCapabilityManifest;
   trustedCapabilities?: SurveyAssistantCapabilitySet;
   versionDigest: string;
@@ -95,8 +73,8 @@ interface SurveyAssistantInspectionOutlineNode {
   parentId?: string;
   depth: number;
   itemType: string;
-  key: string;
-  fullKey: string;
+  editorName: string;
+  breadcrumb: string;
   itemLabel?: string;
   childCount: number;
 }
@@ -110,10 +88,10 @@ interface SurveyAssistantInspectionFocus {
 interface SurveyAssistantInspectionItemNode {
   itemId: string;
   itemType: string;
-  itemKey: string;
-  fullKey: string;
+  editorName: string;
+  breadcrumb: string;
   itemLabel?: string;
-  siblingKeys: string[];
+  siblingNames: string[];
   translations: Array<{
     locale: string;
     contentKey: string;
@@ -121,11 +99,11 @@ interface SurveyAssistantInspectionItemNode {
   }>;
   descendants: SurveyAssistantInspectionItemNode[];
 }
-interface SurveyAssistantInspectionKeyEntry {
+interface SurveyAssistantInspectionItemEntry {
   itemId: string;
   itemType: string;
-  key: string;
-  fullKey: string;
+  editorName: string;
+  breadcrumb: string;
   itemLabel?: string;
   path: string[];
 }
@@ -138,7 +116,7 @@ interface SurveyAssistantInspectionIndex {
   outline: SurveyAssistantInspectionOutlineNode[];
   focus?: SurveyAssistantInspectionFocus;
   focusItem?: SurveyAssistantInspectionItemNode;
-  keyIndex: SurveyAssistantInspectionKeyEntry[];
+  itemIndex: SurveyAssistantInspectionItemEntry[];
   responseSlots: string[];
   focusItemTreeTruncated: boolean;
 }
@@ -150,6 +128,7 @@ interface SurveyAssistantEngineContext {
   ui: SurveyDocumentSnapshot["ui"];
   capabilities: SurveyAssistantCapabilityManifest;
   responseSlotTypes: SurveyAssistantResponseSlotTypes;
+  responseVariables: import("@case-framework/survey-core").OwnedResponseSlotDefinition[];
   inspection: SurveyAssistantInspectionIndex;
   trustedCapabilities?: SurveyAssistantCapabilitySet;
 }
@@ -162,14 +141,7 @@ declare const createSurveyAssistantEngineContext: (document: SurveyDocumentSnaps
 //#region src/engine/expression-validation.d.ts
 type ResponseSlotTypeLookup = Record<string, ValueType | undefined>;
 declare const inferExpressionReturnType: (expression: JsonExpression | undefined, responseSlotTypes: ResponseSlotTypeLookup) => ValueType | undefined;
-declare const validateExpression: ({
-  expression,
-  expectedReturnType,
-  issues,
-  operationIndex,
-  responseSlotTypes,
-  scope
-}: {
+declare const validateExpression: ({ expression, expectedReturnType, issues, operationIndex, responseSlotTypes, scope }: {
   expression: JsonExpression | undefined;
   expectedReturnType?: ValueType;
   issues: SurveyValidationIssue[];
@@ -181,6 +153,7 @@ declare const validateExpression: ({
 //#region src/engine/expression-reference-integrity.d.ts
 declare const deriveSurveyExpressionResponseSlots: (survey: RawSurvey, trustedCapabilities?: SurveyAssistantCapabilitySet) => SurveyExpressionResponseSlot[];
 declare const analyzeSurveyAssistantExpressionReferences: (survey: RawSurvey, trustedCapabilities?: SurveyAssistantCapabilitySet) => SurveyExpressionReferenceDiagnostic[];
+declare const getSurveyAssistantExpressionDiagnosticGuidance: (diagnostic: Pick<SurveyExpressionReferenceDiagnostic, "category" | "disposition">) => string;
 //#endregion
 //#region src/engine/expression-mutations.d.ts
 declare const expressionSchema: z.ZodType<JsonExpression>;
@@ -296,14 +269,16 @@ declare const expressionMutationSchema: z.ZodDiscriminatedUnion<[z.ZodObject<{
   templateKey: z.ZodString;
 }, z.core.$strip>], "kind">;
 type ExpressionMutation = z.infer<typeof expressionMutationSchema>;
-declare const buildExpressionMutationPatches: ({
-  mutation,
-  operationIndex,
-  issues,
-  patches,
-  responseSlotTypes,
-  snapshot
-}: {
+/** Compile an expression delta in order, without mutating the accepted turn draft.
+ * Expression mutations cannot change item structure or response slots, so the
+ * immutable indexes remain valid while each mutation reads the preceding result.
+ * The caller validates and stages the complete delta atomically.
+ */
+declare const buildExpressionMutationBatch: (mutations: ExpressionMutation[], snapshot: SurveyAssistantEngineContext) => {
+  issues: SurveyValidationIssue[];
+  patches: JsonPatchOperation[];
+};
+declare const buildExpressionMutationPatches: ({ mutation, operationIndex, issues, patches, responseSlotTypes, snapshot }: {
   mutation: ExpressionMutation;
   operationIndex: number;
   issues: SurveyValidationIssue[];
@@ -318,14 +293,14 @@ declare const MAX_LIMIT = 50;
 declare const itemSummarySchema: z.ZodObject<{
   itemId: z.ZodString;
   itemType: z.ZodString;
-  key: z.ZodString;
-  fullKey: z.ZodString;
+  editorName: z.ZodString;
+  breadcrumb: z.ZodString;
   itemLabel: z.ZodOptional<z.ZodString>;
   parentId: z.ZodOptional<z.ZodString>;
   depth: z.ZodOptional<z.ZodNumber>;
   childCount: z.ZodOptional<z.ZodNumber>;
   path: z.ZodOptional<z.ZodArray<z.ZodString>>;
-  siblingKeys: z.ZodOptional<z.ZodArray<z.ZodString>>;
+  siblingNames: z.ZodOptional<z.ZodArray<z.ZodString>>;
 }, z.core.$strip>;
 type ItemSummary = z.infer<typeof itemSummarySchema>;
 declare const translationEntrySchema: z.ZodObject<{
@@ -337,7 +312,7 @@ type TranslationEntry = z.infer<typeof translationEntrySchema>;
 declare const choiceOptionDetailsSchema: z.ZodObject<{
   position: z.ZodNumber;
   id: z.ZodString;
-  key: z.ZodOptional<z.ZodString>;
+  code: z.ZodOptional<z.ZodString>;
   labelContentKey: z.ZodString;
   hasDisplayCondition: z.ZodOptional<z.ZodBoolean>;
   embeddedFormItemId: z.ZodOptional<z.ZodString>;
@@ -348,12 +323,11 @@ declare const choiceOptionDetailsSchema: z.ZodObject<{
   }>>;
   embeddedFormSimpleModeValid: z.ZodOptional<z.ZodBoolean>;
   embeddedFormTranslationPrefix: z.ZodOptional<z.ZodString>;
-  embeddedFormResponseSlotPrefix: z.ZodOptional<z.ZodString>;
 }, z.core.$strip>;
 declare const formSelectOptionDetailsSchema: z.ZodObject<{
   position: z.ZodNumber;
   id: z.ZodString;
-  value: z.ZodOptional<z.ZodString>;
+  code: z.ZodOptional<z.ZodString>;
   labelContentKey: z.ZodString;
 }, z.core.$strip>;
 declare const formFieldGroupLayoutSchema: z.ZodObject<{
@@ -366,7 +340,7 @@ declare const formFieldGroupLayoutSchema: z.ZodObject<{
 declare const formFieldDetailsSchema: z.ZodObject<{
   position: z.ZodNumber;
   id: z.ZodString;
-  key: z.ZodString;
+  variableName: z.ZodString;
   type: z.ZodString;
   responseSlotId: z.ZodString;
   labelContentKey: z.ZodString;
@@ -383,7 +357,7 @@ declare const formFieldDetailsSchema: z.ZodObject<{
   selectOptions: z.ZodOptional<z.ZodArray<z.ZodObject<{
     position: z.ZodNumber;
     id: z.ZodString;
-    value: z.ZodOptional<z.ZodString>;
+    code: z.ZodOptional<z.ZodString>;
     labelContentKey: z.ZodString;
   }, z.core.$strip>>>;
 }, z.core.$strip>;
@@ -404,7 +378,7 @@ declare const formFieldGroupDetailsSchema: z.ZodObject<{
   fields: z.ZodArray<z.ZodObject<{
     position: z.ZodNumber;
     id: z.ZodString;
-    key: z.ZodString;
+    variableName: z.ZodString;
     type: z.ZodString;
     responseSlotId: z.ZodString;
     labelContentKey: z.ZodString;
@@ -421,15 +395,15 @@ declare const formFieldGroupDetailsSchema: z.ZodObject<{
     selectOptions: z.ZodOptional<z.ZodArray<z.ZodObject<{
       position: z.ZodNumber;
       id: z.ZodString;
-      value: z.ZodOptional<z.ZodString>;
+      code: z.ZodOptional<z.ZodString>;
       labelContentKey: z.ZodString;
     }, z.core.$strip>>>;
   }, z.core.$strip>>;
 }, z.core.$strip>;
 declare const itemConfigDetailsSchema: z.ZodObject<{
   kind: z.ZodEnum<{
-    choice: "choice";
     form: "form";
+    choice: "choice";
     generic: "generic";
   }>;
   summary: z.ZodArray<z.ZodString>;
@@ -442,7 +416,7 @@ declare const itemConfigDetailsSchema: z.ZodObject<{
   choiceOptions: z.ZodOptional<z.ZodArray<z.ZodObject<{
     position: z.ZodNumber;
     id: z.ZodString;
-    key: z.ZodOptional<z.ZodString>;
+    code: z.ZodOptional<z.ZodString>;
     labelContentKey: z.ZodString;
     hasDisplayCondition: z.ZodOptional<z.ZodBoolean>;
     embeddedFormItemId: z.ZodOptional<z.ZodString>;
@@ -453,7 +427,6 @@ declare const itemConfigDetailsSchema: z.ZodObject<{
     }>>;
     embeddedFormSimpleModeValid: z.ZodOptional<z.ZodBoolean>;
     embeddedFormTranslationPrefix: z.ZodOptional<z.ZodString>;
-    embeddedFormResponseSlotPrefix: z.ZodOptional<z.ZodString>;
   }, z.core.$strip>>>;
   formFieldGroups: z.ZodOptional<z.ZodArray<z.ZodObject<{
     position: z.ZodNumber;
@@ -472,7 +445,7 @@ declare const itemConfigDetailsSchema: z.ZodObject<{
     fields: z.ZodArray<z.ZodObject<{
       position: z.ZodNumber;
       id: z.ZodString;
-      key: z.ZodString;
+      variableName: z.ZodString;
       type: z.ZodString;
       responseSlotId: z.ZodString;
       labelContentKey: z.ZodString;
@@ -489,7 +462,7 @@ declare const itemConfigDetailsSchema: z.ZodObject<{
       selectOptions: z.ZodOptional<z.ZodArray<z.ZodObject<{
         position: z.ZodNumber;
         id: z.ZodString;
-        value: z.ZodOptional<z.ZodString>;
+        code: z.ZodOptional<z.ZodString>;
         labelContentKey: z.ZodString;
       }, z.core.$strip>>>;
     }, z.core.$strip>>;
@@ -502,7 +475,7 @@ type FormFieldGroupDetails = z.infer<typeof formFieldGroupDetailsSchema>;
 type ItemConfigDetails = z.infer<typeof itemConfigDetailsSchema>;
 type SurveyInspectionIndex = SurveyAssistantEngineContext["inspection"];
 type SurveyOutlineNode = SurveyInspectionIndex["outline"][number];
-type SurveyKeyIndexEntry = SurveyInspectionIndex["keyIndex"][number];
+type SurveyItemIndexEntry = SurveyInspectionIndex["itemIndex"][number];
 type SurveyFocusItemNode = NonNullable<SurveyInspectionIndex["focusItem"]>;
 declare const normalizeText: (value: string | undefined) => string;
 declare const clampLimit: (limit: number | undefined) => number;
@@ -517,9 +490,9 @@ declare const sliceWithCursor: <T>(values: T[], input: {
   truncated: boolean;
 };
 declare const mapOutlineById: (snapshot: SurveyAssistantEngineContext) => Map<string, SurveyAssistantInspectionOutlineNode>;
-declare const mapKeyIndexById: (snapshot: SurveyAssistantEngineContext) => Map<string, SurveyAssistantInspectionKeyEntry>;
-/** The full-survey key index, regardless of the (possibly focus-scoped) outline. */
-declare const getKeyIndexEntries: (snapshot: SurveyAssistantEngineContext) => SurveyKeyIndexEntry[];
+declare const mapItemIndexById: (snapshot: SurveyAssistantEngineContext) => Map<string, SurveyAssistantInspectionItemEntry>;
+/** The full-survey item index, regardless of the (possibly focus-scoped) outline. */
+declare const getItemIndexEntries: (snapshot: SurveyAssistantEngineContext) => SurveyItemIndexEntry[];
 declare const getRawSurvey: (snapshot: SurveyAssistantEngineContext) => Partial<RawSurvey>;
 declare const getRawSurveyItems: (snapshot: SurveyAssistantEngineContext) => RawSurveyItem[];
 declare const mapRawItemsById: (snapshot: SurveyAssistantEngineContext) => Map<string, RawSurveyItem>;
@@ -530,81 +503,69 @@ declare const buildItemTranslationEntries: (snapshot: SurveyAssistantEngineConte
   textLimit?: number;
 }) => TranslationEntry[];
 declare const summarizeOutlineNode: (node: SurveyOutlineNode) => ItemSummary;
-declare const summarizeKeyIndexEntry: (entry: SurveyKeyIndexEntry, outlineById: Map<string, SurveyOutlineNode>) => ItemSummary;
-declare const summarizeKeyIndexEntries: (entries: SurveyKeyIndexEntry[], outlineById: Map<string, SurveyOutlineNode>) => ItemSummary[];
+declare const summarizeItemIndexEntry: (entry: SurveyItemIndexEntry, outlineById: Map<string, SurveyOutlineNode>) => ItemSummary;
+declare const summarizeItemIndexEntries: (entries: SurveyItemIndexEntry[], outlineById: Map<string, SurveyOutlineNode>) => ItemSummary[];
 declare const buildItemConfigDetails: (rawItem: RawSurveyItem) => ItemConfigDetails | undefined;
 declare const buildEmbeddedFormDetails: (choiceOption: ChoiceOptionDetails, embeddedForm: unknown) => ItemConfigDetails | undefined;
 declare const buildConfigSearchText: (rawItem: RawSurveyItem) => string[];
 declare const summarizeFocusItemNode: (node: SurveyFocusItemNode, outlineById: Map<string, SurveyOutlineNode>) => ItemSummary;
-declare const summarizeItemById: (itemId: string, indexById: Map<string, SurveyKeyIndexEntry>, outlineById: Map<string, SurveyOutlineNode>) => ItemSummary | undefined;
-/**
- * Resolve an item by internal itemId, or fall back to matching on `key` /
- * `fullKey`. Model-facing text (outline rows, fullKey paths) only ever shows
- * key/fullKey, not the internal itemId, so models often pass a key like
- * "info_1" where an itemId is expected — this keeps that usage working.
- */
-declare const resolveItemSummary: (identifier: string, indexById: Map<string, SurveyKeyIndexEntry>, outlineById: Map<string, SurveyOutlineNode>) => ItemSummary | undefined;
+declare const summarizeItemById: (itemId: string, indexById: Map<string, SurveyItemIndexEntry>, outlineById: Map<string, SurveyOutlineNode>) => ItemSummary | undefined;
+/** Resolve only persistent item IDs. Search can discover names and breadcrumbs. */
+declare const resolveItemSummary: (identifier: string, indexById: Map<string, SurveyItemIndexEntry>, outlineById: Map<string, SurveyOutlineNode>) => ItemSummary | undefined;
 declare const itemMatchesQuery: (item: ItemSummary, query: string) => boolean;
 /**
- * Direct children of `parentFullKey` derived from the full-survey key index.
+ * Direct children of `parentId` derived from the full-survey item index.
  * This works for any item, selected or not.
  */
-declare const findDirectChildrenByFullKey: (entries: SurveyKeyIndexEntry[], outlineById: Map<string, SurveyOutlineNode>, parentFullKey: string) => ItemSummary[];
+declare const findDirectChildrenByParentId: (entries: SurveyItemIndexEntry[], outlineById: Map<string, SurveyOutlineNode>, parentId: string) => ItemSummary[];
 //#endregion
 //#region src/engine/normalization.d.ts
+type SurveyChangeNormalizationIssue = {
+  path: string;
+  message: string;
+};
 /**
  * Accepts common model-authored shorthand and converts it to the strict
  * assistant operation shape before validation. This keeps the public tool
  * compact while making it tolerant of predictable schema-near authoring
  * mistakes: nested raw translation maps, sibling config objects, choice
- * optionId aliases, and flat form fields.
+ * optionId aliases, flat form fields, and compact rich-text blocks.
  */
-declare const normalizeSurveyChangeOperations: (operations: unknown[], defaultLocale: string) => unknown[];
+declare const normalizeSurveyChangeOperations: (operations: unknown[], defaultLocale: string) => {
+  operations: unknown[];
+  issues: SurveyChangeNormalizationIssue[];
+};
 //#endregion
-//#region src/engine/operations.d.ts
-declare const MAX_SURVEY_ASSISTANT_OPERATIONS_PER_PROPOSAL = 200;
-declare const MAX_SURVEY_ASSISTANT_OPERATIONS_PER_TURN_DRAFT = 1000;
-declare const buildSurveyDocumentVersion: (snapshot: SurveyAssistantEngineContext | SurveyDocumentSnapshot) => SurveyDocumentVersion;
-declare const validateSurveyOperations: ({
-  allowExpressionJsonPatches,
-  maxOperations,
-  operations,
-  snapshot: snapshotInput
-}: {
-  allowExpressionJsonPatches?: boolean;
-  maxOperations?: number;
-  operations: SurveyOperation[];
-  snapshot: SurveyAssistantEngineContext | SurveyDocumentSnapshot | undefined;
-}) => SurveyValidationResult;
+//#region src/engine/operation-execution.d.ts
 /**
  * Canonical pure executor for already-normalized, validated survey operation
  * semantics. Raw-draft simulation uses the returned survey directly; editor
  * adapters use it to decide domain results before recording them through the
  * editor's normal mutation and history APIs.
  */
-declare const executeSurveyOperationsOnRawSurvey: ({
-  operations,
-  survey: inputSurvey
-}: {
+declare const executeSurveyOperationsOnRawSurvey: ({ operations, survey, capabilities }: {
   operations: SurveyOperation[];
   survey: RawSurvey;
+  capabilities?: SurveyAssistantCapabilitySet;
 }) => RawSurvey;
-/** @deprecated Prefer `executeSurveyOperationsOnRawSurvey` for new integrations. */
-declare const applyValidatedSurveyOperationsToDraft: ({
-  operations,
-  survey: inputSurvey
-}: {
+//#endregion
+//#region src/engine/operations.d.ts
+declare const MAX_SURVEY_ASSISTANT_OPERATIONS_PER_PROPOSAL = 200;
+declare const MAX_SURVEY_ASSISTANT_OPERATIONS_PER_TURN_DRAFT = 1000;
+declare const validateSurveyTreeStructure: (survey: RawSurvey, operationId?: string, availableItemTypes?: ReadonlySet<string>) => SurveyValidationIssue[];
+/** Preserve existing defects without accepting changed or additional violations. */
+declare const findIntroducedSurveyStructureIssues: ({ before, after }: {
+  before: readonly SurveyValidationIssue[];
+  after: readonly SurveyValidationIssue[];
+}) => SurveyValidationIssue[];
+declare const buildSurveyDocumentVersion: (snapshot: SurveyAssistantEngineContext | SurveyDocumentSnapshot) => SurveyDocumentVersion;
+declare const validateSurveyOperations: ({ allowExpressionJsonPatches, maxOperations, operations, snapshot: snapshotInput }: {
+  allowExpressionJsonPatches?: boolean;
+  maxOperations?: number;
   operations: SurveyOperation[];
-  survey: RawSurvey;
-}) => RawSurvey;
-declare const createSurveyChangeSet: ({
-  allowExpressionJsonPatches,
-  maxOperations,
-  operations,
-  snapshot,
-  summary,
-  turnId
-}: {
+  snapshot: SurveyAssistantEngineContext | SurveyDocumentSnapshot | undefined;
+}) => SurveyValidationResult;
+declare const createSurveyChangeSet: ({ allowExpressionJsonPatches, maxOperations, operations, snapshot, summary, turnId }: {
   allowExpressionJsonPatches?: boolean;
   maxOperations?: number;
   operations: SurveyOperation[];
@@ -613,6 +574,12 @@ declare const createSurveyChangeSet: ({
   turnId: string;
 }) => SurveyChangeSet;
 //#endregion
+//#region src/engine/mutation-recovery.d.ts
+type RecoveryTargetRefinement = {
+  targets: string[];
+  replacement: string;
+};
+//#endregion
 //#region src/engine/turn-survey-draft.d.ts
 declare const mutationRecoveryRouteByIssueCode: {
   readonly "expression-patch-requires-specialized-tool": "expression";
@@ -623,30 +590,25 @@ type SurveyAssistantMutationRoute = (typeof mutationRecoveryRouteByIssueCode)[ke
  *
  * Mutation tools submit deltas. A successful delta replaces the previous
  * candidate with a newly validated, cumulative change set. A rejected delta
- * leaves the accepted draft intact and blocks authorization until a later
- * delta validates. Only the latest cumulative candidate can be authorized.
+ * leaves the accepted draft intact and blocks authorization until all of its
+ * operation/surface obligations have been repaired. Only the latest cumulative
+ * candidate can be authorized.
  */
 declare class TurnSurveyDraft {
   #private;
   readonly turnId: string;
-  constructor(turnId?: `${string}-${string}-${string}-${string}-${string}`);
+  constructor(turnId?: string);
   initialize(context: SurveyAssistantEngineContext): void;
-  stage({
-    addressedTargets,
-    allowExpressionJsonPatches,
-    handledMutationRoutes,
-    operations,
-    snapshot,
-    summary
-  }: {
+  stage({ addressedTargets, allowExpressionJsonPatches, handledMutationRoutes, retryOfChangeIds, operations, snapshot, summary }: {
     addressedTargets?: string[];
     allowExpressionJsonPatches?: boolean;
     handledMutationRoutes?: SurveyAssistantMutationRoute[];
+    retryOfChangeIds?: string[];
     operations: SurveyOperation[];
     snapshot: SurveyAssistantEngineContext | SurveyDocumentSnapshot | undefined;
     summary: string;
   }): SurveyChangeSet;
-  reject(candidate: SurveyChangeSet, addressedTargets?: Iterable<string>): SurveyChangeSet;
+  reject(candidate: SurveyChangeSet, addressedTargets?: Iterable<string>, refinements?: RecoveryTargetRefinement[]): SurveyChangeSet;
   finalize(status: SurveyAssistantTurnFinal["status"], createdAt?: string, details?: Pick<SurveyAssistantTurnFinal, "durationMs" | "startedAt" | "terminationReason">): SurveyAssistantTurnFinal;
   getCandidate(changeSetId: string): SurveyChangeSet | undefined;
   get draftOperations(): readonly SurveyOperation[];
@@ -655,10 +617,13 @@ declare class TurnSurveyDraft {
 }
 //#endregion
 //#region src/engine/task-context.d.ts
-type SurveyAssistantTaskPurpose = "suggest-item-key" | "suggest-item-label" | "translate-content";
+type SurveyAssistantTaskPurpose = "suggest-response-name" | "suggest-response-settings" | "suggest-item-label" | "translate-content";
 interface BuildSurveyAssistantTaskContextOptions {
   purpose: SurveyAssistantTaskPurpose;
+  capabilities?: SurveyAssistantCapabilitySet;
   focusItemId?: string;
+  focusSlotId?: string;
+  slotIds?: readonly string[];
   sourceLocale?: string;
   targetLocales?: readonly string[];
   sourceTexts?: readonly string[];
@@ -683,50 +648,6 @@ declare class SurveyAssistantTaskResultCache {
   clear(): void;
 }
 //#endregion
-//#region src/engine/form-authoring.d.ts
-type FormAuthoringMode = "simple" | "custom";
-declare const getFormAuthoringMode: (config: unknown) => FormAuthoringMode;
-declare const hasSingleFormField: (config: unknown) => boolean;
-declare const isValidSimpleFormConfig: (config: unknown) => boolean;
-/**
- * Canonicalizes the editor-facing mode without modifying groups, fields, or translations.
- * Missing modes and malformed simple forms become custom; valid simple forms stay simple.
- */
-declare const normalizeFormAuthoringConfig: (config: unknown) => Record<string, unknown> | undefined;
-/**
- * Returns true only for an in-place edit of the existing sole field that the
- * simple editor can still represent. Adding, moving, retyping, or exposing
- * hidden field configuration is structural and must promote the form.
- */
-declare const isCompatibleSimpleFieldUpsert: ({
-  config,
-  field,
-  groupId,
-  index
-}: {
-  config: unknown;
-  field: Record<string, unknown> & {
-    id: string;
-    key: string;
-    type: string;
-  };
-  groupId: string;
-  index?: number;
-}) => boolean;
-/**
- * Structural form operations are a one-way transition out of simple mode unless the caller has
- * proved that the same sole field remains compatible with the simple editor.
- */
-declare const transitionFormAuthoringMode: ({
-  config,
-  fieldGroups,
-  preserveSimpleMode
-}: {
-  config: Record<string, unknown>;
-  fieldGroups: Record<string, unknown>[];
-  preserveSimpleMode?: boolean;
-}) => Record<string, unknown>;
-//#endregion
 //#region src/engine/audit.d.ts
 type SurveyAuditSeverity = "error" | "warning" | "info";
 type SurveyAuditCategory = "structure" | "content" | "localization" | "logic" | "responses" | "assets" | "quality";
@@ -746,7 +667,10 @@ interface SurveyQualityReviewPrinciple {
   prompt: string;
 }
 interface SurveyAuditKeyReviewEntry {
-  kind: "item" | "choice-option" | "form-field";
+  kind: "response-variable" | "choice-option";
+  slotId: string;
+  valueType?: string;
+  computed?: boolean;
   itemId: string;
   itemKey: string;
   key: string;
@@ -788,5 +712,5 @@ declare const auditSurvey: (context: SurveyAssistantEngineContext, options?: {
   keyReviewLimit?: number;
 }) => SurveyAuditReport;
 //#endregion
-export { formSelectOptionDetailsSchema as $, ChoiceOptionDetails as A, CreateSurveyAssistantEngineContextOptions as At, SurveyOutlineNode as B, AssistantCapabilityReference as Bt, MAX_SURVEY_ASSISTANT_OPERATIONS_PER_TURN_DRAFT as C, expressionMutationSchema as Ct, executeSurveyOperationsOnRawSurvey as D, ResponseSlotTypeLookup as Dt, createSurveyChangeSet as E, deriveSurveyExpressionResponseSlots as Et, ItemSummary as F, SurveyAssistantInspectionKeyEntry as Ft, buildItemTranslationEntries as G, SurveyAssistantCapabilitySet as Gt, buildConfigSearchText as H, AssistantItemCreationResolution as Ht, MAX_LIMIT as I, SurveyAssistantInspectionOutlineNode as It, clampLimit as J, createUnsupportedItemCapability as Jt, buildSurveyTranslations as K, assertSurveyAssistantCapabilities as Kt, SurveyFocusItemNode as L, SurveyAssistantResponseSlotTypes as Lt, FormFieldDetails as M, SurveyAssistantInspectionFocus as Mt, FormFieldGroupDetails as N, SurveyAssistantInspectionIndex as Nt, validateSurveyOperations as O, inferExpressionReturnType as Ot, ItemConfigDetails as P, SurveyAssistantInspectionItemNode as Pt, formFieldGroupLayoutSchema as Q, resolveAssistantItemCreation as Qt, SurveyInspectionIndex as R, createSurveyAssistantEngineContext as Rt, MAX_SURVEY_ASSISTANT_OPERATIONS_PER_PROPOSAL as S, buildExpressionMutationPatches as St, buildSurveyDocumentVersion as T, analyzeSurveyAssistantExpressionReferences as Tt, buildEmbeddedFormDetails as U, AssistantItemInspection as Ut, TranslationEntry as V, AssistantItemCapabilityAdapter as Vt, buildItemConfigDetails as W, SurveyAssistantCapabilityMismatchError as Wt, formFieldDetailsSchema as X, inspectAssistantItem as Xt, findDirectChildrenByFullKey as Y, getDeterministicCreateItemTypes as Yt, formFieldGroupDetailsSchema as Z, resolveAssistantCapabilityReference as Zt, BuildSurveyAssistantTaskContextOptions as _, summarizeOutlineNode as _t, SurveyAuditSeverity as a, itemSummarySchema as at, SurveyAssistantMutationRoute as b, unique as bt, FormAuthoringMode as c, mapRawItemsById as ct, isCompatibleSimpleFieldUpsert as d, resolveItemSummary as dt, getKeyIndexEntries as et, isValidSimpleFormConfig as f, sliceWithCursor as ft, SurveyAssistantTaskResultCacheOptions as g, summarizeKeyIndexEntry as gt, SurveyAssistantTaskResultCache as h, summarizeKeyIndexEntries as ht, SurveyAuditReport as i, itemMatchesQuery as it, DEFAULT_LIMIT as j, SurveyAssistantEngineContext as jt, normalizeSurveyChangeOperations as k, validateExpression as kt, getFormAuthoringMode as l, normalizeText as lt, transitionFormAuthoringMode as m, summarizeItemById as mt, SurveyAuditFinding as n, getRawSurveyItems as nt, SurveyQualityReviewPrinciple as o, mapKeyIndexById as ot, normalizeFormAuthoringConfig as p, summarizeFocusItemNode as pt, choiceOptionDetailsSchema as q, createSurveyAssistantCapabilities as qt, SurveyAuditKeyReviewEntry as r, itemConfigDetailsSchema as rt, auditSurvey as s, mapOutlineById as st, SurveyAuditCategory as t, getRawSurvey as tt, hasSingleFormField as u, parseCursor as ut, SurveyAssistantTaskPurpose as v, summarizeRawItem as vt, applyValidatedSurveyOperationsToDraft as w, expressionSchema as wt, TurnSurveyDraft as x, ExpressionMutation as xt, buildSurveyAssistantTaskContext as y, translationEntrySchema as yt, SurveyKeyIndexEntry as z, deriveResponseSlotTypes as zt };
-//# sourceMappingURL=index-D6nqkz0O.d.mts.map
+export { formFieldGroupLayoutSchema as $, resolveAssistantCapabilityReference as $t, normalizeSurveyChangeOperations as A, ResponseSlotTypeLookup as At, SurveyItemIndexEntry as B, SurveyAssistantResponseSlotTypes as Bt, MAX_SURVEY_ASSISTANT_OPERATIONS_PER_TURN_DRAFT as C, buildExpressionMutationBatch as Ct, validateSurveyOperations as D, analyzeSurveyAssistantExpressionReferences as Dt, findIntroducedSurveyStructureIssues as E, expressionSchema as Et, ItemConfigDetails as F, SurveyAssistantInspectionFocus as Ft, buildItemConfigDetails as G, AssistantItemInspection as Gt, TranslationEntry as H, deriveResponseSlotTypes as Ht, ItemSummary as I, SurveyAssistantInspectionIndex as It, choiceOptionDetailsSchema as J, assertSurveyAssistantCapabilities as Jt, buildItemTranslationEntries as K, SurveyAssistantCapabilityMismatchError as Kt, MAX_LIMIT as L, SurveyAssistantInspectionItemEntry as Lt, DEFAULT_LIMIT as M, validateExpression as Mt, FormFieldDetails as N, CreateSurveyAssistantEngineContextOptions as Nt, validateSurveyTreeStructure as O, deriveSurveyExpressionResponseSlots as Ot, FormFieldGroupDetails as P, SurveyAssistantEngineContext as Pt, formFieldGroupDetailsSchema as Q, inspectAssistantItem as Qt, SurveyFocusItemNode as R, SurveyAssistantInspectionItemNode as Rt, MAX_SURVEY_ASSISTANT_OPERATIONS_PER_PROPOSAL as S, ExpressionMutation as St, createSurveyChangeSet as T, expressionMutationSchema as Tt, buildConfigSearchText as U, AssistantCapabilityReference as Ut, SurveyOutlineNode as V, createSurveyAssistantEngineContext as Vt, buildEmbeddedFormDetails as W, AssistantItemCapabilityAdapter as Wt, findDirectChildrenByParentId as X, createUnsupportedItemCapability as Xt, clampLimit as Y, createSurveyAssistantCapabilities as Yt, formFieldDetailsSchema as Z, getDeterministicCreateItemTypes as Zt, BuildSurveyAssistantTaskContextOptions as _, summarizeItemIndexEntry as _t, isValidSimpleFormConfig$1 as a, itemMatchesQuery as at, SurveyAssistantMutationRoute as b, translationEntrySchema as bt, SurveyAuditCategory as c, mapOutlineById as ct, SurveyAuditReport as d, parseCursor as dt, formSelectOptionDetailsSchema as et, SurveyAuditSeverity as f, resolveItemSummary as ft, SurveyAssistantTaskResultCacheOptions as g, summarizeItemIndexEntries as gt, SurveyAssistantTaskResultCache as h, summarizeItemById as ht, isCompatibleSimpleFieldUpsert$1 as i, itemConfigDetailsSchema as it, ChoiceOptionDetails as j, inferExpressionReturnType as jt, executeSurveyOperationsOnRawSurvey as k, getSurveyAssistantExpressionDiagnosticGuidance as kt, SurveyAuditFinding as l, mapRawItemsById as lt, auditSurvey as m, summarizeFocusItemNode as mt, getFormAuthoringMode$1 as n, getRawSurvey as nt, normalizeFormAuthoringConfig$1 as o, itemSummarySchema as ot, SurveyQualityReviewPrinciple as p, sliceWithCursor as pt, buildSurveyTranslations as q, SurveyAssistantCapabilitySet as qt, hasSingleFormField as r, getRawSurveyItems as rt, transitionFormAuthoringMode$1 as s, mapItemIndexById as st, FormAuthoringMode as t, getItemIndexEntries as tt, SurveyAuditKeyReviewEntry as u, normalizeText as ut, SurveyAssistantTaskPurpose as v, summarizeOutlineNode as vt, buildSurveyDocumentVersion as w, buildExpressionMutationPatches as wt, TurnSurveyDraft as x, unique as xt, buildSurveyAssistantTaskContext as y, summarizeRawItem as yt, SurveyInspectionIndex as z, SurveyAssistantInspectionOutlineNode as zt };
+//# sourceMappingURL=index-Ciq7vHIs.d.mts.map

package/dist/index-Ciq7vHIs.d.mts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index-Ciq7vHIs.d.mts","names":[],"sources":["../src/engine/capabilities.ts","../src/engine/context.ts","../src/engine/expression-validation.ts","../src/engine/expression-reference-integrity.ts","../src/engine/expression-mutations.ts","../src/engine/inspection.ts","../src/engine/normalization.ts","../src/engine/operation-execution.ts","../src/engine/operations.ts","../src/engine/mutation-recovery.ts","../src/engine/turn-survey-draft.ts","../src/engine/task-context.ts","../src/engine/task-result-cache.ts","../src/engine/audit.ts"],"mappings":"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ACF,+CAA+C;;;;;;;;;;cA2P5C;;WACF;EASG,YAAA;EAIZ,WAAW,SAAS;EAOpB,QACE,kBACA,4BACA,uBACA,kBACA,YACA,UACA;IAEA;IACA;IACA,wBAAwB;IACxB;IACA,YAAY;IACZ,UAAU,+BAA+B;IACzC;MACE;EA2MJ,OACE,WAAW,iBACX,mBAAkB,kBAClB,cAAa,6BACZ;EA8CH,SACE,QAAQ,oCACR,oBACA,UAAS,KAAK,8EACb;EAsBH,aAAa,sBAAsB;MAI/B,4BAA4B;MAI5B,WAAW;MAIX,SAAS;;;;KClqBH;UAMK;EACf,SAAS;EACT,eAAe;EACf;EACA;EACA;EACA;EACA;EACA;;cA2BW,kCACX,UAAU,wBACV,SAAS,2CACR;;;UCtDc;EACf;EACA;EACA;;;cAYW;mBACM;mBACA;mBACA;mBACA;EAEL,YAAA,UAAS;EAMrB,IAAI,SAAS,cAAc;EAa3B,IAAI,SAAS,aAAa,OAAO;EAUjC;;;;KCtCU;KACA;UASK;EACf;EACA,UAAU;EACV,UAAU;EACV;EACA;EACA;EACA;EACA;;UAGe;EACf;EACA;EACA;;UAGe;EACf;EACA;EACA;EACA;EACA;EACA;EACA;EACA;EACA;EACA;;UAGe;EACf,SAAS,OAAO;IAAiC;;EACjD;EACA;EACA;IACE;IACA;IACA;IACA;IACA,WAAW;;EAEb,UAAU;EACV,yBAAyB;EACzB;IACE;IACA;IACA;IACA;IACA;IACA,SAAS;IACT;;EAEF;;cA6LW,cACX,SAAS,8BACT;EACE;EACA;EACA;EACA;EACA;MAED"}